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:
+193
-20
@@ -366,23 +366,33 @@ impl SessionState {
|
||||
);
|
||||
}
|
||||
|
||||
pub(super) fn cancel_pending_tab(&mut self, tab: TabId) -> Result<()> {
|
||||
if self
|
||||
pub(super) fn detach_remote(&mut self, tab: TabId) -> Result<Option<DetachedRemote>> {
|
||||
let (&group, remote) = self
|
||||
.remotes
|
||||
.get(&tab)
|
||||
.is_some_and(|remote| remote.latest.is_none())
|
||||
.iter()
|
||||
.find(|(_, remote)| remote.owns_tab(tab))
|
||||
.context("tab is not attached to an SSH session")?;
|
||||
// A nested SSH tab is owned by the upstream workspace. Detach it
|
||||
// there so the enclosing SSH session and its other tabs stay open.
|
||||
if let Some(frame) = &remote.latest
|
||||
&& let Some(id) = original(&remote.tabs, tab)
|
||||
&& frame.tabs.iter().any(|t| t.id == id && t.remote.is_some())
|
||||
{
|
||||
self.remove_remote(tab);
|
||||
return Ok(());
|
||||
remote.send(ClientMessage::DetachRemote { tab: id })?;
|
||||
return Ok(None);
|
||||
}
|
||||
if let Some((remote, id)) = self
|
||||
.remotes
|
||||
.values()
|
||||
.find_map(|remote| original(&remote.tabs, tab).map(|id| (remote, id)))
|
||||
{
|
||||
return remote.send(ClientMessage::ClosePendingTab { tab: id });
|
||||
}
|
||||
anyhow::bail!("SSH tab is no longer connecting")
|
||||
let target = remote.connection.as_ref().and_then(|client| {
|
||||
let identity = client
|
||||
.remote_identity()
|
||||
.or_else(|| remote.latest.as_ref()?.lineage.first().copied())?;
|
||||
Some(DetachedRemote {
|
||||
destination: remote.destination.clone(),
|
||||
identity,
|
||||
executable: client.remote_executable().map(str::to_owned),
|
||||
})
|
||||
});
|
||||
self.remove_remote(group);
|
||||
Ok(target)
|
||||
}
|
||||
|
||||
fn remove_remote(&mut self, group: u64) {
|
||||
@@ -467,7 +477,7 @@ impl SessionState {
|
||||
| Copy { pane }
|
||||
| Scroll { pane, .. }
|
||||
| Split { pane, .. }
|
||||
| ClosePane { pane }
|
||||
| Close { id: pane }
|
||||
| RenamePane { pane, .. } => self.remote_pane(*pane).map(|(remote, original)| {
|
||||
*pane = original;
|
||||
remote
|
||||
@@ -620,11 +630,103 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detaching_a_mirror_keeps_its_tabs_and_live_shell_for_reattach() {
|
||||
use super::super::tests::contains;
|
||||
let upstream = super::super::tests::TestServer::start();
|
||||
let (client, updates) = Transport::connect(
|
||||
&upstream.socket,
|
||||
None,
|
||||
SessionTarget::New { cwd: None },
|
||||
SshOptions::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let receive = receive_updates(updates);
|
||||
client.send(ClientMessage::NewTab { cwd: None }).unwrap();
|
||||
let before = next_frame(&receive, |frame| frame.tabs.len() == 2);
|
||||
let pane = before.active_tab().unwrap().active_pane;
|
||||
client
|
||||
.send(ClientMessage::Input {
|
||||
pane,
|
||||
bytes: b"psyterm_check=alive; printf 'SET_%s\\n' DONE\n".to_vec(),
|
||||
})
|
||||
.unwrap();
|
||||
next_frame(&receive, |frame| contains(frame, "SET_DONE"));
|
||||
|
||||
let mut local = session(1);
|
||||
local.new_tab(None).unwrap();
|
||||
let origin = local.active_tab;
|
||||
let group = reserve(&mut local, 0);
|
||||
local.remotes.get_mut(&group).unwrap().connection = Some(client);
|
||||
apply(&mut local, group, (*before).clone()).unwrap();
|
||||
assert!(local.detach_remote(origin).is_err());
|
||||
local.focus_tab(origin).unwrap();
|
||||
let clicked = local.tabs[1].id;
|
||||
assert_ne!(clicked, group);
|
||||
let target = local.detach_remote(clicked).unwrap().unwrap();
|
||||
assert_eq!(target.destination, "user@work");
|
||||
assert_eq!(target.identity, before.lineage[0]);
|
||||
assert_eq!(local.tabs.len(), 1);
|
||||
assert_eq!(local.active_tab, origin);
|
||||
|
||||
let (resumed, updates) = Transport::connect(
|
||||
&upstream.socket,
|
||||
None,
|
||||
SessionTarget::Remembered(target.identity),
|
||||
SshOptions::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let receive = receive_updates(updates);
|
||||
let restored = next_frame(&receive, |_| true);
|
||||
assert_eq!(restored.tabs.len(), 2);
|
||||
assert_eq!(restored.active_tab, before.active_tab);
|
||||
resumed
|
||||
.send(ClientMessage::Input {
|
||||
pane,
|
||||
bytes: b"printf 'REATTACHED_%s\\n' \"$psyterm_check\"\n".to_vec(),
|
||||
})
|
||||
.unwrap();
|
||||
next_frame(&receive, |frame| contains(frame, "REATTACHED_alive"));
|
||||
|
||||
// A replacement daemon can allocate the same session and pane
|
||||
// numbers. Refuse its input channel even if the numeric attach succeeds.
|
||||
let replacement = super::super::tests::TestServer::start();
|
||||
let (_other, updates) = Transport::connect(
|
||||
&replacement.socket,
|
||||
None,
|
||||
SessionTarget::New { cwd: None },
|
||||
SshOptions::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let other = next_frame(&receive_updates(updates), |_| true).lineage[0];
|
||||
assert_eq!(other.session, target.identity.session);
|
||||
assert_ne!(other.server, target.identity.server);
|
||||
let error = Transport::connect(
|
||||
&replacement.socket,
|
||||
None,
|
||||
SessionTarget::Remembered(target.identity),
|
||||
SshOptions::default(),
|
||||
)
|
||||
.err()
|
||||
.expect("refuse a recycled session ID");
|
||||
assert!(
|
||||
error
|
||||
.to_string()
|
||||
.contains("remembered remote session has ended"),
|
||||
"{error:#}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stacked_remote_focus_publishes_matching_grids_while_requests_are_in_flight() {
|
||||
let upstream = super::super::tests::TestServer::start();
|
||||
let (client, updates) =
|
||||
Transport::connect(&upstream.socket, None, SessionTarget::New { cwd: None }).unwrap();
|
||||
let (client, updates) = Transport::connect(
|
||||
&upstream.socket,
|
||||
None,
|
||||
SessionTarget::New { cwd: None },
|
||||
SshOptions::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let receive = receive_updates(updates);
|
||||
for _ in 0..3 {
|
||||
client
|
||||
@@ -690,6 +792,59 @@ mod tests {
|
||||
assert_eq!(frame.panes[0].id, top);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn discarded_ssh_frame_keeps_the_mounted_workspace_and_accepts_the_next_frame() {
|
||||
let mut upstream = session(2);
|
||||
upstream.new_tab(None).unwrap();
|
||||
let mut local = session(1);
|
||||
local.new_tab(None).unwrap();
|
||||
let origin = local.active_tab;
|
||||
let group = reserve(&mut local, 0);
|
||||
apply(&mut local, group, upstream.snapshot()).unwrap();
|
||||
let id = local.id;
|
||||
let mut server = Server {
|
||||
identity: local.identity.server,
|
||||
socket: local.socket.clone(),
|
||||
shell: None,
|
||||
sender: local.sender.clone(),
|
||||
sessions: BTreeMap::from([(id, local)]),
|
||||
clients: HashMap::new(),
|
||||
next_session: id + 1,
|
||||
last_detached_remote: None,
|
||||
last_frame: Instant::now(),
|
||||
last_cwd_refresh: Instant::now(),
|
||||
};
|
||||
server.remote_event(
|
||||
id,
|
||||
group,
|
||||
RemoteEvent::Updated(Update {
|
||||
error: Some("Discarded workspace update: invalid terminal grid".into()),
|
||||
..Update::default()
|
||||
}),
|
||||
);
|
||||
assert_eq!(server.sessions[&id].active_tab, group);
|
||||
upstream.new_tab(None).unwrap();
|
||||
server.remote_event(
|
||||
id,
|
||||
group,
|
||||
RemoteEvent::Updated(Update {
|
||||
snapshot: Some(Arc::new(upstream.snapshot())),
|
||||
..Update::default()
|
||||
}),
|
||||
);
|
||||
assert_eq!(server.sessions[&id].remotes[&group].tabs.len(), 2);
|
||||
server.remote_event(
|
||||
id,
|
||||
group,
|
||||
RemoteEvent::Updated(Update {
|
||||
disconnected: true,
|
||||
..Update::default()
|
||||
}),
|
||||
);
|
||||
assert_eq!(server.sessions[&id].active_tab, origin);
|
||||
assert!(!server.sessions[&id].remotes.contains_key(&group));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remote_ids_remain_stable_and_do_not_collide_with_local_tabs_or_other_mirrors() {
|
||||
let mut local = session(1);
|
||||
@@ -702,6 +857,13 @@ mod tests {
|
||||
let group = reserve(&mut local, 0);
|
||||
assert_eq!(local.active_tab, group);
|
||||
assert!(local.snapshot().panes.is_empty());
|
||||
let output = Arc::new(Outbox::default());
|
||||
assert!(
|
||||
local
|
||||
.command(ClientMessage::Close { id: group }, &output)
|
||||
.is_err()
|
||||
);
|
||||
assert!(local.remotes.contains_key(&group));
|
||||
remote.new_tab(None).unwrap();
|
||||
remote.new_tab(None).unwrap();
|
||||
// The peers allocated exactly the same tab/pane IDs.
|
||||
@@ -720,6 +882,12 @@ mod tests {
|
||||
assert_eq!(local.snapshot().panes[0].id, remote_pane);
|
||||
assert_ne!(remote_pane, right.active_pane);
|
||||
let first_remote = local.tabs[1].id;
|
||||
assert!(
|
||||
local
|
||||
.command(ClientMessage::Close { id: first_remote }, &output)
|
||||
.is_err()
|
||||
);
|
||||
assert!(local.remotes.contains_key(&group));
|
||||
local.focus_tab(left.id).unwrap();
|
||||
let second = reserve(&mut local, 0);
|
||||
apply(&mut local, second, remote.snapshot()).unwrap();
|
||||
@@ -753,8 +921,13 @@ mod tests {
|
||||
#[test]
|
||||
fn copies_from_different_views_are_serialized_and_disconnect_completes_waiters() {
|
||||
let upstream = super::super::tests::TestServer::start();
|
||||
let (client, updates) =
|
||||
Transport::connect(&upstream.socket, None, SessionTarget::New { cwd: None }).unwrap();
|
||||
let (client, updates) = Transport::connect(
|
||||
&upstream.socket,
|
||||
None,
|
||||
SessionTarget::New { cwd: None },
|
||||
SshOptions::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let receive = receive_updates(updates);
|
||||
let mut local = session(1);
|
||||
local.new_tab(None).unwrap();
|
||||
@@ -817,7 +990,7 @@ mod tests {
|
||||
.to_string()
|
||||
.contains("inside itself")
|
||||
);
|
||||
local.cancel_pending_tab(group).unwrap();
|
||||
assert_eq!(local.detach_remote(group).unwrap(), None);
|
||||
assert!(cancelled.load(Ordering::Acquire));
|
||||
assert_eq!(local.active_tab, anchor);
|
||||
assert_eq!(local.tabs.len(), 1);
|
||||
|
||||
Reference in New Issue
Block a user