Close local tabs and detach or reattach live SSH sessions
Remember the remote daemon and session identity for hostless reattachment. Keep other tabs usable after a discarded snapshot and preserve the last live detach target when a remote shell exits. Reject remote flags for local daemon control commands.
This commit is contained in:
+280
-74
@@ -1,6 +1,8 @@
|
||||
//! Display-only client transport. No terminal parser, PTY, or shell lives here.
|
||||
use crate::protocol::{self, ClientMessage, ServerMessage, SessionTarget, Snapshot, SshOptions};
|
||||
use anyhow::{Context, Result, bail};
|
||||
use crate::protocol::{
|
||||
self, ClientMessage, ServerMessage, SessionIdentity, SessionTarget, Snapshot, SshOptions,
|
||||
};
|
||||
use anyhow::{Context, Result, bail, ensure};
|
||||
use std::{
|
||||
collections::{HashSet, VecDeque},
|
||||
io::{self, Read, Write},
|
||||
@@ -42,10 +44,18 @@ impl Updates {
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Client(Arc<Connection>);
|
||||
pub struct Client {
|
||||
connection: Arc<Connection>,
|
||||
remote_session: Option<Arc<RemoteSession>>,
|
||||
}
|
||||
struct RemoteSession {
|
||||
identity: SessionIdentity,
|
||||
live: AtomicBool,
|
||||
}
|
||||
struct Connection {
|
||||
launcher_socket: PathBuf,
|
||||
remote: Option<String>,
|
||||
remote_executable: Option<String>,
|
||||
commands: mpsc::Sender<ClientMessage>,
|
||||
socket: Option<UnixStream>,
|
||||
ssh: Mutex<Option<Child>>,
|
||||
@@ -90,14 +100,9 @@ impl Client {
|
||||
launcher_socket: &Path,
|
||||
remote: Option<&str>,
|
||||
session: SessionTarget,
|
||||
options: SshOptions,
|
||||
) -> Result<(Self, Updates)> {
|
||||
Self::connect_with(
|
||||
launcher_socket,
|
||||
remote,
|
||||
session,
|
||||
SshOptions::from_env(),
|
||||
None,
|
||||
)
|
||||
Self::connect_with(launcher_socket, remote, session, options, None)
|
||||
}
|
||||
|
||||
pub fn connect_remote(
|
||||
@@ -123,6 +128,13 @@ impl Client {
|
||||
options: SshOptions,
|
||||
cancelled: Option<Arc<AtomicBool>>,
|
||||
) -> Result<(Self, Updates)> {
|
||||
let (session, expected) = match session {
|
||||
SessionTarget::Remembered(identity) => (
|
||||
SessionTarget::Attach(Some(identity.session)),
|
||||
Some(identity),
|
||||
),
|
||||
other => (other, None),
|
||||
};
|
||||
let (mut reader, mut writer, socket, mut ssh): (_, Box<dyn Write + Send>, _, _) =
|
||||
if let Some(remote) = remote {
|
||||
validate_destination(remote)?;
|
||||
@@ -175,13 +187,14 @@ impl Client {
|
||||
let (commands, receive) = mpsc::channel();
|
||||
let (signal, notifications) = async_channel::bounded(1);
|
||||
let pending = Arc::new(Mutex::new(Update::default()));
|
||||
let connection = Self(Arc::new(Connection {
|
||||
let connection = Arc::new(Connection {
|
||||
launcher_socket: launcher_socket.to_owned(),
|
||||
remote: remote.map(str::to_owned),
|
||||
remote_executable: options.executable,
|
||||
commands,
|
||||
socket,
|
||||
ssh: Mutex::new(ssh),
|
||||
}));
|
||||
});
|
||||
let diagnostic = stderr.map(ssh_diagnostics).transpose()?;
|
||||
reader.set_read_timeout(Some(Duration::from_millis(150)))?;
|
||||
let mut greeting = GreetingReader {
|
||||
@@ -189,15 +202,34 @@ impl Client {
|
||||
deadline: Instant::now() + Duration::from_secs(if remote.is_some() { 30 } else { 5 }),
|
||||
cancelled: cancelled.as_deref(),
|
||||
};
|
||||
if let Err(error) = greet(&mut greeting, &mut writer, session) {
|
||||
drop(connection);
|
||||
if let Some(detail) = diagnostic
|
||||
.and_then(|rx| rx.recv_timeout(Duration::from_millis(150)).ok())
|
||||
.filter(|s| !s.is_empty())
|
||||
{
|
||||
bail!("{error:#}: {detail}");
|
||||
let first_frame = match greet(
|
||||
&mut greeting,
|
||||
&mut writer,
|
||||
session,
|
||||
remote.is_some(),
|
||||
expected,
|
||||
) {
|
||||
Ok(greeting) => greeting,
|
||||
Err(error) => {
|
||||
drop(connection);
|
||||
if let Some(detail) = diagnostic
|
||||
.and_then(|rx| rx.recv_timeout(Duration::from_millis(150)).ok())
|
||||
.filter(|s| !s.is_empty())
|
||||
{
|
||||
bail!("{error:#}: {detail}");
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
return Err(error);
|
||||
};
|
||||
let remote_session = first_frame.as_ref().map(|frame| {
|
||||
Arc::new(RemoteSession {
|
||||
identity: frame.lineage[0],
|
||||
live: AtomicBool::new(!frame.tabs.is_empty()),
|
||||
})
|
||||
});
|
||||
if let Some(frame) = first_frame {
|
||||
pending.lock().unwrap().snapshot = Some(Arc::new(frame));
|
||||
let _ = signal.try_send(());
|
||||
}
|
||||
reader.set_read_timeout(None)?;
|
||||
let errors = pending.clone();
|
||||
@@ -215,57 +247,15 @@ impl Client {
|
||||
}
|
||||
})?;
|
||||
let incoming = pending.clone();
|
||||
let reader_session = remote_session.clone();
|
||||
thread::Builder::new()
|
||||
.name("psyterm-client-reader".into())
|
||||
.spawn(move || {
|
||||
let mut reader = reader;
|
||||
loop {
|
||||
let message = protocol::read_message::<ServerMessage>(&mut reader);
|
||||
let mut update = incoming.lock().unwrap();
|
||||
match message {
|
||||
Ok(ServerMessage::Snapshot(snapshot)) => {
|
||||
if let Err(error) = validate_snapshot(&snapshot) {
|
||||
update.disconnected = true;
|
||||
update.error = Some(error.to_string());
|
||||
let _ = signal.try_send(());
|
||||
break;
|
||||
}
|
||||
// A slow window never accumulates a queue of obsolete frames.
|
||||
update.snapshot = Some(Arc::new(snapshot));
|
||||
}
|
||||
Ok(ServerMessage::Clipboard(text)) => {
|
||||
if update.clipboard.len() < 16 {
|
||||
update.clipboard.push_back(text);
|
||||
}
|
||||
}
|
||||
Ok(ServerMessage::Error(error)) => update.error = Some(error),
|
||||
Ok(ServerMessage::Closing) => {
|
||||
update.disconnected = true;
|
||||
update.error =
|
||||
Some("Server stopped. Shell sessions have ended.".into());
|
||||
let _ = signal.try_send(());
|
||||
break;
|
||||
}
|
||||
Ok(ServerMessage::Pong) => {}
|
||||
Ok(_) => {
|
||||
update.error =
|
||||
Some("Unexpected server response after session handshake".into());
|
||||
}
|
||||
Err(error) => {
|
||||
update.disconnected = true;
|
||||
update.error = Some(format!(
|
||||
"Disconnected — sessions remain on the server. {error:#}"
|
||||
));
|
||||
let _ = signal.try_send(());
|
||||
break;
|
||||
}
|
||||
}
|
||||
drop(update);
|
||||
let _ = signal.try_send(());
|
||||
}
|
||||
})?;
|
||||
.spawn(move || read_updates(reader, &incoming, signal, reader_session.as_deref()))?;
|
||||
Ok((
|
||||
connection,
|
||||
Self {
|
||||
connection,
|
||||
remote_session,
|
||||
},
|
||||
Updates {
|
||||
signal: notifications,
|
||||
pending,
|
||||
@@ -274,13 +264,42 @@ impl Client {
|
||||
}
|
||||
|
||||
pub fn remote(&self) -> Option<&str> {
|
||||
self.0.remote.as_deref()
|
||||
self.connection.remote.as_deref()
|
||||
}
|
||||
|
||||
pub fn remote_identity(&self) -> Option<SessionIdentity> {
|
||||
self.remote_session.as_ref().map(|session| session.identity)
|
||||
}
|
||||
|
||||
pub fn remote_executable(&self) -> Option<&str> {
|
||||
self.connection.remote_executable.as_deref()
|
||||
}
|
||||
|
||||
/// Remember a direct SSH window on its local launcher before detaching it.
|
||||
pub fn remember_remote_detach(&self) -> Result<()> {
|
||||
let destination = self.remote().context("this window is local")?.to_owned();
|
||||
let session = self
|
||||
.remote_session
|
||||
.as_ref()
|
||||
.context("missing SSH session identity")?;
|
||||
if !session.live.load(Ordering::Acquire) {
|
||||
return Ok(());
|
||||
}
|
||||
crate::launcher::control(
|
||||
&self.connection.launcher_socket,
|
||||
ClientMessage::RememberDetachedRemote(protocol::DetachedRemote {
|
||||
destination,
|
||||
identity: session.identity,
|
||||
executable: self.remote_executable().map(str::to_owned),
|
||||
}),
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Launch through the local daemon even when this terminal connects over SSH.
|
||||
pub fn open_window(&self, remote: Option<String>, cwd: Option<String>) -> Result<()> {
|
||||
crate::launcher::control(
|
||||
&self.0.launcher_socket,
|
||||
&self.connection.launcher_socket,
|
||||
ClientMessage::OpenWindow {
|
||||
target: remote,
|
||||
session: SessionTarget::New { cwd },
|
||||
@@ -290,7 +309,7 @@ impl Client {
|
||||
}
|
||||
|
||||
pub fn send(&self, message: ClientMessage) -> Result<()> {
|
||||
self.0
|
||||
self.connection
|
||||
.commands
|
||||
.send(message)
|
||||
.context("server transport is closed")
|
||||
@@ -306,6 +325,66 @@ impl Client {
|
||||
}
|
||||
}
|
||||
|
||||
fn read_updates(
|
||||
mut reader: impl Read,
|
||||
pending: &Mutex<Update>,
|
||||
signal: async_channel::Sender<()>,
|
||||
remote_session: Option<&RemoteSession>,
|
||||
) {
|
||||
loop {
|
||||
let message = protocol::read_message::<ServerMessage>(&mut reader);
|
||||
let mut update = pending.lock().unwrap();
|
||||
match message {
|
||||
Ok(ServerMessage::Snapshot(snapshot)) => {
|
||||
match validate_snapshot(&snapshot) {
|
||||
Ok(()) => {
|
||||
if let Some(session) = remote_session {
|
||||
session
|
||||
.live
|
||||
.store(!snapshot.tabs.is_empty(), Ordering::Release);
|
||||
}
|
||||
update.snapshot = Some(Arc::new(snapshot));
|
||||
}
|
||||
Err(error) => {
|
||||
// Older daemons can briefly mix layouts and grids during SSH
|
||||
// navigation. A complete frame leaves the stream synchronized.
|
||||
update.error = Some(format!("Discarded workspace update: {error}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(ServerMessage::Clipboard(text)) => {
|
||||
if update.clipboard.len() < 16 {
|
||||
update.clipboard.push_back(text);
|
||||
}
|
||||
}
|
||||
Ok(ServerMessage::Error(error)) => update.error = Some(error),
|
||||
Ok(ServerMessage::Closing) => {
|
||||
if let Some(session) = remote_session {
|
||||
session.live.store(false, Ordering::Release);
|
||||
}
|
||||
update.disconnected = true;
|
||||
update.error = Some("Server stopped. Shell sessions have ended.".into());
|
||||
}
|
||||
Ok(ServerMessage::Pong) => {}
|
||||
Ok(_) => {
|
||||
update.error = Some("Unexpected server response after session handshake".into());
|
||||
}
|
||||
Err(error) => {
|
||||
update.disconnected = true;
|
||||
update.error = Some(format!(
|
||||
"Disconnected — sessions remain on the server. {error:#}"
|
||||
));
|
||||
}
|
||||
}
|
||||
let disconnected = update.disconnected;
|
||||
drop(update);
|
||||
let _ = signal.try_send(());
|
||||
if disconnected {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Drain SSH stderr throughout the connection. Keep a bounded tail to explain
|
||||
/// startup failures in the invoking window as well as in the daemon log.
|
||||
fn ssh_diagnostics(mut stderr: ChildStderr) -> io::Result<mpsc::Receiver<String>> {
|
||||
@@ -383,7 +462,9 @@ fn greet(
|
||||
reader: &mut GreetingReader<'_>,
|
||||
writer: &mut impl Write,
|
||||
session: SessionTarget,
|
||||
) -> Result<()> {
|
||||
from_ssh: bool,
|
||||
expected: Option<SessionIdentity>,
|
||||
) -> Result<Option<Snapshot>> {
|
||||
reader.check()?;
|
||||
protocol::write_message(
|
||||
writer,
|
||||
@@ -398,11 +479,37 @@ fn greet(
|
||||
}
|
||||
reader.check()?;
|
||||
protocol::write_message(writer, &ClientMessage::Connect(session))?;
|
||||
match protocol::read_message::<ServerMessage>(reader)? {
|
||||
ServerMessage::Connected { .. } => Ok(()),
|
||||
let session = match protocol::read_message::<ServerMessage>(reader)? {
|
||||
ServerMessage::Connected { session } => session,
|
||||
ServerMessage::Error(error) => bail!("{error}"),
|
||||
_ => bail!("server did not acknowledge the session"),
|
||||
};
|
||||
if !from_ssh && expected.is_none() {
|
||||
return Ok(None);
|
||||
}
|
||||
// Session numbers start over after a daemon restart. Check the identity
|
||||
// before handing a display or an input channel to the attaching client.
|
||||
let frame = match protocol::read_message::<ServerMessage>(reader)? {
|
||||
ServerMessage::Snapshot(frame) => frame,
|
||||
ServerMessage::Error(error) => bail!("{error}"),
|
||||
_ => bail!("expected initial SSH session snapshot"),
|
||||
};
|
||||
validate_snapshot(&frame)?;
|
||||
let identity = frame
|
||||
.lineage
|
||||
.first()
|
||||
.context("missing SSH session identity")?;
|
||||
ensure!(
|
||||
identity.session == session,
|
||||
"incorrect SSH session identity"
|
||||
);
|
||||
if let Some(expected) = expected {
|
||||
ensure!(
|
||||
*identity == expected,
|
||||
"the remembered remote session has ended"
|
||||
);
|
||||
}
|
||||
Ok(Some(frame))
|
||||
}
|
||||
|
||||
fn shell_quote(value: &str) -> String {
|
||||
@@ -502,6 +609,105 @@ fn copy_and_flush(reader: &mut impl Read, writer: &mut impl Write) -> std::io::R
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn invalid_frame_does_not_disconnect_local_or_remote_workspaces() {
|
||||
let remote = RemoteSession {
|
||||
identity: SessionIdentity {
|
||||
server: [1; 16],
|
||||
session: 1,
|
||||
},
|
||||
live: AtomicBool::new(true),
|
||||
};
|
||||
for session in [None, Some(&remote)] {
|
||||
let (client, mut server) = UnixStream::pair().unwrap();
|
||||
client
|
||||
.set_read_timeout(Some(Duration::from_secs(5)))
|
||||
.unwrap();
|
||||
let pending = Mutex::new(Update::default());
|
||||
let (signal, received) = async_channel::bounded(1);
|
||||
thread::scope(|threads| {
|
||||
threads.spawn(|| read_updates(client, &pending, signal, session));
|
||||
let mut send_snapshot = |snapshot| {
|
||||
protocol::write_message(&mut server, &ServerMessage::Snapshot(snapshot))
|
||||
.unwrap();
|
||||
received.recv_blocking().unwrap();
|
||||
std::mem::take(&mut *pending.lock().unwrap())
|
||||
};
|
||||
let frame = Snapshot {
|
||||
lineage: vec![remote.identity],
|
||||
revision: 1,
|
||||
tabs: vec![protocol::TabInfo {
|
||||
id: 1,
|
||||
remote: Some("work".into()),
|
||||
title: "work".into(),
|
||||
manual_title: None,
|
||||
panes: Vec::new(),
|
||||
active_pane: 0,
|
||||
stacks: Vec::new(),
|
||||
}],
|
||||
active_tab: 1,
|
||||
panes: Vec::new(),
|
||||
};
|
||||
assert_eq!(send_snapshot(frame.clone()).snapshot.unwrap().revision, 1);
|
||||
|
||||
let skipped = send_snapshot(Snapshot {
|
||||
revision: 2,
|
||||
active_tab: 42,
|
||||
..frame.clone()
|
||||
});
|
||||
assert!(skipped.snapshot.is_none());
|
||||
assert!(skipped.error.unwrap().contains("invalid active tab"));
|
||||
assert!(!skipped.disconnected);
|
||||
|
||||
let resumed = send_snapshot(Snapshot {
|
||||
revision: 3,
|
||||
..frame
|
||||
});
|
||||
assert_eq!(resumed.snapshot.unwrap().revision, 3);
|
||||
assert!(!resumed.disconnected);
|
||||
|
||||
server.shutdown(Shutdown::Write).unwrap();
|
||||
received.recv_blocking().unwrap();
|
||||
assert!(pending.lock().unwrap().disconnected);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remote_session_can_be_remembered_after_transport_loss_but_not_after_exit() {
|
||||
let empty = ServerMessage::Snapshot(Snapshot {
|
||||
revision: 2,
|
||||
lineage: Vec::new(),
|
||||
tabs: Vec::new(),
|
||||
active_tab: 0,
|
||||
panes: Vec::new(),
|
||||
});
|
||||
for (last_message, resumable) in [
|
||||
(ServerMessage::Pong, true),
|
||||
(empty, false),
|
||||
(ServerMessage::Closing, false),
|
||||
] {
|
||||
let remote = RemoteSession {
|
||||
identity: SessionIdentity {
|
||||
server: [1; 16],
|
||||
session: 1,
|
||||
},
|
||||
live: AtomicBool::new(true),
|
||||
};
|
||||
let mut bytes = Vec::new();
|
||||
protocol::write_message(&mut bytes, &last_message).unwrap();
|
||||
let (signal, _updates) = async_channel::bounded(1);
|
||||
read_updates(
|
||||
bytes.as_slice(),
|
||||
&Mutex::new(Update::default()),
|
||||
signal,
|
||||
Some(&remote),
|
||||
);
|
||||
assert_eq!(remote.live.load(Ordering::Acquire), resumable);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_bridge_flushes_without_newlines() {
|
||||
struct Output {
|
||||
|
||||
Reference in New Issue
Block a user