guest_cli/
attach.rs

1// Copyright 2022 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::platform::{GuestConsole, PlatformServices, Stdio};
6use anyhow::{anyhow, Error};
7use fidl::endpoints::create_proxy;
8use fidl_fuchsia_virtualization::{GuestMarker, GuestProxy, GuestStatus};
9use std::fmt;
10use {fuchsia_async as fasync, guest_cli_args as arguments};
11
12#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
13pub enum AttachResult {
14    Attached,
15    NotRunning,
16    AttachFailure,
17}
18
19impl fmt::Display for AttachResult {
20    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
21        match self {
22            AttachResult::Attached => {
23                write!(f, "Disconnected from guest after a successful attach")
24            }
25            AttachResult::NotRunning => write!(f, "Can't attach to a non-running guest"),
26            AttachResult::AttachFailure => write!(f, "Failed to attach to guest"),
27        }
28    }
29}
30
31pub async fn handle_attach<P: PlatformServices>(
32    services: &P,
33    args: &arguments::attach_args::AttachArgs,
34) -> Result<AttachResult, Error> {
35    let manager = services.connect_to_manager(args.guest_type).await?;
36    let status = manager.get_info().await?.guest_status.expect("guest status should always be set");
37    if status != GuestStatus::Starting && status != GuestStatus::Running {
38        return Ok(AttachResult::NotRunning);
39    }
40
41    let (guest_endpoint, guest_server_end) = create_proxy::<GuestMarker>();
42    manager
43        .connect(guest_server_end)
44        .await
45        .map_err(|err| anyhow!("failed to get a connect response: {}", err))?
46        .map_err(|err| anyhow!("connect failed with: {:?}", err))?;
47
48    Ok(match attach(guest_endpoint, args.serial).await {
49        Ok(()) => AttachResult::Attached,
50        Err(_) => AttachResult::AttachFailure,
51    })
52}
53
54pub async fn attach(guest: GuestProxy, serial_only: bool) -> Result<(), Error> {
55    if serial_only {
56        attach_serial(guest).await
57    } else {
58        attach_console_and_serial(guest).await
59    }
60}
61
62// Attach to a running guest, using the guest's virtio-console and serial output for stdout, and
63// the guest's virtio-console for stdin.
64async fn attach_console_and_serial(guest: GuestProxy) -> Result<(), Error> {
65    // Tie serial output to stdout.
66    let guest_serial_response = guest.get_serial().await?;
67    let guest_serial = fasync::Socket::from_socket(guest_serial_response);
68    let serial_output = async {
69        futures::io::copy(guest_serial, &mut GuestConsole::get_unblocked_stdio(Stdio::Stdout))
70            .await
71            .map(|_| ())
72            .map_err(anyhow::Error::from)
73    };
74
75    // Host doesn't currently support duplicating Fuchsia handles, so just call get console twice
76    // and let the VMM duplicate the socket for reading and writing.
77    let console_input = guest.get_console().await?.map_err(|err| anyhow!(format!("{:?}", err)))?;
78    let console_output = guest.get_console().await?.map_err(|err| anyhow!(format!("{:?}", err)))?;
79    let guest_console = GuestConsole::new(console_input, console_output)?;
80
81    futures::future::try_join(serial_output, guest_console.run_with_stdio())
82        .await
83        .map(|_| ())
84        .map_err(anyhow::Error::from)
85}
86
87// Attach to a running guest using serial for stdout and stdin.
88async fn attach_serial(guest: GuestProxy) -> Result<(), Error> {
89    // Host doesn't currently support duplicating Fuchsia handles, so just call get serial twice
90    // and let the VMM duplicate the socket for reading and writing.
91    let serial_input = guest.get_serial().await?;
92    let serial_output = guest.get_serial().await?;
93
94    let guest_console = GuestConsole::new(serial_input, serial_output)?;
95    guest_console.run_with_stdio().await
96}
97
98#[cfg(test)]
99mod test {
100    use super::*;
101    use fidl::endpoints::create_proxy_and_stream;
102    use fidl::Socket;
103    use fidl_fuchsia_virtualization::GuestError;
104    use futures::future::join;
105    use futures::StreamExt;
106
107    #[fasync::run_until_stalled(test)]
108    async fn launch_invalid_console_returns_error() {
109        let (guest_proxy, mut guest_stream) = create_proxy_and_stream::<GuestMarker>();
110        let (serial_launch_sock, _serial_server_sock) = Socket::create_stream();
111
112        let server = async move {
113            let serial_responder = guest_stream
114                .next()
115                .await
116                .expect("Failed to read from stream")
117                .expect("Failed to parse request")
118                .into_get_serial()
119                .expect("Unexpected call to Guest Proxy");
120            serial_responder.send(serial_launch_sock).expect("Failed to send response to proxy");
121
122            let console_responder = guest_stream
123                .next()
124                .await
125                .expect("Failed to read from stream")
126                .expect("Failed to parse request")
127                .into_get_console()
128                .expect("Unexpected call to Guest Proxy");
129            console_responder
130                .send(Err(GuestError::DeviceNotPresent))
131                .expect("Failed to send response to proxy");
132        };
133
134        let client = attach(guest_proxy, false);
135        let (_, client_res) = join(server, client).await;
136        assert!(client_res.is_err());
137    }
138}
guest_cli/attach.rs

guest_cli/
attach.rs
