feat(macos): improve bundled app integration

This commit is contained in:
Kevin Yue committed 2026-07-19 22:26:19 +08:00
1 parent 822d10528f
commit bd064713a8
8 files changed
+182 -29

No files matched your search

+1
View File
@@ -415,6 +415,7 @@ jobs:
brew install \ brew install \
autoconf \ autoconf \
automake \ automake \
create-dmg \
dylibbundler \ dylibbundler \
gettext \ gettext \
gmp \ gmp \
Generated
+10 -1
View File
@@ -1852,6 +1852,7 @@ dependencies = [
"netdev", "netdev",
"openssl", "openssl",
"os_info", "os_info",
"oslog",
"pem", "pem",
"proptest", "proptest",
"redact-engine", "redact-engine",
@@ -1886,7 +1887,6 @@ dependencies = [
"clap", "clap",
"common", "common",
"compile-time", "compile-time",
"env_logger",
"gpapi", "gpapi",
"home", "home",
"log", "log",
@@ -3368,6 +3368,15 @@ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
[[package]]
name = "oslog"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "80d2043d1f61d77cb2f4b1f7b7b2295f40507f5f8e9d1c8bf10a1ca5f97a3969"
dependencies = [
"cc",
]
[[package]] [[package]]
name = "pango" name = "pango"
version = "0.18.3" version = "0.18.3"
+1 -2
View File
@@ -11,14 +11,13 @@ tauri-build = { version = "2", features = [], optional = true }
[dependencies] [dependencies]
common = { path = "../../crates/common" } common = { path = "../../crates/common" }
gpapi = { path = "../../crates/gpapi", features = ["clap"] } gpapi = { path = "../../crates/gpapi", features = ["clap", "logger"] }
auth = { path = "../../crates/auth", features = ["browser-auth"] } auth = { path = "../../crates/auth", features = ["browser-auth"] }
# Shared dependencies # Shared dependencies
anyhow.workspace = true anyhow.workspace = true
clap.workspace = true clap.workspace = true
env_logger.workspace = true
log.workspace = true log.workspace = true
serde_json.workspace = true serde_json.workspace = true
tokio = { workspace = true, features = ["rt-multi-thread"] } tokio = { workspace = true, features = ["rt-multi-thread"] }
+5 -3
View File
@@ -206,9 +206,11 @@ impl Cli {
} }
fn init_logger(cli: &Cli) { fn init_logger(cli: &Cli) {
env_logger::builder() if let Some(level) = cli.verbose.log_level_filter().to_level() {
.filter_level(cli.verbose.log_level_filter()) gpapi::logger::init(level, "com.yuezk.gpgui", "gpauth");
.init(); } else {
log::set_max_level(log::LevelFilter::Off);
}
} }
pub async fn run() { pub async fn run() {
+49 -6
View File
@@ -18,6 +18,8 @@ use gpapi::{
service::{request::WsRequest, vpn_state::VpnState}, service::{request::WsRequest, vpn_state::VpnState},
utils::{env_utils, lock_file::LockFile, redact::Redaction, shutdown_signal}, utils::{env_utils, lock_file::LockFile, redact::Redaction, shutdown_signal},
}; };
#[cfg(target_os = "macos")]
use log::{Log, Metadata, Record};
use log::{info, warn}; use log::{info, warn};
use tokio::sync::{mpsc, watch}; use tokio::sync::{mpsc, watch};
use uuid::Uuid; use uuid::Uuid;
@@ -35,6 +37,28 @@ const VERSION: &str = concat!(
")" ")"
); );
#[cfg(target_os = "macos")]
struct RedactingMacosLogger {
logger: logger::MacosLogger,
redaction: Arc<Redaction>,
}
#[cfg(target_os = "macos")]
impl Log for RedactingMacosLogger {
fn enabled(&self, metadata: &Metadata<'_>) -> bool {
self.logger.enabled(metadata)
}
fn log(&self, record: &Record<'_>) {
if self.enabled(record.metadata()) {
let message = self.redaction.redact_str(&record.args().to_string());
self.logger.write(record.level(), record.target(), &message);
}
}
fn flush(&self) {}
}
#[derive(Parser)] #[derive(Parser)]
#[command(version = VERSION)] #[command(version = VERSION)]
struct Cli { struct Cli {
@@ -77,15 +101,22 @@ impl Cli {
let gui_restart_requested = Arc::new(AtomicBool::new(false)); let gui_restart_requested = Arc::new(AtomicBool::new(false));
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let externally_brokered = self.externally_brokered(); let externally_brokered = self.externally_brokered();
let brokered_helpers_dir = externally_brokered let brokered_scripts_dir = if externally_brokered {
.then(|| std::env::current_exe().ok()?.parent().map(ToOwned::to_owned)) let executable = std::env::current_exe().context("Failed to locate the gpservice executable")?;
.flatten(); let contents_dir = executable
.parent()
.and_then(std::path::Path::parent)
.context("gpservice is not inside a macOS application bundle")?;
Some(contents_dir.join("Resources/Scripts"))
} else {
None
};
let dispatcher = Arc::new(RequestDispatcher::new( let dispatcher = Arc::new(RequestDispatcher::new(
ws_req_tx.clone(), ws_req_tx.clone(),
Arc::clone(&gui_restart_requested), Arc::clone(&gui_restart_requested),
Arc::clone(&redaction), Arc::clone(&redaction),
!externally_brokered, !externally_brokered,
brokered_helpers_dir, brokered_scripts_dir,
)); ));
let mut vpn_task = VpnTask::new(ws_req_rx, vpn_state_tx, externally_brokered); let mut vpn_task = VpnTask::new(ws_req_rx, vpn_state_tx, externally_brokered);
@@ -201,6 +232,20 @@ impl Cli {
fn init_logger(&self) -> Arc<Redaction> { fn init_logger(&self) -> Arc<Redaction> {
let redaction = Arc::new(Redaction::new()); let redaction = Arc::new(Redaction::new());
let level = self.verbose.log_level_filter().to_level().unwrap_or(log::Level::Info);
#[cfg(target_os = "macos")]
if logger::macos_unified_log_enabled() {
logger::init_with_logger(
level,
RedactingMacosLogger {
logger: logger::MacosLogger::new("com.yuezk.gpgui", "gpservice"),
redaction: Arc::clone(&redaction),
},
);
return redaction;
}
let redaction_clone = Arc::clone(&redaction); let redaction_clone = Arc::clone(&redaction);
let inner_logger = env_logger::builder() let inner_logger = env_logger::builder()
@@ -219,8 +264,6 @@ impl Cli {
}) })
.build(); .build();
let level = self.verbose.log_level_filter().to_level().unwrap_or(log::Level::Info);
logger::init_with_logger(level, inner_logger); logger::init_with_logger(level, inner_logger);
redaction redaction
+35 -9
View File
@@ -30,7 +30,7 @@ pub struct RequestDispatcher {
redaction: Arc<Redaction>, redaction: Arc<Redaction>,
install_lock: Mutex<()>, install_lock: Mutex<()>,
gui_management_enabled: bool, gui_management_enabled: bool,
brokered_helpers_dir: Option<std::path::PathBuf>, brokered_scripts_dir: Option<std::path::PathBuf>,
} }
impl RequestDispatcher { impl RequestDispatcher {
@@ -39,7 +39,7 @@ impl RequestDispatcher {
gui_restart_requested: Arc<AtomicBool>, gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>, redaction: Arc<Redaction>,
gui_management_enabled: bool, gui_management_enabled: bool,
brokered_helpers_dir: Option<std::path::PathBuf>, brokered_scripts_dir: Option<std::path::PathBuf>,
) -> Self { ) -> Self {
Self { Self {
ws_req_tx, ws_req_tx,
@@ -47,7 +47,7 @@ impl RequestDispatcher {
redaction, redaction,
install_lock: Mutex::new(()), install_lock: Mutex::new(()),
gui_management_enabled, gui_management_enabled,
brokered_helpers_dir, brokered_scripts_dir,
} }
} }
@@ -97,11 +97,11 @@ impl RequestDispatcher {
} }
fn validate_connect_paths(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> { fn validate_connect_paths(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
let Some(helpers) = &self.brokered_helpers_dir else { let Some(scripts) = &self.brokered_scripts_dir else {
return Ok(()); return Ok(());
}; };
let expected_script = helpers.join("vpnc-script").to_string_lossy().into_owned(); let expected_script = scripts.join("vpnc-script").to_string_lossy().into_owned();
let expected_wrapper = helpers.join("hipreport.sh").to_string_lossy().into_owned(); let expected_wrapper = scripts.join("hipreport.sh").to_string_lossy().into_owned();
if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) { if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) {
return Err("macOS VPN script must be the bundled script"); return Err("macOS VPN script must be the bundled script");
} }
@@ -329,7 +329,7 @@ mod tests {
Arc::new(AtomicBool::new(false)), Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()), Arc::new(Redaction::new()),
false, false,
Some(std::path::PathBuf::from("/app/Contents/Helpers")), Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")),
); );
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::RestartGui).await else { let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::RestartGui).await else {
panic!("brokered mode accepted GUI restart"); panic!("brokered mode accepted GUI restart");
@@ -339,12 +339,38 @@ mod tests {
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into()); let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]); let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let request = ConnectRequest::new(info, "cookie".into()) let request = ConnectRequest::new(info, "cookie".into())
.with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string())) .with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Helpers/hipreport.sh".to_string())) .with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string()))
.with_certificate(Some("/Users/example/client.pem".to_string())); .with_certificate(Some("/Users/example/client.pem".to_string()));
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else { let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else {
panic!("brokered mode accepted a root-readable identity path"); panic!("brokered mode accepted a root-readable identity path");
}; };
assert_eq!(rejection.code(), ServiceErrorCode::InvalidRequest); assert_eq!(rejection.code(), ServiceErrorCode::InvalidRequest);
} }
#[test]
fn brokered_mode_accepts_only_resource_script_paths() {
let (request_tx, _request_rx) = mpsc::channel(1);
let dispatcher = RequestDispatcher::new(
request_tx,
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
false,
Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")),
);
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let bundled = ConnectRequest::new(info.clone(), "cookie".into())
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string()));
assert_eq!(dispatcher.validate_connect_paths(&bundled), Ok(()));
let old_layout = ConnectRequest::new(info, "cookie".into())
.with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Helpers/hipreport.sh".to_string()));
assert_eq!(
dispatcher.validate_connect_paths(&old_layout),
Err("macOS VPN script must be the bundled script")
);
}
} }
+4 -1
View File
@@ -49,6 +49,9 @@ clap-verbosity-flag = { workspace = true, optional = true }
env_logger = { workspace = true, optional = true } env_logger = { workspace = true, optional = true }
log-reload = { version = "0.1", optional = true } log-reload = { version = "0.1", optional = true }
[target.'cfg(target_os="macos")'.dependencies]
oslog = { version = "0.2", default-features = false, optional = true }
# Dependencies for Linux and other OSes only # Dependencies for Linux and other OSes only
[target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies] [target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies]
gtk = { version = "0.18", optional = true } gtk = { version = "0.18", optional = true }
@@ -60,4 +63,4 @@ proptest.workspace = true
tauri = ["dep:tauri", "dep:gtk"] tauri = ["dep:tauri", "dep:gtk"]
clap = ["dep:clap", "dep:clap-verbosity-flag"] clap = ["dep:clap", "dep:clap-verbosity-flag"]
webview-auth = [] webview-auth = []
logger = ["dep:env_logger", "dep:log-reload"] logger = ["dep:env_logger", "dep:log-reload", "dep:oslog"]
+77 -7
View File
@@ -1,21 +1,33 @@
use std::sync::OnceLock; use std::sync::OnceLock;
use anyhow::bail; use anyhow::bail;
use env_logger::Logger; use log::{Level, Log, warn};
use log::{Level, warn};
use log_reload::{ReloadHandle, ReloadLog}; use log_reload::{ReloadHandle, ReloadLog};
static LOG_HANDLE: OnceLock<ReloadHandle<log_reload::LevelFilter<Logger>>> = OnceLock::new(); pub const LOG_BACKEND_ENV: &str = "GP_LOG_BACKEND";
pub const MACOS_UNIFIED_LOG_BACKEND: &str = "macos-unified";
type BoxedLogger = Box<dyn Log + Send + Sync>;
static LOG_HANDLE: OnceLock<ReloadHandle<log_reload::LevelFilter<BoxedLogger>>> = OnceLock::new();
pub fn init(level: Level, subsystem: &str, category: &str) {
#[cfg(target_os = "macos")]
if macos_unified_log_enabled() {
init_with_logger(level, MacosLogger::new(subsystem, category));
return;
}
#[cfg(not(target_os = "macos"))]
let _ = (subsystem, category);
pub fn init(level: Level) {
// Initialize the env_logger and global max level to trace, the logs will be // Initialize the env_logger and global max level to trace, the logs will be
// filtered by the outer logger // filtered by the outer logger
let logger = env_logger::builder().filter_level(log::LevelFilter::Trace).build(); let logger = env_logger::builder().filter_level(log::LevelFilter::Trace).build();
init_with_logger(level, logger); init_with_logger(level, logger);
} }
pub fn init_with_logger(level: Level, logger: Logger) { pub fn init_with_logger(level: Level, logger: impl Log + Send + Sync + 'static) {
if let Some(_) = LOG_HANDLE.get() { if LOG_HANDLE.get().is_some() {
warn!("Logger already initialized"); warn!("Logger already initialized");
return; return;
} }
@@ -23,7 +35,7 @@ pub fn init_with_logger(level: Level, logger: Logger) {
log::set_max_level(log::LevelFilter::Trace); log::set_max_level(log::LevelFilter::Trace);
// Create a new logger that will filter the logs based on the max level // Create a new logger that will filter the logs based on the max level
let level_filter_logger = log_reload::LevelFilter::new(level, logger); let level_filter_logger = log_reload::LevelFilter::new(level, Box::new(logger) as BoxedLogger);
let reload_log = ReloadLog::new(level_filter_logger); let reload_log = ReloadLog::new(level_filter_logger);
let handle = reload_log.handle(); let handle = reload_log.handle();
@@ -42,3 +54,61 @@ pub fn set_max_level(level: Level) -> anyhow::Result<()> {
.modify(|logger| logger.set_level(level)) .modify(|logger| logger.set_level(level))
.map_err(|e| anyhow::anyhow!(e)) .map_err(|e| anyhow::anyhow!(e))
} }
pub fn macos_unified_log_enabled() -> bool {
cfg!(target_os = "macos") && std::env::var(LOG_BACKEND_ENV).as_deref() == Ok(MACOS_UNIFIED_LOG_BACKEND)
}
#[cfg(target_os = "macos")]
pub struct MacosLogger {
inner: oslog::OsLog,
}
#[cfg(target_os = "macos")]
impl MacosLogger {
pub fn new(subsystem: &str, category: &str) -> Self {
Self {
inner: oslog::OsLog::new(subsystem, category),
}
}
pub fn write(&self, level: Level, target: &str, message: &str) {
self
.inner
.with_level(macos_log_level(level), &format!("[{target}] {message}"));
}
}
#[cfg(target_os = "macos")]
impl Log for MacosLogger {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
self.inner.level_is_enabled(macos_log_level(metadata.level()))
}
fn log(&self, record: &log::Record<'_>) {
if self.enabled(record.metadata()) {
self.write(record.level(), record.target(), &record.args().to_string());
}
}
fn flush(&self) {}
}
#[cfg(target_os = "macos")]
fn macos_log_level(level: Level) -> oslog::Level {
match level {
Level::Trace | Level::Debug => oslog::Level::Debug,
Level::Info => oslog::Level::Default,
Level::Warn | Level::Error => oslog::Level::Error,
}
}
#[cfg(all(test, target_os = "macos"))]
mod tests {
use super::*;
#[test]
fn info_logs_use_the_persistent_macos_level() {
assert_eq!(macos_log_level(Level::Info) as u8, oslog::Level::Default as u8);
}
}