vsh_rust_proto/

vm_tools.vsh.rs

/// Request to set up a connection to a container. This must be the first
/// message sent to the server from the client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetupConnectionRequest {
    /// Target container. "vm_shell" is a special value to get a VM shell.
    #[prost(string, tag="1")]
    pub target: ::prost::alloc::string::String,
    /// User to execute the target program.
    #[prost(string, tag="2")]
    pub user: ::prost::alloc::string::String,
    /// Map of environment variables to forward.
    #[prost(map="string, string", tag="3")]
    pub env: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// Deprecated. Target command. Empty indicates a login shell.
    #[prost(string, tag="4")]
    pub command: ::prost::alloc::string::String,
    /// Argv of the target program to run. Empty indicates a login shell.
    #[prost(string, repeated, tag="5")]
    pub argv: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Initial window size (rows) of the pty.
    #[prost(int32, tag="6")]
    pub window_rows: i32,
    /// Initial window size (cols) of the pty.
    #[prost(int32, tag="7")]
    pub window_cols: i32,
    /// True if using a noninteractive client and a pty should not be allocated.
    /// The logic here is inverted to keep backwards compatibility with the
    /// current behavior (always allocate a pty).
    #[prost(bool, tag="8")]
    pub nopty: bool,
    /// Optional: directory to set for current working directory.
    #[prost(string, tag="9")]
    pub cwd: ::prost::alloc::string::String,
    /// Optional: use /proc/<cwd_pid>/cwd for current working directory.
    #[prost(int32, tag="10")]
    pub cwd_pid: i32,
}
/// Response to a SetupConnectionRequest.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetupConnectionResponse {
    /// Status of the connection.
    #[prost(enumeration="ConnectionStatus", tag="1")]
    pub status: i32,
    /// Short description of any error encountered when setting up the
    /// connection.
    #[prost(string, tag="2")]
    pub description: ::prost::alloc::string::String,
    /// Process ID of new shell.
    #[prost(int32, tag="3")]
    pub pid: i32,
}
/// A message that indicates to either the server or the client a change
/// in connection status.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionStatusMessage {
    /// New connection status. If the connection status is changed to anything
    /// except READY, the recipient must shut down.
    #[prost(enumeration="ConnectionStatus", tag="1")]
    pub status: i32,
    /// Short description of any error that triggered the status change.
    #[prost(string, tag="2")]
    pub description: ::prost::alloc::string::String,
    /// Return code of the command, if any.
    #[prost(sint32, tag="3")]
    pub code: i32,
}
/// DataMessages encapsulate stdio to be forwarded between the server and client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataMessage {
    /// Type of stream in this message.
    #[prost(enumeration="StdioStream", tag="1")]
    pub stream: i32,
    /// Data to be forwarded.
    #[prost(bytes="vec", tag="2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Indicates that the server should resize its pseudoterminal to the given
/// dimensions. Sent by the client in response to SIGWINCH.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WindowResizeMessage {
    /// New number of rows for the tty.
    #[prost(int32, tag="1")]
    pub rows: i32,
    /// New number of cols for the tty.
    #[prost(int32, tag="2")]
    pub cols: i32,
}
/// Wrapper message for all messages that can be sent to the host/client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostMessage {
    #[prost(oneof="host_message::Msg", tags="1, 2")]
    pub msg: ::core::option::Option<host_message::Msg>,
}
/// Nested message and enum types in `HostMessage`.
pub mod host_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Msg {
        #[prost(message, tag="1")]
        DataMessage(super::DataMessage),
        #[prost(message, tag="2")]
        StatusMessage(super::ConnectionStatusMessage),
    }
}
/// Wrapper message for all messages that can be sent to the guest/server.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GuestMessage {
    #[prost(oneof="guest_message::Msg", tags="1, 2, 3, 4")]
    pub msg: ::core::option::Option<guest_message::Msg>,
}
/// Nested message and enum types in `GuestMessage`.
pub mod guest_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Msg {
        #[prost(message, tag="1")]
        DataMessage(super::DataMessage),
        #[prost(message, tag="2")]
        StatusMessage(super::ConnectionStatusMessage),
        #[prost(message, tag="3")]
        ResizeMessage(super::WindowResizeMessage),
        #[prost(enumeration="super::Signal", tag="4")]
        Signal(i32),
    }
}
/// Indicates the status of a connection.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ConnectionStatus {
    /// Connection status is unknown.
    Unknown = 0,
    /// Connection was set up successfully. Server and client may now exchange
    /// messages.
    Ready = 1,
    /// The server's target program has exited. The server will immediately close
    /// the connection, and the client is expected to exit after its cleanup.
    Exited = 2,
    /// A fatal error was encountered. The connection will be closed.
    Failed = 3,
}
impl ConnectionStatus {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            ConnectionStatus::Unknown => "UNKNOWN",
            ConnectionStatus::Ready => "READY",
            ConnectionStatus::Exited => "EXITED",
            ConnectionStatus::Failed => "FAILED",
        }
    }
}
/// Type of stdio stream that is being sent.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StdioStream {
    /// The stream is invalid.
    InvalidStream = 0,
    /// This is a stdin stream, flowing from client to server.
    StdinStream = 1,
    /// This is a stdout stream, flowing from server to client.
    StdoutStream = 2,
    /// This is a stderr stream, flowing from server to client.
    StderrStream = 3,
}
impl StdioStream {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            StdioStream::InvalidStream => "INVALID_STREAM",
            StdioStream::StdinStream => "STDIN_STREAM",
            StdioStream::StdoutStream => "STDOUT_STREAM",
            StdioStream::StderrStream => "STDERR_STREAM",
        }
    }
}
/// Encapsulates a POSIX signal to be sent to the target program.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Signal {
    Unknown = 0,
    Hup = 1,
    Int = 2,
    Quit = 3,
    Term = 15,
}
impl Signal {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Signal::Unknown => "SIGNAL_UNKNOWN",
            Signal::Hup => "SIGNAL_HUP",
            Signal::Int => "SIGNAL_INT",
            Signal::Quit => "SIGNAL_QUIT",
            Signal::Term => "SIGNAL_TERM",
        }
    }
}