Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
remote: Separate handshake and resync timeouts during remote reconnection (#65457)
狐狸b25dc0937022
diff --git a/crates/remote/src/remote_client.rs b/crates/remote/src/remote_client.rsindex 1563a95f43b..70c70537e5a 100644--- a/crates/remote/src/remote_client.rs+++ b/crates/remote/src/remote_client.rs@@ -163,6 +163,9 @@ const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);const HEARTBEAT_TIMEOUT: Duration = Duration::from_secs(5);const INITIAL_CONNECTION_TIMEOUT: Duration =Duration::from_secs(if cfg!(debug_assertions) { 5 } else { 60 });+const RECONNECT_HANDSHAKE_TIMEOUT: Duration =+ Duration::from_secs(if cfg!(debug_assertions) { 5 } else { 15 });+const RESYNC_TIMEOUT: Duration = Duration::from_secs(if cfg!(debug_assertions) { 5 } else { 15 });pub const MAX_RECONNECT_ATTEMPTS: usize = 3;@@ -715,9 +718,20 @@ impl RemoteClient {};let multiplex_task = Self::monitor(this.clone(), io_task, cx);- client.reconnect(incoming_rx, outgoing_tx, cx);+ let connection_ready_rx = client.reconnect(incoming_rx, outgoing_tx, cx);+ let resync = client.resync(RESYNC_TIMEOUT);- if let Err(error) = client.resync(HEARTBEAT_TIMEOUT).await {+ if let Err(error) = async {+ connection_ready_rx+ .with_timeout(RECONNECT_HANDSHAKE_TIMEOUT, cx.background_executor())+ .await+ .context("Timed out waiting for remote connection")?+ .context("Remote connection closed before becoming ready")?;++ resync.await+ }+ .await+ {failed!(error, attempts, remote_connection, delegate);};@@ -1401,208 +1415,6 @@ impl RemoteConnectionOptions {}}-#[cfg(test)]-mod tests {- use super::*;- use gpui::TestAppContext;- use rpc::{ErrorCodeExt, proto::ErrorCode};-- #[test]- fn test_ssh_display_name_prefers_nickname() {- let options = RemoteConnectionOptions::Ssh(SshConnectionOptions {- host: "1.2.3.4".into(),- nickname: Some("My Cool Project".to_string()),- ..Default::default()- });-- assert_eq!(options.display_name(), "My Cool Project");- }-- #[test]- fn test_ssh_display_name_falls_back_to_host() {- let options = RemoteConnectionOptions::Ssh(SshConnectionOptions {- host: "1.2.3.4".into(),- ..Default::default()- });-- assert_eq!(options.display_name(), "1.2.3.4");- }-- #[test]- fn test_connection_type() {- assert_eq!(- RemoteConnectionOptions::Ssh(SshConnectionOptions::default()).connection_type(),- "ssh"- );- assert_eq!(- RemoteConnectionOptions::Wsl(WslConnectionOptions {- distro_name: "Ubuntu".to_string(),- user: None,- })- .connection_type(),- "wsl"- );- assert_eq!(- RemoteConnectionOptions::Docker(DockerConnectionOptions {- use_podman: false,- ..Default::default()- })- .connection_type(),- "docker"- );- assert_eq!(- RemoteConnectionOptions::Docker(DockerConnectionOptions {- use_podman: true,- ..Default::default()- })- .connection_type(),- "podman"- );- }-- #[gpui::test]- async fn test_channel_client_request_stream_terminates_on_error(cx: &mut TestAppContext) {- let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();- let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();-- let client =- cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "test-client", false));-- // The client sends RemoteStarted on startup; drain the outgoing channel- // so it doesn't block.- let _drain_outgoing = cx- .executor()- .spawn(async move { while outgoing_rx.next().await.is_some() {} });-- let mut stream = client- .request_stream_dynamic(proto::Test { id: 0 }.into_envelope(0, None, None), "Test")- .await- .unwrap();-- let request_id = 0;-- incoming_tx- .unbounded_send(proto::Test { id: 1 }.into_envelope(100, Some(request_id), None))- .unwrap();-- let first = stream.next().await.unwrap().unwrap();- assert_eq!(- proto::Test::from_envelope(first).unwrap(),- proto::Test { id: 1 }- );-- // Send an Error without a trailing EndStream. The Error alone should- // terminate the stream.- incoming_tx- .unbounded_send(- ErrorCode::Internal- .message("boom".to_string())- .to_proto()- .into_envelope(101, Some(request_id), None),- )- .unwrap();-- let second = stream.next().await.unwrap();- let error = second.unwrap_err();- assert!(- format!("{error}").contains("boom"),- "expected error to surface server message, got: {error}"- );-- assert!(stream.next().await.is_none());- assert_eq!(client.stream_response_channels.lock().len(), 0);- }-- #[gpui::test]- async fn test_channel_client_dropping_stream_request_before_response_cleans_up_channel(- cx: &mut TestAppContext,- ) {- let (_incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();- let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();-- let client =- cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "test-client", false));-- let _drain_outgoing = cx- .executor()- .spawn(async move { while outgoing_rx.next().await.is_some() {} });-- let stream = client- .request_stream_dynamic(proto::Test { id: 0 }.into_envelope(0, None, None), "Test")- .await- .unwrap();-- assert_eq!(client.stream_response_channels.lock().len(), 1);-- drop(stream);- cx.run_until_parked();-- assert_eq!(- client.stream_response_channels.lock().len(),- 0,- "dropping a stream before any responses arrive should remove response channel bookkeeping"- );- }-- #[gpui::test]- async fn test_channel_client_dropping_stream_request_before_completion(- cx: &mut TestAppContext,- ) {- let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();- let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();-- let client =- cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "test-client", false));-- let _drain_outgoing = cx- .executor()- .spawn(async move { while outgoing_rx.next().await.is_some() {} });-- let mut stream = client- .request_stream_dynamic(proto::Test { id: 0 }.into_envelope(0, None, None), "Test")- .await- .unwrap();-- let request_id = 0;-- incoming_tx- .unbounded_send(proto::Test { id: 1 }.into_envelope(100, Some(request_id), None))- .unwrap();- let _ = stream.next().await.unwrap().unwrap();-- assert_eq!(client.stream_response_channels.lock().len(), 1);-- drop(stream);-- // Inject an orphaned non-terminal response. The read loop should detect- // that the consumer has been dropped and clean up its bookkeeping (no- // EndStream sent here on purpose, otherwise the cleanup would happen- // via the terminal-response path and mask the bug under test).- incoming_tx- .unbounded_send(proto::Test { id: 2 }.into_envelope(101, Some(request_id), None))- .unwrap();-- cx.run_until_parked();-- assert_eq!(- client.stream_response_channels.lock().len(),- 0,- "stream channel should be removed once the consumer has dropped the stream"- );- }-- #[test]- fn test_ssh_host_ignores_nickname() {- let options = RemoteConnectionOptions::Ssh(SshConnectionOptions {- host: "1.2.3.4".into(),- nickname: Some("My Cool Project".to_string()),- ..Default::default()- });-- assert_eq!(options.host(), "1.2.3.4");- }-}-impl From<SshConnectionOptions> for RemoteConnectionOptions {fn from(opts: SshConnectionOptions) -> Self {RemoteConnectionOptions::Ssh(opts)@@ -1769,163 +1581,215 @@ impl ChannelClient {self.remote_started.wait()}+ fn send_handshake(&self) -> Result<u32> {+ let handshake_id = self.next_message_id.fetch_add(1, SeqCst);+ let envelope = proto::RemoteStarted {}.into_envelope(handshake_id, None, None);+ self.outgoing_tx.lock().unbounded_send(envelope)?;+ Ok(handshake_id)+ }+fn start_handling_messages(this: Weak<Self>,- mut incoming_rx: mpsc::UnboundedReceiver<Envelope>,+ incoming_rx: mpsc::UnboundedReceiver<Envelope>,cx: &AsyncApp,) -> Task<Result<()>> {cx.spawn(async move |cx| {- if let Some(this) = this.upgrade() {- let envelope = proto::RemoteStarted {}.into_envelope(0, None, None);- this.outgoing_tx.lock().unbounded_send(envelope).ok();+ let handshake_id = if let Some(this) = this.upgrade() {+ this.send_handshake()?+ } else {+ return anyhow::Ok(());};- let peer_id = PeerId { owner_id: 0, id: 0 };- while let Some(incoming) = incoming_rx.next().await {- let Some(this) = this.upgrade() else {- return anyhow::Ok(());- };- if let Some(ack_id) = incoming.ack_id {- let mut buffer = this.buffer.lock();- while buffer.front().is_some_and(|msg| msg.id <= ack_id) {- buffer.pop_front();- }- }- if let Some(proto::envelope::Payload::FlushBufferedMessages(_)) = &incoming.payload- {- log::debug!(- "{}:remote message received. name:FlushBufferedMessages",- this.name- );- {- let buffer = this.buffer.lock();- for envelope in buffer.iter() {- this.outgoing_tx- .lock()- .unbounded_send(envelope.clone())- .ok();- }- }- let mut envelope = proto::Ack {}.into_envelope(0, Some(incoming.id), None);- envelope.id = this.next_message_id.fetch_add(1, SeqCst);- this.outgoing_tx.lock().unbounded_send(envelope).ok();- continue;- }+ Self::read_messages(this, incoming_rx, handshake_id, cx).await+ })+ }- if let Some(proto::envelope::Payload::RemoteStarted(_)) = &incoming.payload {- this.remote_started.set(());- let mut envelope = proto::Ack {}.into_envelope(0, Some(incoming.id), None);- envelope.id = this.next_message_id.fetch_add(1, SeqCst);- this.outgoing_tx.lock().unbounded_send(envelope).ok();- continue;+ async fn read_messages(+ this: Weak<Self>,+ mut incoming_rx: mpsc::UnboundedReceiver<Envelope>,+ handshake_id: u32,+ cx: &mut AsyncApp,+ ) -> Result<()> {+ while let Some(incoming) = incoming_rx.next().await {+ let Some(this) = this.upgrade() else {+ return anyhow::Ok(());+ };+ if incoming.responding_to == Some(handshake_id)+ && matches!(incoming.payload, Some(proto::envelope::Payload::Ack(_)))+ {+ // Handshake replies do not acknowledge buffered messages that still need replay.+ continue;+ }+ Self::handle_message(this, incoming, cx).await;+ }+ anyhow::Ok(())+ }++ async fn handle_message(this: Arc<Self>, incoming: Envelope, cx: &mut AsyncApp) {+ let peer_id = PeerId { owner_id: 0, id: 0 };+ if let Some(ack_id) = incoming.ack_id {+ let mut buffer = this.buffer.lock();+ while buffer.front().is_some_and(|msg| msg.id <= ack_id) {+ buffer.pop_front();+ }+ }+ if let Some(proto::envelope::Payload::FlushBufferedMessages(_)) = &incoming.payload {+ log::debug!(+ "{}:remote message received. name:FlushBufferedMessages",+ this.name+ );+ {+ let buffer = this.buffer.lock();+ for envelope in buffer.iter() {+ this.outgoing_tx+ .lock()+ .unbounded_send(envelope.clone())+ .ok();}+ }+ let mut envelope = proto::Ack {}.into_envelope(0, Some(incoming.id), None);+ envelope.id = this.next_message_id.fetch_add(1, SeqCst);+ this.outgoing_tx.lock().unbounded_send(envelope).ok();+ return;+ }++ if let Some(proto::envelope::Payload::RemoteStarted(_)) = &incoming.payload {+ this.remote_started.set(());+ let mut envelope = proto::Ack {}.into_envelope(0, Some(incoming.id), None);+ envelope.id = this.next_message_id.fetch_add(1, SeqCst);+ this.outgoing_tx.lock().unbounded_send(envelope).ok();+ return;+ }- this.max_received.store(incoming.id, SeqCst);+ this.max_received.store(incoming.id, SeqCst);- if let Some(request_id) = incoming.responding_to {- let request_id = MessageId(request_id);- // An incoming response with no payload is malformed; drop- // it. The request future and any stream consumers will- // remain pending until either a real response arrives or- // the connection is torn down.- if incoming.payload.is_none() {- continue;+ if let Some(request_id) = incoming.responding_to {+ let request_id = MessageId(request_id);+ // An incoming response with no payload is malformed; drop+ // it. The request future and any stream consumers will+ // remain pending until either a real response arrives or+ // the connection is torn down.+ if incoming.payload.is_none() {+ return;+ }+ let sender = this.response_channels.lock().remove(&request_id);+ if let Some(sender) = sender {+ let (tx, rx) = oneshot::channel();+ sender.send((incoming, tx)).ok();+ rx.await.ok();+ } else {+ let terminal_stream_response = matches!(+ &incoming.payload,+ Some(proto::envelope::Payload::Error(_))+ | Some(proto::envelope::Payload::EndStream(_))+ );+ let sender = if terminal_stream_response {+ this.stream_response_channels.lock().remove(&request_id)+ } else {+ this.stream_response_channels+ .lock()+ .get(&request_id)+ .cloned()+ };+ if let Some(sender) = sender {+ let (tx, rx) = oneshot::channel();+ if sender.unbounded_send((Ok(incoming), tx)).is_err() {+ this.stream_response_channels.lock().remove(&request_id);+ return;}- let sender = this.response_channels.lock().remove(&request_id);- if let Some(sender) = sender {- let (tx, rx) = oneshot::channel();- sender.send((incoming, tx)).ok();- rx.await.ok();- } else {- let terminal_stream_response = matches!(- &incoming.payload,- Some(proto::envelope::Payload::Error(_))- | Some(proto::envelope::Payload::EndStream(_))- );- let sender = if terminal_stream_response {- this.stream_response_channels.lock().remove(&request_id)- } else {- this.stream_response_channels- .lock()- .get(&request_id)- .cloned()- };- if let Some(sender) = sender {- let (tx, rx) = oneshot::channel();- if sender.unbounded_send((Ok(incoming), tx)).is_err() {- this.stream_response_channels.lock().remove(&request_id);- continue;+ rx.await.ok();+ }+ }+ } else if let Some(envelope) = build_typed_envelope(peer_id, Instant::now(), incoming) {+ let type_name = envelope.payload_type_name();+ let message_id = envelope.message_id();+ if let Some(future) = ProtoMessageHandlerSet::handle_message(+ &this.message_handlers,+ envelope,+ this.clone().into(),+ cx.clone(),+ ) {+ log::debug!("{}:remote message received. name:{type_name}", this.name);+ cx.foreground_executor()+ .spawn(async move {+ match future.await {+ Ok(_) => {+ log::debug!(+ "{}:remote message handled. name:{type_name}",+ this.name+ );+ }+ Err(error) => {+ log::error!(+ "{}:error handling message. type:{}, error:{:#}",+ this.name,+ type_name,+ format!("{error:#}").lines().fold(+ String::new(),+ |mut message, line| {+ if !message.is_empty() {+ message.push(' ');+ }+ message.push_str(line);+ message+ }+ )+ );}- rx.await.ok();- }- }- } else if let Some(envelope) =- build_typed_envelope(peer_id, Instant::now(), incoming)- {- let type_name = envelope.payload_type_name();- let message_id = envelope.message_id();- if let Some(future) = ProtoMessageHandlerSet::handle_message(- &this.message_handlers,- envelope,- this.clone().into(),- cx.clone(),- ) {- log::debug!("{}:remote message received. name:{type_name}", this.name);- cx.foreground_executor()- .spawn(async move {- match future.await {- Ok(_) => {- log::debug!(- "{}:remote message handled. name:{type_name}",- this.name- );- }- Err(error) => {- log::error!(- "{}:error handling message. type:{}, error:{:#}",- this.name,- type_name,- format!("{error:#}").lines().fold(- String::new(),- |mut message, line| {- if !message.is_empty() {- message.push(' ');- }- message.push_str(line);- message- }- )- );- }- }- })- .detach()- } else {- log::error!("{}:unhandled remote message name:{type_name}", this.name);- if let Err(e) = AnyProtoClient::from(this.clone()).send_response(- message_id,- anyhow::anyhow!("no handler registered for {type_name}").to_proto(),- ) {- log::error!(- "{}:error sending error response for {type_name}:{e:#}",- this.name- );}- }+ })+ .detach()+ } else {+ log::error!("{}:unhandled remote message name:{type_name}", this.name);+ if let Err(e) = AnyProtoClient::from(this.clone()).send_response(+ message_id,+ anyhow::anyhow!("no handler registered for {type_name}").to_proto(),+ ) {+ log::error!(+ "{}:error sending error response for {type_name}:{e:#}",+ this.name+ );}}- anyhow::Ok(())- })+ }}pub(crate) fn reconnect(self: &Arc<Self>,- incoming_rx: UnboundedReceiver<Envelope>,+ mut incoming_rx: UnboundedReceiver<Envelope>,outgoing_tx: UnboundedSender<Envelope>,cx: &AsyncApp,- ) {+ ) -> oneshot::Receiver<()> {*self.outgoing_tx.lock() = outgoing_tx;- *self.task.lock() = Self::start_handling_messages(Arc::downgrade(self), incoming_rx, cx);+ let handshake_id = self.send_handshake();+ let (connection_ready_tx, connection_ready_rx) = oneshot::channel();++ *self.task.lock() = cx.spawn({+ let this = Arc::downgrade(self);+ async move |cx| {+ let handshake_id = handshake_id?;++ loop {+ let Some(incoming) = incoming_rx.next().await else {+ return anyhow::Ok(());+ };+ let Some(this) = this.upgrade() else {+ return anyhow::Ok(());+ };+ if incoming.responding_to == Some(handshake_id)+ && matches!(incoming.payload, Some(proto::envelope::Payload::Ack(_)))+ {+ connection_ready_tx.send(()).ok();+ break;+ }+ Self::handle_message(this, incoming, cx).await;+ }++ Self::read_messages(this, incoming_rx, handshake_id, cx).await+ }+ });++ connection_ready_rx}fn request<T: RequestMessage>(@@ -1950,26 +1814,26 @@ impl ChannelClient {}}- async fn resync(&self, timeout: Duration) -> Result<()> {- smol::future::or(- async {- self.request_internal(proto::FlushBufferedMessages {}, false)- .await?;+ fn resync(&self, timeout: Duration) -> impl Future<Output = Result<()>> {+ // Queue the flush before waiting for the handshake, or its ack_id could+ // cause the server to discard messages we missed while disconnected.+ let response = self.request_internal(proto::FlushBufferedMessages {}, false);- for envelope in self.buffer.lock().iter() {- self.outgoing_tx- .lock()- .unbounded_send(envelope.clone())- .ok();- }- Ok(())- },- async {- self.executor.timer(timeout).await;- anyhow::bail!("Timed out resyncing remote client")- },- )- .await+ async move {+ response+ .with_timeout(timeout, &self.executor)+ .await+ .context("Timed out resyncing remote client")??;++ for envelope in self.buffer.lock().iter() {+ self.outgoing_tx+ .lock()+ .unbounded_send(envelope.clone())+ .ok();+ }++ Ok(())+ }}async fn ping(&self, timeout: Duration) -> Result<()> {@@ -2129,3 +1993,336 @@ impl ProtoClient for ChannelClient {self.has_wsl_interop}}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::transport::mock::{MockConnection, MockConnectionRegistry, MockDelegate};+ use gpui::TestAppContext;+ use rpc::{ErrorCodeExt, proto::ErrorCode};++ #[test]+ fn test_ssh_display_name_prefers_nickname() {+ let options = RemoteConnectionOptions::Ssh(SshConnectionOptions {+ host: "1.2.3.4".into(),+ nickname: Some("My Cool Project".to_string()),+ ..Default::default()+ });++ assert_eq!(options.display_name(), "My Cool Project");+ }++ #[test]+ fn test_ssh_display_name_falls_back_to_host() {+ let options = RemoteConnectionOptions::Ssh(SshConnectionOptions {+ host: "1.2.3.4".into(),+ ..Default::default()+ });++ assert_eq!(options.display_name(), "1.2.3.4");+ }++ #[test]+ fn test_connection_type() {+ assert_eq!(+ RemoteConnectionOptions::Ssh(SshConnectionOptions::default()).connection_type(),+ "ssh"+ );+ assert_eq!(+ RemoteConnectionOptions::Wsl(WslConnectionOptions {+ distro_name: "Ubuntu".to_string(),+ user: None,+ })+ .connection_type(),+ "wsl"+ );+ assert_eq!(+ RemoteConnectionOptions::Docker(DockerConnectionOptions {+ use_podman: false,+ ..Default::default()+ })+ .connection_type(),+ "docker"+ );+ assert_eq!(+ RemoteConnectionOptions::Docker(DockerConnectionOptions {+ use_podman: true,+ ..Default::default()+ })+ .connection_type(),+ "podman"+ );+ }++ #[gpui::test]+ async fn test_resync_timeout_starts_after_the_handshake(+ cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+ ) {+ let (options, _, connect_guard) = MockConnection::new(cx, server_cx);+ drop(connect_guard);+ let connection = cx+ .update(|cx| {+ cx.default_global::<MockConnectionRegistry>()+ .take(&options)+ .unwrap()+ })+ .await;++ let (proxy_tx, mut proxy_rx) = mpsc::unbounded();+ *connection.proxy_tx.lock() = Some(proxy_tx);+ let connection: Arc<dyn RemoteConnection> = connection;++ let (_cancellation_tx, cancellation_rx) = oneshot::channel();+ let initial_connection = cx.update(|cx| {+ release_channel::init_test(Version::new(0, 0, 0), ReleaseChannel::Dev, cx);+ cx.default_global::<ConnectionPool>().connections.insert(+ connection.connection_options(),+ ConnectionPoolEntry::Connected(Arc::downgrade(&connection)),+ );+ RemoteClient::new(+ ConnectionIdentifier::setup(),+ connection,+ cancellation_rx,+ Arc::new(MockDelegate),+ cx,+ )+ });++ let (incoming_tx, mut outgoing_rx) = proxy_rx.next().await.unwrap();+ let initial_handshake = outgoing_rx.next().await.unwrap();+ assert!(matches!(+ initial_handshake.payload,+ Some(proto::envelope::Payload::RemoteStarted(_))+ ));+ incoming_tx+ .unbounded_send(proto::RemoteStarted {}.into_envelope(0, None, None))+ .unwrap();+ outgoing_rx.next().await.unwrap();++ let ping = outgoing_rx.next().await.unwrap();+ let last_response_id = 2;+ let mut ping_response = proto::Ack {}.into_envelope(last_response_id, Some(ping.id), None);+ ping_response.ack_id = Some(ping.id);+ incoming_tx.unbounded_send(ping_response).unwrap();+ let remote = initial_connection.await.unwrap().unwrap();++ remote.update(cx, |remote, _| {+ remote.client.send(proto::Test { id: 1 }).unwrap();+ remote.client.send(proto::Test { id: 2 }).unwrap();+ });+ let unacknowledged_messages = [+ outgoing_rx.next().await.unwrap(),+ outgoing_rx.next().await.unwrap(),+ ];++ remote.update(cx, |remote, cx| remote.reconnect(cx).unwrap());+ let (incoming_tx, mut outgoing_rx) = proxy_rx.next().await.unwrap();+ let reconnect_handshake = outgoing_rx.next().await.unwrap();+ assert!(matches!(+ reconnect_handshake.payload,+ Some(proto::envelope::Payload::RemoteStarted(_))+ ));+ assert_ne!(reconnect_handshake.id, initial_handshake.id);++ let flush_request = outgoing_rx.next().await.unwrap();+ assert!(matches!(+ flush_request.payload,+ Some(proto::envelope::Payload::FlushBufferedMessages(_))+ ));+ assert_eq!(flush_request.ack_id, Some(last_response_id));++ incoming_tx+ .unbounded_send(proto::Ack {}.into_envelope(98, Some(ping.id), None))+ .unwrap();++ let server_greeting_id = 99;+ incoming_tx+ .unbounded_send(proto::RemoteStarted {}.into_envelope(server_greeting_id, None, None))+ .unwrap();+ let greeting_ack = outgoing_rx.next().await.unwrap();+ assert_eq!(greeting_ack.responding_to, Some(server_greeting_id));+ assert!(matches!(+ greeting_ack.payload,+ Some(proto::envelope::Payload::Ack(_))+ ));+ assert!(outgoing_rx.next().now_or_never().is_none());++ cx.background_executor+ .timer(RECONNECT_HANDSHAKE_TIMEOUT - Duration::from_secs(1))+ .await;++ incoming_tx+ .unbounded_send(proto::Ack {}.into_envelope(100, Some(reconnect_handshake.id), None))+ .unwrap();++ cx.background_executor.timer(RESYNC_TIMEOUT / 2).await;+ assert_eq!(+ remote.read_with(cx, |remote, _| remote.connection_state()),+ ConnectionState::Reconnecting+ );++ remote.update(cx, |remote, _| {+ remote.client.send(proto::Test { id: 3 }).unwrap();+ });+ let message_during_resync = outgoing_rx.next().await.unwrap();+ assert_eq!(message_during_resync.ack_id, Some(98));++ incoming_tx+ .unbounded_send(proto::Ack {}.into_envelope(101, Some(flush_request.id), None))+ .unwrap();++ cx.condition(&remote, |remote, _| {+ remote.connection_state() == ConnectionState::Connected+ })+ .await;++ for expected in unacknowledged_messages {+ assert_eq!(outgoing_rx.next().await.unwrap(), expected);+ }+ assert_eq!(outgoing_rx.next().await.unwrap(), message_during_resync);+ assert!(outgoing_rx.next().now_or_never().is_none());+ }++ #[gpui::test]+ async fn test_channel_client_request_stream_terminates_on_error(cx: &mut TestAppContext) {+ let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();+ let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();++ let client =+ cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "test-client", false));++ // The client sends RemoteStarted on startup; drain the outgoing channel+ // so it doesn't block.+ let _drain_outgoing = cx+ .executor()+ .spawn(async move { while outgoing_rx.next().await.is_some() {} });++ let mut stream = client+ .request_stream_dynamic(proto::Test { id: 0 }.into_envelope(0, None, None), "Test")+ .await+ .unwrap();++ let request_id = 0;++ incoming_tx+ .unbounded_send(proto::Test { id: 1 }.into_envelope(100, Some(request_id), None))+ .unwrap();++ let first = stream.next().await.unwrap().unwrap();+ assert_eq!(+ proto::Test::from_envelope(first).unwrap(),+ proto::Test { id: 1 }+ );++ // Send an Error without a trailing EndStream. The Error alone should+ // terminate the stream.+ incoming_tx+ .unbounded_send(+ ErrorCode::Internal+ .message("boom".to_string())+ .to_proto()+ .into_envelope(101, Some(request_id), None),+ )+ .unwrap();++ let second = stream.next().await.unwrap();+ let error = second.unwrap_err();+ assert!(+ format!("{error}").contains("boom"),+ "expected error to surface server message, got: {error}"+ );++ assert!(stream.next().await.is_none());+ assert_eq!(client.stream_response_channels.lock().len(), 0);+ }++ #[gpui::test]+ async fn test_channel_client_dropping_stream_request_before_response_cleans_up_channel(+ cx: &mut TestAppContext,+ ) {+ let (_incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();+ let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();++ let client =+ cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "test-client", false));++ let _drain_outgoing = cx+ .executor()+ .spawn(async move { while outgoing_rx.next().await.is_some() {} });++ let stream = client+ .request_stream_dynamic(proto::Test { id: 0 }.into_envelope(0, None, None), "Test")+ .await+ .unwrap();++ assert_eq!(client.stream_response_channels.lock().len(), 1);++ drop(stream);+ cx.run_until_parked();++ assert_eq!(+ client.stream_response_channels.lock().len(),+ 0,+ "dropping a stream before any responses arrive should remove response channel bookkeeping"+ );+ }++ #[gpui::test]+ async fn test_channel_client_dropping_stream_request_before_completion(+ cx: &mut TestAppContext,+ ) {+ let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();+ let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();++ let client =+ cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "test-client", false));++ let _drain_outgoing = cx+ .executor()+ .spawn(async move { while outgoing_rx.next().await.is_some() {} });++ let mut stream = client+ .request_stream_dynamic(proto::Test { id: 0 }.into_envelope(0, None, None), "Test")+ .await+ .unwrap();++ let request_id = 0;++ incoming_tx+ .unbounded_send(proto::Test { id: 1 }.into_envelope(100, Some(request_id), None))+ .unwrap();+ let _ = stream.next().await.unwrap().unwrap();++ assert_eq!(client.stream_response_channels.lock().len(), 1);++ drop(stream);++ // Inject an orphaned non-terminal response. The read loop should detect+ // that the consumer has been dropped and clean up its bookkeeping (no+ // EndStream sent here on purpose, otherwise the cleanup would happen+ // via the terminal-response path and mask the bug under test).+ incoming_tx+ .unbounded_send(proto::Test { id: 2 }.into_envelope(101, Some(request_id), None))+ .unwrap();++ cx.run_until_parked();++ assert_eq!(+ client.stream_response_channels.lock().len(),+ 0,+ "stream channel should be removed once the consumer has dropped the stream"+ );+ }++ #[test]+ fn test_ssh_host_ignores_nickname() {+ let options = RemoteConnectionOptions::Ssh(SshConnectionOptions {+ host: "1.2.3.4".into(),+ nickname: Some("My Cool Project".to_string()),+ ..Default::default()+ });++ assert_eq!(options.host(), "1.2.3.4");+ }+}diff --git a/crates/remote/src/transport/mock.rs b/crates/remote/src/transport/mock.rsindex 79a4587de6f..734b98bf7a0 100644--- a/crates/remote/src/transport/mock.rs+++ b/crates/remote/src/transport/mock.rs@@ -69,6 +69,14 @@ pub struct MockRemoteConnection {options: MockConnectionOptions,server_channel: Arc<ChannelClient>,server_cx: SendableCx,+ pub(crate) proxy_tx: parking_lot::Mutex<+ Option<+ mpsc::UnboundedSender<(+ mpsc::UnboundedSender<Envelope>,+ mpsc::UnboundedReceiver<Envelope>,+ )>,+ >,+ >,}/// Wrapper to pass `AsyncApp` across thread boundaries in tests.@@ -172,6 +180,7 @@ impl MockConnection {options: opts.clone(),server_channel: server_client.clone(),server_cx: SendableCx::new(server_cx),+ proxy_tx: Default::default(),});let (tx, rx) = oneshot::channel();@@ -251,8 +260,10 @@ impl RemoteConnection for MockRemoteConnection {fn simulate_disconnect(&self, cx: &AsyncApp) {let (outgoing_tx, _) = mpsc::unbounded::<Envelope>();let (_, incoming_rx) = mpsc::unbounded::<Envelope>();- self.server_channel- .reconnect(incoming_rx, outgoing_tx, &self.server_cx.get(cx));+ drop(+ self.server_channel+ .reconnect(incoming_rx, outgoing_tx, &self.server_cx.get(cx)),+ );}fn start_proxy(@@ -265,14 +276,24 @@ impl RemoteConnection for MockRemoteConnection {_delegate: Arc<dyn RemoteClientDelegate>,cx: &mut AsyncApp,) -> Task<Result<i32>> {+ if let Some(proxy_tx) = self.proxy_tx.lock().as_ref() {+ proxy_tx+ .unbounded_send((client_incoming_tx, client_outgoing_rx))+ .unwrap();+ return cx.background_spawn(async move {+ let _connection_activity_tx = connection_activity_tx;+ futures::future::pending().await+ });+ }+let (mut server_incoming_tx, server_incoming_rx) = mpsc::unbounded::<Envelope>();let (server_outgoing_tx, mut server_outgoing_rx) = mpsc::unbounded::<Envelope>();- self.server_channel.reconnect(+ drop(self.server_channel.reconnect(server_incoming_rx,server_outgoing_tx,&self.server_cx.get(cx),- );+ ));cx.background_spawn(async move {loop {