krata: reorganize crates

crates/kratactl/src/client.rs

@@ -0,0 +1,44 @@
+use anyhow::Result;
+use krata::{control::control_service_client::ControlServiceClient, dial::ControlDialAddress};
+use tokio::net::UnixStream;
+use tonic::transport::{Channel, ClientTlsConfig, Endpoint, Uri};
+use tower::service_fn;
+
+pub struct ControlClientProvider {}
+
+impl ControlClientProvider {
+    pub async fn dial(addr: ControlDialAddress) -> Result<ControlServiceClient<Channel>> {
+        let channel = match addr {
+            ControlDialAddress::UnixSocket { path } => {
+                // This URL is not actually used but is required to be specified.
+                Endpoint::try_from(format!("unix://localhost/{}", path))?
+                    .connect_with_connector(service_fn(|uri: Uri| {
+                        let path = uri.path().to_string();
+                        UnixStream::connect(path)
+                    }))
+                    .await?
+            }
+
+            ControlDialAddress::Tcp { host, port } => {
+                Endpoint::try_from(format!("http://{}:{}", host, port))?
+                    .connect()
+                    .await?
+            }
+
+            ControlDialAddress::Tls {
+                host,
+                port,
+                insecure: _,
+            } => {
+                let tls_config = ClientTlsConfig::new().domain_name(&host);
+                let address = format!("https://{}:{}", host, port);
+                Channel::from_shared(address)?
+                    .tls_config(tls_config)?
+                    .connect()
+                    .await?
+            }
+        };
+
+        Ok(ControlServiceClient::new(channel))
+    }
+}

crates/kratactl/src/console.rs

@@ -0,0 +1,57 @@
+use std::{
+    io::stdout,
+    os::fd::{AsRawFd, FromRawFd},
+};
+
+use anyhow::Result;
+use async_stream::stream;
+use krata::control::{ConsoleDataReply, ConsoleDataRequest};
+use log::debug;
+use termion::raw::IntoRawMode;
+use tokio::{
+    fs::File,
+    io::{stdin, AsyncReadExt, AsyncWriteExt},
+};
+use tokio_stream::{Stream, StreamExt};
+use tonic::Streaming;
+
+pub struct StdioConsoleStream;
+
+impl StdioConsoleStream {
+    pub async fn stdin_stream(guest: String) -> impl Stream<Item = ConsoleDataRequest> {
+        let mut stdin = stdin();
+        stream! {
+            yield ConsoleDataRequest { guest_id: guest, data: vec![] };
+
+            let mut buffer = vec![0u8; 60];
+            loop {
+                let size = match stdin.read(&mut buffer).await {
+                    Ok(size) => size,
+                    Err(error) => {
+                        debug!("failed to read stdin: {}", error);
+                        break;
+                    }
+                };
+                let data = buffer[0..size].to_vec();
+                if size == 1 && buffer[0] == 0x1d {
+                    break;
+                }
+                yield ConsoleDataRequest { guest_id: String::default(), data };
+            }
+        }
+    }
+
+    pub async fn stdout(mut stream: Streaming<ConsoleDataReply>) -> Result<()> {
+        let terminal = stdout().into_raw_mode()?;
+        let mut stdout = unsafe { File::from_raw_fd(terminal.as_raw_fd()) };
+        while let Some(reply) = stream.next().await {
+            let reply = reply?;
+            if reply.data.is_empty() {
+                continue;
+            }
+            stdout.write_all(&reply.data).await?;
+            stdout.flush().await?;
+        }
+        Ok(())
+    }
+}

crates/kratactl/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod client;
+pub mod console;