Merge branch 'main' into feat/auth-callback-handler

# Conflicts:
#	apps/gpauth/src/cli.rs
#	apps/gpclient/src/cli.rs
#	apps/gpclient/src/connect/credential.rs
#	apps/gpclient/src/connect/gateway.rs
#	crates/gpapi/src/process/auth_launcher.rs
This commit is contained in:
Kevin Yue committed 2026-08-21 01:36:08 +08:00
commit dbab0150fe
14 files changed
+792 -93

No files matched your search

+132 -3
View File
@@ -7,6 +7,7 @@ use anyhow::bail;
use clap::{Parser, Subcommand};
use gpapi::{
clap::{Args, InfoLevelVerbosity, handle_error},
log_format::{LogFormat, write_json_record},
utils::openssl,
};
use log::info;
@@ -36,6 +37,7 @@ pub(crate) struct SharedArgs<'a> {
pub(crate) ignore_tls_errors: bool,
pub(crate) lock_file: &'a Path,
pub(crate) verbose: &'a InfoLevelVerbosity,
pub(crate) log_format: LogFormat,
}
#[derive(Subcommand)]
@@ -87,6 +89,14 @@ struct Cli {
)]
lock_file: PathBuf,
#[arg(
long,
value_enum,
default_value_t = LogFormat::Text,
help = "Log output format. JSON is intended for non-interactive consumers; interactive prompts remain text."
)]
log_format: LogFormat,
#[command(flatten)]
verbose: InfoLevelVerbosity,
}
@@ -99,6 +109,10 @@ impl Args for Cli {
fn ignore_tls_errors(&self) -> bool {
self.ignore_tls_errors
}
fn log_format(&self) -> LogFormat {
self.log_format
}
}
impl Cli {
@@ -152,6 +166,7 @@ impl Cli {
ignore_tls_errors: self.ignore_tls_errors,
lock_file: &self.lock_file,
verbose: &self.verbose,
log_format: self.log_format,
};
if self.ignore_tls_errors {
@@ -167,17 +182,23 @@ impl Cli {
}
}
fn init_logger(cli: &Cli) {
fn build_logger(cli: &Cli) -> env_logger::Builder {
let mut builder = env_logger::builder();
builder.filter_level(cli.verbose.log_level_filter());
builder.init();
// Text is env_logger's own format, so leave it untouched rather than
// reimplementing it.
if cli.log_format == LogFormat::Json {
builder.format(write_json_record);
}
builder
}
pub(crate) async fn run() {
let cli = Cli::parse();
init_logger(&cli);
build_logger(&cli).init();
info!("gpclient started: {}", VERSION);
@@ -189,6 +210,13 @@ pub(crate) async fn run() {
#[cfg(test)]
mod tests {
use std::{
io::Write,
sync::{Arc, Mutex},
};
use log::Log;
use super::*;
#[test]
@@ -240,4 +268,105 @@ mod tests {
fn launch_gui_rejects_non_callback_positional() {
assert!(Cli::try_parse_from(["gpclient", "launch-gui", "https://example.com/callback"]).is_err());
}
fn parse_cli(args: &[&str]) -> Cli {
Cli::try_parse_from(args).expect("arguments should parse")
}
/// Text stays the default: a plain `gpclient connect` must keep the output it
/// has always had, or every existing user's terminal changes under them.
#[test]
fn log_format_defaults_to_text() {
assert_eq!(parse_cli(&["gpclient", "disconnect"]).log_format, LogFormat::Text);
}
#[test]
fn log_format_accepts_json() {
assert_eq!(
parse_cli(&["gpclient", "--log-format", "json", "disconnect"]).log_format,
LogFormat::Json
);
}
/// An unknown value is a mistake worth reporting rather than silently
/// falling back to text, which would leave a caller parsing prose.
#[test]
fn log_format_rejects_an_unknown_value() {
// `.err()` rather than `unwrap_err()`: the Ok side is `Cli`, which is not
// `Debug`, and it is not worth deriving it just to print an error we expect.
let err = Cli::try_parse_from(["gpclient", "--log-format", "yaml", "disconnect"])
.err()
.expect("an unknown log format should be rejected");
let msg = err.to_string();
assert!(msg.contains("yaml"), "error should name the input: {msg}");
assert!(msg.contains("json"), "error should list the valid values: {msg}");
}
/// A `Write` that keeps what was written, so the logger can be driven for
/// real instead of asserting on how it was configured.
#[derive(Clone, Default)]
struct Captured(Arc<Mutex<Vec<u8>>>);
impl Captured {
fn contents(&self) -> String {
String::from_utf8(self.0.lock().unwrap().clone()).expect("log output should be UTF-8")
}
}
impl Write for Captured {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.0.lock().unwrap().extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
fn log_one_record(args: &[&str]) -> String {
let captured = Captured::default();
let logger = build_logger(&parse_cli(args))
.target(env_logger::Target::Pipe(Box::new(captured.clone())))
.build();
// Drive the logger directly: `init()` installs a global that a second test
// could not replace.
logger.log(
&log::Record::builder()
.level(log::Level::Info)
.target("gpclient")
.args(format_args!("connected to {}", "vpn.example.com"))
.build(),
);
logger.flush();
captured.contents()
}
/// The point of the flag: with `json`, a caller gets fields, and gets them one
/// record per line so the stream can be read incrementally.
#[test]
fn json_format_emits_one_json_object_per_record() {
let out = log_one_record(&["gpclient", "--log-format", "json", "disconnect"]);
let lines: Vec<_> = out.lines().collect();
assert_eq!(lines.len(), 1, "expected exactly one line, got: {out:?}");
let v: serde_json::Value = serde_json::from_str(lines[0]).unwrap_or_else(|e| panic!("not JSON: {out:?} ({e})"));
assert_eq!(v["level"], "INFO");
assert_eq!(v["target"], "gpclient");
assert_eq!(v["message"], "connected to vpn.example.com");
}
#[test]
fn text_format_is_left_alone() {
let out = log_one_record(&["gpclient", "disconnect"]);
assert!(out.contains("connected to vpn.example.com"), "message missing: {out:?}");
assert!(
serde_json::from_str::<serde_json::Value>(out.trim()).is_err(),
"text output should not be JSON: {out:?}"
);
}
}
+1
View File
@@ -86,6 +86,7 @@ impl ConnectHandler<'_> {
.key_password(key_password.as_deref())
.browser(browser)
.browser_listen(self.args.browser_listen)
.log_format(self.shared_args.log_format)
.verbose(verbose);
#[cfg(feature = "webview-auth")]
+20 -6
View File
@@ -8,6 +8,7 @@ use std::{
};
use gpapi::{
clap::report,
cookie_store,
credential::{AuthCookieCredential, Credential},
gateway::{GatewayLogin, GatewayLoginContext, SessionExtensionAuth, gateway_login, gateway_login_with_context},
@@ -18,7 +19,7 @@ use gpapi::{
utils::shutdown_signal,
};
use inquire::Text;
use log::{info, warn};
use log::{Level, info, warn};
use openconnect::{Vpn, VpnBuilder};
use tokio::{runtime::Handle, task::JoinHandle};
@@ -281,9 +282,22 @@ impl ConnectHandler<'_> {
return;
}
eprintln!("\nNOTE: Gateway authentication failed after portal login.");
eprintln!("NOTE: If this server also accepts direct gateway login, try:");
eprintln!("NOTE: {}", direct_gateway_command(gateway));
let format = self.shared_args.log_format;
report(
format,
Level::Warn,
"\nNOTE: Gateway authentication failed after portal login.",
);
report(
format,
Level::Warn,
"NOTE: If this server also accepts direct gateway login, try:",
);
report(
format,
Level::Warn,
&format!("NOTE: {}", direct_gateway_command(gateway)),
);
}
async fn login_gateway(
@@ -386,7 +400,7 @@ impl ConnectHandler<'_> {
let lock_file = self.shared_args.lock_file.to_path_buf();
let lock_file_on_connect = lock_file.clone();
let log_format = self.shared_args.log_format;
let connect_result = vpn.connect(move |vpn_session_info| {
tunnel_established_on_connect.store(true, Ordering::SeqCst);
write_pid_file(&lock_file_on_connect);
@@ -397,7 +411,7 @@ impl ConnectHandler<'_> {
let session_info = session_info_from_vpn(vpn_session_info, allow_extend_session);
info!("VPN session info: {}", session_info.log_summary());
let task = spawn_session_runtime_with_info(&runtime_handle, session_ctx, session_info);
let task = spawn_session_runtime_with_info(&runtime_handle, session_ctx, session_info, log_format);
session_task_on_connect.lock().unwrap().replace(task);
});
let tunnel_established = tunnel_established.load(Ordering::SeqCst);
+24 -5
View File
@@ -6,6 +6,7 @@ use std::cell::RefCell;
use anyhow::bail;
use gpapi::{
clap::report,
error::PortalError,
gateway::{GatewayLoginContext, GatewaySelection},
gp_params::GpParams,
@@ -14,7 +15,7 @@ use gpapi::{
utils::request::RequestIdentityError,
};
use inquire::{Password, PasswordDisplayMode, Select};
use log::{info, warn};
use log::{Level, info, warn};
use crate::cli::SharedArgs;
@@ -116,8 +117,17 @@ impl<'a> ConnectHandler<'a> {
match root_cause {
RequestIdentityError::NoKey => {
eprintln!("ERROR: No private key found in the certificate file");
eprintln!("ERROR: Please provide the private key file using the `-k` option");
let format = self.shared_args.log_format;
report(
format,
Level::Error,
"ERROR: No private key found in the certificate file",
);
report(
format,
Level::Error,
"ERROR: Please provide the private key file using the `-k` option",
);
return Ok(());
}
RequestIdentityError::NoPassphrase(cert_type) | RequestIdentityError::DecryptError(cert_type) => {
@@ -159,8 +169,17 @@ impl<'a> ConnectHandler<'a> {
info!("Trying the gateway authentication workflow...");
self.connect_gateway_with_prelogin(server, server, false, None).await?;
eprintln!("\nNOTE: the server may be a gateway, not a portal.");
eprintln!("NOTE: try to use the `--as-gateway` option if you were authenticated twice.");
let format = self.shared_args.log_format;
report(
format,
Level::Warn,
"\nNOTE: the server may be a gateway, not a portal.",
);
report(
format,
Level::Warn,
"NOTE: try to use the `--as-gateway` option if you were authenticated twice.",
);
Ok(())
} else {
+13 -6
View File
@@ -1,11 +1,13 @@
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use gpapi::{
clap::report,
gateway::{SessionContext, SessionExtensionAuth, extend_session},
log_format::LogFormat,
os_profile::OsProfile,
session::{SessionInfo, SessionRequestArgs, SessionWarning},
};
use log::{info, warn};
use log::{Level, info, warn};
use openconnect::VpnSessionInfo;
use tokio::{runtime::Handle, task::JoinHandle};
@@ -59,11 +61,12 @@ pub(crate) fn spawn_session_runtime_with_info(
handle: &Handle,
session_ctx: SessionContext,
session_info: SessionInfo,
log_format: LogFormat,
) -> JoinHandle<()> {
handle.spawn(run_session_runtime(session_ctx, session_info))
handle.spawn(run_session_runtime(session_ctx, session_info, log_format))
}
async fn run_session_runtime(session_ctx: SessionContext, mut session_info: SessionInfo) {
async fn run_session_runtime(session_ctx: SessionContext, mut session_info: SessionInfo, log_format: LogFormat) {
loop {
let Some(schedule) = build_session_warning_schedule(&session_info) else {
info!("No session warning schedule provided by the gateway");
@@ -72,7 +75,7 @@ async fn run_session_runtime(session_ctx: SessionContext, mut session_info: Sess
tokio::time::sleep(schedule.delay).await;
eprintln!("\nWARNING: {}", schedule.message);
report(log_format, Level::Warn, &format!("\nWARNING: {}", schedule.message));
if !schedule.should_auto_extend {
info!("Session extension is not allowed by the gateway");
@@ -87,12 +90,16 @@ async fn run_session_runtime(session_ctx: SessionContext, mut session_info: Sess
return;
};
eprintln!("Session extended.");
report(log_format, Level::Info, "Session extended.");
session_info = next_session_info;
}
Err(err) => {
warn!("Failed to extend session: {}", err);
eprintln!("WARNING: Failed to extend session: {}", err);
report(
log_format,
Level::Warn,
&format!("WARNING: Failed to extend session: {}", err),
);
return;
}
}