Merge 780bb6dcdb into 4fc3ff8ce8

easytier/locales/app.yml

@@ -120,6 +120,9 @@ core_clap:
   ipv6_listener:
     en: "the url of the ipv6 listener, e.g.: tcp://[::]:11010, if not set, will listen on random udp port"
     zh-CN: "IPv6 监听器的URL，例如：tcp://[::]:11010，如果未设置，将在随机UDP端口上监听"
+  work_dir:
+    en: "Specify the working directory for the program. If not specified, the current directory will be used."
+    zh-CN: "指定程序的工作目录。如果未指定，将使用当前目录。"
 
 core_app:
   panic_backtrace_save:

easytier/src/common/constants.rs

@@ -25,8 +25,6 @@ define_global_var!(OSPF_UPDATE_MY_GLOBAL_FOREIGN_NETWORK_INTERVAL_SEC, u64, 10);
 
 pub const UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID: u32 = 2;
 
-pub const WIN_SERVICE_WORK_DIR_REG_KEY: &str = "SOFTWARE\\EasyTier\\Service\\WorkDir";
-
 pub const EASYTIER_VERSION: &str = git_version::git_version!(
     args = ["--abbrev=8", "--always", "--dirty=~"],
     prefix = concat!(env!("CARGO_PKG_VERSION"), "-"),

easytier/src/easytier-cli.rs

@@ -1,13 +1,18 @@
 use std::{
-    ffi::OsString, fmt::Write, net::SocketAddr, path::PathBuf, sync::Mutex, time::Duration, vec,
+    ffi::OsString,
+    net::SocketAddr, 
+    path::PathBuf, 
+    sync::Mutex, 
+    time::Duration, 
+    vec
 };
 
 use anyhow::{Context, Ok};
 use clap::{command, Args, Parser, Subcommand};
 use humansize::format_size;
-use service_manager::*;
 use tabled::settings::Style;
 use tokio::time::timeout;
+use service_manager::*;
 
 use easytier::{
     common::{
@@ -57,7 +62,7 @@ enum SubCommand {
     PeerCenter,
     VpnPortal,
     Node(NodeArgs),
-    Service(ServiceArgs),
+    Service(ServiceArgs)
 }
 
 #[derive(Args, Debug)]
@@ -125,12 +130,9 @@ struct NodeArgs {
 }
 
 #[derive(Args, Debug)]
-struct ServiceArgs {
-    #[arg(short, long, default_value = env!("CARGO_PKG_NAME"), help = "service name")]
-    name: String,
-
+struct ServiceArgs{
     #[command(subcommand)]
-    sub_command: ServiceSubCommand,
+    sub_command: ServiceSubCommand
 }
 
 #[derive(Subcommand, Debug)]
@@ -139,28 +141,15 @@ enum ServiceSubCommand {
     Uninstall,
     Status,
     Start,
-    Stop,
+    Stop
 }
 
 #[derive(Args, Debug)]
 struct InstallArgs {
-    #[arg(long, default_value = env!("CARGO_PKG_DESCRIPTION"), help = "service description")]
-    description: String,
-
-    #[arg(long)]
-    display_name: Option<String>,
-
-    #[arg(long, default_value = "false")]
-    disable_autostart: bool,
-
     #[arg(long)]
     core_path: Option<PathBuf>,
-
-    #[arg(long)]
-    service_work_dir: Option<PathBuf>,
-
     #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
-    core_args: Option<Vec<OsString>>,
+    core_args: Option<Vec<OsString>>
 }
 
 type Error = anyhow::Error;
@@ -519,54 +508,48 @@ impl CommandHandler {
     }
 }
 
-pub struct ServiceInstallOptions {
-    pub program: PathBuf,
-    pub args: Vec<OsString>,
-    pub work_directory: PathBuf,
-    pub disable_autostart: bool,
-    pub description: Option<String>,
-    pub display_name: Option<String>,
-}
-pub struct Service {
+pub struct Service{
     lable: ServiceLabel,
-    kind: ServiceManagerKind,
-    service_manager: Box<dyn ServiceManager>,
+    service_manager: Box<dyn ServiceManager>
 }
 
 impl Service {
-    pub fn new(name: String) -> Result<Self, Error> {
+    pub fn new() -> Result<Self, Error> {
         #[cfg(target_os = "windows")]
-        let service_manager = Box::new(crate::win_service_manager::WinServiceManager::new()?);
+        let service_manager = Box::new(
+            crate::win_service_manager::WinServiceManager::new(
+                Some(OsString::from("EasyTier Service")),
+                Some(OsString::from(env!("CARGO_PKG_DESCRIPTION"))),
+                vec![OsString::from("dnscache"), OsString::from("rpcss")],
+            )?
+        );
 
         #[cfg(not(target_os = "windows"))]
         let service_manager = <dyn ServiceManager>::native()?;
-        let kind = ServiceManagerKind::native()?;
 
         Ok(Self {
-            lable: name.parse()?,
-            kind,
-            service_manager,
+            lable: env!("CARGO_PKG_NAME").parse().unwrap(),
+            service_manager
         })
     }
 
-    pub fn install(&self, options: &ServiceInstallOptions) -> Result<(), Error> {
+    pub fn install(&self, bin_path: std::path::PathBuf, bin_args: Vec<OsString>) -> Result<(), Error> {
         let ctx = ServiceInstallCtx {
             label: self.lable.clone(),
-            program: options.program.clone(),
-            args: options.args.clone(),
-            contents: self.make_install_content_option(options),
-            autostart: !options.disable_autostart,
+            contents: None,
+            program: bin_path,
+            args: bin_args,
+            autostart: true,
             username: None, 
-            working_directory: Some(options.work_directory.clone()),
+            working_directory: None,
             environment: None,
         };
+
         if self.status()? != ServiceStatus::NotInstalled {
             return Err(anyhow::anyhow!("Service is already installed"));
         }
 
-        self.service_manager
-            .install(ctx)
-            .map_err(|e| anyhow::anyhow!("failed to install service: {}", e))
+        self.service_manager.install(ctx).map_err(|e| anyhow::anyhow!("failed to install service: {}", e))
     }
 
     pub fn uninstall(&self) -> Result<(), Error> {
@@ -585,9 +568,7 @@ impl Service {
             })?;
         }
 
-        self.service_manager
-            .uninstall(ctx)
-            .map_err(|e| anyhow::anyhow!("failed to uninstall service: {}", e))
+        self.service_manager.uninstall(ctx).map_err(|e| anyhow::anyhow!("failed to uninstall service: {}", e))
     }
 
     pub fn status(&self) -> Result<ServiceStatus, Error> {
@@ -606,14 +587,16 @@ impl Service {
         let status = self.status()?;
 
         match status {
-            ServiceStatus::Running => Err(anyhow::anyhow!("Service is already running")),
+            ServiceStatus::Running => {
+                Err(anyhow::anyhow!("Service is already running"))
+            }
             ServiceStatus::Stopped(_) => {
-                self.service_manager
-                    .start(ctx)
-                    .map_err(|e| anyhow::anyhow!("failed to start service: {}", e))?;
+                self.service_manager.start(ctx).map_err(|e| anyhow::anyhow!("failed to start service: {}", e))?;
                 Ok(())
             }
-            ServiceStatus::NotInstalled => Err(anyhow::anyhow!("Service is not installed")),
+            ServiceStatus::NotInstalled => {
+                Err(anyhow::anyhow!("Service is not installed"))
+            }            
         }
     }
 
@@ -625,149 +608,18 @@ impl Service {
 
         match status {
             ServiceStatus::Running => {
-                self.service_manager
-                    .stop(ctx)
-                    .map_err(|e| anyhow::anyhow!("failed to stop service: {}", e))?;
+                self.service_manager.stop(ctx).map_err(|e| anyhow::anyhow!("failed to stop service: {}", e))?;
                 Ok(())
             }
-            ServiceStatus::Stopped(_) => Err(anyhow::anyhow!("Service is already stopped")),
-            ServiceStatus::NotInstalled => Err(anyhow::anyhow!("Service is not installed")),
-        }
-    }
-
-    fn make_install_content_option(&self, options: &ServiceInstallOptions) -> Option<String> {
-        match self.kind {
-            ServiceManagerKind::Systemd => Some(self.make_systemd_unit(options).unwrap()),
-            ServiceManagerKind::Rcd => Some(self.make_rcd_script(options).unwrap()),
-            ServiceManagerKind::OpenRc => Some(self.make_open_rc_script(options).unwrap()),
-            _ => {
-                #[cfg(target_os = "windows")]
-                {
-                    let win_options = win_service_manager::WinServiceInstallOptions {
-                        description: options.description.clone(),
-                        display_name: options.display_name.clone(),
-                        dependencies: Some(vec!["rpcss".to_string(), "dnscache".to_string()]),
-                    };
-
-                    Some(serde_json::to_string(&win_options).unwrap())
-                }
-
-                #[cfg(not(target_os = "windows"))]
-                None
+            ServiceStatus::Stopped(_) => {
+                Err(anyhow::anyhow!("Service is already stopped"))
+            }
+            ServiceStatus::NotInstalled => {
+                Err(anyhow::anyhow!("Service is not installed"))
             }
         }
     }
 
-    fn make_systemd_unit(
-        &self,
-        options: &ServiceInstallOptions,
-    ) -> Result<String, std::fmt::Error> {
-        let args = options
-            .args
-            .iter()
-            .map(|a| a.to_string_lossy())
-            .collect::<Vec<_>>()
-            .join(" ");
-        let target_app = options.program.display().to_string();
-        let work_dir = options.work_directory.display().to_string();
-        let mut unit_content = String::new();
-
-        writeln!(unit_content, "[Unit]")?;
-        writeln!(unit_content, "After=network.target syslog.target")?;
-        if let Some(ref d) = options.description {
-            writeln!(unit_content, "Description={d}")?;
-        }
-        writeln!(unit_content, "StartLimitIntervalSec=0")?;
-        writeln!(unit_content)?;
-        writeln!(unit_content, "[Service]")?;
-        writeln!(unit_content, "Type=simple")?;
-        writeln!(unit_content, "WorkingDirectory={work_dir}")?;
-        writeln!(unit_content, "ExecStart={target_app} {args}")?;
-        writeln!(unit_content, "Restart=Always")?;
-        writeln!(unit_content, "LimitNOFILE=infinity")?;
-        writeln!(unit_content)?;
-        writeln!(unit_content, "[Install]")?;
-        writeln!(unit_content, "WantedBy=multi-user.target")?;
-
-        std::result::Result::Ok(unit_content)
-    }
-
-    fn make_rcd_script(&self, options: &ServiceInstallOptions) -> Result<String, std::fmt::Error> {
-        let name = self.lable.to_qualified_name();
-        let args = options
-            .args
-            .iter()
-            .map(|a| a.to_string_lossy())
-            .collect::<Vec<_>>()
-            .join(" ");
-        let target_app = options.program.display().to_string();
-        let work_dir = options.work_directory.display().to_string();
-        let mut script = String::new();
-
-        writeln!(script, "#!/bin/sh")?;
-        writeln!(script, "#")?;
-        writeln!(script, "# PROVIDE: {name}")?;
-        writeln!(script, "# REQUIRE: LOGIN FILESYSTEMS NETWORKING ")?;
-        writeln!(script, "# KEYWORD: shutdown")?;
-        writeln!(script)?;
-        writeln!(script, ". /etc/rc.subr")?;
-        writeln!(script)?;
-        writeln!(script, "name=\"{name}\"")?;
-        if let Some(ref d) = options.description {
-            writeln!(script, "desc=\"{d}\"")?;
-        }
-        writeln!(script, "rcvar=\"{name}_enable\"")?;
-        writeln!(script)?;
-        writeln!(script, "load_rc_config ${{name}}")?;
-        writeln!(script)?;
-        writeln!(script, ": ${{{name}_options=\"{args}\"}}")?;
-        writeln!(script)?;
-        writeln!(script, "{name}_chdir=\"{work_dir}\"")?;
-        writeln!(script, "pidfile=\"/var/run/${{name}}.pid\"")?;
-        writeln!(script, "procname=\"{target_app}\"")?;
-        writeln!(script, "command=\"/usr/sbin/daemon\"")?;
-        writeln!(
-            script,
-            "command_args=\"-c -S -T ${{name}} -p ${{pidfile}} ${{procname}} ${{{name}_options}}\""
-        )?;
-        writeln!(script)?;
-        writeln!(script, "run_rc_command \"$1\"")?;
-
-        std::result::Result::Ok(script)
-    }
-
-    fn make_open_rc_script(
-        &self,
-        options: &ServiceInstallOptions,
-    ) -> Result<String, std::fmt::Error> {
-        let args = options
-            .args
-            .iter()
-            .map(|a| a.to_string_lossy())
-            .collect::<Vec<_>>()
-            .join(" ");
-        let target_app = options.program.display().to_string();
-        let work_dir = options.work_directory.display().to_string();
-        let mut script = String::new();
-
-        writeln!(script, "#!/sbin/openrc-run")?;
-        writeln!(script)?;
-        if let Some(ref d) = options.description {
-            writeln!(script, "description=\"{d}\"")?;
-        }
-        writeln!(script, "command=\"{target_app}\"")?;
-        writeln!(script, "command_args=\"{args}\"")?;
-        writeln!(script, "pidfile=\"/run/${{RC_SVCNAME}}.pid\"")?;
-        writeln!(script, "command_background=\"yes\"")?;
-        writeln!(script, "directory=\"{work_dir}\"")?;
-        writeln!(script)?;
-        writeln!(script, "depend() {{")?;
-        writeln!(script, "    need net")?;
-        writeln!(script, "    use looger")?;
-        writeln!(script, "}}")?;
-
-        std::result::Result::Ok(script)
-    }
 }
 
 #[tokio::main]
@@ -933,7 +785,7 @@ async fn main() -> Result<(), Error> {
             }
         }
         SubCommand::Service(service_args) => {
-            let service = Service::new(service_args.name)?;
+            let service = Service::new()?;
             match service_args.sub_command {
                 ServiceSubCommand::Install(install_args) => {                    
                     let bin_path = install_args.core_path.unwrap_or_else(|| {
@@ -953,35 +805,7 @@ async fn main() -> Result<(), Error> {
                         anyhow::anyhow!("failed to get easytier core application: {}", e)
                     })?;
                     let bin_args = install_args.core_args.unwrap_or_default();
-                    let work_dir = install_args.service_work_dir.unwrap_or_else(|| {
-                        if cfg!(target_os = "windows") {
-                            bin_path.parent().unwrap().to_path_buf()
-                        } else {
-                            std::env::temp_dir()
-                        }
-                    });
-
-                    let work_dir = std::fs::canonicalize(&work_dir).map_err(|e| {
-                        anyhow::anyhow!(
-                            "failed to get service work directory[{}]: {}",
-                            work_dir.display(),
-                            e
-                        )
-                    })?;
-
-                    if !work_dir.is_dir() {
-                        return Err(anyhow::anyhow!("work directory is not a directory"));
-                    }
-
-                    let install_options = ServiceInstallOptions {
-                        program: bin_path,
-                        args: bin_args,
-                        work_directory: work_dir,
-                        disable_autostart: install_args.disable_autostart,
-                        description: Some(install_args.description),
-                        display_name: install_args.display_name,
-                    };
-                    service.install(&install_options)?;
+                    service.install(bin_path, bin_args)?;
                 }
                 ServiceSubCommand::Uninstall => {
                     service.uninstall()?;
@@ -1009,42 +833,55 @@ async fn main() -> Result<(), Error> {
 
 #[cfg(target_os = "windows")]
 mod win_service_manager {
-    use std::{ffi::OsStr, ffi::OsString, io, path::PathBuf};
     use windows_service::{
         service::{
-            ServiceAccess, ServiceDependency, ServiceErrorControl, ServiceInfo, ServiceStartType,
             ServiceType,
+            ServiceErrorControl,
+            ServiceDependency,
+            ServiceInfo,
+            ServiceStartType,
+            ServiceAccess
         },
-        service_manager::{ServiceManager, ServiceManagerAccess},
+        service_manager::{
+            ServiceManagerAccess,
+            ServiceManager
+        }  
+    };
+    use std::{
+        io,
+        ffi::OsString,
+        ffi::OsStr
     };
 
     use service_manager::{
-        ServiceInstallCtx, ServiceLevel, ServiceStartCtx, ServiceStatus, ServiceStatusCtx,
-        ServiceStopCtx, ServiceUninstallCtx,
+        ServiceInstallCtx, 
+        ServiceLevel, 
+        ServiceStartCtx, 
+        ServiceStatus, 
+        ServiceStatusCtx, 
+        ServiceUninstallCtx,
+        ServiceStopCtx
     };
 
-    use winreg::{enums::*, RegKey};
-
-    use easytier::common::constants::WIN_SERVICE_WORK_DIR_REG_KEY;
-
-    use serde::{Deserialize, Serialize};
-
-    #[derive(Serialize, Deserialize)]
-    pub struct WinServiceInstallOptions {
-        pub dependencies: Option<Vec<String>>,
-        pub description: Option<String>,
-        pub display_name: Option<String>,
-    }
-
     pub struct WinServiceManager {
         service_manager: ServiceManager,
+        display_name: Option<OsString>,
+        description: Option<OsString>,
+        dependencies: Vec<OsString>  
     }
 
     impl WinServiceManager {
-        pub fn new() -> Result<Self, crate::Error> {
-            let service_manager =
-                ServiceManager::local_computer(None::<&str>, ServiceManagerAccess::ALL_ACCESS)?;
-            Ok(Self { service_manager })
+        pub fn new(display_name: Option<OsString>, description: Option<OsString>, dependencies: Vec<OsString>,) -> Result<Self, crate::Error> {
+            let service_manager = ServiceManager::local_computer(
+                None::<&str>,
+                ServiceManagerAccess::ALL_ACCESS,
+            )?;
+            Ok(Self {
+                service_manager,
+                display_name,
+                description,
+                dependencies,
+            })
         }
     }
     impl service_manager::ServiceManager for WinServiceManager {
@@ -1053,32 +890,10 @@ mod win_service_manager {
         }
     
         fn install(&self, ctx: ServiceInstallCtx) -> io::Result<()> {
-            let start_type_ = if ctx.autostart {
-                ServiceStartType::AutoStart
-            } else {
-                ServiceStartType::OnDemand
-            };
+            let start_type_ = if ctx.autostart { ServiceStartType::AutoStart } else { ServiceStartType::OnDemand };
             let srv_name = OsString::from(ctx.label.to_qualified_name());
-            let mut dis_name = srv_name.clone();
-            let mut description: Option<OsString> = None;
-            let mut dependencies = Vec::<ServiceDependency>::new();
-
-            if let Some(s) = ctx.contents.as_ref() {
-                let options: WinServiceInstallOptions = serde_json::from_str(s.as_str()).unwrap();
-                if let Some(d) = options.dependencies {
-                    dependencies = d
-                        .iter()
-                        .map(|dep| ServiceDependency::Service(OsString::from(dep.clone())))
-                        .collect::<Vec<_>>();
-                }
-                if let Some(d) = options.description {
-                    description = Some(OsString::from(d));
-                }
-                if let Some(d) = options.display_name {
-                    dis_name = OsString::from(d);
-                }
-            }
-
+            let dis_name = self.display_name.clone().unwrap_or_else(|| srv_name.clone());
+            let dependencies = self.dependencies.iter().map(|dep| ServiceDependency::Service(dep.clone())).collect::<Vec<_>>();
             let service_info = ServiceInfo {
                 name: srv_name,
                 display_name: dis_name,
@@ -1089,58 +904,50 @@ mod win_service_manager {
                 launch_arguments: ctx.args,
                 dependencies: dependencies.clone(),
                 account_name: None,
-                account_password: None,
+                account_password: None
             };
     
-            let service = self
-                .service_manager
-                .create_service(&service_info, ServiceAccess::ALL_ACCESS)
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            let service = self.service_manager.create_service(&service_info, ServiceAccess::ALL_ACCESS).map_err(|e| {
+                io::Error::new(io::ErrorKind::Other, e)
+            })?;
     
-            if let Some(s) = description {
-                service
-                    .set_description(s.clone())
-                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-            }
-
-            if let Some(work_dir) = ctx.working_directory {
-                set_service_work_directory(&ctx.label.to_qualified_name(), work_dir)?;
+            if let Some(s) = &self.description {
+                service.set_description(s.clone()).map_err(|e| {
+                    io::Error::new(io::ErrorKind::Other, e)
+                })?;
             }
     
             Ok(())
         }
         
         fn uninstall(&self, ctx: ServiceUninstallCtx) -> io::Result<()> {
-            let service = self
-                .service_manager
-                .open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS)
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            let service = self.service_manager.open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS).map_err(|e|{
+                io::Error::new(io::ErrorKind::Other, e)
+            })?;
     
-            service
-                .delete()
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+            service.delete().map_err(|e|{
+                io::Error::new(io::ErrorKind::Other, e)
+            })
         }
         
         fn start(&self, ctx: ServiceStartCtx) -> io::Result<()> {
-            let service = self
-                .service_manager
-                .open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS)
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            let service = self.service_manager.open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS).map_err(|e|{
+                io::Error::new(io::ErrorKind::Other, e)
+            })?;
     
-            service
-                .start(&[] as &[&OsStr])
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+            service.start(&[] as &[&OsStr]).map_err(|e|{
+                io::Error::new(io::ErrorKind::Other, e)
+            })
         }
         
         fn stop(&self, ctx: ServiceStopCtx) -> io::Result<()> {
-            let service = self
-                .service_manager
-                .open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS)
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            let service = self.service_manager.open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS).map_err(|e|{
+                io::Error::new(io::ErrorKind::Other, e)
+            })?;
     
-            _ = service
-                .stop()
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            _ = service.stop().map_err(|e|{
+                io::Error::new(io::ErrorKind::Other, e)
+            })?;
     
             Ok(())
         }
@@ -1152,18 +959,12 @@ mod win_service_manager {
         fn set_level(&mut self, level: ServiceLevel) -> io::Result<()> {
             match level {
                 ServiceLevel::System => Ok(()),
-                _ => Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "Unsupported service level",
-                )),
+                _ => Err(io::Error::new(io::ErrorKind::Other, "Unsupported service level"))            
             }
         }
         
         fn status(&self, ctx: ServiceStatusCtx) -> io::Result<ServiceStatus> {
-            let service = match self
-                .service_manager
-                .open_service(ctx.label.to_qualified_name(), ServiceAccess::QUERY_STATUS)
-            {
+            let service = match self.service_manager.open_service(ctx.label.to_qualified_name(), ServiceAccess::QUERY_STATUS) {
                 Ok(s) => s,
                 Err(e) => {
                     if let windows_service::Error::Winapi(ref win_err) = e {
@@ -1175,9 +976,9 @@ mod win_service_manager {
                 }
             };
     
-            let status = service
-                .query_status()
-                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            let status = service.query_status().map_err(|e|{
+                io::Error::new(io::ErrorKind::Other, e)
+            })?;
     
             match status.current_state {
                 windows_service::service::ServiceState::Stopped => Ok(ServiceStatus::Stopped(None)),
@@ -1185,12 +986,4 @@ mod win_service_manager {
             }
         }
     }
-
-    fn set_service_work_directory(service_name: &str, work_directory: PathBuf) -> io::Result<()> {
-        let (reg_key, _) =
-            RegKey::predef(HKEY_LOCAL_MACHINE).create_subkey(WIN_SERVICE_WORK_DIR_REG_KEY)?;
-        reg_key
-            .set_value::<OsString, _>(service_name, &work_directory.as_os_str().to_os_string())?;
-        Ok(())
-    }
 }

easytier/src/easytier-core.rs

@@ -289,6 +289,12 @@ struct Cli {
         help = t!("core_clap.ipv6_listener").to_string()
     )]
     ipv6_listener: Option<String>,
+
+    #[arg(
+        long,
+        help = t!("core_clap.work_dir").to_string()
+    )]
+    work_dir: Option<String>,
 }
 
 rust_i18n::i18n!("locales", fallback = "en");
@@ -357,7 +363,7 @@ impl Cli {
                 }
                 return Ok("0.0.0.0:0".parse().unwrap());
             }
-            return Ok(format!("0.0.0.0:{}", port).parse().unwrap());
+            return Ok("0.0.0.0:0".parse().unwrap());
         }
 
         Ok(rpc_portal.parse()?)
@@ -374,32 +380,28 @@ impl TryFrom<&Cli> for TomlConfigLoader {
                 config_file
             );
             return Ok(TomlConfigLoader::new(config_file)
-                .with_context(|| format!("failed to load config file: {:?}", cli.config_file))?);
+                .with_context(|| format!("failed to load config file: {:?}", cli.config_file))?)
         }
 
         let cfg = TomlConfigLoader::default();
 
         cfg.set_hostname(cli.hostname.clone());
 
-        cfg.set_network_identity(NetworkIdentity::new(
-            cli.network_name.clone(),
-            cli.network_secret.clone(),
-        ));
+        cfg.set_network_identity(NetworkIdentity::new(cli.network_name.clone(), cli.network_secret.clone()));
 
         cfg.set_dhcp(cli.dhcp);
 
         if let Some(ipv4) = &cli.ipv4 {
-            cfg.set_ipv4(Some(ipv4.parse().with_context(|| {
-                format!("failed to parse ipv4 address: {}", ipv4)
-            })?))
+            cfg.set_ipv4(Some(
+                ipv4.parse()
+                    .with_context(|| format!("failed to parse ipv4 address: {}", ipv4))?
+            ))
         }
 
         let mut peers = Vec::<PeerConfig>::with_capacity(cli.peers.len());
         for p in &cli.peers {
             peers.push(PeerConfig {
-                uri: p
-                    .parse()
-                    .with_context(|| format!("failed to parse peer uri: {}", p))?,
+                uri: p.parse().with_context(|| format!("failed to parse peer uri: {}", p))?,
             });
         }
         cfg.set_peers(peers);
@@ -414,21 +416,22 @@ impl TryFrom<&Cli> for TomlConfigLoader {
         for n in cli.proxy_networks.iter() {
             cfg.add_proxy_cidr(
                 n.parse()
-                    .with_context(|| format!("failed to parse proxy network: {}", n))?,
+                    .with_context(|| format!("failed to parse proxy network: {}", n))?
             );
         }
 
-        cfg.set_rpc_portal(
-            Cli::parse_rpc_portal(cli.rpc_portal.clone())
-                .with_context(|| format!("failed to parse rpc portal: {}", cli.rpc_portal))?,
-        );
+        cfg.set_rpc_portal(Cli::parse_rpc_portal(cli.rpc_portal.clone()).with_context(|| {
+            format!("failed to parse rpc portal: {}", cli.rpc_portal)
+        })?);
 
         if let Some(external_nodes) = cli.external_node.as_ref() {
             let mut old_peers = cfg.get_peers();
             old_peers.push(PeerConfig {
-                uri: external_nodes.parse().with_context(|| {
-                    format!("failed to parse external node uri: {}", external_nodes)
-                })?,
+                uri: external_nodes
+                    .parse()
+                    .with_context(|| {
+                        format!("failed to parse external node uri: {}", external_nodes)
+                    })?
             });
             cfg.set_peers(old_peers);
         }
@@ -453,15 +456,11 @@ impl TryFrom<&Cli> for TomlConfigLoader {
             let url: url::Url = vpn_portal
                 .parse()
                 .with_context(|| format!("failed to parse vpn portal url: {}", vpn_portal))?;
-            let host = url
-                .host_str()
-                .ok_or_else(|| anyhow::anyhow!("vpn portal url missing host"))?;
-            let port = url
-                .port()
-                .ok_or_else(|| anyhow::anyhow!("vpn portal url missing port"))?;
-            let client_cidr = url.path()[1..].parse().with_context(|| {
-                format!("failed to parse vpn portal client cidr: {}", url.path())
-            })?;
+            let host = url.host_str().ok_or_else(|| anyhow::anyhow!("vpn portal url missing host"))?;
+            let port = url.port().ok_or_else(|| anyhow::anyhow!("vpn portal url missing port"))?;
+            let client_cidr = url.path()[1..]
+                .parse()
+                .with_context(|| format!("failed to parse vpn portal client cidr: {}", url.path()))?;
             let wireguard_listen: SocketAddr = format!("{}:{}", host, port).parse().unwrap();
             cfg.set_vpn_portal_config(VpnPortalConfig {
                 wireguard_listen,
@@ -471,11 +470,8 @@ impl TryFrom<&Cli> for TomlConfigLoader {
 
         if let Some(manual_routes) = cli.manual_routes.as_ref() {
             let mut routes = Vec::<cidr::Ipv4Cidr>::with_capacity(manual_routes.len());
-            for r in manual_routes {
-                routes.push(
-                    r.parse()
-                        .with_context(|| format!("failed to parse route: {}", r))?,
-                );
+            for r in manual_routes{
+                routes.push(r.parse().with_context(|| format!("failed to parse route: {}", r))?);
             }
             cfg.set_routes(Some(routes));
         }
@@ -644,30 +640,14 @@ pub fn handle_event(mut events: EventBusSubscriber) -> tokio::task::JoinHandle<(
     })
 }
 
-#[cfg(target_os = "windows")]
-fn win_service_set_work_dir(service_name: &std::ffi::OsString) -> anyhow::Result<()> {
-    use easytier::common::constants::WIN_SERVICE_WORK_DIR_REG_KEY;
-    use winreg::enums::*;
-    use winreg::RegKey;
-
-    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
-    let key = hklm.open_subkey_with_flags(WIN_SERVICE_WORK_DIR_REG_KEY, KEY_READ)?;
-    let dir_pat_str = key.get_value::<std::ffi::OsString, _>(service_name)?;
-    let dir_path = std::fs::canonicalize(dir_pat_str)?;
-
-    std::env::set_current_dir(dir_path)?;
-
-    Ok(())
-}
-
 #[cfg(target_os = "windows")]
 fn win_service_event_loop(
     stop_notify: std::sync::Arc<tokio::sync::Notify>,
     cli: Cli,
     status_handle: windows_service::service_control_handler::ServiceStatusHandle,  
 ) {  
-    use std::time::Duration;
     use tokio::runtime::Runtime;
+    use std::time::Duration;
     use windows_service::service::*;
 
     let normal_status = ServiceStatus {
@@ -689,6 +669,12 @@ fn win_service_event_loop(
         process_id: None,
     };
 
+    if cli.work_dir == None {
+        let mut path = std::env::current_exe().unwrap();
+        path.pop();
+        std::env::set_current_dir(path).unwrap();
+    }
+
     std::thread::spawn(move || {
         let rt = Runtime::new().unwrap();
         rt.block_on(async move {
@@ -715,15 +701,13 @@ fn win_service_event_loop(
 }
 
 #[cfg(target_os = "windows")]
-fn win_service_main(arg: Vec<std::ffi::OsString>) {
+fn win_service_main(_: Vec<std::ffi::OsString>) {
     use std::sync::Arc;
     use std::time::Duration;
     use tokio::sync::Notify;
     use windows_service::service::*;
     use windows_service::service_control_handler::*;
 
-    _ = win_service_set_work_dir(&arg[0]);
-
     let cli = Cli::parse();
 
     let stop_notify_send = Arc::new(Notify::new());
@@ -748,16 +732,15 @@ fn win_service_main(arg: Vec<std::ffi::OsString>) {
         wait_hint: Duration::default(),
         process_id: None,
     }; 
-    status_handle
-        .set_service_status(next_status)
-        .expect("set service status fail");
+    status_handle.set_service_status(next_status).expect("set service status fail");
 
     win_service_event_loop(stop_notify_recv, cli, status_handle);
 }
 
 async fn run_main(cli: Cli) -> anyhow::Result<()> {
-    let cfg = TomlConfigLoader::try_from(&cli)?;
-    init_logger(&cfg, false)?;
+    if let Some(dir) = cli.work_dir.as_ref() {
+        std::env::set_current_dir(dir).map_err(|e| anyhow::anyhow!("failed to set work dir: {}", e))?;
+    }
 
     if cli.config_server.is_some() {
         let config_server_url_s = cli.config_server.clone().unwrap();
@@ -793,6 +776,9 @@ async fn run_main(cli: Cli) -> anyhow::Result<()> {
         return Ok(());
     }
 
+    let cfg = TomlConfigLoader::try_from(&cli)?;
+    init_logger(&cfg, false)?;
+
     println!("Starting easytier with config:");
     println!("############### TOML ###############\n");
     println!("{}", cfg.dump());
@@ -800,8 +786,8 @@ async fn run_main(cli: Cli) -> anyhow::Result<()> {
 
     let mut l = launcher::NetworkInstance::new(cfg).set_fetch_node_info(false);
     let _t = ScopedTask::from(handle_event(l.start().unwrap()));
-    if let Some(e) = l.wait().await {
-        anyhow::bail!("launcher error: {}", e);
+    if let Some(e) = l.wait().await{
+        return Err(anyhow::anyhow!("launcher error: {}", e));
     }
     Ok(())
 }
@@ -815,18 +801,17 @@ async fn main() {
     #[cfg(target_os = "windows")]
     match windows_service::service_dispatcher::start(String::new(), ffi_service_main) {
         Ok(_) => std::thread::park(),
-        Err(e) => {
-            let should_panic = if let windows_service::Error::Winapi(ref io_error) = e {
-                io_error.raw_os_error() != Some(0x427) // ERROR_FAILED_SERVICE_CONTROLLER_CONNECT
-            } else {
-                true
-            };
+        Err(e) =>
+        {    
+             let should_panic = if let windows_service::Error::Winapi(ref io_error) = e { 
+                 io_error.raw_os_error() != Some(0x427) // ERROR_FAILED_SERVICE_CONTROLLER_CONNECT
+             } else { true };
              
-            if should_panic {
-                panic!("SCM start an error: {}", e);
-            }
-        }
-    };
+             if should_panic {
+                 panic!("SCM start an error: {}", e);
+             }
+         }
+     };
      
     let cli = Cli::parse();