sdgoij/rustfs
1
0
Fork 0
mirror of https://github.com/rustfs/rustfs.git synced 2026-01-17 01:30:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add utility functions and configurations for rustfs-gui (#220)

Browse Source 
* Initialize rustfs-gui crate

- Set up the `rustfs-gui` package in the workspace.
- Add `dioxus` dependency with `router` feature.
- Configure workspace settings for edition, license, repository, and rust-version.
- Include lints configuration for the workspace.

* Add utility functions and configurations for rustfs-gui

- Implement `RustFSConfig` struct with default values and methods for loading, saving, and clearing configurations.
- Add `ServiceCommand` enum for managing service commands.
- Implement `ServiceManager` struct for starting, stopping, and restarting the service.
- Include helper functions for checking service status, preparing the service, downloading files, and unzipping files.
- Add logging and error handling for service operations.
This commit is contained in:
houseme
2025-02-18 00:55:34 +08:00
committed by GitHub
parent f8cc6f45b8
commit 624889bae5
9 changed files with 4827 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4096
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

7
Cargo.toml
View File

@@ -38,10 +38,11 @@ bytesize = "1.3.0"
chrono = { version = "0.4.39", features = ["serde"] }
clap = { version = "4.5.27", features = ["derive", "env"] }
dioxus = { version = "0.6.3", features = ["router"] }
dirs = "6.0.0"
ecstore = { path = "./ecstore" }
flatbuffers = "24.12.23"
futures = "0.3.31"
futures-util = "0.3.30"
futures-util = "0.3.31"
common = { path = "./common/common" }
reader = { path = "./reader" }
hyper = "1.6.0"
@@ -53,6 +54,7 @@ hyper-util = { version = "0.1.10", features = [
http = "1.2.0"
http-body = "1.0.1"
humantime = "2.1.0"
keyring = { version = "3.6.1", features = ["apple-native", "windows-native", "sync-secret-service"] }
lock = { path = "./common/lock" }
lazy_static = "1.5.0"
mime = "0.3.17"
@@ -65,6 +67,8 @@ prost-types = "0.13.4"
protobuf = "3.7"
protos = { path = "./common/protos" }
rand = "0.8.5"
reqwest = { version = "0.12.12", default-features = false, features = ["rustls-tls", "charset", "http2", "macos-system-configuration", "stream"] }
rfd = "0.15.2"
rmp = "0.8.14"
rmp-serde = "1.3.0"
s3s = { git = "https://github.com/Nugine/s3s.git", rev = "529c8933a11528c506d5fbf7c4c2ab155db37dfe", default-features = true, features = [
@@ -103,3 +107,4 @@ axum = "0.7.9"
md-5 = "0.10.6"
workers = { path = "./common/workers" }
test-case = "3.3.1"
zip = "2.2.2"

35
cli/rustfs-gui/Cargo.toml
View File

@@ -7,7 +7,42 @@ rust-version.workspace = true
version.workspace = true
[dependencies]
chrono = { workspace = true }
dioxus = { workspace = true, features = ["router"] }
dirs = { workspace = true }
futures-util = { workspace = true }
keyring = { workspace = true }
reqwest = { workspace = true }
rfd = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
tokio = { workspace = true, features = ["io-util", "net", "process", "sync"] }
zip = { workspace = true }
[features]
default = ["desktop"]
web = ["dioxus/web"]
desktop = ["dioxus/desktop"]
mobile = ["dioxus/mobile"]
[profile]
[profile.wasm-dev]
inherits = "dev"
opt-level = 1
[profile.server-dev]
inherits = "dev"
[profile.android-dev]
inherits = "dev"
[profile.release]
opt-level = 3 # 优化级别（0-3）
lto = true # 启用链接时优化
codegen-units = 1 # 减少代码生成单元以提高优化效果
[lints]
workspace = true

60
cli/rustfs-gui/Dioxus.toml Normal file
View File

@@ -0,0 +1,60 @@
[application]
# App (Project) Name
name = "rustfs-gui"
# The static resource path
asset_dir = "public"
[web.app]
# HTML title tag content
title = "rustfs-gui"
# include `assets` in web platform
[web.resource]
# Additional CSS style files
style = []
# Additional JavaScript files
script = []
[web.resource.dev]
# Javascript code file
# serve: [dev-server] only
script = []
[bundle]
identifier = "com.rustfs.cli.gui"
publisher = "RustFsGUI"
category = "Utility"
copyright = "Copyright 2025 rustfs.com"
icon = [
"assets/icons/icon_16x16.png",
"assets/icons/icon_16x16@2x.png",
"assets/icons/icon_32x32.png",
"assets/icons/icon_32x32@2x.png",
"assets/icons/icon_128x128.png",
"assets/icons/icon_128x128@2x.png",
"assets/icons/icon_256x256.png",
"assets/icons/icon_256x256@2x.png",
"assets/icons/icon_512x512.png",
"assets/icons/icon_512x512@2x.png",
"assets/icons/icon.icns",
"assets/icons/icon.ico"
]
#[bundle.macos]
#provider_short_name = "RustFs"
[bundle.windows]
tsp = true
icon_path = "assets/icons/icon.ico"
allow_downgrades = true
[bundle.windows.webview_install_mode]
[bundle.windows.webview_install_mode.EmbedBootstrapper]
silent = true

4
cli/rustfs-gui/assets/tailwind.css
View File

@@ -552,4 +552,8 @@ video {
[hidden]:where(:not([hidden="until-found"])) {
display: none;
}
.static {
position: static;
}

1
cli/rustfs-gui/src/main.rs
View File

@@ -1,4 +1,5 @@
mod components;
mod utils;
mod views;
use dioxus::prelude::*;

228
cli/rustfs-gui/src/utils/config.rs Normal file
View File

@@ -0,0 +1,228 @@
use keyring::Entry;
use serde::{Deserialize, Serialize};
use std::error::Error;
/// Configuration for the RustFS service
///
/// # Fields
/// * `address` - The address of the RustFS service
/// * `host` - The host of the RustFS service
/// * `port` - The port of the RustFS service
/// * `access_key` - The access key of the RustFS service
/// * `secret_key` - The secret key of the RustFS service
/// * `domain_name` - The domain name of the RustFS service
/// * `volume_name` - The volume name of the RustFS service
/// * `console_address` - The console address of the RustFS service
///
/// # Example
/// ```
/// let config = RustFSConfig {
/// address: "127.0.0.1:9000".to_string(),
/// host: "127.0.0.1".to_string(),
/// port: "9000".to_string(),
/// access_key: "rustfsadmin".to_string(),
/// secret_key: "rustfsadmin".to_string(),
/// domain_name: "demo.rustfs.com".to_string(),
/// volume_name: "data".to_string(),
/// console_address: "127.0.0.1:9001".to_string(),
/// };
/// println!("{:?}", config);
/// assert_eq!(config.address, "127.0.0.1:9000");
/// ```
#[derive(Debug, Clone, Default, Deserialize, Serialize, Ord, PartialOrd, Eq, PartialEq)]
pub struct RustFSConfig {
pub address: String,
pub host: String,
pub port: String,
pub access_key: String,
pub secret_key: String,
pub domain_name: String,
pub volume_name: String,
pub console_address: String,
}
impl RustFSConfig {
/// keyring the name of the service
const SERVICE_NAME: &'static str = "rustfs-service";
/// keyring the key of the service
const SERVICE_KEY: &'static str = "rustfs_key";
/// default domain name
const DEFAULT_DOMAIN_NAME_VALUE: &'static str = "demo.rustfs.com";
/// default address value
const DEFAULT_ADDRESS_VALUE: &'static str = "127.0.0.1:9000";
/// default port value
const DEFAULT_PORT_VALUE: &'static str = "9000";
/// default host value
const DEFAULT_HOST_VALUE: &'static str = "127.0.0.1";
/// default access key value
const DEFAULT_ACCESS_KEY_VALUE: &'static str = "rustfsadmin";
/// default secret key value
const DEFAULT_SECRET_KEY_VALUE: &'static str = "rustfsadmin";
/// default console address value
const DEFAULT_CONSOLE_ADDRESS_VALUE: &'static str = "127.0.0.1:9001";
/// get the default volume_name
///
/// # Returns
/// * The default volume name
///
/// # Example
/// ```
/// let volume_name = RustFSConfig::default_volume_name();
/// ```
pub fn default_volume_name() -> String {
dirs::home_dir()
.map(|home| home.join("rustfs").join("data"))
.and_then(|path| path.to_str().map(String::from))
.unwrap_or_else(|| "data".to_string())
}
/// create a default configuration
///
/// # Returns
/// * The default configuration
///
/// # Example
/// ```
/// let config = RustFSConfig::default_config();
/// println!("{:?}", config);
/// assert_eq!(config.address, "127.0.0.1:9000");
/// ```
pub fn default_config() -> Self {
Self {
address: Self::DEFAULT_ADDRESS_VALUE.to_string(),
host: Self::DEFAULT_HOST_VALUE.to_string(),
port: Self::DEFAULT_PORT_VALUE.to_string(),
access_key: Self::DEFAULT_ACCESS_KEY_VALUE.to_string(),
secret_key: Self::DEFAULT_SECRET_KEY_VALUE.to_string(),
domain_name: Self::DEFAULT_DOMAIN_NAME_VALUE.to_string(),
volume_name: Self::default_volume_name(),
console_address: Self::DEFAULT_CONSOLE_ADDRESS_VALUE.to_string(),
}
}
/// Load the configuration from the keyring
///
/// # Errors
/// * If the configuration cannot be loaded from the keyring
/// * If the configuration cannot be deserialized
/// * If the address cannot be extracted from the configuration
///
/// # Example
/// ```
/// let config = RustFSConfig::load().unwrap();
/// println!("{:?}", config);
/// assert_eq!(config.address, "127.0.0.1:9000");
/// ```
pub fn load() -> Result<Self, Box<dyn Error>> {
let mut config = Self::default_config();
// Try to get the configuration of the storage from the keyring
let entry = Entry::new(Self::SERVICE_NAME, Self::SERVICE_KEY)?;
if let Ok(stored_json) = entry.get_password() {
if let Ok(stored_config) = serde_json::from_str::<RustFSConfig>(&stored_json) {
// update fields that are not empty and non default
if !stored_config.address.is_empty()
&& stored_config.address != Self::DEFAULT_ADDRESS_VALUE
{
config.address = stored_config.address;
let (host, port) = Self::extract_host_port(config.address.as_str())
.ok_or_else(|| {
format!("无法从地址 '{}' 中提取主机和端口", config.address)
})?;
config.host = host.to_string();
config.port = port.to_string();
}
if !stored_config.access_key.is_empty()
&& stored_config.access_key != Self::DEFAULT_ACCESS_KEY_VALUE
{
config.access_key = stored_config.access_key;
}
if !stored_config.secret_key.is_empty()
&& stored_config.secret_key != Self::DEFAULT_SECRET_KEY_VALUE
{
config.secret_key = stored_config.secret_key;
}
if !stored_config.domain_name.is_empty()
&& stored_config.domain_name != Self::DEFAULT_DOMAIN_NAME_VALUE
{
config.domain_name = stored_config.domain_name;
}
// The stored volume_name is updated only if it is not empty and different from the default
if !stored_config.volume_name.is_empty()
&& stored_config.volume_name != Self::default_volume_name()
{
config.volume_name = stored_config.volume_name;
}
if !stored_config.console_address.is_empty()
&& stored_config.console_address != Self::DEFAULT_CONSOLE_ADDRESS_VALUE
{
config.console_address = stored_config.console_address;
}
}
}
Ok(config)
}
/// Auxiliary method: Extract the host and port from the address string
/// # Arguments
/// * `address` - The address string
///
/// # Returns
/// * `Some((host, port))` - The host and port
///
/// # Errors
/// * If the address is not in the form 'host:port'
/// * If the port is not a valid u16
///
/// # Example
/// ```
/// let (host, port) = RustFSConfig::extract_host_port("127.0.0.1:9000").unwrap();
/// assert_eq!(host, "127.0.0.1");
/// assert_eq!(port, 9000);
/// ```
pub fn extract_host_port(address: &str) -> Option<(&str, u16)> {
let parts: Vec<&str> = address.split(':').collect();
if parts.len() == 2 {
if let Ok(port) = parts[1].parse::<u16>() {
return Some((parts[0], port));
}
}
None
}
/// save the configuration to keyring
///
/// # Errors
/// * If the configuration cannot be serialized
/// * If the configuration cannot be saved to the keyring
///
/// # Example
/// ```
/// let config = RustFSConfig::default_config();
/// config.save().unwrap();
/// ```
pub fn save(&self) -> Result<(), Box<dyn Error>> {
let entry = Entry::new(Self::SERVICE_NAME, Self::SERVICE_KEY)?;
let json = serde_json::to_string(self)?;
entry.set_password(&json)?;
Ok(())
}
/// delete the stored configuration
///
/// # Errors
/// * If the configuration cannot be deleted from the keyring
///
/// # Example
/// ```
/// RustFSConfig::clear().unwrap();
/// ```
#[allow(dead_code)]
pub fn clear() -> Result<(), Box<dyn Error>> {
let entry = Entry::new(Self::SERVICE_NAME, Self::SERVICE_KEY)?;
entry.delete_credential()?;
Ok(())
}
}

662
cli/rustfs-gui/src/utils/helper.rs Normal file
View File

@@ -0,0 +1,662 @@
use crate::utils::RustFSConfig;
use dioxus::logger::tracing::{debug, error, info};
use futures_util::TryStreamExt;
use std::error::Error;
use std::fs::File;
use std::path::{Path, PathBuf};
use std::process::Command as StdCommand;
use std::time::Duration;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio::sync::mpsc;
/// Service command
/// This enum represents the commands that can be sent to the service manager
/// to start, stop, or restart the service
/// The `Start` variant contains the configuration for the service
/// The `Restart` variant contains the configuration for the service
///
/// # Example
/// ```
/// let config = RustFSConfig {
/// address: "127.0.0.1:9000".to_string(),
/// host: "127.0.0.1".to_string(),
/// port: "9000".to_string(),
/// access_key: "rustfsadmin".to_string(),
/// secret_key: "rustfsadmin".to_string(),
/// domain_name: "demo.rustfs.com".to_string(),
/// volume_name: "data".to_string(),
/// console_address: "127.0.0.1:9001".to_string(),
/// };
///
/// let command = ServiceCommand::Start(config);
/// println!("{:?}", command);
///
/// assert_eq!(command, ServiceCommand::Start(config));
/// ```
pub enum ServiceCommand {
Start(RustFSConfig),
Stop,
Restart(RustFSConfig),
}
/// Service operation result
/// This struct represents the result of a service operation
/// It contains information about the success of the operation,
///
/// # Example
/// ```
/// use chrono::Local;
///
/// let result = ServiceOperationResult {
/// success: true,
/// start_time: chrono::Local::now(),
/// end_time: chrono::Local::now(),
/// message: "服务启动成功".to_string(),
/// };
///
/// println!("{:?}", result);
/// assert_eq!(result.success, true);
/// ```
#[derive(Debug)]
pub struct ServiceOperationResult {
pub success: bool,
pub start_time: chrono::DateTime<chrono::Local>,
pub end_time: chrono::DateTime<chrono::Local>,
pub message: String,
}
/// Service manager
/// This struct represents a service manager that can be used to start, stop, or restart a service
/// It contains a command sender that can be used to send commands to the service manager
///
/// # Example
/// ```
/// let service_manager = ServiceManager::new();
/// println!("{:?}", service_manager);
/// ```
#[derive(Debug, Clone)]
pub struct ServiceManager {
command_tx: mpsc::Sender<ServiceCommand>,
// process: Arc<Mutex<Option<Child>>>,
// pid: Arc<Mutex<Option<u32>>>, // Add PID storage
// current_config: Arc<Mutex<Option<RustFSConfig>>>, // Add configuration storage
}
impl ServiceManager {
/// check if the service is running and return a pid
/// This function is platform dependent
/// On Unix systems, it uses the `ps` command to check for the service
/// On Windows systems, it uses the `wmic` command to check for the service
///
/// # Example
/// ```
/// let pid = check_service_status().await;
/// println!("{:?}", pid);
/// ```
pub async fn check_service_status() -> Option<u32> {
#[cfg(unix)]
{
// use the ps command on a unix system
if let Ok(output) = StdCommand::new("ps").arg("-ef").output() {
let output_str = String::from_utf8_lossy(&output.stdout);
for line in output_str.lines() {
// match contains `rustfs/bin/rustfs` of the line
if line.contains("rustfs/bin/rustfs") && !line.contains("grep") {
if let Some(pid_str) = line.split_whitespace().nth(1) {
if let Ok(pid) = pid_str.parse::<u32>() {
return Some(pid);
}
}
}
}
}
}
#[cfg(windows)]
{
if let Ok(output) = StdCommand::new("wmic")
.arg("process")
.arg("where")
.arg("caption='rustfs.exe'")
.arg("get")
.arg("processid")
.output()
{
let output_str = String::from_utf8_lossy(&output.stdout);
for line in output_str.lines() {
if let Ok(pid) = line.trim().parse::<u32>() {
return Some(pid);
}
}
}
}
None
}
/// Prepare the service
/// This function downloads the service executable if it doesn't exist
/// It also creates the necessary directories for the service
///
/// # Example
/// ```
/// let executable_path = prepare_service().await;
/// println!("{:?}", executable_path);
/// ```
async fn prepare_service() -> Result<PathBuf, Box<dyn Error>> {
// get the user directory
let home_dir = dirs::home_dir().ok_or("无法获取用户目录")?;
let rustfs_dir = home_dir.join("rustfs");
let bin_dir = rustfs_dir.join("bin");
let data_dir = rustfs_dir.join("data");
let logs_dir = rustfs_dir.join("logs");
// create the necessary directories
for dir in [&bin_dir, &data_dir, &logs_dir] {
if !dir.exists() {
tokio::fs::create_dir_all(dir).await?;
}
}
let executable_path = if cfg!(windows) {
bin_dir.join("rustfs.exe")
} else {
bin_dir.join("rustfs")
};
// If the executable file doesn't exist, download and unzip it
if !executable_path.exists() {
// download the file
let tmp_zip = rustfs_dir.join("rustfs.zip");
let file_download_url = if cfg!(windows) {
"https://api.xmb.xyz/download/rustfs-win.zip"
} else {
"https://api.xmb.xyz/download/rustfs.zip"
};
let download_task = Self::download_file(file_download_url, &tmp_zip);
let unzip_task = async {
download_task.await?;
Self::unzip_file(&tmp_zip, &bin_dir)?;
tokio::fs::remove_file(&tmp_zip).await?;
Ok::<(), Box<dyn Error>>(())
};
unzip_task.await?;
// delete the temporary zip file
tokio::fs::remove_file(&tmp_zip).await?;
// set execution permissions on unix systems
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mut perms = std::fs::metadata(&executable_path)?.permissions();
perms.set_mode(0o755);
std::fs::set_permissions(&executable_path, perms)?;
}
Self::show_info("服务程序已成功下载并准备就绪");
}
Ok(executable_path)
}
/// Download the file
/// This function is a modified version of the example from the `reqwest` crate documentation
///
/// # Example
/// ```
/// let url = "https://api.xmb.xyz/download/rustfs.zip";
/// let path = Path::new("rustfs.zip");
/// download_file(url, path).await;
/// ```
async fn download_file(url: &str, path: &Path) -> Result<(), Box<dyn Error>> {
let client = reqwest::Client::new();
let res = client.get(url).send().await?;
if !res.status().is_success() {
return Err(format!("下载失败：{}", res.status()).into());
}
let mut file = tokio::fs::File::create(path).await?;
let mut stream = res.bytes_stream();
while let Ok(Some(chunk)) = stream.try_next().await {
file.write_all(&chunk).await?;
}
Ok(())
}
/// unzip the file
/// This function is a modified version of the example from the `zip` crate documentation
///
/// # Example
/// ```
/// let zip_path = Path::new("rustfs.zip");
/// let extract_path = Path::new("rustfs");
/// unzip_file(zip_path, extract_path);
/// ```
fn unzip_file(zip_path: &Path, extract_path: &Path) -> Result<(), Box<dyn Error>> {
let file = File::open(zip_path)?;
let mut archive = zip::ZipArchive::new(file)?;
for i in 0..archive.len() {
let mut file = archive.by_index(i)?;
let out_path = extract_path.join(file.name());
if file.name().ends_with('/') {
std::fs::create_dir_all(&out_path)?;
} else {
if let Some(p) = out_path.parent() {
if !p.exists() {
std::fs::create_dir_all(p)?;
}
}
let mut outfile = File::create(&out_path)?;
std::io::copy(&mut file, &mut outfile)?;
}
}
Ok(())
}
/// Helper function: Extracts the port from the address string
///
/// # Example
/// ```
/// let address = "127.0.0.1:9000";
/// let port = extract_port(address);
/// println!("{:?}", port);
/// ```
fn extract_port(address: &str) -> Option<u16> {
address.split(':').nth(1)?.parse().ok()
}
/// Create a new instance of the service manager
///
/// # Example
/// ```
/// let service_manager = ServiceManager::new();
/// println!("{:?}", service_manager);
/// ```
pub(crate) fn new() -> Self {
let (command_tx, mut command_rx) = mpsc::channel(10);
// Start the control loop
tokio::spawn(async move {
while let Some(cmd) = command_rx.recv().await {
match cmd {
ServiceCommand::Start(config) => {
if let Err(e) = Self::start_service(&config).await {
Self::show_error(&format!("启动服务失败：{}", e));
}
}
ServiceCommand::Stop => {
if let Err(e) = Self::stop_service().await {
Self::show_error(&format!("停止服务失败：{}", e));
}
}
ServiceCommand::Restart(config) => {
if Self::check_service_status().await.is_some() {
if let Err(e) = Self::stop_service().await {
Self::show_error(&format!("重启服务失败：{}", e));
continue;
}
}
if let Err(e) = Self::start_service(&config).await {
Self::show_error(&format!("重启服务失败：{}", e));
}
}
}
}
});
ServiceManager { command_tx }
}
/// Start the service
/// This function starts the service with the given configuration
///
/// # Example
/// ```
/// let config = RustFSConfig {
/// address: "127.0.0.1:9000".to_string(),
/// host: "127.0.0.1".to_string(),
/// port: "9000".to_string(),
/// access_key: "rustfsadmin".to_string(),
/// secret_key: "rustfsadmin".to_string(),
/// domain_name: "demo.rustfs.com".to_string(),
/// volume_name: "data".to_string(),
/// console_address: "127.0.0.1:9001".to_string(),
/// };
///
/// let result = start_service(&config).await;
/// println!("{:?}", result);
/// ```
async fn start_service(config: &RustFSConfig) -> Result<(), Box<dyn Error>> {
// Check if the service is already running
if let Some(existing_pid) = Self::check_service_status().await {
return Err(format!("服务已经在运行，PID: {}", existing_pid).into());
}
// Prepare the service program
let executable_path = Self::prepare_service().await?;
// Check the data catalog
let volume_name_path = Path::new(&config.volume_name);
if !volume_name_path.exists() {
tokio::fs::create_dir_all(&config.volume_name).await?;
}
// Extract the port from the configuration
let main_port = Self::extract_port(&config.address).ok_or("无法解析主服务端口")?;
let console_port = Self::extract_port(&config.console_address).ok_or("无法解析控制台端口")?;
let host = config.address.split(':').next().ok_or("无法解析主机地址")?;
// Check the port
let ports = vec![main_port, console_port];
for port in ports {
if Self::is_port_in_use(host, port).await {
return Err(format!("端口 {} 已被占用", port).into());
}
}
// Start the service
let mut child = tokio::process::Command::new(executable_path)
.arg("--address")
.arg(&config.address)
.arg("--access-key")
.arg(&config.access_key)
.arg("--secret-key")
.arg(&config.secret_key)
.arg("--console-address")
.arg(&config.console_address)
.arg(config.volume_name.clone())
.spawn()?;
let process_pid = child.id().unwrap();
// Wait for the service to start
tokio::time::sleep(Duration::from_secs(2)).await;
// Check if the service started successfully
if Self::is_port_in_use(host, main_port).await {
Self::show_info(&format!("服务启动成功！进程 ID: {}", process_pid));
Ok(())
} else {
child.kill().await?;
Err("服务启动失败".into())
}
}
/// Stop the service
/// This function stops the service
///
/// # Example
/// ```
/// let result = stop_service().await;
/// println!("{:?}", result);
/// ```
async fn stop_service() -> Result<(), Box<dyn Error>> {
let existing_pid = Self::check_service_status().await;
debug!("existing_pid: {:?}", existing_pid);
if let Some(service_pid) = existing_pid {
// An attempt was made to terminate the process
#[cfg(unix)]
{
StdCommand::new("kill").arg("-9").arg(service_pid.to_string()).output()?;
}
#[cfg(windows)]
{
StdCommand::new("taskkill")
.arg("/F")
.arg("/PID")
.arg(&service_pid.to_string())
.output()?;
}
// Verify that the service is indeed stopped
tokio::time::sleep(Duration::from_secs(1)).await;
if Self::check_service_status().await.is_some() {
return Err("服务停止失败".into());
}
Self::show_info("服务已成功停止");
Ok(())
} else {
Err("服务未运行".into())
}
}
/// Check if the port is in use
/// This function checks if the given port is in use on the given host
///
/// # Example
/// ```
/// let host = "127.0.0.1";
/// let port = 9000;
/// let result = is_port_in_use(host, port).await;
/// println!("{:?}", result);
/// ```
async fn is_port_in_use(host: &str, port: u16) -> bool {
TcpStream::connect(format!("{}:{}", host, port)).await.is_ok()
}
/// Show an error message
/// This function shows an error message dialog
///
/// # Example
/// ```
/// show_error("This is an error message");
/// ```
pub(crate) fn show_error(message: &str) {
rfd::MessageDialog::new()
.set_title("错误")
.set_description(message)
.set_level(rfd::MessageLevel::Error)
.show();
}
/// Show an information message
/// This function shows an information message dialog
///
/// # Example
/// ```
/// show_info("This is an information message");
/// ```
pub(crate) fn show_info(message: &str) {
rfd::MessageDialog::new()
.set_title("成功")
.set_description(message)
.set_level(rfd::MessageLevel::Info)
.show();
}
/// Start the service
/// This function sends a `Start` command to the service manager
///
/// # Example
/// ```
/// let config = RustFSConfig {
/// address: "127.0.0.1:9000".to_string(),
/// host: "127.0.0.1".to_string(),
/// port: "9000".to_string(),
/// access_key: "rustfsadmin".to_string(),
/// secret_key: "rustfsadmin".to_string(),
/// domain_name: "demo.rustfs.com".to_string(),
/// volume_name: "data".to_string(),
/// console_address: "127.0.0.1:9001".to_string(),
/// };
///
/// let service_manager = ServiceManager::new();
/// let result = service_manager.start(config).await;
/// println!("{:?}", result);
/// ```
///
/// # Errors
/// This function returns an error if the service fails to start
///
/// # Panics
/// This function panics if the port number is invalid
///
/// # Safety
/// This function is not marked as unsafe
///
/// # Performance
/// This function is not optimized for performance
///
/// # Design
/// This function is designed to be simple and easy to use
///
/// # Security
/// This function does not have any security implications
pub async fn start(&self, config: RustFSConfig) -> Result<ServiceOperationResult, Box<dyn Error>> {
let start_time = chrono::Local::now();
self.command_tx.send(ServiceCommand::Start(config.clone())).await?;
let host = &config.host;
let port = config.port.parse::<u16>().expect("无效的端口号");
// wait for the service to actually start
let mut retries = 0;
while retries < 30 {
// wait up to 30 seconds
if Self::check_service_status().await.is_some() && Self::is_port_in_use(host, port).await {
let end_time = chrono::Local::now();
return Ok(ServiceOperationResult {
success: true,
start_time,
end_time,
message: "服务启动成功".to_string(),
});
}
tokio::time::sleep(Duration::from_secs(1)).await;
retries += 1;
}
Err("服务启动超时".into())
}
/// Stop the service
/// This function sends a `Stop` command to the service manager
///
/// # Example
/// ```
/// let service_manager = ServiceManager::new();
/// let result = service_manager.stop().await;
/// println!("{:?}", result);
/// ```
///
/// # Errors
/// This function returns an error if the service fails to stop
///
/// # Panics
/// This function panics if the port number is invalid
///
/// # Safety
/// This function is not marked as unsafe
///
/// # Performance
/// This function is not optimized for performance
///
/// # Design
/// This function is designed to be simple and easy to use
///
/// # Security
/// This function does not have any security implications
pub async fn stop(&self) -> Result<ServiceOperationResult, Box<dyn Error>> {
let start_time = chrono::Local::now();
self.command_tx.send(ServiceCommand::Stop).await?;
// Wait for the service to actually stop
let mut retries = 0;
while retries < 15 {
// Wait up to 15 seconds
if Self::check_service_status().await.is_none() {
let end_time = chrono::Local::now();
return Ok(ServiceOperationResult {
success: true,
start_time,
end_time,
message: "服务停止成功".to_string(),
});
}
tokio::time::sleep(Duration::from_secs(1)).await;
retries += 1;
}
Err("服务停止超时".into())
}
/// Restart the service
/// This function sends a `Restart` command to the service manager
///
/// # Example
/// ```
/// let config = RustFSConfig {
/// address: "127.0.0.1:9000".to_string(),
/// host: "127.0.0.1".to_string(),
/// port: "9000".to_string(),
/// access_key: "rustfsadmin".to_string(),
/// secret_key: "rustfsadmin".to_string(),
/// domain_name: "demo.rustfs.com".to_string(),
/// volume_name: "data".to_string(),
/// console_address: "127.0.0.1:9001".to_string(),
/// };
///
/// let service_manager = ServiceManager::new();
/// let result = service_manager.restart(config).await;
/// println!("{:?}", result);
/// ```
///
/// # Errors
/// This function returns an error if the service fails to restart
///
/// # Panics
/// This function panics if the port number is invalid
///
/// # Safety
/// This function is not marked as unsafe
///
/// # Performance
/// This function is not optimized for performance
///
/// # Design
/// This function is designed to be simple and easy to use
///
/// # Security
/// This function does not have any security implications
pub async fn restart(&self, config: RustFSConfig) -> Result<ServiceOperationResult, Box<dyn Error>> {
let start_time = chrono::Local::now();
self.command_tx.send(ServiceCommand::Restart(config.clone())).await?;
let host = &config.host;
let port = config.port.parse::<u16>().expect("无效的端口号");
// wait for the service to restart
let mut retries = 0;
while retries < 45 {
// Longer waiting time is given as both the stop and start processes are involved
if Self::check_service_status().await.is_some() && Self::is_port_in_use(host, port).await {
match config.save() {
Ok(_) => info!("save config success"),
Err(e) => {
error!("save config error: {}", e);
self.command_tx.send(ServiceCommand::Stop).await?;
Self::show_error("保存配置失败");
return Err("保存配置失败".into());
}
}
let end_time = chrono::Local::now();
return Ok(ServiceOperationResult {
success: true,
start_time,
end_time,
message: "服务重启成功".to_string(),
});
}
tokio::time::sleep(Duration::from_secs(1)).await;
retries += 1;
}
Err("服务重启超时".into())
}
}

4
cli/rustfs-gui/src/utils/mod.rs Normal file
View File

@@ -0,0 +1,4 @@
mod config;
mod helper;
pub use config::RustFSConfig;