feat(linux): switch desktop interfaces and preserve selection on upgrade

This commit is contained in:
Kevin Yue committed 2026-11-01 23:35:55 +08:00
1 parent 0df25fbd28
commit e284840d89
17 files changed
+818 -58

No files matched your search

+10 -2
View File
@@ -11,19 +11,27 @@ pub struct App {
credential: Arc<SessionCredential>,
credential_lease: watch::Receiver<bool>,
gui_version: String,
variant: gpapi::gui::GuiVariant,
}
impl App {
pub fn new(credential: Arc<SessionCredential>, credential_lease: watch::Receiver<bool>, gui_version: &str) -> Self {
pub fn new(
credential: Arc<SessionCredential>,
credential_lease: watch::Receiver<bool>,
gui_version: &str,
variant: gpapi::gui::GuiVariant,
) -> Self {
Self {
credential,
credential_lease,
gui_version: gui_version.to_string(),
variant,
}
}
pub fn run(&self) -> anyhow::Result<()> {
let gui_version = self.gui_version.clone();
let variant = self.variant;
let credential = Arc::clone(&self.credential);
let credential_lease = self.credential_lease.clone();
@@ -34,7 +42,7 @@ impl App {
let notifier = ProgressNotifier::new(win.clone());
let installer = Installer::new(credential, credential_lease.clone());
let updater = Arc::new(GuiUpdater::new(gui_version, notifier, installer));
let updater = Arc::new(GuiUpdater::new(gui_version, notifier, installer, variant));
let app_handle = app.handle().clone();
let mut app_credential_lease = credential_lease;
+12 -1
View File
@@ -29,6 +29,8 @@ struct Cli {
#[arg(long, default_value = env!("CARGO_PKG_VERSION"), help = "The version of the GUI")]
gui_version: String,
#[arg(long, default_value = "tauri", value_parser = ["tauri", "nsh"])]
gui_variant: String,
#[command(flatten)]
verbose: InfoLevelVerbosity,
@@ -38,7 +40,16 @@ impl Cli {
fn run(&self) -> anyhow::Result<()> {
let credential = self.read_credential()?;
let credential_lease = monitor_credential_lease().context("Failed to monitor service credential lifetime")?;
let app = App::new(Arc::new(credential), credential_lease, &self.gui_version);
let variant = if self.gui_variant == "nsh" {
gpapi::gui::GuiVariant::Nsh
} else {
gpapi::gui::GuiVariant::Tauri
};
anyhow::ensure!(
variant != gpapi::gui::GuiVariant::Nsh || cfg!(target_os = "linux"),
"Native Shell is available only on Linux"
);
let app = App::new(Arc::new(credential), credential_lease, &self.gui_version, variant);
env_utils::patch_gui_runtime_env(false);
+43 -12
View File
@@ -41,10 +41,20 @@ const GUI_LIBC_SUFFIX: &str = "-musl";
#[cfg(not(target_env = "musl"))]
const GUI_LIBC_SUFFIX: &str = "";
fn gui_asset_name() -> Option<String> {
fn gui_asset_name(variant: gpapi::gui::GuiVariant) -> Option<String> {
if variant == gpapi::gui::GuiVariant::Nsh {
return nsh_asset_name_for(std::env::consts::OS, std::env::consts::ARCH);
}
gui_asset_name_for(std::env::consts::OS, std::env::consts::ARCH, GUI_LIBC_SUFFIX)
}
fn nsh_asset_name_for(os: &str, arch: &str) -> Option<String> {
match (os, arch) {
("linux", "x86_64" | "aarch64") => Some(format!("gpgui-nsh_{arch}.bin.tar.xz")),
_ => None,
}
}
fn gui_asset_name_for(os: &str, arch: &str, libc_suffix: &str) -> Option<String> {
let name = match (os, arch) {
("linux", "x86_64" | "aarch64") => format!("gpgui_{arch}{libc_suffix}.bin.tar.xz"),
@@ -97,10 +107,11 @@ impl Installer {
Self { command_tx }
}
async fn install(&self, path: &str, checksum: &str) -> anyhow::Result<()> {
async fn install(&self, path: &str, checksum: &str, variant: gpapi::gui::GuiVariant) -> anyhow::Result<()> {
let request = UpdateGuiRequest {
path: path.to_string(),
checksum: checksum.to_string(),
variant,
};
let (reply, result) = oneshot::channel();
self
@@ -363,6 +374,7 @@ async fn receive_binary(socket: &mut Socket) -> anyhow::Result<Vec<u8>> {
pub struct GuiUpdater {
version: String,
variant: gpapi::gui::GuiVariant,
notifier: Arc<ProgressNotifier>,
installer: Installer,
in_progress: RwLock<bool>,
@@ -370,9 +382,15 @@ pub struct GuiUpdater {
}
impl GuiUpdater {
pub fn new(version: String, notifier: ProgressNotifier, installer: Installer) -> Self {
pub fn new(
version: String,
notifier: ProgressNotifier,
installer: Installer,
variant: gpapi::gui::GuiVariant,
) -> Self {
Self {
version,
variant,
notifier: Arc::new(notifier),
installer,
in_progress: Default::default(),
@@ -381,7 +399,7 @@ impl GuiUpdater {
}
pub async fn update(&self) {
let Some(asset_name) = gui_asset_name() else {
let Some(asset_name) = gui_asset_name(self.variant) else {
info!("GUI updates are not supported on this platform.");
return;
};
@@ -438,7 +456,7 @@ impl GuiUpdater {
info!("Checksum success");
if let Err(err) = self.installer.install(&file_path, &checksum).await {
if let Err(err) = self.installer.install(&file_path, &checksum, self.variant).await {
warn!("Install error: {}", err);
self.notify_error();
} else {
@@ -488,13 +506,10 @@ impl GuiUpdater {
#[cfg(test)]
mod tests {
use gpapi::{
os_profile::HostIdentity,
service::{
transport::{ClientPrelude, NoiseResponder},
vpn_env::{HostInfo, VpnEnv},
vpn_state::VpnState,
},
use gpapi::service::{
transport::{ClientPrelude, NoiseResponder},
vpn_env::{HostInfo, VpnEnv},
vpn_state::VpnState,
};
use tokio::net::TcpListener;
use tokio_tungstenite::accept_async;
@@ -522,6 +537,21 @@ mod tests {
assert_eq!(gui_asset_name_for("macos", "aarch64", ""), None);
}
#[test]
fn nsh_assets_are_linux_only_and_use_the_nsh_binary_archive() {
assert_eq!(
nsh_asset_name_for("linux", "x86_64"),
Some("gpgui-nsh_x86_64.bin.tar.xz".into())
);
assert_eq!(
nsh_asset_name_for("linux", "aarch64"),
Some("gpgui-nsh_aarch64.bin.tar.xz".into())
);
for os in ["freebsd", "openbsd", "macos"] {
assert_eq!(nsh_asset_name_for(os, "x86_64"), None);
}
}
#[tokio::test]
async fn pending_install_reconnects_with_a_fresh_handshake() {
let credential = Arc::new(SessionCredential::generate(Uuid::new_v4(), env!("CARGO_PKG_VERSION")).unwrap());
@@ -532,6 +562,7 @@ mod tests {
request: UpdateGuiRequest {
path: "/tmp/gpgui-update".to_owned(),
checksum: "checksum".to_owned(),
variant: gpapi::gui::GuiVariant::Tauri,
},
reply: reply_tx,
})
+61 -3
View File
@@ -17,7 +17,9 @@ use tokio::io::unix::AsyncFd;
use tokio_util::sync::CancellationToken;
use crate::session_registry::SessionRegistry;
use gpapi::service::transport::{DESKTOP_GUI_EXITED, DESKTOP_RENDERING_RETRY};
use gpapi::service::transport::{
DESKTOP_GUI_EXITED, DESKTOP_RENDERING_RETRY, DESKTOP_SWITCH_BEGIN, DESKTOP_SWITCH_CANCEL, DESKTOP_SWITCH_COMMIT,
};
/// Private parent/service pipes; credentials never pass through argv, environment or files.
pub(crate) struct DesktopClient {
@@ -62,15 +64,38 @@ impl DesktopClient {
let mut rendering_renewed = false;
loop {
let credential = registry.issue(env!("CARGO_PKG_VERSION"), Some(uid))?;
let session_id = credential.session_id();
let mut session_id = credential.session_id();
let mut pending = None;
let result = tokio::select! {
_ = cancel.cancelled() => Ok(None),
result = async {
self.write_frame(&credential.encode_frame()?).await?;
self.gui_exited().await
loop {
match self.gui_exited().await? {
Some(DESKTOP_SWITCH_BEGIN) => {
ensure!(pending.is_none(), "A GUI switch is already pending");
let credential = registry.issue(env!("CARGO_PKG_VERSION"), Some(uid))?;
pending = Some(credential.session_id());
self.write_frame(&credential.encode_frame()?).await?;
}
Some(DESKTOP_SWITCH_COMMIT) => {
let replacement = pending.take().context("No GUI switch is pending")?;
registry.revoke(session_id);
session_id = replacement;
}
Some(DESKTOP_SWITCH_CANCEL) => {
let replacement = pending.take().context("No GUI switch is pending")?;
registry.revoke(replacement);
}
message => break Ok(message),
}
}
} => result,
};
registry.revoke(session_id);
if let Some(session_id) = pending {
registry.revoke(session_id);
}
let requested = restart.swap(false, Ordering::SeqCst);
match result? {
None => return Ok(()),
@@ -253,6 +278,39 @@ mod tests {
assert!(registry.last_successful_hip_report(issued.session_id()).is_err());
}
#[tokio::test]
async fn switch_cancel_preserves_current_session_and_commit_replaces_it() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::for_tests(uuid::Uuid::new_v4()));
let task = tokio::spawn(channel.serve(
registry.clone(),
1000,
Arc::new(AtomicBool::new(false)),
CancellationToken::new(),
));
let (reader, first) = credential(reader).await;
write(&control, &[DESKTOP_SWITCH_BEGIN]).unwrap();
let (reader, cancelled) = credential(reader).await;
assert_ne!(first.session_id(), cancelled.session_id());
assert!(registry.last_successful_hip_report(first.session_id()).is_ok());
write(&control, &[DESKTOP_SWITCH_CANCEL, DESKTOP_SWITCH_BEGIN]).unwrap();
let (reader, replacement) = credential(reader).await;
assert!(registry.last_successful_hip_report(cancelled.session_id()).is_err());
assert!(registry.last_successful_hip_report(first.session_id()).is_ok());
write(&control, &[DESKTOP_SWITCH_COMMIT, DESKTOP_SWITCH_BEGIN]).unwrap();
let (_, pending) = credential(reader).await;
assert!(registry.last_successful_hip_report(first.session_id()).is_err());
assert!(registry.last_successful_hip_report(replacement.session_id()).is_ok());
drop(control);
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.unwrap();
assert!(registry.last_successful_hip_report(replacement.session_id()).is_err());
assert!(registry.last_successful_hip_report(pending.session_id()).is_err());
}
#[tokio::test]
async fn desktop_channel_rejects_invalid_control_messages_and_revokes() {
let (channel, control, reader) = pipes();
+47 -13
View File
@@ -6,7 +6,6 @@ use std::{
sync::{Arc, atomic::AtomicBool},
};
use common::binary_paths;
use gpapi::{
service::{
request::{UpdateGuiRequest, UpdateLogLevelRequest, WsRequest},
@@ -299,10 +298,17 @@ impl RequestDispatcher {
}
async fn update_gui(&self, request: UpdateGuiRequest) -> ServiceResult {
if request.variant == gpapi::gui::GuiVariant::Nsh && !cfg!(target_os = "linux") {
return ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"Native Shell is available only on Linux",
);
}
let _install = self.install_lock.lock().await;
let path = request.path;
let checksum = request.checksum;
let installed = tokio::task::spawn_blocking(move || install_gui(&path, &checksum)).await;
let target = request.variant.update_target();
let installed = tokio::task::spawn_blocking(move || install_gui_at(Path::new(&path), &checksum, &target)).await;
match installed {
Ok(Ok(())) => ServiceResult::Accepted,
Ok(Err(GuiInstallError::Checksum(err))) => {
@@ -327,10 +333,6 @@ enum GuiInstallError {
Install(anyhow::Error),
}
fn install_gui(src: &str, checksum: &str) -> Result<(), GuiInstallError> {
install_gui_at(Path::new(src), checksum, &binary_paths::gpgui_update_target())
}
fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiInstallError> {
let Some(dir) = target.parent() else {
return Err(GuiInstallError::Install(anyhow::anyhow!(
@@ -350,7 +352,8 @@ fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiIn
))
.take(MAX_GUI_ARCHIVE_CONTENT_SIZE);
let mut archive = Archive::new(tar);
let file = extract_gui_binary(&mut archive, dir)?;
let binary_name = target.file_name().and_then(|name| name.to_str()).unwrap_or("gpgui");
let file = extract_gui_binary(&mut archive, dir, binary_name)?;
file
.as_file()
.set_permissions(Permissions::from_mode(0o755))
@@ -398,14 +401,18 @@ fn stage_gui_archive(src: &Path, dir: &Path) -> Result<NamedTempFile, GuiInstall
Ok(staged)
}
fn extract_gui_binary<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<NamedTempFile, GuiInstallError> {
fn extract_gui_binary<R: Read>(
archive: &mut Archive<R>,
dir: &Path,
binary_name: &str,
) -> Result<NamedTempFile, GuiInstallError> {
for entry in archive.entries().map_err(|err| GuiInstallError::Install(err.into()))? {
let mut entry = entry.map_err(|err| GuiInstallError::Install(err.into()))?;
let is_gui = entry
.path()
.map_err(|err| GuiInstallError::Install(err.into()))?
.file_name()
.is_some_and(|name| name == "gpgui");
.is_some_and(|name| name == binary_name);
if is_gui && entry.header().entry_type().is_file() {
let declared_size = entry.size();
if declared_size == 0 || declared_size > MAX_GUI_BINARY_SIZE {
@@ -425,7 +432,7 @@ fn extract_gui_binary<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<N
}
}
Err(GuiInstallError::Install(anyhow::anyhow!(
"GUI update archive does not contain a non-empty regular gpgui file"
"GUI update archive does not contain a non-empty regular {binary_name} file"
)))
}
@@ -475,7 +482,7 @@ mod tests {
for (entry_type, contents) in [(EntryType::Directory, &[][..]), (EntryType::Regular, &[][..])] {
let data = archive_with_entry(entry_type, contents);
let mut archive = Archive::new(Cursor::new(data));
assert!(extract_gui_binary(&mut archive, output.path()).is_err());
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
}
}
@@ -484,7 +491,7 @@ mod tests {
let output = tempfile::tempdir().unwrap();
let data = archive_with_entry(EntryType::Regular, b"gui binary");
let mut archive = Archive::new(Cursor::new(data));
let extracted = extract_gui_binary(&mut archive, output.path()).unwrap();
let extracted = extract_gui_binary(&mut archive, output.path(), "gpgui").unwrap();
let contents = std::fs::read(extracted.path()).unwrap();
assert_eq!(contents, b"gui binary");
}
@@ -515,7 +522,7 @@ mod tests {
data.resize(512 * 3, 0);
let mut archive = Archive::new(Cursor::new(data));
assert!(extract_gui_binary(&mut archive, output.path()).is_err());
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
}
#[test]
@@ -531,6 +538,33 @@ mod tests {
assert_eq!(std::fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o755);
}
#[test]
fn installs_nsh_beside_tauri_without_replacing_it() {
let output = tempfile::tempdir().unwrap();
let tauri = output.path().join("gpgui");
std::fs::write(&tauri, b"tauri").unwrap();
let mut encoder = XzEncoder::new(Vec::new(), 1);
{
let mut archive = Builder::new(&mut encoder);
let mut header = Header::new_gnu();
header.set_size(3);
header.set_mode(0o755);
header.set_cksum();
archive
.append_data(&mut header, "gpgui-nsh_3.2.0/gpgui-nsh", &b"nsh"[..])
.unwrap();
archive.finish().unwrap();
}
let mut archive = NamedTempFile::new().unwrap();
archive.write_all(&encoder.finish().unwrap()).unwrap();
archive.flush().unwrap();
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let nsh = output.path().join("gpgui-nsh");
install_gui_at(archive.path(), &checksum, &nsh).unwrap();
assert_eq!(std::fs::read(nsh).unwrap(), b"nsh");
assert_eq!(std::fs::read(tauri).unwrap(), b"tauri");
}
#[test]
fn checksum_failure_preserves_the_existing_gui() {
let archive = compressed_gui_archive(b"replacement");
+1
View File
@@ -763,6 +763,7 @@ mod tests {
request: WsRequest::UpdateGui(UpdateGuiRequest {
path: update_file.path().to_string_lossy().into_owned(),
checksum: "invalid".to_owned(),
variant: gpapi::gui::GuiVariant::Tauri,
}),
};
socket