diff --git a/.github/typos.toml b/.github/typos.toml index b84d436c27..1ae92b3de3 100644 --- a/.github/typos.toml +++ b/.github/typos.toml @@ -8,3 +8,8 @@ extend-ignore-re = [ extend-ignore-re = [ "ws", ] + +[files] +extend-exclude = [ + "go.mod" +] diff --git a/Cargo.lock b/Cargo.lock index f8ec35e70c..813b63cfc9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -90,6 +90,19 @@ version = "1.0.82" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519" +[[package]] +name = "async-channel" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3" +dependencies = [ + "concurrent-queue", + "event-listener", + "event-listener-strategy", + "futures-core", + "pin-project-lite", +] + [[package]] name = "async-stream" version = "0.3.5" @@ -136,13 +149,43 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3b829e4e32b91e643de6eafe82b1d90675f5874230191a4ffbc1b336dec4d6bf" dependencies = [ "async-trait", - "axum-core", + "axum-core 0.3.4", "bitflags 1.3.2", "bytes", "futures-util", - "http", - "http-body", - "hyper", + "http 0.2.12", + "http-body 0.4.6", + "hyper 0.14.28", + "itoa", + "matchit", + "memchr", + "mime", + "percent-encoding", + "pin-project-lite", + "rustversion", + "serde", + "sync_wrapper", + "tower", + "tower-layer", + "tower-service", +] + +[[package]] +name = "axum" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1236b4b292f6c4d6dc34604bb5120d85c3fe1d1aa596bd5cc52ca054d13e7b9e" +dependencies = [ + "async-trait", + "axum-core 0.4.3", + "base64", + "bytes", + "futures-util", + "http 1.1.0", + "http-body 1.0.0", + "http-body-util", + "hyper 1.2.0", + "hyper-util", "itoa", "matchit", "memchr", @@ -151,10 +194,17 @@ dependencies = [ "pin-project-lite", "rustversion", "serde", + "serde_json", + "serde_path_to_error", + "serde_urlencoded", + "sha1", "sync_wrapper", + "tokio", + "tokio-tungstenite", "tower", "tower-layer", "tower-service", + "tracing", ] [[package]] @@ -166,12 +216,33 @@ dependencies = [ "async-trait", "bytes", "futures-util", - "http", - "http-body", + "http 0.2.12", + "http-body 0.4.6", + "mime", + "rustversion", + "tower-layer", + "tower-service", +] + +[[package]] +name = "axum-core" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a15c63fd72d41492dc4f497196f5da1fb04fb7529e631d73630d1b491e47a2e3" +dependencies = [ + "async-trait", + "bytes", + "futures-util", + "http 1.1.0", + "http-body 1.0.0", + "http-body-util", "mime", + "pin-project-lite", "rustversion", + "sync_wrapper", "tower-layer", "tower-service", + "tracing", ] [[package]] @@ -222,6 +293,12 @@ version = "3.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + [[package]] name = "bytes" version = "1.6.0" @@ -352,6 +429,15 @@ dependencies = [ "tokio", ] +[[package]] +name = "concurrent-queue" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "conmon-common" version = "0.6.2" @@ -365,6 +451,8 @@ name = "conmonrs" version = "0.6.2" dependencies = [ "anyhow", + "async-channel", + "axum 0.7.4", "capnp", "capnp-rpc", "clap", @@ -400,6 +488,7 @@ dependencies = [ "tokio-eventfd", "tokio-seqpacket", "tokio-util", + "tower-http", "tracing", "tracing-opentelemetry", "tracing-subscriber", @@ -500,6 +589,12 @@ dependencies = [ "parking_lot_core", ] +[[package]] +name = "data-encoding" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5" + [[package]] name = "deranged" version = "0.3.11" @@ -554,6 +649,27 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "event-listener" +version = "5.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b5fb89194fa3cad959b833185b3063ba881dbfc7030680b314250779fb4cc91" +dependencies = [ + "concurrent-queue", + "parking", + "pin-project-lite", +] + +[[package]] +name = "event-listener-strategy" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "feedafcaa9b749175d5ac357452a9d41ea2911da598fde46ce1fe02c37751291" +dependencies = [ + "event-listener", + "pin-project-lite", +] + [[package]] name = "fastrand" version = "1.9.0" @@ -793,7 +909,26 @@ dependencies = [ "futures-core", "futures-sink", "futures-util", - "http", + "http 0.2.12", + "indexmap 2.0.1", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "h2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51ee2dd2e4f378392eeff5d51618cd9a63166a2513846bbc55f21cfacd9199d4" +dependencies = [ + "bytes", + "fnv", + "futures-core", + "futures-sink", + "futures-util", + "http 1.1.0", "indexmap 2.0.1", "slab", "tokio", @@ -845,6 +980,17 @@ dependencies = [ "itoa", ] +[[package]] +name = "http" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + [[package]] name = "http-body" version = "0.4.6" @@ -852,7 +998,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" dependencies = [ "bytes", - "http", + "http 0.2.12", + "pin-project-lite", +] + +[[package]] +name = "http-body" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643" +dependencies = [ + "bytes", + "http 1.1.0", +] + +[[package]] +name = "http-body-util" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0475f8b2ac86659c21b64320d5d653f9efe42acd2a4e560073ec61a155a34f1d" +dependencies = [ + "bytes", + "futures-core", + "http 1.1.0", + "http-body 1.0.0", "pin-project-lite", ] @@ -878,9 +1047,9 @@ dependencies = [ "futures-channel", "futures-core", "futures-util", - "h2", - "http", - "http-body", + "h2 0.3.26", + "http 0.2.12", + "http-body 0.4.6", "httparse", "httpdate", "itoa", @@ -892,18 +1061,54 @@ dependencies = [ "want", ] +[[package]] +name = "hyper" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "186548d73ac615b32a73aafe38fb4f56c0d340e110e5a200bcadbaf2e199263a" +dependencies = [ + "bytes", + "futures-channel", + "futures-util", + "h2 0.4.3", + "http 1.1.0", + "http-body 1.0.0", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "smallvec", + "tokio", +] + [[package]] name = "hyper-timeout" version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1" dependencies = [ - "hyper", + "hyper 0.14.28", "pin-project-lite", "tokio", "tokio-io-timeout", ] +[[package]] +name = "hyper-util" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca38ef113da30126bbff9cd1705f9273e15d45498615d138b0c20279ac7a76aa" +dependencies = [ + "bytes", + "futures-util", + "http 1.1.0", + "http-body 1.0.0", + "hyper 1.2.0", + "pin-project-lite", + "socket2", + "tokio", +] + [[package]] name = "iana-time-zone" version = "0.1.60" @@ -1378,7 +1583,7 @@ checksum = "1a016b8d9495c639af2145ac22387dcb88e44118e45320d9238fbf4e7889abcb" dependencies = [ "async-trait", "futures-core", - "http", + "http 0.2.12", "opentelemetry", "opentelemetry-proto", "opentelemetry-semantic-conventions", @@ -1789,6 +1994,39 @@ dependencies = [ "serde", ] +[[package]] +name = "serde_path_to_error" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6" +dependencies = [ + "itoa", + "serde", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "sha1" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + [[package]] name = "sha2" version = "0.10.8" @@ -2106,6 +2344,18 @@ dependencies = [ "tokio", ] +[[package]] +name = "tokio-tungstenite" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38" +dependencies = [ + "futures-util", + "log", + "tokio", + "tungstenite", +] + [[package]] name = "tokio-util" version = "0.7.10" @@ -2129,13 +2379,13 @@ checksum = "76c4eb7a4e9ef9d4763600161f12f5070b92a578e1b634db88a6887844c91a13" dependencies = [ "async-stream", "async-trait", - "axum", + "axum 0.6.20", "base64", "bytes", - "h2", - "http", - "http-body", - "hyper", + "h2 0.3.26", + "http 0.2.12", + "http-body 0.4.6", + "hyper 0.14.28", "hyper-timeout", "percent-encoding", "pin-project", @@ -2168,6 +2418,23 @@ dependencies = [ "tracing", ] +[[package]] +name = "tower-http" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5" +dependencies = [ + "bitflags 2.4.1", + "bytes", + "http 1.1.0", + "http-body 1.0.0", + "http-body-util", + "pin-project-lite", + "tower-layer", + "tower-service", + "tracing", +] + [[package]] name = "tower-layer" version = "0.3.2" @@ -2186,6 +2453,7 @@ version = "0.1.40" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" dependencies = [ + "log", "pin-project-lite", "tracing-attributes", "tracing-core", @@ -2261,6 +2529,25 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" +[[package]] +name = "tungstenite" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1" +dependencies = [ + "byteorder", + "bytes", + "data-encoding", + "http 1.1.0", + "httparse", + "log", + "rand", + "sha1", + "thiserror", + "url", + "utf-8", +] + [[package]] name = "typenum" version = "1.17.0" @@ -2355,6 +2642,12 @@ version = "2.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + [[package]] name = "utf8parse" version = "0.2.1" diff --git a/Makefile b/Makefile index 56aa57ef35..d10e05378f 100644 --- a/Makefile +++ b/Makefile @@ -55,7 +55,7 @@ integration-static: .install.ginkgo # It needs to be release so we correctly tes $(MAKE) release-static; \ fi && \ export RUNTIME_BINARY="$(RUNTIME_PATH)" && \ - export MAX_RSS_KB=9500 && \ + export MAX_RSS_KB=12000 && \ sudo -E "$(GOTOOLS_BINDIR)/ginkgo" $(TEST_FLAGS) $(GINKGO_FLAGS) .install.ginkgo: diff --git a/conmon-rs/common/proto/conmon.capnp b/conmon-rs/common/proto/conmon.capnp index a5b3ded083..de2fa82ac6 100644 --- a/conmon-rs/common/proto/conmon.capnp +++ b/conmon-rs/common/proto/conmon.capnp @@ -194,4 +194,52 @@ interface Conmon { key @0 :Text; value @1 :Text; } + + ############################################### + # ServeExecContainer + struct ServeExecContainerRequest { + metadata @0 :Metadata; # Standard metadata to carry. + id @1 :Text; + command @2 :List(Text); + tty @3 :Bool; + stdin @4 :Bool; + stdout @5 :Bool; + stderr @6 :Bool; + cgroupManager @7 :CgroupManager; + } + + struct ServeExecContainerResponse { + url @0 :Text; + } + + serveExecContainer @8 (request: ServeExecContainerRequest) -> (response: ServeExecContainerResponse); + + ############################################### + # ServeAttachContainer + struct ServeAttachContainerRequest { + metadata @0 :Metadata; # Standard metadata to carry. + id @1 :Text; + stdin @2 :Bool; + stdout @3 :Bool; + stderr @4 :Bool; + } + + struct ServeAttachContainerResponse { + url @0 :Text; + } + + serveAttachContainer @9 (request: ServeAttachContainerRequest) -> (response: ServeAttachContainerResponse); + + ############################################### + # ServePortForwardContainer + struct ServePortForwardContainerRequest { + metadata @0 :Metadata; # Standard metadata to carry. + netNsPath @1 :Text; + } + + struct ServePortForwardContainerResponse { + url @0 :Text; + } + + servePortForwardContainer @10 (request: ServePortForwardContainerRequest) -> (response: ServePortForwardContainerResponse); } diff --git a/conmon-rs/server/Cargo.toml b/conmon-rs/server/Cargo.toml index 35038db9bb..751f23c0af 100644 --- a/conmon-rs/server/Cargo.toml +++ b/conmon-rs/server/Cargo.toml @@ -9,6 +9,8 @@ path = "src/main.rs" [dependencies] anyhow = "1.0.82" +async-channel = "2.2.0" +axum = { version = "0.7.4", features = ["ws"]} capnp = "0.19.3" capnp-rpc = "0.19.0" clap = { version = "4.3.8", features = ["color", "cargo", "deprecated", "derive", "deprecated", "env", "string", "unicode", "wrap_help"] } @@ -41,6 +43,7 @@ tokio = { version = "1.37.0", features = ["fs", "io-std", "io-util", "macros", " tokio-eventfd = "0.2.1" tokio-seqpacket = "0.7.1" tokio-util = { version = "0.7.10", features = ["compat"] } +tower-http = { version = "0.5.2", features = ["trace"] } tracing = "0.1.40" tracing-opentelemetry = "0.23.0" tracing-subscriber = "0.3.18" diff --git a/conmon-rs/server/src/attach.rs b/conmon-rs/server/src/attach.rs index bc048551cf..40f8826b7f 100644 --- a/conmon-rs/server/src/attach.rs +++ b/conmon-rs/server/src/attach.rs @@ -104,6 +104,11 @@ impl SharedContainerAttach { } Ok(()) } + + /// Retrieve the stdin sender. + pub fn stdin(&self) -> &Sender> { + &self.read_half_tx + } } #[derive(Clone, Debug)] diff --git a/conmon-rs/server/src/bounded_hashmap.rs b/conmon-rs/server/src/bounded_hashmap.rs new file mode 100644 index 0000000000..84bfe5cdc5 --- /dev/null +++ b/conmon-rs/server/src/bounded_hashmap.rs @@ -0,0 +1,133 @@ +use std::{ + collections::HashMap, + fmt::Debug, + hash::Hash, + time::{Duration, Instant}, +}; +use tracing::warn; + +#[derive(Debug)] +/// A HashMap bounded by element age and maximum amount of items +pub struct BoundedHashMap { + map: HashMap, + max_duration: Duration, + max_items: usize, +} + +impl BoundedHashMap +where + K: Eq + Hash + Clone + Debug, + V: Debug, +{ + /// Insert an element into the hashmap by: + /// - removing timed-out elements + /// - removing the oldest element if no space left + pub fn insert(&mut self, k: K, v: V) -> Option { + let now = Instant::now(); + + // Remove timed-out items + let old_len = self.map.len(); + self.map + .retain(|_, (inserted, _)| now - *inserted <= self.max_duration); + if old_len < self.map.len() { + warn!("Removed {} timed out elements", self.map.len() - old_len) + } + + // Remove the oldest entry if still not enough space left + if self.map.len() >= self.max_items { + let mut key_to_remove = k.clone(); + + let mut oldest = now; + for (key, (inserted, _)) in self.map.iter() { + if *inserted < oldest { + oldest = *inserted; + key_to_remove = key.clone(); + } + } + + warn!("Removing oldest key: {:?}", key_to_remove); + self.map.remove(&key_to_remove); + } + + self.map.insert(k, (Instant::now(), v)).map(|v| v.1) + } + + /// Remove an element from the hashmap and return it if the element has not expired. + pub fn remove(&mut self, k: &K) -> Option { + let now = Instant::now(); + + if let Some((key, (inserted, value))) = self.map.remove_entry(k) { + if now - inserted > self.max_duration { + warn!("Max duration expired for key: {:?}", key); + None + } else { + Some(value) + } + } else { + None + } + } +} + +impl Default for BoundedHashMap { + fn default() -> Self { + Self { + map: HashMap::with_capacity(0), + max_duration: Duration::new(60 * 60, 0), // 1 hour + max_items: 1000, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::thread::sleep; + + #[test] + fn bounded_hashmap_test() { + let mut sut = BoundedHashMap { + max_items: 2, + ..Default::default() + }; + + assert_eq!(sut.map.len(), 0); + + // Insert first item should be fine + assert!(sut.insert(0, 0).is_none()); + assert_eq!(sut.map.len(), 1); + + // Insert second item should be fine, removal should work as well + assert!(sut.insert(1, 0).is_none()); + assert_eq!(sut.map.len(), 2); + assert!(sut.remove(&1).is_some()); + assert_eq!(sut.map.len(), 1); + assert!(sut.insert(1, 0).is_none()); + + // Insert third item should be fine, but remove oldest + assert!(sut.insert(2, 0).is_none()); + assert_eq!(sut.map.len(), 2); + assert!(!sut.map.contains_key(&0)); + assert!(sut.map.contains_key(&1)); + assert!(sut.map.contains_key(&2)); + + // Insert another item should be fine, but remove oldest + assert!(sut.insert(3, 0).is_none()); + assert_eq!(sut.map.len(), 2); + assert!(!sut.map.contains_key(&1)); + assert!(sut.map.contains_key(&2)); + assert!(sut.map.contains_key(&3)); + + // Change the max age of the elements, all should be timed out + sut.max_duration = Duration::from_millis(100); + sleep(Duration::from_millis(200)); + assert!(sut.insert(0, 0).is_none()); + assert!(!sut.map.contains_key(&1)); + assert!(!sut.map.contains_key(&2)); + assert!(!sut.map.contains_key(&3)); + + // The last element should be also timed out if we wait + sleep(Duration::from_millis(200)); + assert!(sut.remove(&0).is_none()); + } +} diff --git a/conmon-rs/server/src/config.rs b/conmon-rs/server/src/config.rs index 5165ebf0cb..2e41b4f09e 100644 --- a/conmon-rs/server/src/config.rs +++ b/conmon-rs/server/src/config.rs @@ -12,7 +12,9 @@ macro_rules! prefix { }; } -#[derive(CopyGetters, Debug, Deserialize, Eq, Getters, Parser, PartialEq, Serialize, Setters)] +#[derive( + Clone, CopyGetters, Debug, Deserialize, Eq, Getters, Parser, PartialEq, Serialize, Setters, +)] #[serde(rename_all = "kebab-case")] #[command( after_help("More info at: https://github.com/containers/conmon-rs"), diff --git a/conmon-rs/server/src/container_io.rs b/conmon-rs/server/src/container_io.rs index 19c555ad1e..cb2492f9cd 100644 --- a/conmon-rs/server/src/container_io.rs +++ b/conmon-rs/server/src/container_io.rs @@ -3,6 +3,7 @@ use crate::{ terminal::Terminal, }; use anyhow::{bail, Context, Result}; +use async_channel::{Receiver, Sender}; use getset::{Getters, MutGetters}; use nix::errno::Errno; use std::{ @@ -15,10 +16,7 @@ use tempfile::Builder; use tokio::{ io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}, select, - sync::{ - mpsc::{UnboundedReceiver, UnboundedSender}, - RwLock, - }, + sync::RwLock, time::{self, Instant}, }; use tokio_util::sync::CancellationToken; @@ -59,6 +57,11 @@ impl SharedContainerIO { pub async fn attach(&self) -> SharedContainerAttach { self.0.read().await.attach().clone() } + + /// Retrieve the underlying stdout and stderr channels. + pub async fn stdio(&self) -> Result<(Receiver, Receiver)> { + self.0.read().await.stdio() + } } #[derive(Debug, Getters, MutGetters)] @@ -155,6 +158,23 @@ impl ContainerIO { Ok(path) } + /// Retrieve clones of the stdout and stderr channels. + pub fn stdio(&self) -> Result<(Receiver, Receiver)> { + match self.typ() { + ContainerIOType::Terminal(t) => { + if let Some(message_rx) = t.message_rx() { + let (_, fake_rx) = async_channel::unbounded(); + Ok((message_rx.clone(), fake_rx)) + } else { + bail!("called before message receiver was registered") + } + } + ContainerIOType::Streams(s) => { + Ok((s.message_rx_stdout.clone(), s.message_rx_stderr.clone())) + } + } + } + pub async fn read_all_with_timeout( &mut self, time_to_timeout: Option, @@ -184,7 +204,7 @@ impl ContainerIO { async fn read_stream_with_timeout( time_to_timeout: Option, - receiver: &mut UnboundedReceiver, + receiver: &mut Receiver, ) -> (Vec, bool) { let mut stdio = vec![]; let mut timed_out = false; @@ -192,19 +212,18 @@ impl ContainerIO { let msg = if let Some(time_to_timeout) = time_to_timeout { { match time::timeout_at(time_to_timeout, receiver.recv()).await { - Ok(Some(msg)) => msg, - Err(_) => { + Ok(Ok(msg)) => msg, + _ => { timed_out = true; Message::Done } - Ok(None) => unreachable!(), } } } else { { match receiver.recv().await { - Some(msg) => msg, - None => Message::Done, + Ok(msg) => msg, + _ => Message::Done, } } }; @@ -230,7 +249,7 @@ impl ContainerIO { mut reader: T, pipe: Pipe, logger: SharedContainerLog, - message_tx: UnboundedSender, + message_tx: Sender, mut attach: SharedContainerAttach, ) -> Result<()> where @@ -251,6 +270,7 @@ impl ContainerIO { if !message_tx.is_closed() { message_tx .send(Message::Done) + .await .context("send done message")?; } @@ -275,6 +295,7 @@ impl ContainerIO { if !message_tx.is_closed() { message_tx .send(Message::Data(data.into(), pipe)) + .await .context("send data message")?; } } @@ -290,6 +311,7 @@ impl ContainerIO { if !message_tx.is_closed() { message_tx .send(Message::Done) + .await .context("send done message")?; } return Ok(()); diff --git a/conmon-rs/server/src/lib.rs b/conmon-rs/server/src/lib.rs index c47ef04cc2..dd6b410583 100644 --- a/conmon-rs/server/src/lib.rs +++ b/conmon-rs/server/src/lib.rs @@ -8,6 +8,7 @@ pub use version::Version; mod macros; mod attach; +mod bounded_hashmap; mod capnp_util; mod child; mod child_reaper; @@ -24,6 +25,7 @@ mod oom_watcher; mod pause; mod rpc; mod server; +mod streaming_server; mod streams; mod telemetry; mod terminal; diff --git a/conmon-rs/server/src/rpc.rs b/conmon-rs/server/src/rpc.rs index 6acc98aa62..7db40f8ad1 100644 --- a/conmon-rs/server/src/rpc.rs +++ b/conmon-rs/server/src/rpc.rs @@ -462,4 +462,153 @@ impl conmon::Server for Server { .instrument(debug_span!("promise")), ) } + + fn serve_exec_container( + &mut self, + params: conmon::ServeExecContainerParams, + mut results: conmon::ServeExecContainerResults, + ) -> Promise<(), capnp::Error> { + debug!("Got a serve exec container request"); + let req = pry!(pry!(params.get()).get_request()); + + let span = debug_span!( + "serve_exec_container", + uuid = Uuid::new_v4().to_string().as_str() + ); + let _enter = span.enter(); + pry_err!(Telemetry::set_parent_context(pry!(req.get_metadata()))); + + let id = pry_err!(pry_err!(req.get_id()).to_string()); + + // Validate that the container actually exists + pry_err!(self.reaper().get(&id)); + + let command = capnp_vec_str!(req.get_command()); + let (tty, stdin, stdout, stderr) = ( + req.get_tty(), + req.get_stdin(), + req.get_stdout(), + req.get_stderr(), + ); + + let streaming_server = self.streaming_server().clone(); + let child_reaper = self.reaper().clone(); + let container_io = pry_err!(ContainerIO::new(tty, ContainerLog::new())); + let config = self.config().clone(); + let cgroup_manager = pry!(req.get_cgroup_manager()); + + Promise::from_future( + async move { + capnp_err!(streaming_server + .write() + .await + .start_if_required() + .await + .context("start streaming server if required"))?; + + let url = streaming_server + .read() + .await + .exec_url( + child_reaper, + container_io, + config, + cgroup_manager, + id, + command, + stdin, + stdout, + stderr, + ) + .await; + + results.get().init_response().set_url(&url); + Ok(()) + } + .instrument(debug_span!("promise")), + ) + } + + fn serve_attach_container( + &mut self, + params: conmon::ServeAttachContainerParams, + mut results: conmon::ServeAttachContainerResults, + ) -> Promise<(), capnp::Error> { + debug!("Got a serve attach container request"); + let req = pry!(pry!(params.get()).get_request()); + + let span = debug_span!( + "serve_attach_container", + uuid = Uuid::new_v4().to_string().as_str() + ); + let _enter = span.enter(); + pry_err!(Telemetry::set_parent_context(pry!(req.get_metadata()))); + + let id = pry_err!(pry_err!(req.get_id()).to_str()); + let (stdin, stdout, stderr) = (req.get_stdin(), req.get_stdout(), req.get_stderr()); + + let streaming_server = self.streaming_server().clone(); + let child = pry_err!(self.reaper().get(id)); + + Promise::from_future( + async move { + capnp_err!(streaming_server + .write() + .await + .start_if_required() + .await + .context("start streaming server"))?; + + let url = streaming_server + .read() + .await + .attach_url(child, stdin, stdout, stderr) + .await; + + results.get().init_response().set_url(&url); + Ok(()) + } + .instrument(debug_span!("promise")), + ) + } + + fn serve_port_forward_container( + &mut self, + params: conmon::ServePortForwardContainerParams, + mut results: conmon::ServePortForwardContainerResults, + ) -> Promise<(), capnp::Error> { + debug!("Got a serve port forward container request"); + let req = pry!(pry!(params.get()).get_request()); + + let span = debug_span!( + "serve_port_forward_container", + uuid = Uuid::new_v4().to_string().as_str() + ); + let _enter = span.enter(); + pry_err!(Telemetry::set_parent_context(pry!(req.get_metadata()))); + + let net_ns_path = pry_err!(pry_err!(req.get_net_ns_path()).to_string()); + let streaming_server = self.streaming_server().clone(); + + Promise::from_future( + async move { + capnp_err!(streaming_server + .write() + .await + .start_if_required() + .await + .context("start streaming server if required"))?; + + let url = streaming_server + .read() + .await + .port_forward_url(net_ns_path) + .await; + + results.get().init_response().set_url(&url); + Ok(()) + } + .instrument(debug_span!("promise")), + ) + } } diff --git a/conmon-rs/server/src/server.rs b/conmon-rs/server/src/server.rs index 3d0a0adbff..675f3a3409 100644 --- a/conmon-rs/server/src/server.rs +++ b/conmon-rs/server/src/server.rs @@ -9,6 +9,7 @@ use crate::{ journal::Journal, listener::{DefaultListener, Listener}, pause::Pause, + streaming_server::StreamingServer, telemetry::Telemetry, version::Version, }; @@ -30,7 +31,7 @@ use tokio::{ fs, runtime::{Builder, Handle}, signal::unix::{signal, SignalKind}, - sync::oneshot, + sync::{oneshot, RwLock}, task::{self, LocalSet}, }; use tokio_util::compat::TokioAsyncReadCompatExt; @@ -53,6 +54,10 @@ pub struct Server { /// Fd socket instance. #[getset(get = "pub(crate)")] fd_socket: Arc, + + /// Streaming server instance. + #[getset(get = "pub(crate)")] + streaming_server: Arc>, } impl Server { @@ -62,6 +67,7 @@ impl Server { config: Default::default(), reaper: Default::default(), fd_socket: Default::default(), + streaming_server: Default::default(), }; if let Some(v) = server.config().version() { @@ -357,6 +363,17 @@ impl GenerateRuntimeArgs<'_> { /// Generate the OCI runtime CLI arguments from the provided parameters. pub(crate) fn exec_sync_args(&self, command: Reader) -> Result> { + let mut args = self.exec_sync_args_without_command(); + + for arg in command { + args.push(arg?.to_string()?); + } + + debug!("Exec args {:?}", args.join(" ")); + Ok(args) + } + + pub(crate) fn exec_sync_args_without_command(&self) -> Vec { let mut args = vec![]; if let Some(rr) = self.config.runtime_root() { @@ -378,11 +395,6 @@ impl GenerateRuntimeArgs<'_> { args.push(format!("--pid-file={}", self.pidfile.display())); args.push(self.id.into()); - for arg in command { - args.push(arg?.to_string()?); - } - - debug!("Exec args {:?}", args.join(" ")); - Ok(args) + args } } diff --git a/conmon-rs/server/src/streaming_server.rs b/conmon-rs/server/src/streaming_server.rs new file mode 100644 index 0000000000..094940b996 --- /dev/null +++ b/conmon-rs/server/src/streaming_server.rs @@ -0,0 +1,575 @@ +use crate::{ + bounded_hashmap::BoundedHashMap, + child::Child, + child_reaper::{ChildReaper, ReapableChild}, + config::Config, + container_io::{ContainerIO, Message as IOMessage, SharedContainerIO}, + server::GenerateRuntimeArgs, +}; +use anyhow::{Context, Result}; +use axum::{ + extract::{ + ws::{close_code, CloseFrame, Message, WebSocket, WebSocketUpgrade}, + Path, State as AxumState, + }, + http::StatusCode, + response::IntoResponse, + routing::get, + Router, +}; +use conmon_common::conmon_capnp::conmon::CgroupManager; +use futures::{ + sink::SinkExt, + stream::{SplitSink, SplitStream, StreamExt}, +}; +use serde::{Deserialize, Serialize}; +use std::{fmt::Debug, ops::ControlFlow, sync::Arc}; +use tokio::{ + net::TcpListener, + sync::{ + mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}, + RwLock, + }, + task::{self, JoinHandle}, +}; +use tower_http::trace::{DefaultMakeSpan, TraceLayer}; +use tracing::{debug, debug_span, error, info, trace, warn}; +use uuid::Uuid; + +const ADDR: &str = "127.0.0.1"; + +const PROTOCOL_V5: &str = "v5.channel.k8s.io"; +const PROTOCOL_PORT_FORWARD: &str = "SPDY/3.1+portforward.k8s.io"; + +const EXEC_PATH: &str = "exec"; +const ATTACH_PATH: &str = "attach"; +const PORT_FORWARD_PATH: &str = "port-forward"; + +const STDIN_BYTE: u8 = 0; +const STDOUT_BYTE: u8 = 1; +const STDERR_BYTE: u8 = 2; +const STREAM_ERR_BYTE: u8 = 3; +const RESIZE_BYTE: u8 = 4; +const CLOSE_BYTE: u8 = 255; + +#[derive(Debug, Default)] +/// The main streaming server structure of this module. +pub struct StreamingServer { + running: bool, + port: u16, + state: Arc>, +} + +/// State handled by the streaming server. +type State = BoundedHashMap; + +#[derive(Debug)] +/// A dedicated session for each provided functionality. +enum Session { + Exec(ExecSession), + Attach(AttachSession), + PortForward(PortForwardSession), +} + +#[derive(Debug)] +/// Required exec session data. +struct ExecSession { + child_reaper: Arc, + container_io: ContainerIO, + server_config: Config, + cgroup_manager: CgroupManager, + container_id: String, + command: Vec, + stdin: bool, + stdout: bool, + stderr: bool, +} + +#[derive(Debug)] +/// Required attach session data. +struct AttachSession { + child: ReapableChild, + stdin: bool, + stdout: bool, + stderr: bool, +} + +#[derive(Debug)] +/// Required port forward session data. +struct PortForwardSession { + #[allow(dead_code)] + net_ns_path: String, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "PascalCase")] +/// Terminal resize event for exec and attach. +struct ResizeEvent { + width: u16, + height: u16, +} + +#[derive(Debug, Serialize)] +/// Error message type used for exec in case that the command fails. +struct ErrorMessage { + status: &'static str, + reason: &'static str, + details: ErrorDetails, + message: &'static str, +} + +impl ErrorMessage { + fn new(exit_code: T) -> Self + where + T: ToString, + { + Self { + status: "Failure", + reason: "NonZeroExitCode", + details: ErrorDetails { + causes: vec![ErrorCause { + reason: "ExitCode", + message: exit_code.to_string(), + }], + }, + message: "command terminated with non-zero exit code", + } + } +} + +#[derive(Debug, Serialize)] +/// Error details for the ErrorMessage. +struct ErrorDetails { + causes: Vec, +} + +#[derive(Debug, Serialize)] +/// Error cause for the ErrorDetails. +struct ErrorCause { + reason: &'static str, + message: String, +} + +impl StreamingServer { + /// Start the streaming server if not already running. + pub async fn start_if_required(&mut self) -> Result<()> { + if self.running { + return Ok(()); + } + + let listener = TcpListener::bind(ADDR.to_string() + ":0") + .await + .context("bind streaming server")?; + + let local_addr = listener + .local_addr() + .context("get listeners local address")?; + + self.port = local_addr.port(); + + info!("Starting streaming server on {local_addr}"); + task::spawn_local(Self::serve(listener, self.state.clone())); + self.running = true; + + Ok(()) + } + + /// Serve the main streaming server. + async fn serve(listener: TcpListener, state: Arc>) -> Result<()> { + let router = Router::new() + .route(&Self::path_for(EXEC_PATH), get(Self::handle)) + .route(&Self::path_for(ATTACH_PATH), get(Self::handle)) + .route(&Self::path_for(PORT_FORWARD_PATH), get(Self::handle)) + .fallback(Self::fallback) + .with_state(state) + .layer( + TraceLayer::new_for_http() + .make_span_with(DefaultMakeSpan::default().include_headers(true)), + ); + axum::serve(listener, router) + .await + .context("start streaming server") + } + + /// Token parse path for the web server. + fn path_for(p: &str) -> String { + format!("/{}/:token", p) + } + + /// Return the URL for a specific path and Uuid. + fn url_for(&self, p: &str, uuid: &Uuid) -> String { + format!("http://{}:{}/{}/{}", ADDR, self.port, p, uuid) + } + + /// Fallback response. + async fn fallback() -> impl IntoResponse { + StatusCode::NOT_FOUND + } + + #[allow(clippy::too_many_arguments)] + /// Returns the URL used for the provided exec parameters. + pub async fn exec_url( + &self, + child_reaper: Arc, + container_io: ContainerIO, + server_config: Config, + cgroup_manager: CgroupManager, + container_id: String, + command: Vec, + stdin: bool, + stdout: bool, + stderr: bool, + ) -> String { + let mut state_lock = self.state.write().await; + let uuid = Uuid::new_v4(); + state_lock.insert( + uuid, + Session::Exec(ExecSession { + child_reaper, + container_io, + server_config, + cgroup_manager, + container_id, + command, + stdin, + stdout, + stderr, + }), + ); + self.url_for(EXEC_PATH, &uuid) + } + + /// Returns the URL used for the provided attach parameters. + pub async fn attach_url( + &self, + child: ReapableChild, + stdin: bool, + stdout: bool, + stderr: bool, + ) -> String { + let mut state_lock = self.state.write().await; + let uuid = Uuid::new_v4(); + state_lock.insert( + uuid, + Session::Attach(AttachSession { + child, + stdin, + stdout, + stderr, + }), + ); + self.url_for(ATTACH_PATH, &uuid) + } + + /// Returns the URL used for the provided port forward parameters. + pub async fn port_forward_url(&self, net_ns_path: String) -> String { + let mut state_lock = self.state.write().await; + let uuid = Uuid::new_v4(); + state_lock.insert( + uuid, + Session::PortForward(PortForwardSession { net_ns_path }), + ); + self.url_for(PORT_FORWARD_PATH, &uuid) + } + + /// Handle a webserver connection which should be upgraded to become a websocket one. + async fn handle( + ws: WebSocketUpgrade, + Path(token): Path, + AxumState(state): AxumState>>, + ) -> impl IntoResponse { + let span = debug_span!("handle_common", token = token.to_string().as_str()); + let _enter = span.enter(); + + info!("Got request for token: {token}"); + let mut state_lock = state.write().await; + + match state_lock.remove(&token) { + Some(session) => { + info!("Got valid session for token {token}: {session:?}"); + ws.protocols([PROTOCOL_V5, PROTOCOL_PORT_FORWARD]) + .on_upgrade(move |socket| Self::handle_websocket(socket, session)) + } + None => { + error!("Unable to find session for token: {token}"); + StatusCode::NOT_FOUND.into_response() + } + } + } + + /// Handle a single websocket connection. + async fn handle_websocket(socket: WebSocket, session: Session) { + let (sender, receiver) = socket.split(); + let (stdin_tx, stdin_rx) = unbounded_channel(); + + let mut send_task = Self::write_task(sender, stdin_rx, session).await; + let mut recv_task = Self::read_task(receiver, stdin_tx).await; + + tokio::select! { + rv_a = (&mut send_task) => { + match rv_a { + Ok(_) => info!("All messages sent"), + Err(a) => error!("Error sending messages: {a:?}") + } + recv_task.abort(); + }, + rv_b = (&mut recv_task) => { + match rv_b { + Ok(_) => info!("All messages received"), + Err(b) => error!("Error receiving messages: {b:?}") + } + send_task.abort(); + } + } + + info!("Closing websocket connection"); + } + + /// Build a common write task based on the session type. + async fn write_task( + mut sender: SplitSink, + stdin_rx: UnboundedReceiver>, + session: Session, + ) -> JoinHandle<()> { + tokio::spawn(async move { + if let (Err(e), typ) = match session { + Session::Exec(s) => (Self::exec_loop(s, &mut sender, stdin_rx).await, "exec"), + Session::Attach(s) => (Self::attach_loop(s, &mut sender, stdin_rx).await, "attach"), + Session::PortForward(s) => ( + Self::port_forward_loop(s, &mut sender, stdin_rx).await, + "port forward", + ), + } { + error!("Unable to run {typ} for container: {e}"); + } + + if let Err(e) = sender + .send(Message::Close( + CloseFrame { + code: close_code::NORMAL, + reason: "done".into(), + } + .into(), + )) + .await + { + error!("Unable to send close message: {e}") + } + }) + } + + /// Build a common read task. + async fn read_task( + mut receiver: SplitStream, + mut stdin_tx: UnboundedSender>, + ) -> JoinHandle<()> { + tokio::spawn(async move { + while let Some(Ok(msg)) = receiver.next().await { + if Self::read_message(msg, &mut stdin_tx).is_break() { + break; + } + } + }) + } + + /// Read a single message and return the control flow decision. + fn read_message(msg: Message, stdin_tx: &mut UnboundedSender>) -> ControlFlow<(), ()> { + match msg { + Message::Binary(data) if !data.is_empty() => { + debug!("Got {} binary bytes", data.len()); + if let Err(e) = stdin_tx.send(data) { + error!("Unable to send stdin data: {e}"); + } + } + Message::Close(c) => { + if let Some(cf) = c { + info!( + "Got websocket close with code {} and reason `{}`", + cf.code, cf.reason + ); + } else { + warn!("Got close message without close frame"); + } + return ControlFlow::Break(()); + } + Message::Text(t) => trace!("Got text message: {t:?}"), + Message::Pong(_) => trace!("Got pong"), + Message::Ping(_) => trace!("Got ping"), + Message::Binary(_) => trace!("Got unknown binary data"), + } + + ControlFlow::Continue(()) + } + + /// The exec specific read/write loop. + async fn exec_loop( + mut session: ExecSession, + sender: &mut SplitSink, + mut stdin_rx: UnboundedReceiver>, + ) -> Result<()> { + let pidfile = ContainerIO::temp_file_name( + Some(session.server_config.runtime_dir()), + "exec_streaming", + "pid", + ) + .context("build pid file path")?; + + let args = GenerateRuntimeArgs { + config: &session.server_config, + id: &session.container_id, + container_io: &session.container_io, + pidfile: &pidfile, + cgroup_manager: session.cgroup_manager, + }; + let mut args = args.exec_sync_args_without_command(); + args.extend(session.command); + + let (grandchild_pid, token) = session + .child_reaper + .create_child( + session.server_config.runtime(), + &args, + session.stdin, + &mut session.container_io, + &pidfile, + vec![], + vec![], + ) + .await + .context("create new child process")?; + + let io = SharedContainerIO::new(session.container_io); + let child = Child::new( + session.container_id.clone(), + grandchild_pid, + vec![], + vec![], + None, + io.clone(), + vec![], + token.clone(), + ); + + let mut exit_rx = session + .child_reaper + .watch_grandchild(child, vec![]) + .context("watch grandchild for pid")?; + + let (stdout_rx, stderr_rx) = io + .stdio() + .await + .context("retrieve stdout and stderr channels")?; + + loop { + tokio::select! { + Some(mut data) = stdin_rx.recv() => if session.stdin { + // First element is the message type indicator + match data.remove(0) { + STDIN_BYTE => { + trace!("Got stdin message of len {}", data.len()); + io.attach().await.stdin().send(data).context("send to attach session")?; + }, + RESIZE_BYTE => { + let e = serde_json::from_slice::(&data).context("unmarshal resize event")?; + trace!("Got resize message: {e:?}"); + io.resize(e.width, e.height).await.context("resize terminal")?; + }, + CLOSE_BYTE => { + info!("Got close message"); + break + }, + x => warn!("Unknown start byte for stdin: {x}"), + }; + }, + + Ok(IOMessage::Data(mut data, _)) = stdout_rx.recv() => if session.stdout { + data.insert(0, STDOUT_BYTE); + sender.send(Message::Binary(data)).await.context("send to stdout")?; + }, + + Ok(IOMessage::Data(mut data, _)) = stderr_rx.recv() => if session.stderr { + data.insert(0, STDERR_BYTE); + sender.send(Message::Binary(data)).await.context("send to stderr")?; + }, + + Ok(exit_data) = exit_rx.recv() => { + if exit_data.exit_code != 0 { + let mut err = vec![STREAM_ERR_BYTE]; + let msg = ErrorMessage::new(exit_data.exit_code); + err.extend(serde_json::to_vec(&msg).context("serialize error message")?); + sender.send(Message::Binary(err)).await.context("send exit failure message")?; + } + break + }, + } + } + + Ok(()) + } + + /// The attach specific read/write loop. + async fn attach_loop( + session: AttachSession, + sender: &mut SplitSink, + mut stdin_rx: UnboundedReceiver>, + ) -> Result<()> { + let io = session.child.io(); + + let (stdout_rx, stderr_rx) = io + .stdio() + .await + .context("retrieve stdout and stderr channels")?; + + loop { + tokio::select! { + Some(mut data) = stdin_rx.recv() => if session.stdin { + // First element is the message type indicator + match data.remove(0) { + STDIN_BYTE => { + trace!("Got stdin message of len {}", data.len()); + io.attach().await.stdin().send(data).context("send to attach session")?; + }, + RESIZE_BYTE => { + let e = serde_json::from_slice::(&data).context("unmarshal resize event")?; + trace!("Got resize message: {e:?}"); + io.resize(e.width, e.height).await.context("resize terminal")?; + }, + CLOSE_BYTE => { + info!("Got close message"); + break + }, + x => warn!("Unknown start byte for stdin: {x}"), + }; + }, + + Ok(IOMessage::Data(mut data, _)) = stdout_rx.recv() => if session.stdout { + data.insert(0, STDOUT_BYTE); + sender.send(Message::Binary(data)).await.context("send to stdout")?; + }, + + Ok(IOMessage::Data(mut data, _)) = stderr_rx.recv() => if session.stderr { + data.insert(0, STDERR_BYTE); + sender.send(Message::Binary(data)).await.context("send to stderr")?; + }, + + _ = session.child.token().cancelled() => { + debug!("Exiting streaming attach because token cancelled"); + break + } + } + } + + Ok(()) + } + + /// The port forward specific read/write loop. + async fn port_forward_loop( + _session: PortForwardSession, + _sender: &mut SplitSink, + mut _in_rx: UnboundedReceiver>, + ) -> Result<()> { + unimplemented!( + "Requires SPDY protocol implementation from https://github.com/moby/spdystream" + ) + } +} diff --git a/conmon-rs/server/src/streams.rs b/conmon-rs/server/src/streams.rs index f6f8be5100..fadcc3544a 100644 --- a/conmon-rs/server/src/streams.rs +++ b/conmon-rs/server/src/streams.rs @@ -6,10 +6,10 @@ use crate::{ container_log::SharedContainerLog, }; use anyhow::Result; +use async_channel::{Receiver, Sender}; use getset::Getters; use tokio::{ process::{ChildStderr, ChildStdin, ChildStdout}, - sync::mpsc::{self, UnboundedReceiver, UnboundedSender}, task, }; use tokio_util::sync::CancellationToken; @@ -23,15 +23,15 @@ pub struct Streams { #[getset(get = "pub")] attach: SharedContainerAttach, - pub message_rx_stdout: UnboundedReceiver, + pub message_rx_stdout: Receiver, #[getset(get = "pub")] - message_tx_stdout: UnboundedSender, + message_tx_stdout: Sender, - pub message_rx_stderr: UnboundedReceiver, + pub message_rx_stderr: Receiver, #[getset(get = "pub")] - message_tx_stderr: UnboundedSender, + message_tx_stderr: Sender, } impl Streams { @@ -39,8 +39,8 @@ impl Streams { pub fn new(logger: SharedContainerLog, attach: SharedContainerAttach) -> Result { debug!("Creating new IO streams"); - let (message_tx_stdout, message_rx_stdout) = mpsc::unbounded_channel(); - let (message_tx_stderr, message_rx_stderr) = mpsc::unbounded_channel(); + let (message_tx_stdout, message_rx_stdout) = async_channel::unbounded(); + let (message_tx_stderr, message_rx_stderr) = async_channel::unbounded(); Ok(Self { logger, @@ -130,7 +130,7 @@ mod tests { let attach = SharedContainerAttach::default(); let token = CancellationToken::new(); - let mut sut = Streams::new(logger, attach)?; + let sut = Streams::new(logger, attach)?; let expected = "hello world"; let mut child = Command::new("echo") diff --git a/conmon-rs/server/src/terminal.rs b/conmon-rs/server/src/terminal.rs index 3b7e99dc0e..2068dd29e4 100644 --- a/conmon-rs/server/src/terminal.rs +++ b/conmon-rs/server/src/terminal.rs @@ -7,6 +7,7 @@ use crate::{ listener::{DefaultListener, Listener}, }; use anyhow::{format_err, Context as _, Result}; +use async_channel::Receiver as UnboundedReceiver; use getset::{Getters, MutGetters, Setters}; use libc::{winsize, TIOCSWINSZ}; use nix::{ @@ -29,7 +30,7 @@ use tokio::{ fs, io::{unix::AsyncFd, AsyncRead, AsyncWrite, AsyncWriteExt, Interest, ReadBuf}, net::UnixStream, - sync::mpsc::{self, Receiver, Sender, UnboundedReceiver}, + sync::mpsc::{self, Receiver, Sender}, task, }; use tokio_util::sync::CancellationToken; @@ -118,7 +119,7 @@ impl Terminal { let attach_clone = self.attach.clone(); let logger_clone = self.logger.clone(); - let (message_tx, message_rx) = mpsc::unbounded_channel(); + let (message_tx, message_rx) = async_channel::unbounded(); self.message_rx = Some(message_rx); task::spawn({ diff --git a/go.mod b/go.mod index 3398880155..bc73e0de80 100644 --- a/go.mod +++ b/go.mod @@ -15,30 +15,54 @@ require ( github.com/sirupsen/logrus v1.9.3 go.opentelemetry.io/otel v1.25.0 go.opentelemetry.io/otel/trace v1.25.0 + k8s.io/client-go v0.29.0 ) require ( github.com/coreos/go-systemd/v22 v22.5.0 // indirect github.com/cyphar/filepath-securejoin v0.2.4 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/docker/go-units v0.5.0 // indirect github.com/go-logr/logr v1.4.1 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect github.com/godbus/dbus/v5 v5.1.0 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/protobuf v1.5.3 // indirect github.com/google/go-cmp v0.6.0 // indirect + github.com/google/gofuzz v1.2.0 // indirect github.com/google/pprof v0.0.0-20230323073829-e72429f035bd // indirect + github.com/gorilla/websocket v1.5.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/moby/spdystream v0.2.0 // indirect github.com/moby/sys/mountinfo v0.7.1 // indirect github.com/moby/sys/user v0.1.0 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect github.com/opencontainers/runtime-spec v1.2.0 // indirect github.com/seccomp/libseccomp-golang v0.10.0 // indirect github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 // indirect - github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect go.opentelemetry.io/otel/metric v1.25.0 // indirect golang.org/x/net v0.23.0 // indirect + golang.org/x/oauth2 v0.10.0 // indirect golang.org/x/sync v0.6.0 // indirect golang.org/x/sys v0.18.0 // indirect + golang.org/x/term v0.18.0 // indirect golang.org/x/text v0.14.0 // indirect + golang.org/x/time v0.3.0 // indirect golang.org/x/tools v0.18.0 // indirect + google.golang.org/appengine v1.6.7 // indirect + google.golang.org/protobuf v1.33.0 // indirect + gopkg.in/inf.v0 v0.9.1 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect + k8s.io/api v0.29.0 // indirect + k8s.io/apimachinery v0.29.0 // indirect + k8s.io/klog/v2 v2.110.1 // indirect + k8s.io/utils v0.0.0-20230726121419-3b25d923346b // indirect + sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect + sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect + sigs.k8s.io/yaml v1.4.0 // indirect zenhack.net/go/util v0.0.0-20230218002511-744d2d6d1739 // indirect ) diff --git a/go.sum b/go.sum index ae042be2b3..4d3c08a7de 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,7 @@ capnproto.org/go/capnp/v3 v3.0.0-alpha.25 h1:VfSMVPjhSJMe+SMtbaBgFS5a2BLo4W2HHhd5M2EivUI= capnproto.org/go/capnp/v3 v3.0.0-alpha.25/go.mod h1:SazsSKIo0mjdwYyEMD8l65Tvg5pvm2kO1emuWa1+YB4= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM= github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ= github.com/containers/common v0.58.2 h1:5nu9lQz4QNSgovNk7NRk33SkqkVNKYoXh7L6gXmACow= @@ -15,30 +17,78 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g= +github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-openapi/jsonpointer v0.19.6 h1:eCs3fxoIi3Wh6vtgmLTOjdhSpiqphQ+DaPn38N2ZdrE= +github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs= +github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE= +github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k= +github.com/go-openapi/swag v0.22.10 h1:4y86NVn7Z2yYd6pfS4Z+Nyh3aAUL3Nul+LMbhFKy0gA= +github.com/go-openapi/swag v0.22.10/go.mod h1:Cnn8BYtRlx6BNE3DPN86f/xkapGIcLWzh3CLEb4C1jI= github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI= github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I= +github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/pprof v0.0.0-20230323073829-e72429f035bd h1:r8yyd+DJDmsUhGrRBxH5Pj7KeFK5l+Y3FsgT8keqKtk= github.com/google/pprof v0.0.0-20230323073829-e72429f035bd/go.mod h1:79YE0hCXdHag9sBkw2o+N/YnZtTkXi0UT9Nnixa5eYk= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= +github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= +github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= +github.com/moby/spdystream v0.2.0 h1:cjW1zVyyoiM0T7b6UoySUFqzXMoqRckQtXwGPiBhOM8= +github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c= github.com/moby/sys/mountinfo v0.7.1 h1:/tTvQaSJRr2FshkhXiIpux6fQ2Zvc4j7tAhMTStAG2g= github.com/moby/sys/mountinfo v0.7.1/go.mod h1:IJb6JQeOklcdMU9F5xQ8ZALD+CUr5VlGpwtX+VE0rpI= github.com/moby/sys/user v0.1.0 h1:WmZ93f5Ux6het5iituh9x2zAG7NFY9Aqi49jjE1PaQg= github.com/moby/sys/user v0.1.0/go.mod h1:fKJhFOnsCN6xZ5gSfbM6zaHGgDJMrqt9/reuj4T7MmU= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f h1:y5//uYreIhSUg3J1GEMiLbxo1LJaP8RfCpH6pymGZus= +github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw= github.com/onsi/ginkgo/v2 v2.17.1 h1:V++EzdbhI4ZV4ev0UTIj0PzhzOcReJFyJaLjtSF55M8= github.com/onsi/ginkgo/v2 v2.17.1/go.mod h1:llBI3WDLL9Z6taip6f33H76YcWtJv+7R3HigUjbIBOs= github.com/onsi/gomega v1.33.0 h1:snPCflnZrpMsy94p4lXVEkHo12lmPnc3vY5XBbreexE= @@ -55,11 +105,16 @@ github.com/philhofer/fwd v1.1.1 h1:GdGcTjf5RNAxwS4QLsiMzJYj5KEvPJD3Abr261yRQXQ= github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= +github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= github.com/seccomp/libseccomp-golang v0.10.0 h1:aA4bp+/Zzi0BnWZ2F1wgNBs5gTpm+na2rWM6M9YjLpY= github.com/seccomp/libseccomp-golang v0.10.0/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= @@ -68,36 +123,99 @@ github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 h1:kdXcSzyDtse github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= github.com/tinylib/msgp v1.1.5 h1:2gXmtWueD2HefZHQe1QOy9HVzmFrLOVvsXwXBQ0ayy0= github.com/tinylib/msgp v1.1.5/go.mod h1:eQsjooMTnV42mHu917E26IogZ2930nFyBQdofk10Udg= -github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo= -github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= go.opentelemetry.io/otel v1.25.0 h1:gldB5FfhRl7OJQbUHt/8s0a7cE8fbsPAtdpRaApKy4k= go.opentelemetry.io/otel v1.25.0/go.mod h1:Wa2ds5NOXEMkCmUou1WA7ZBfLTHWIsp034OVD7AO+Vg= go.opentelemetry.io/otel/metric v1.25.0 h1:LUKbS7ArpFL/I2jJHdJcqMGxkRdxpPHE0VU/D4NuEwA= go.opentelemetry.io/otel/metric v1.25.0/go.mod h1:rkDLUSd2lC5lq2dFNrX9LGAbINP5B7WBkC78RXCpH5s= go.opentelemetry.io/otel/trace v1.25.0 h1:tqukZGLwQYRIFtSQM2u2+yfMVTgGVeqRLPUYx1Dq6RM= go.opentelemetry.io/otel/trace v1.25.0/go.mod h1:hCCs70XM/ljO+BeQkyFnbK28SBIJ/Emuha+ccrCRT7I= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= +golang.org/x/oauth2 v0.10.0 h1:zHCpF2Khkwy4mMB4bv0U37YtJdTGW8jI0glAApi0Kh8= +golang.org/x/oauth2 v0.10.0/go.mod h1:kTpgurOux7LqtuxjuyZa4Gj2gdezIt/jQtGnNFfypQI= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.18.0 h1:FcHjZXDMxI8mM3nwhX9HlKop4C0YQvCVCdwYl2wOtE8= +golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ= golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= +gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +k8s.io/api v0.29.0 h1:NiCdQMY1QOp1H8lfRyeEf8eOwV6+0xA6XEE44ohDX2A= +k8s.io/api v0.29.0/go.mod h1:sdVmXoz2Bo/cb77Pxi71IPTSErEW32xa4aXwKH7gfBA= +k8s.io/apimachinery v0.29.0 h1:+ACVktwyicPz0oc6MTMLwa2Pw3ouLAfAon1wPLtG48o= +k8s.io/apimachinery v0.29.0/go.mod h1:eVBxQ/cwiJxH58eK/jd/vAk4mrxmVlnpBH5J2GbMeis= +k8s.io/client-go v0.29.0 h1:KmlDtFcrdUzOYrBhXHgKw5ycWzc3ryPX5mQe0SkG3y8= +k8s.io/client-go v0.29.0/go.mod h1:yLkXH4HKMAywcrD82KMSmfYg2DlE8mepPR4JGSo5n38= +k8s.io/klog/v2 v2.110.1 h1:U/Af64HJf7FcwMcXyKm2RPM22WZzyR7OSpYj5tg3cL0= +k8s.io/klog/v2 v2.110.1/go.mod h1:YGtd1984u+GgbuZ7e08/yBuAfKLSO0+uR1Fhi6ExXjo= +k8s.io/kube-openapi v0.0.0-20231010175941-2dd684a91f00 h1:aVUu9fTY98ivBPKR9Y5w/AuzbMm96cd3YHRTU83I780= +k8s.io/kube-openapi v0.0.0-20231010175941-2dd684a91f00/go.mod h1:AsvuZPBlUDVuCdzJ87iajxtXuR9oktsTctW/R9wwouA= +k8s.io/utils v0.0.0-20230726121419-3b25d923346b h1:sgn3ZU783SCgtaSJjpcVVlRqd6GSnlTLKgpAAttJvpI= +k8s.io/utils v0.0.0-20230726121419-3b25d923346b/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd h1:EDPBXCAspyGV4jQlpZSudPeMmr1bNJefnuqLsRAsHZo= +sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1 h1:150L+0vs/8DA78h1u02ooW1/fFq/Lwr+sGiqlzvrtq4= +sigs.k8s.io/structured-merge-diff/v4 v4.4.1/go.mod h1:N8hJocpFajUSSeSJ9bOZ77VzejKZaXsTtZo4/u7Io08= +sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E= +sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= zenhack.net/go/util v0.0.0-20230218002511-744d2d6d1739 h1:/QnbZBURrZUFvnxB4wDyRrPsWzh2KWbJ6AjUjohCHJ8= zenhack.net/go/util v0.0.0-20230218002511-744d2d6d1739/go.mod h1:0lafdGg7tDb7RcXASgmJmRbLFLkAxu328+KGIs7icDE= diff --git a/internal/proto/conmon.capnp.go b/internal/proto/conmon.capnp.go index 1e636b4229..cd9e7a3660 100644 --- a/internal/proto/conmon.capnp.go +++ b/internal/proto/conmon.capnp.go @@ -176,6 +176,66 @@ func (c Conmon) StartFdSocket(ctx context.Context, params func(Conmon_startFdSoc } +func (c Conmon) ServeExecContainer(ctx context.Context, params func(Conmon_serveExecContainer_Params) error) (Conmon_serveExecContainer_Results_Future, capnp.ReleaseFunc) { + + s := capnp.Send{ + Method: capnp.Method{ + InterfaceID: 0xb737e899dd6633f1, + MethodID: 8, + InterfaceName: "internal/proto/conmon.capnp:Conmon", + MethodName: "serveExecContainer", + }, + } + if params != nil { + s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1} + s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_serveExecContainer_Params(s)) } + } + + ans, release := capnp.Client(c).SendCall(ctx, s) + return Conmon_serveExecContainer_Results_Future{Future: ans.Future()}, release + +} + +func (c Conmon) ServeAttachContainer(ctx context.Context, params func(Conmon_serveAttachContainer_Params) error) (Conmon_serveAttachContainer_Results_Future, capnp.ReleaseFunc) { + + s := capnp.Send{ + Method: capnp.Method{ + InterfaceID: 0xb737e899dd6633f1, + MethodID: 9, + InterfaceName: "internal/proto/conmon.capnp:Conmon", + MethodName: "serveAttachContainer", + }, + } + if params != nil { + s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1} + s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_serveAttachContainer_Params(s)) } + } + + ans, release := capnp.Client(c).SendCall(ctx, s) + return Conmon_serveAttachContainer_Results_Future{Future: ans.Future()}, release + +} + +func (c Conmon) ServePortForwardContainer(ctx context.Context, params func(Conmon_servePortForwardContainer_Params) error) (Conmon_servePortForwardContainer_Results_Future, capnp.ReleaseFunc) { + + s := capnp.Send{ + Method: capnp.Method{ + InterfaceID: 0xb737e899dd6633f1, + MethodID: 10, + InterfaceName: "internal/proto/conmon.capnp:Conmon", + MethodName: "servePortForwardContainer", + }, + } + if params != nil { + s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1} + s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_servePortForwardContainer_Params(s)) } + } + + ans, release := capnp.Client(c).SendCall(ctx, s) + return Conmon_servePortForwardContainer_Results_Future{Future: ans.Future()}, release + +} + func (c Conmon) WaitStreaming() error { return capnp.Client(c).WaitStreaming() } @@ -264,6 +324,12 @@ type Conmon_Server interface { CreateNamespaces(context.Context, Conmon_createNamespaces) error StartFdSocket(context.Context, Conmon_startFdSocket) error + + ServeExecContainer(context.Context, Conmon_serveExecContainer) error + + ServeAttachContainer(context.Context, Conmon_serveAttachContainer) error + + ServePortForwardContainer(context.Context, Conmon_servePortForwardContainer) error } // Conmon_NewServer creates a new Server from an implementation of Conmon_Server. @@ -282,7 +348,7 @@ func Conmon_ServerToClient(s Conmon_Server) Conmon { // This can be used to create a more complicated Server. func Conmon_Methods(methods []server.Method, s Conmon_Server) []server.Method { if cap(methods) == 0 { - methods = make([]server.Method, 0, 8) + methods = make([]server.Method, 0, 11) } methods = append(methods, server.Method{ @@ -381,6 +447,42 @@ func Conmon_Methods(methods []server.Method, s Conmon_Server) []server.Method { }, }) + methods = append(methods, server.Method{ + Method: capnp.Method{ + InterfaceID: 0xb737e899dd6633f1, + MethodID: 8, + InterfaceName: "internal/proto/conmon.capnp:Conmon", + MethodName: "serveExecContainer", + }, + Impl: func(ctx context.Context, call *server.Call) error { + return s.ServeExecContainer(ctx, Conmon_serveExecContainer{call}) + }, + }) + + methods = append(methods, server.Method{ + Method: capnp.Method{ + InterfaceID: 0xb737e899dd6633f1, + MethodID: 9, + InterfaceName: "internal/proto/conmon.capnp:Conmon", + MethodName: "serveAttachContainer", + }, + Impl: func(ctx context.Context, call *server.Call) error { + return s.ServeAttachContainer(ctx, Conmon_serveAttachContainer{call}) + }, + }) + + methods = append(methods, server.Method{ + Method: capnp.Method{ + InterfaceID: 0xb737e899dd6633f1, + MethodID: 10, + InterfaceName: "internal/proto/conmon.capnp:Conmon", + MethodName: "servePortForwardContainer", + }, + Impl: func(ctx context.Context, call *server.Call) error { + return s.ServePortForwardContainer(ctx, Conmon_servePortForwardContainer{call}) + }, + }) + return methods } @@ -520,6 +622,57 @@ func (c Conmon_startFdSocket) AllocResults() (Conmon_startFdSocket_Results, erro return Conmon_startFdSocket_Results(r), err } +// Conmon_serveExecContainer holds the state for a server call to Conmon.serveExecContainer. +// See server.Call for documentation. +type Conmon_serveExecContainer struct { + *server.Call +} + +// Args returns the call's arguments. +func (c Conmon_serveExecContainer) Args() Conmon_serveExecContainer_Params { + return Conmon_serveExecContainer_Params(c.Call.Args()) +} + +// AllocResults allocates the results struct. +func (c Conmon_serveExecContainer) AllocResults() (Conmon_serveExecContainer_Results, error) { + r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_serveExecContainer_Results(r), err +} + +// Conmon_serveAttachContainer holds the state for a server call to Conmon.serveAttachContainer. +// See server.Call for documentation. +type Conmon_serveAttachContainer struct { + *server.Call +} + +// Args returns the call's arguments. +func (c Conmon_serveAttachContainer) Args() Conmon_serveAttachContainer_Params { + return Conmon_serveAttachContainer_Params(c.Call.Args()) +} + +// AllocResults allocates the results struct. +func (c Conmon_serveAttachContainer) AllocResults() (Conmon_serveAttachContainer_Results, error) { + r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_serveAttachContainer_Results(r), err +} + +// Conmon_servePortForwardContainer holds the state for a server call to Conmon.servePortForwardContainer. +// See server.Call for documentation. +type Conmon_servePortForwardContainer struct { + *server.Call +} + +// Args returns the call's arguments. +func (c Conmon_servePortForwardContainer) Args() Conmon_servePortForwardContainer_Params { + return Conmon_servePortForwardContainer_Params(c.Call.Args()) +} + +// AllocResults allocates the results struct. +func (c Conmon_servePortForwardContainer) AllocResults() (Conmon_servePortForwardContainer_Results, error) { + r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_servePortForwardContainer_Results(r), err +} + // Conmon_List is a list of Conmon. type Conmon_List = capnp.CapList[Conmon] @@ -3112,1678 +3265,2919 @@ func (f Conmon_TextTextMapEntry_Future) Struct() (Conmon_TextTextMapEntry, error return Conmon_TextTextMapEntry(p.Struct()), err } -type Conmon_version_Params capnp.Struct +type Conmon_ServeExecContainerRequest capnp.Struct -// Conmon_version_Params_TypeID is the unique identifier for the type Conmon_version_Params. -const Conmon_version_Params_TypeID = 0xcc2f70676afee4e7 +// Conmon_ServeExecContainerRequest_TypeID is the unique identifier for the type Conmon_ServeExecContainerRequest. +const Conmon_ServeExecContainerRequest_TypeID = 0xd01c697281e61c21 -func NewConmon_version_Params(s *capnp.Segment) (Conmon_version_Params, error) { - st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_version_Params(st), err +func NewConmon_ServeExecContainerRequest(s *capnp.Segment) (Conmon_ServeExecContainerRequest, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}) + return Conmon_ServeExecContainerRequest(st), err } -func NewRootConmon_version_Params(s *capnp.Segment) (Conmon_version_Params, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_version_Params(st), err +func NewRootConmon_ServeExecContainerRequest(s *capnp.Segment) (Conmon_ServeExecContainerRequest, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}) + return Conmon_ServeExecContainerRequest(st), err } -func ReadRootConmon_version_Params(msg *capnp.Message) (Conmon_version_Params, error) { +func ReadRootConmon_ServeExecContainerRequest(msg *capnp.Message) (Conmon_ServeExecContainerRequest, error) { root, err := msg.Root() - return Conmon_version_Params(root.Struct()), err + return Conmon_ServeExecContainerRequest(root.Struct()), err } -func (s Conmon_version_Params) String() string { - str, _ := text.Marshal(0xcc2f70676afee4e7, capnp.Struct(s)) +func (s Conmon_ServeExecContainerRequest) String() string { + str, _ := text.Marshal(0xd01c697281e61c21, capnp.Struct(s)) return str } -func (s Conmon_version_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_ServeExecContainerRequest) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_version_Params) DecodeFromPtr(p capnp.Ptr) Conmon_version_Params { - return Conmon_version_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_ServeExecContainerRequest) DecodeFromPtr(p capnp.Ptr) Conmon_ServeExecContainerRequest { + return Conmon_ServeExecContainerRequest(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_version_Params) ToPtr() capnp.Ptr { +func (s Conmon_ServeExecContainerRequest) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_version_Params) IsValid() bool { +func (s Conmon_ServeExecContainerRequest) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_version_Params) Message() *capnp.Message { +func (s Conmon_ServeExecContainerRequest) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_version_Params) Segment() *capnp.Segment { +func (s Conmon_ServeExecContainerRequest) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_version_Params) Request() (Conmon_VersionRequest, error) { +func (s Conmon_ServeExecContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_VersionRequest(p.Struct()), err + return Conmon_TextTextMapEntry_List(p.List()), err } -func (s Conmon_version_Params) HasRequest() bool { +func (s Conmon_ServeExecContainerRequest) HasMetadata() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_version_Params) SetRequest(v Conmon_VersionRequest) error { - return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +func (s Conmon_ServeExecContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error { + return capnp.Struct(s).SetPtr(0, v.ToPtr()) } -// NewRequest sets the request field to a newly -// allocated Conmon_VersionRequest struct, preferring placement in s's segment. -func (s Conmon_version_Params) NewRequest() (Conmon_VersionRequest, error) { - ss, err := NewConmon_VersionRequest(capnp.Struct(s).Segment()) +// NewMetadata sets the metadata field to a newly +// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment. +func (s Conmon_ServeExecContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) { + l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n) if err != nil { - return Conmon_VersionRequest{}, err + return Conmon_TextTextMapEntry_List{}, err } - err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) - return ss, err + err = capnp.Struct(s).SetPtr(0, l.ToPtr()) + return l, err +} +func (s Conmon_ServeExecContainerRequest) Id() (string, error) { + p, err := capnp.Struct(s).Ptr(1) + return p.Text(), err } -// Conmon_version_Params_List is a list of Conmon_version_Params. -type Conmon_version_Params_List = capnp.StructList[Conmon_version_Params] +func (s Conmon_ServeExecContainerRequest) HasId() bool { + return capnp.Struct(s).HasPtr(1) +} -// NewConmon_version_Params creates a new list of Conmon_version_Params. -func NewConmon_version_Params_List(s *capnp.Segment, sz int32) (Conmon_version_Params_List, error) { - l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_version_Params](l), err +func (s Conmon_ServeExecContainerRequest) IdBytes() ([]byte, error) { + p, err := capnp.Struct(s).Ptr(1) + return p.TextBytes(), err } -// Conmon_version_Params_Future is a wrapper for a Conmon_version_Params promised by a client call. -type Conmon_version_Params_Future struct{ *capnp.Future } +func (s Conmon_ServeExecContainerRequest) SetId(v string) error { + return capnp.Struct(s).SetText(1, v) +} -func (f Conmon_version_Params_Future) Struct() (Conmon_version_Params, error) { - p, err := f.Future.Ptr() - return Conmon_version_Params(p.Struct()), err +func (s Conmon_ServeExecContainerRequest) Command() (capnp.TextList, error) { + p, err := capnp.Struct(s).Ptr(2) + return capnp.TextList(p.List()), err } -func (p Conmon_version_Params_Future) Request() Conmon_VersionRequest_Future { - return Conmon_VersionRequest_Future{Future: p.Future.Field(0, nil)} + +func (s Conmon_ServeExecContainerRequest) HasCommand() bool { + return capnp.Struct(s).HasPtr(2) } -type Conmon_version_Results capnp.Struct +func (s Conmon_ServeExecContainerRequest) SetCommand(v capnp.TextList) error { + return capnp.Struct(s).SetPtr(2, v.ToPtr()) +} -// Conmon_version_Results_TypeID is the unique identifier for the type Conmon_version_Results. -const Conmon_version_Results_TypeID = 0xe313695ea9477b30 +// NewCommand sets the command field to a newly +// allocated capnp.TextList, preferring placement in s's segment. +func (s Conmon_ServeExecContainerRequest) NewCommand(n int32) (capnp.TextList, error) { + l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n) + if err != nil { + return capnp.TextList{}, err + } + err = capnp.Struct(s).SetPtr(2, l.ToPtr()) + return l, err +} +func (s Conmon_ServeExecContainerRequest) Tty() bool { + return capnp.Struct(s).Bit(0) +} -func NewConmon_version_Results(s *capnp.Segment) (Conmon_version_Results, error) { +func (s Conmon_ServeExecContainerRequest) SetTty(v bool) { + capnp.Struct(s).SetBit(0, v) +} + +func (s Conmon_ServeExecContainerRequest) Stdin() bool { + return capnp.Struct(s).Bit(1) +} + +func (s Conmon_ServeExecContainerRequest) SetStdin(v bool) { + capnp.Struct(s).SetBit(1, v) +} + +func (s Conmon_ServeExecContainerRequest) Stdout() bool { + return capnp.Struct(s).Bit(2) +} + +func (s Conmon_ServeExecContainerRequest) SetStdout(v bool) { + capnp.Struct(s).SetBit(2, v) +} + +func (s Conmon_ServeExecContainerRequest) Stderr() bool { + return capnp.Struct(s).Bit(3) +} + +func (s Conmon_ServeExecContainerRequest) SetStderr(v bool) { + capnp.Struct(s).SetBit(3, v) +} + +func (s Conmon_ServeExecContainerRequest) CgroupManager() Conmon_CgroupManager { + return Conmon_CgroupManager(capnp.Struct(s).Uint16(2)) +} + +func (s Conmon_ServeExecContainerRequest) SetCgroupManager(v Conmon_CgroupManager) { + capnp.Struct(s).SetUint16(2, uint16(v)) +} + +// Conmon_ServeExecContainerRequest_List is a list of Conmon_ServeExecContainerRequest. +type Conmon_ServeExecContainerRequest_List = capnp.StructList[Conmon_ServeExecContainerRequest] + +// NewConmon_ServeExecContainerRequest creates a new list of Conmon_ServeExecContainerRequest. +func NewConmon_ServeExecContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_ServeExecContainerRequest_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz) + return capnp.StructList[Conmon_ServeExecContainerRequest](l), err +} + +// Conmon_ServeExecContainerRequest_Future is a wrapper for a Conmon_ServeExecContainerRequest promised by a client call. +type Conmon_ServeExecContainerRequest_Future struct{ *capnp.Future } + +func (f Conmon_ServeExecContainerRequest_Future) Struct() (Conmon_ServeExecContainerRequest, error) { + p, err := f.Future.Ptr() + return Conmon_ServeExecContainerRequest(p.Struct()), err +} + +type Conmon_ServeExecContainerResponse capnp.Struct + +// Conmon_ServeExecContainerResponse_TypeID is the unique identifier for the type Conmon_ServeExecContainerResponse. +const Conmon_ServeExecContainerResponse_TypeID = 0xa9e93cf268b17735 + +func NewConmon_ServeExecContainerResponse(s *capnp.Segment) (Conmon_ServeExecContainerResponse, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_version_Results(st), err + return Conmon_ServeExecContainerResponse(st), err } -func NewRootConmon_version_Results(s *capnp.Segment) (Conmon_version_Results, error) { +func NewRootConmon_ServeExecContainerResponse(s *capnp.Segment) (Conmon_ServeExecContainerResponse, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_version_Results(st), err + return Conmon_ServeExecContainerResponse(st), err } -func ReadRootConmon_version_Results(msg *capnp.Message) (Conmon_version_Results, error) { +func ReadRootConmon_ServeExecContainerResponse(msg *capnp.Message) (Conmon_ServeExecContainerResponse, error) { root, err := msg.Root() - return Conmon_version_Results(root.Struct()), err + return Conmon_ServeExecContainerResponse(root.Struct()), err } -func (s Conmon_version_Results) String() string { - str, _ := text.Marshal(0xe313695ea9477b30, capnp.Struct(s)) +func (s Conmon_ServeExecContainerResponse) String() string { + str, _ := text.Marshal(0xa9e93cf268b17735, capnp.Struct(s)) return str } -func (s Conmon_version_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_ServeExecContainerResponse) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_version_Results) DecodeFromPtr(p capnp.Ptr) Conmon_version_Results { - return Conmon_version_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_ServeExecContainerResponse) DecodeFromPtr(p capnp.Ptr) Conmon_ServeExecContainerResponse { + return Conmon_ServeExecContainerResponse(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_version_Results) ToPtr() capnp.Ptr { +func (s Conmon_ServeExecContainerResponse) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_version_Results) IsValid() bool { +func (s Conmon_ServeExecContainerResponse) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_version_Results) Message() *capnp.Message { +func (s Conmon_ServeExecContainerResponse) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_version_Results) Segment() *capnp.Segment { +func (s Conmon_ServeExecContainerResponse) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_version_Results) Response() (Conmon_VersionResponse, error) { +func (s Conmon_ServeExecContainerResponse) Url() (string, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_VersionResponse(p.Struct()), err + return p.Text(), err } -func (s Conmon_version_Results) HasResponse() bool { +func (s Conmon_ServeExecContainerResponse) HasUrl() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_version_Results) SetResponse(v Conmon_VersionResponse) error { - return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +func (s Conmon_ServeExecContainerResponse) UrlBytes() ([]byte, error) { + p, err := capnp.Struct(s).Ptr(0) + return p.TextBytes(), err } -// NewResponse sets the response field to a newly -// allocated Conmon_VersionResponse struct, preferring placement in s's segment. -func (s Conmon_version_Results) NewResponse() (Conmon_VersionResponse, error) { - ss, err := NewConmon_VersionResponse(capnp.Struct(s).Segment()) - if err != nil { - return Conmon_VersionResponse{}, err - } - err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) - return ss, err +func (s Conmon_ServeExecContainerResponse) SetUrl(v string) error { + return capnp.Struct(s).SetText(0, v) } -// Conmon_version_Results_List is a list of Conmon_version_Results. -type Conmon_version_Results_List = capnp.StructList[Conmon_version_Results] +// Conmon_ServeExecContainerResponse_List is a list of Conmon_ServeExecContainerResponse. +type Conmon_ServeExecContainerResponse_List = capnp.StructList[Conmon_ServeExecContainerResponse] -// NewConmon_version_Results creates a new list of Conmon_version_Results. -func NewConmon_version_Results_List(s *capnp.Segment, sz int32) (Conmon_version_Results_List, error) { +// NewConmon_ServeExecContainerResponse creates a new list of Conmon_ServeExecContainerResponse. +func NewConmon_ServeExecContainerResponse_List(s *capnp.Segment, sz int32) (Conmon_ServeExecContainerResponse_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_version_Results](l), err + return capnp.StructList[Conmon_ServeExecContainerResponse](l), err } -// Conmon_version_Results_Future is a wrapper for a Conmon_version_Results promised by a client call. -type Conmon_version_Results_Future struct{ *capnp.Future } +// Conmon_ServeExecContainerResponse_Future is a wrapper for a Conmon_ServeExecContainerResponse promised by a client call. +type Conmon_ServeExecContainerResponse_Future struct{ *capnp.Future } -func (f Conmon_version_Results_Future) Struct() (Conmon_version_Results, error) { +func (f Conmon_ServeExecContainerResponse_Future) Struct() (Conmon_ServeExecContainerResponse, error) { p, err := f.Future.Ptr() - return Conmon_version_Results(p.Struct()), err -} -func (p Conmon_version_Results_Future) Response() Conmon_VersionResponse_Future { - return Conmon_VersionResponse_Future{Future: p.Future.Field(0, nil)} + return Conmon_ServeExecContainerResponse(p.Struct()), err } -type Conmon_createContainer_Params capnp.Struct +type Conmon_ServeAttachContainerRequest capnp.Struct -// Conmon_createContainer_Params_TypeID is the unique identifier for the type Conmon_createContainer_Params. -const Conmon_createContainer_Params_TypeID = 0xf44732c48f949ab8 +// Conmon_ServeAttachContainerRequest_TypeID is the unique identifier for the type Conmon_ServeAttachContainerRequest. +const Conmon_ServeAttachContainerRequest_TypeID = 0xca8c8e0d7826ae86 -func NewConmon_createContainer_Params(s *capnp.Segment) (Conmon_createContainer_Params, error) { - st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createContainer_Params(st), err +func NewConmon_ServeAttachContainerRequest(s *capnp.Segment) (Conmon_ServeAttachContainerRequest, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}) + return Conmon_ServeAttachContainerRequest(st), err } -func NewRootConmon_createContainer_Params(s *capnp.Segment) (Conmon_createContainer_Params, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createContainer_Params(st), err +func NewRootConmon_ServeAttachContainerRequest(s *capnp.Segment) (Conmon_ServeAttachContainerRequest, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}) + return Conmon_ServeAttachContainerRequest(st), err } -func ReadRootConmon_createContainer_Params(msg *capnp.Message) (Conmon_createContainer_Params, error) { +func ReadRootConmon_ServeAttachContainerRequest(msg *capnp.Message) (Conmon_ServeAttachContainerRequest, error) { root, err := msg.Root() - return Conmon_createContainer_Params(root.Struct()), err + return Conmon_ServeAttachContainerRequest(root.Struct()), err } -func (s Conmon_createContainer_Params) String() string { - str, _ := text.Marshal(0xf44732c48f949ab8, capnp.Struct(s)) +func (s Conmon_ServeAttachContainerRequest) String() string { + str, _ := text.Marshal(0xca8c8e0d7826ae86, capnp.Struct(s)) return str } -func (s Conmon_createContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_ServeAttachContainerRequest) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_createContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_createContainer_Params { - return Conmon_createContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_ServeAttachContainerRequest) DecodeFromPtr(p capnp.Ptr) Conmon_ServeAttachContainerRequest { + return Conmon_ServeAttachContainerRequest(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_createContainer_Params) ToPtr() capnp.Ptr { +func (s Conmon_ServeAttachContainerRequest) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_createContainer_Params) IsValid() bool { +func (s Conmon_ServeAttachContainerRequest) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_createContainer_Params) Message() *capnp.Message { +func (s Conmon_ServeAttachContainerRequest) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_createContainer_Params) Segment() *capnp.Segment { +func (s Conmon_ServeAttachContainerRequest) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_createContainer_Params) Request() (Conmon_CreateContainerRequest, error) { +func (s Conmon_ServeAttachContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_CreateContainerRequest(p.Struct()), err + return Conmon_TextTextMapEntry_List(p.List()), err } -func (s Conmon_createContainer_Params) HasRequest() bool { +func (s Conmon_ServeAttachContainerRequest) HasMetadata() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_createContainer_Params) SetRequest(v Conmon_CreateContainerRequest) error { - return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +func (s Conmon_ServeAttachContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error { + return capnp.Struct(s).SetPtr(0, v.ToPtr()) } -// NewRequest sets the request field to a newly -// allocated Conmon_CreateContainerRequest struct, preferring placement in s's segment. -func (s Conmon_createContainer_Params) NewRequest() (Conmon_CreateContainerRequest, error) { - ss, err := NewConmon_CreateContainerRequest(capnp.Struct(s).Segment()) +// NewMetadata sets the metadata field to a newly +// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment. +func (s Conmon_ServeAttachContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) { + l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n) if err != nil { - return Conmon_CreateContainerRequest{}, err + return Conmon_TextTextMapEntry_List{}, err } - err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) - return ss, err + err = capnp.Struct(s).SetPtr(0, l.ToPtr()) + return l, err +} +func (s Conmon_ServeAttachContainerRequest) Id() (string, error) { + p, err := capnp.Struct(s).Ptr(1) + return p.Text(), err } -// Conmon_createContainer_Params_List is a list of Conmon_createContainer_Params. -type Conmon_createContainer_Params_List = capnp.StructList[Conmon_createContainer_Params] +func (s Conmon_ServeAttachContainerRequest) HasId() bool { + return capnp.Struct(s).HasPtr(1) +} -// NewConmon_createContainer_Params creates a new list of Conmon_createContainer_Params. -func NewConmon_createContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_createContainer_Params_List, error) { - l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_createContainer_Params](l), err +func (s Conmon_ServeAttachContainerRequest) IdBytes() ([]byte, error) { + p, err := capnp.Struct(s).Ptr(1) + return p.TextBytes(), err } -// Conmon_createContainer_Params_Future is a wrapper for a Conmon_createContainer_Params promised by a client call. -type Conmon_createContainer_Params_Future struct{ *capnp.Future } +func (s Conmon_ServeAttachContainerRequest) SetId(v string) error { + return capnp.Struct(s).SetText(1, v) +} -func (f Conmon_createContainer_Params_Future) Struct() (Conmon_createContainer_Params, error) { - p, err := f.Future.Ptr() - return Conmon_createContainer_Params(p.Struct()), err +func (s Conmon_ServeAttachContainerRequest) Stdin() bool { + return capnp.Struct(s).Bit(0) } -func (p Conmon_createContainer_Params_Future) Request() Conmon_CreateContainerRequest_Future { - return Conmon_CreateContainerRequest_Future{Future: p.Future.Field(0, nil)} + +func (s Conmon_ServeAttachContainerRequest) SetStdin(v bool) { + capnp.Struct(s).SetBit(0, v) } -type Conmon_createContainer_Results capnp.Struct +func (s Conmon_ServeAttachContainerRequest) Stdout() bool { + return capnp.Struct(s).Bit(1) +} -// Conmon_createContainer_Results_TypeID is the unique identifier for the type Conmon_createContainer_Results. -const Conmon_createContainer_Results_TypeID = 0xceba3c1a97be15f8 +func (s Conmon_ServeAttachContainerRequest) SetStdout(v bool) { + capnp.Struct(s).SetBit(1, v) +} -func NewConmon_createContainer_Results(s *capnp.Segment) (Conmon_createContainer_Results, error) { +func (s Conmon_ServeAttachContainerRequest) Stderr() bool { + return capnp.Struct(s).Bit(2) +} + +func (s Conmon_ServeAttachContainerRequest) SetStderr(v bool) { + capnp.Struct(s).SetBit(2, v) +} + +// Conmon_ServeAttachContainerRequest_List is a list of Conmon_ServeAttachContainerRequest. +type Conmon_ServeAttachContainerRequest_List = capnp.StructList[Conmon_ServeAttachContainerRequest] + +// NewConmon_ServeAttachContainerRequest creates a new list of Conmon_ServeAttachContainerRequest. +func NewConmon_ServeAttachContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_ServeAttachContainerRequest_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz) + return capnp.StructList[Conmon_ServeAttachContainerRequest](l), err +} + +// Conmon_ServeAttachContainerRequest_Future is a wrapper for a Conmon_ServeAttachContainerRequest promised by a client call. +type Conmon_ServeAttachContainerRequest_Future struct{ *capnp.Future } + +func (f Conmon_ServeAttachContainerRequest_Future) Struct() (Conmon_ServeAttachContainerRequest, error) { + p, err := f.Future.Ptr() + return Conmon_ServeAttachContainerRequest(p.Struct()), err +} + +type Conmon_ServeAttachContainerResponse capnp.Struct + +// Conmon_ServeAttachContainerResponse_TypeID is the unique identifier for the type Conmon_ServeAttachContainerResponse. +const Conmon_ServeAttachContainerResponse_TypeID = 0x94a72d9a2ccb9a30 + +func NewConmon_ServeAttachContainerResponse(s *capnp.Segment) (Conmon_ServeAttachContainerResponse, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createContainer_Results(st), err + return Conmon_ServeAttachContainerResponse(st), err } -func NewRootConmon_createContainer_Results(s *capnp.Segment) (Conmon_createContainer_Results, error) { +func NewRootConmon_ServeAttachContainerResponse(s *capnp.Segment) (Conmon_ServeAttachContainerResponse, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createContainer_Results(st), err + return Conmon_ServeAttachContainerResponse(st), err } -func ReadRootConmon_createContainer_Results(msg *capnp.Message) (Conmon_createContainer_Results, error) { +func ReadRootConmon_ServeAttachContainerResponse(msg *capnp.Message) (Conmon_ServeAttachContainerResponse, error) { root, err := msg.Root() - return Conmon_createContainer_Results(root.Struct()), err + return Conmon_ServeAttachContainerResponse(root.Struct()), err } -func (s Conmon_createContainer_Results) String() string { - str, _ := text.Marshal(0xceba3c1a97be15f8, capnp.Struct(s)) +func (s Conmon_ServeAttachContainerResponse) String() string { + str, _ := text.Marshal(0x94a72d9a2ccb9a30, capnp.Struct(s)) return str } -func (s Conmon_createContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_ServeAttachContainerResponse) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_createContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_createContainer_Results { - return Conmon_createContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_ServeAttachContainerResponse) DecodeFromPtr(p capnp.Ptr) Conmon_ServeAttachContainerResponse { + return Conmon_ServeAttachContainerResponse(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_createContainer_Results) ToPtr() capnp.Ptr { +func (s Conmon_ServeAttachContainerResponse) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_createContainer_Results) IsValid() bool { +func (s Conmon_ServeAttachContainerResponse) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_createContainer_Results) Message() *capnp.Message { +func (s Conmon_ServeAttachContainerResponse) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_createContainer_Results) Segment() *capnp.Segment { +func (s Conmon_ServeAttachContainerResponse) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_createContainer_Results) Response() (Conmon_CreateContainerResponse, error) { +func (s Conmon_ServeAttachContainerResponse) Url() (string, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_CreateContainerResponse(p.Struct()), err + return p.Text(), err } -func (s Conmon_createContainer_Results) HasResponse() bool { +func (s Conmon_ServeAttachContainerResponse) HasUrl() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_createContainer_Results) SetResponse(v Conmon_CreateContainerResponse) error { - return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +func (s Conmon_ServeAttachContainerResponse) UrlBytes() ([]byte, error) { + p, err := capnp.Struct(s).Ptr(0) + return p.TextBytes(), err } -// NewResponse sets the response field to a newly -// allocated Conmon_CreateContainerResponse struct, preferring placement in s's segment. -func (s Conmon_createContainer_Results) NewResponse() (Conmon_CreateContainerResponse, error) { - ss, err := NewConmon_CreateContainerResponse(capnp.Struct(s).Segment()) - if err != nil { - return Conmon_CreateContainerResponse{}, err - } - err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) - return ss, err +func (s Conmon_ServeAttachContainerResponse) SetUrl(v string) error { + return capnp.Struct(s).SetText(0, v) } -// Conmon_createContainer_Results_List is a list of Conmon_createContainer_Results. -type Conmon_createContainer_Results_List = capnp.StructList[Conmon_createContainer_Results] +// Conmon_ServeAttachContainerResponse_List is a list of Conmon_ServeAttachContainerResponse. +type Conmon_ServeAttachContainerResponse_List = capnp.StructList[Conmon_ServeAttachContainerResponse] -// NewConmon_createContainer_Results creates a new list of Conmon_createContainer_Results. -func NewConmon_createContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_createContainer_Results_List, error) { +// NewConmon_ServeAttachContainerResponse creates a new list of Conmon_ServeAttachContainerResponse. +func NewConmon_ServeAttachContainerResponse_List(s *capnp.Segment, sz int32) (Conmon_ServeAttachContainerResponse_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_createContainer_Results](l), err + return capnp.StructList[Conmon_ServeAttachContainerResponse](l), err } -// Conmon_createContainer_Results_Future is a wrapper for a Conmon_createContainer_Results promised by a client call. -type Conmon_createContainer_Results_Future struct{ *capnp.Future } +// Conmon_ServeAttachContainerResponse_Future is a wrapper for a Conmon_ServeAttachContainerResponse promised by a client call. +type Conmon_ServeAttachContainerResponse_Future struct{ *capnp.Future } -func (f Conmon_createContainer_Results_Future) Struct() (Conmon_createContainer_Results, error) { +func (f Conmon_ServeAttachContainerResponse_Future) Struct() (Conmon_ServeAttachContainerResponse, error) { p, err := f.Future.Ptr() - return Conmon_createContainer_Results(p.Struct()), err -} -func (p Conmon_createContainer_Results_Future) Response() Conmon_CreateContainerResponse_Future { - return Conmon_CreateContainerResponse_Future{Future: p.Future.Field(0, nil)} + return Conmon_ServeAttachContainerResponse(p.Struct()), err } -type Conmon_execSyncContainer_Params capnp.Struct +type Conmon_ServePortForwardContainerRequest capnp.Struct -// Conmon_execSyncContainer_Params_TypeID is the unique identifier for the type Conmon_execSyncContainer_Params. -const Conmon_execSyncContainer_Params_TypeID = 0x83479da67279e173 +// Conmon_ServePortForwardContainerRequest_TypeID is the unique identifier for the type Conmon_ServePortForwardContainerRequest. +const Conmon_ServePortForwardContainerRequest_TypeID = 0xc865d8a1122038c5 -func NewConmon_execSyncContainer_Params(s *capnp.Segment) (Conmon_execSyncContainer_Params, error) { - st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_execSyncContainer_Params(st), err +func NewConmon_ServePortForwardContainerRequest(s *capnp.Segment) (Conmon_ServePortForwardContainerRequest, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}) + return Conmon_ServePortForwardContainerRequest(st), err } -func NewRootConmon_execSyncContainer_Params(s *capnp.Segment) (Conmon_execSyncContainer_Params, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_execSyncContainer_Params(st), err +func NewRootConmon_ServePortForwardContainerRequest(s *capnp.Segment) (Conmon_ServePortForwardContainerRequest, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}) + return Conmon_ServePortForwardContainerRequest(st), err } -func ReadRootConmon_execSyncContainer_Params(msg *capnp.Message) (Conmon_execSyncContainer_Params, error) { +func ReadRootConmon_ServePortForwardContainerRequest(msg *capnp.Message) (Conmon_ServePortForwardContainerRequest, error) { root, err := msg.Root() - return Conmon_execSyncContainer_Params(root.Struct()), err + return Conmon_ServePortForwardContainerRequest(root.Struct()), err } -func (s Conmon_execSyncContainer_Params) String() string { - str, _ := text.Marshal(0x83479da67279e173, capnp.Struct(s)) +func (s Conmon_ServePortForwardContainerRequest) String() string { + str, _ := text.Marshal(0xc865d8a1122038c5, capnp.Struct(s)) return str } -func (s Conmon_execSyncContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_ServePortForwardContainerRequest) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_execSyncContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_execSyncContainer_Params { - return Conmon_execSyncContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_ServePortForwardContainerRequest) DecodeFromPtr(p capnp.Ptr) Conmon_ServePortForwardContainerRequest { + return Conmon_ServePortForwardContainerRequest(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_execSyncContainer_Params) ToPtr() capnp.Ptr { +func (s Conmon_ServePortForwardContainerRequest) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_execSyncContainer_Params) IsValid() bool { +func (s Conmon_ServePortForwardContainerRequest) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_execSyncContainer_Params) Message() *capnp.Message { +func (s Conmon_ServePortForwardContainerRequest) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_execSyncContainer_Params) Segment() *capnp.Segment { +func (s Conmon_ServePortForwardContainerRequest) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_execSyncContainer_Params) Request() (Conmon_ExecSyncContainerRequest, error) { +func (s Conmon_ServePortForwardContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_ExecSyncContainerRequest(p.Struct()), err + return Conmon_TextTextMapEntry_List(p.List()), err } -func (s Conmon_execSyncContainer_Params) HasRequest() bool { +func (s Conmon_ServePortForwardContainerRequest) HasMetadata() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_execSyncContainer_Params) SetRequest(v Conmon_ExecSyncContainerRequest) error { - return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +func (s Conmon_ServePortForwardContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error { + return capnp.Struct(s).SetPtr(0, v.ToPtr()) } -// NewRequest sets the request field to a newly -// allocated Conmon_ExecSyncContainerRequest struct, preferring placement in s's segment. -func (s Conmon_execSyncContainer_Params) NewRequest() (Conmon_ExecSyncContainerRequest, error) { - ss, err := NewConmon_ExecSyncContainerRequest(capnp.Struct(s).Segment()) +// NewMetadata sets the metadata field to a newly +// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment. +func (s Conmon_ServePortForwardContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) { + l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n) if err != nil { - return Conmon_ExecSyncContainerRequest{}, err + return Conmon_TextTextMapEntry_List{}, err } - err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) - return ss, err + err = capnp.Struct(s).SetPtr(0, l.ToPtr()) + return l, err +} +func (s Conmon_ServePortForwardContainerRequest) NetNsPath() (string, error) { + p, err := capnp.Struct(s).Ptr(1) + return p.Text(), err } -// Conmon_execSyncContainer_Params_List is a list of Conmon_execSyncContainer_Params. -type Conmon_execSyncContainer_Params_List = capnp.StructList[Conmon_execSyncContainer_Params] +func (s Conmon_ServePortForwardContainerRequest) HasNetNsPath() bool { + return capnp.Struct(s).HasPtr(1) +} -// NewConmon_execSyncContainer_Params creates a new list of Conmon_execSyncContainer_Params. -func NewConmon_execSyncContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_execSyncContainer_Params_List, error) { - l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_execSyncContainer_Params](l), err +func (s Conmon_ServePortForwardContainerRequest) NetNsPathBytes() ([]byte, error) { + p, err := capnp.Struct(s).Ptr(1) + return p.TextBytes(), err } -// Conmon_execSyncContainer_Params_Future is a wrapper for a Conmon_execSyncContainer_Params promised by a client call. -type Conmon_execSyncContainer_Params_Future struct{ *capnp.Future } +func (s Conmon_ServePortForwardContainerRequest) SetNetNsPath(v string) error { + return capnp.Struct(s).SetText(1, v) +} -func (f Conmon_execSyncContainer_Params_Future) Struct() (Conmon_execSyncContainer_Params, error) { - p, err := f.Future.Ptr() - return Conmon_execSyncContainer_Params(p.Struct()), err +// Conmon_ServePortForwardContainerRequest_List is a list of Conmon_ServePortForwardContainerRequest. +type Conmon_ServePortForwardContainerRequest_List = capnp.StructList[Conmon_ServePortForwardContainerRequest] + +// NewConmon_ServePortForwardContainerRequest creates a new list of Conmon_ServePortForwardContainerRequest. +func NewConmon_ServePortForwardContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_ServePortForwardContainerRequest_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz) + return capnp.StructList[Conmon_ServePortForwardContainerRequest](l), err } -func (p Conmon_execSyncContainer_Params_Future) Request() Conmon_ExecSyncContainerRequest_Future { - return Conmon_ExecSyncContainerRequest_Future{Future: p.Future.Field(0, nil)} + +// Conmon_ServePortForwardContainerRequest_Future is a wrapper for a Conmon_ServePortForwardContainerRequest promised by a client call. +type Conmon_ServePortForwardContainerRequest_Future struct{ *capnp.Future } + +func (f Conmon_ServePortForwardContainerRequest_Future) Struct() (Conmon_ServePortForwardContainerRequest, error) { + p, err := f.Future.Ptr() + return Conmon_ServePortForwardContainerRequest(p.Struct()), err } -type Conmon_execSyncContainer_Results capnp.Struct +type Conmon_ServePortForwardContainerResponse capnp.Struct -// Conmon_execSyncContainer_Results_TypeID is the unique identifier for the type Conmon_execSyncContainer_Results. -const Conmon_execSyncContainer_Results_TypeID = 0xf8e86a5c0baa01bc +// Conmon_ServePortForwardContainerResponse_TypeID is the unique identifier for the type Conmon_ServePortForwardContainerResponse. +const Conmon_ServePortForwardContainerResponse_TypeID = 0xf7507d1843e734e4 -func NewConmon_execSyncContainer_Results(s *capnp.Segment) (Conmon_execSyncContainer_Results, error) { +func NewConmon_ServePortForwardContainerResponse(s *capnp.Segment) (Conmon_ServePortForwardContainerResponse, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_execSyncContainer_Results(st), err + return Conmon_ServePortForwardContainerResponse(st), err } -func NewRootConmon_execSyncContainer_Results(s *capnp.Segment) (Conmon_execSyncContainer_Results, error) { +func NewRootConmon_ServePortForwardContainerResponse(s *capnp.Segment) (Conmon_ServePortForwardContainerResponse, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_execSyncContainer_Results(st), err + return Conmon_ServePortForwardContainerResponse(st), err } -func ReadRootConmon_execSyncContainer_Results(msg *capnp.Message) (Conmon_execSyncContainer_Results, error) { +func ReadRootConmon_ServePortForwardContainerResponse(msg *capnp.Message) (Conmon_ServePortForwardContainerResponse, error) { root, err := msg.Root() - return Conmon_execSyncContainer_Results(root.Struct()), err + return Conmon_ServePortForwardContainerResponse(root.Struct()), err } -func (s Conmon_execSyncContainer_Results) String() string { - str, _ := text.Marshal(0xf8e86a5c0baa01bc, capnp.Struct(s)) +func (s Conmon_ServePortForwardContainerResponse) String() string { + str, _ := text.Marshal(0xf7507d1843e734e4, capnp.Struct(s)) return str } -func (s Conmon_execSyncContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_ServePortForwardContainerResponse) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_execSyncContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_execSyncContainer_Results { - return Conmon_execSyncContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_ServePortForwardContainerResponse) DecodeFromPtr(p capnp.Ptr) Conmon_ServePortForwardContainerResponse { + return Conmon_ServePortForwardContainerResponse(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_execSyncContainer_Results) ToPtr() capnp.Ptr { +func (s Conmon_ServePortForwardContainerResponse) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_execSyncContainer_Results) IsValid() bool { +func (s Conmon_ServePortForwardContainerResponse) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_execSyncContainer_Results) Message() *capnp.Message { +func (s Conmon_ServePortForwardContainerResponse) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_execSyncContainer_Results) Segment() *capnp.Segment { +func (s Conmon_ServePortForwardContainerResponse) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_execSyncContainer_Results) Response() (Conmon_ExecSyncContainerResponse, error) { +func (s Conmon_ServePortForwardContainerResponse) Url() (string, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_ExecSyncContainerResponse(p.Struct()), err + return p.Text(), err } -func (s Conmon_execSyncContainer_Results) HasResponse() bool { +func (s Conmon_ServePortForwardContainerResponse) HasUrl() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_execSyncContainer_Results) SetResponse(v Conmon_ExecSyncContainerResponse) error { - return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +func (s Conmon_ServePortForwardContainerResponse) UrlBytes() ([]byte, error) { + p, err := capnp.Struct(s).Ptr(0) + return p.TextBytes(), err } -// NewResponse sets the response field to a newly -// allocated Conmon_ExecSyncContainerResponse struct, preferring placement in s's segment. -func (s Conmon_execSyncContainer_Results) NewResponse() (Conmon_ExecSyncContainerResponse, error) { - ss, err := NewConmon_ExecSyncContainerResponse(capnp.Struct(s).Segment()) - if err != nil { - return Conmon_ExecSyncContainerResponse{}, err - } - err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) - return ss, err +func (s Conmon_ServePortForwardContainerResponse) SetUrl(v string) error { + return capnp.Struct(s).SetText(0, v) } -// Conmon_execSyncContainer_Results_List is a list of Conmon_execSyncContainer_Results. -type Conmon_execSyncContainer_Results_List = capnp.StructList[Conmon_execSyncContainer_Results] +// Conmon_ServePortForwardContainerResponse_List is a list of Conmon_ServePortForwardContainerResponse. +type Conmon_ServePortForwardContainerResponse_List = capnp.StructList[Conmon_ServePortForwardContainerResponse] -// NewConmon_execSyncContainer_Results creates a new list of Conmon_execSyncContainer_Results. -func NewConmon_execSyncContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_execSyncContainer_Results_List, error) { +// NewConmon_ServePortForwardContainerResponse creates a new list of Conmon_ServePortForwardContainerResponse. +func NewConmon_ServePortForwardContainerResponse_List(s *capnp.Segment, sz int32) (Conmon_ServePortForwardContainerResponse_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_ServePortForwardContainerResponse](l), err +} + +// Conmon_ServePortForwardContainerResponse_Future is a wrapper for a Conmon_ServePortForwardContainerResponse promised by a client call. +type Conmon_ServePortForwardContainerResponse_Future struct{ *capnp.Future } + +func (f Conmon_ServePortForwardContainerResponse_Future) Struct() (Conmon_ServePortForwardContainerResponse, error) { + p, err := f.Future.Ptr() + return Conmon_ServePortForwardContainerResponse(p.Struct()), err +} + +type Conmon_version_Params capnp.Struct + +// Conmon_version_Params_TypeID is the unique identifier for the type Conmon_version_Params. +const Conmon_version_Params_TypeID = 0xcc2f70676afee4e7 + +func NewConmon_version_Params(s *capnp.Segment) (Conmon_version_Params, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_version_Params(st), err +} + +func NewRootConmon_version_Params(s *capnp.Segment) (Conmon_version_Params, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_version_Params(st), err +} + +func ReadRootConmon_version_Params(msg *capnp.Message) (Conmon_version_Params, error) { + root, err := msg.Root() + return Conmon_version_Params(root.Struct()), err +} + +func (s Conmon_version_Params) String() string { + str, _ := text.Marshal(0xcc2f70676afee4e7, capnp.Struct(s)) + return str +} + +func (s Conmon_version_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_version_Params) DecodeFromPtr(p capnp.Ptr) Conmon_version_Params { + return Conmon_version_Params(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_version_Params) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_version_Params) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_version_Params) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_version_Params) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_version_Params) Request() (Conmon_VersionRequest, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_VersionRequest(p.Struct()), err +} + +func (s Conmon_version_Params) HasRequest() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_version_Params) SetRequest(v Conmon_VersionRequest) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewRequest sets the request field to a newly +// allocated Conmon_VersionRequest struct, preferring placement in s's segment. +func (s Conmon_version_Params) NewRequest() (Conmon_VersionRequest, error) { + ss, err := NewConmon_VersionRequest(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_VersionRequest{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_version_Params_List is a list of Conmon_version_Params. +type Conmon_version_Params_List = capnp.StructList[Conmon_version_Params] + +// NewConmon_version_Params creates a new list of Conmon_version_Params. +func NewConmon_version_Params_List(s *capnp.Segment, sz int32) (Conmon_version_Params_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_version_Params](l), err +} + +// Conmon_version_Params_Future is a wrapper for a Conmon_version_Params promised by a client call. +type Conmon_version_Params_Future struct{ *capnp.Future } + +func (f Conmon_version_Params_Future) Struct() (Conmon_version_Params, error) { + p, err := f.Future.Ptr() + return Conmon_version_Params(p.Struct()), err +} +func (p Conmon_version_Params_Future) Request() Conmon_VersionRequest_Future { + return Conmon_VersionRequest_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_version_Results capnp.Struct + +// Conmon_version_Results_TypeID is the unique identifier for the type Conmon_version_Results. +const Conmon_version_Results_TypeID = 0xe313695ea9477b30 + +func NewConmon_version_Results(s *capnp.Segment) (Conmon_version_Results, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_version_Results(st), err +} + +func NewRootConmon_version_Results(s *capnp.Segment) (Conmon_version_Results, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_version_Results(st), err +} + +func ReadRootConmon_version_Results(msg *capnp.Message) (Conmon_version_Results, error) { + root, err := msg.Root() + return Conmon_version_Results(root.Struct()), err +} + +func (s Conmon_version_Results) String() string { + str, _ := text.Marshal(0xe313695ea9477b30, capnp.Struct(s)) + return str +} + +func (s Conmon_version_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_version_Results) DecodeFromPtr(p capnp.Ptr) Conmon_version_Results { + return Conmon_version_Results(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_version_Results) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_version_Results) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_version_Results) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_version_Results) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_version_Results) Response() (Conmon_VersionResponse, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_VersionResponse(p.Struct()), err +} + +func (s Conmon_version_Results) HasResponse() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_version_Results) SetResponse(v Conmon_VersionResponse) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewResponse sets the response field to a newly +// allocated Conmon_VersionResponse struct, preferring placement in s's segment. +func (s Conmon_version_Results) NewResponse() (Conmon_VersionResponse, error) { + ss, err := NewConmon_VersionResponse(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_VersionResponse{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_version_Results_List is a list of Conmon_version_Results. +type Conmon_version_Results_List = capnp.StructList[Conmon_version_Results] + +// NewConmon_version_Results creates a new list of Conmon_version_Results. +func NewConmon_version_Results_List(s *capnp.Segment, sz int32) (Conmon_version_Results_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_version_Results](l), err +} + +// Conmon_version_Results_Future is a wrapper for a Conmon_version_Results promised by a client call. +type Conmon_version_Results_Future struct{ *capnp.Future } + +func (f Conmon_version_Results_Future) Struct() (Conmon_version_Results, error) { + p, err := f.Future.Ptr() + return Conmon_version_Results(p.Struct()), err +} +func (p Conmon_version_Results_Future) Response() Conmon_VersionResponse_Future { + return Conmon_VersionResponse_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_createContainer_Params capnp.Struct + +// Conmon_createContainer_Params_TypeID is the unique identifier for the type Conmon_createContainer_Params. +const Conmon_createContainer_Params_TypeID = 0xf44732c48f949ab8 + +func NewConmon_createContainer_Params(s *capnp.Segment) (Conmon_createContainer_Params, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_createContainer_Params(st), err +} + +func NewRootConmon_createContainer_Params(s *capnp.Segment) (Conmon_createContainer_Params, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_createContainer_Params(st), err +} + +func ReadRootConmon_createContainer_Params(msg *capnp.Message) (Conmon_createContainer_Params, error) { + root, err := msg.Root() + return Conmon_createContainer_Params(root.Struct()), err +} + +func (s Conmon_createContainer_Params) String() string { + str, _ := text.Marshal(0xf44732c48f949ab8, capnp.Struct(s)) + return str +} + +func (s Conmon_createContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_createContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_createContainer_Params { + return Conmon_createContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_createContainer_Params) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_createContainer_Params) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_createContainer_Params) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_createContainer_Params) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_createContainer_Params) Request() (Conmon_CreateContainerRequest, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_CreateContainerRequest(p.Struct()), err +} + +func (s Conmon_createContainer_Params) HasRequest() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_createContainer_Params) SetRequest(v Conmon_CreateContainerRequest) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewRequest sets the request field to a newly +// allocated Conmon_CreateContainerRequest struct, preferring placement in s's segment. +func (s Conmon_createContainer_Params) NewRequest() (Conmon_CreateContainerRequest, error) { + ss, err := NewConmon_CreateContainerRequest(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_CreateContainerRequest{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_createContainer_Params_List is a list of Conmon_createContainer_Params. +type Conmon_createContainer_Params_List = capnp.StructList[Conmon_createContainer_Params] + +// NewConmon_createContainer_Params creates a new list of Conmon_createContainer_Params. +func NewConmon_createContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_createContainer_Params_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_createContainer_Params](l), err +} + +// Conmon_createContainer_Params_Future is a wrapper for a Conmon_createContainer_Params promised by a client call. +type Conmon_createContainer_Params_Future struct{ *capnp.Future } + +func (f Conmon_createContainer_Params_Future) Struct() (Conmon_createContainer_Params, error) { + p, err := f.Future.Ptr() + return Conmon_createContainer_Params(p.Struct()), err +} +func (p Conmon_createContainer_Params_Future) Request() Conmon_CreateContainerRequest_Future { + return Conmon_CreateContainerRequest_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_createContainer_Results capnp.Struct + +// Conmon_createContainer_Results_TypeID is the unique identifier for the type Conmon_createContainer_Results. +const Conmon_createContainer_Results_TypeID = 0xceba3c1a97be15f8 + +func NewConmon_createContainer_Results(s *capnp.Segment) (Conmon_createContainer_Results, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_createContainer_Results(st), err +} + +func NewRootConmon_createContainer_Results(s *capnp.Segment) (Conmon_createContainer_Results, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_createContainer_Results(st), err +} + +func ReadRootConmon_createContainer_Results(msg *capnp.Message) (Conmon_createContainer_Results, error) { + root, err := msg.Root() + return Conmon_createContainer_Results(root.Struct()), err +} + +func (s Conmon_createContainer_Results) String() string { + str, _ := text.Marshal(0xceba3c1a97be15f8, capnp.Struct(s)) + return str +} + +func (s Conmon_createContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_createContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_createContainer_Results { + return Conmon_createContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_createContainer_Results) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_createContainer_Results) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_createContainer_Results) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_createContainer_Results) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_createContainer_Results) Response() (Conmon_CreateContainerResponse, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_CreateContainerResponse(p.Struct()), err +} + +func (s Conmon_createContainer_Results) HasResponse() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_createContainer_Results) SetResponse(v Conmon_CreateContainerResponse) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewResponse sets the response field to a newly +// allocated Conmon_CreateContainerResponse struct, preferring placement in s's segment. +func (s Conmon_createContainer_Results) NewResponse() (Conmon_CreateContainerResponse, error) { + ss, err := NewConmon_CreateContainerResponse(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_CreateContainerResponse{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_createContainer_Results_List is a list of Conmon_createContainer_Results. +type Conmon_createContainer_Results_List = capnp.StructList[Conmon_createContainer_Results] + +// NewConmon_createContainer_Results creates a new list of Conmon_createContainer_Results. +func NewConmon_createContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_createContainer_Results_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_createContainer_Results](l), err +} + +// Conmon_createContainer_Results_Future is a wrapper for a Conmon_createContainer_Results promised by a client call. +type Conmon_createContainer_Results_Future struct{ *capnp.Future } + +func (f Conmon_createContainer_Results_Future) Struct() (Conmon_createContainer_Results, error) { + p, err := f.Future.Ptr() + return Conmon_createContainer_Results(p.Struct()), err +} +func (p Conmon_createContainer_Results_Future) Response() Conmon_CreateContainerResponse_Future { + return Conmon_CreateContainerResponse_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_execSyncContainer_Params capnp.Struct + +// Conmon_execSyncContainer_Params_TypeID is the unique identifier for the type Conmon_execSyncContainer_Params. +const Conmon_execSyncContainer_Params_TypeID = 0x83479da67279e173 + +func NewConmon_execSyncContainer_Params(s *capnp.Segment) (Conmon_execSyncContainer_Params, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_execSyncContainer_Params(st), err +} + +func NewRootConmon_execSyncContainer_Params(s *capnp.Segment) (Conmon_execSyncContainer_Params, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_execSyncContainer_Params(st), err +} + +func ReadRootConmon_execSyncContainer_Params(msg *capnp.Message) (Conmon_execSyncContainer_Params, error) { + root, err := msg.Root() + return Conmon_execSyncContainer_Params(root.Struct()), err +} + +func (s Conmon_execSyncContainer_Params) String() string { + str, _ := text.Marshal(0x83479da67279e173, capnp.Struct(s)) + return str +} + +func (s Conmon_execSyncContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_execSyncContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_execSyncContainer_Params { + return Conmon_execSyncContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_execSyncContainer_Params) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_execSyncContainer_Params) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_execSyncContainer_Params) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_execSyncContainer_Params) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_execSyncContainer_Params) Request() (Conmon_ExecSyncContainerRequest, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_ExecSyncContainerRequest(p.Struct()), err +} + +func (s Conmon_execSyncContainer_Params) HasRequest() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_execSyncContainer_Params) SetRequest(v Conmon_ExecSyncContainerRequest) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewRequest sets the request field to a newly +// allocated Conmon_ExecSyncContainerRequest struct, preferring placement in s's segment. +func (s Conmon_execSyncContainer_Params) NewRequest() (Conmon_ExecSyncContainerRequest, error) { + ss, err := NewConmon_ExecSyncContainerRequest(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_ExecSyncContainerRequest{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_execSyncContainer_Params_List is a list of Conmon_execSyncContainer_Params. +type Conmon_execSyncContainer_Params_List = capnp.StructList[Conmon_execSyncContainer_Params] + +// NewConmon_execSyncContainer_Params creates a new list of Conmon_execSyncContainer_Params. +func NewConmon_execSyncContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_execSyncContainer_Params_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_execSyncContainer_Params](l), err +} + +// Conmon_execSyncContainer_Params_Future is a wrapper for a Conmon_execSyncContainer_Params promised by a client call. +type Conmon_execSyncContainer_Params_Future struct{ *capnp.Future } + +func (f Conmon_execSyncContainer_Params_Future) Struct() (Conmon_execSyncContainer_Params, error) { + p, err := f.Future.Ptr() + return Conmon_execSyncContainer_Params(p.Struct()), err +} +func (p Conmon_execSyncContainer_Params_Future) Request() Conmon_ExecSyncContainerRequest_Future { + return Conmon_ExecSyncContainerRequest_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_execSyncContainer_Results capnp.Struct + +// Conmon_execSyncContainer_Results_TypeID is the unique identifier for the type Conmon_execSyncContainer_Results. +const Conmon_execSyncContainer_Results_TypeID = 0xf8e86a5c0baa01bc + +func NewConmon_execSyncContainer_Results(s *capnp.Segment) (Conmon_execSyncContainer_Results, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_execSyncContainer_Results(st), err +} + +func NewRootConmon_execSyncContainer_Results(s *capnp.Segment) (Conmon_execSyncContainer_Results, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_execSyncContainer_Results(st), err +} + +func ReadRootConmon_execSyncContainer_Results(msg *capnp.Message) (Conmon_execSyncContainer_Results, error) { + root, err := msg.Root() + return Conmon_execSyncContainer_Results(root.Struct()), err +} + +func (s Conmon_execSyncContainer_Results) String() string { + str, _ := text.Marshal(0xf8e86a5c0baa01bc, capnp.Struct(s)) + return str +} + +func (s Conmon_execSyncContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_execSyncContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_execSyncContainer_Results { + return Conmon_execSyncContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_execSyncContainer_Results) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_execSyncContainer_Results) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_execSyncContainer_Results) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_execSyncContainer_Results) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_execSyncContainer_Results) Response() (Conmon_ExecSyncContainerResponse, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_ExecSyncContainerResponse(p.Struct()), err +} + +func (s Conmon_execSyncContainer_Results) HasResponse() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_execSyncContainer_Results) SetResponse(v Conmon_ExecSyncContainerResponse) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewResponse sets the response field to a newly +// allocated Conmon_ExecSyncContainerResponse struct, preferring placement in s's segment. +func (s Conmon_execSyncContainer_Results) NewResponse() (Conmon_ExecSyncContainerResponse, error) { + ss, err := NewConmon_ExecSyncContainerResponse(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_ExecSyncContainerResponse{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_execSyncContainer_Results_List is a list of Conmon_execSyncContainer_Results. +type Conmon_execSyncContainer_Results_List = capnp.StructList[Conmon_execSyncContainer_Results] + +// NewConmon_execSyncContainer_Results creates a new list of Conmon_execSyncContainer_Results. +func NewConmon_execSyncContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_execSyncContainer_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return capnp.StructList[Conmon_execSyncContainer_Results](l), err } -// Conmon_execSyncContainer_Results_Future is a wrapper for a Conmon_execSyncContainer_Results promised by a client call. -type Conmon_execSyncContainer_Results_Future struct{ *capnp.Future } +// Conmon_execSyncContainer_Results_Future is a wrapper for a Conmon_execSyncContainer_Results promised by a client call. +type Conmon_execSyncContainer_Results_Future struct{ *capnp.Future } + +func (f Conmon_execSyncContainer_Results_Future) Struct() (Conmon_execSyncContainer_Results, error) { + p, err := f.Future.Ptr() + return Conmon_execSyncContainer_Results(p.Struct()), err +} +func (p Conmon_execSyncContainer_Results_Future) Response() Conmon_ExecSyncContainerResponse_Future { + return Conmon_ExecSyncContainerResponse_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_attachContainer_Params capnp.Struct + +// Conmon_attachContainer_Params_TypeID is the unique identifier for the type Conmon_attachContainer_Params. +const Conmon_attachContainer_Params_TypeID = 0xaa2f3c8ad1c3af24 + +func NewConmon_attachContainer_Params(s *capnp.Segment) (Conmon_attachContainer_Params, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_attachContainer_Params(st), err +} + +func NewRootConmon_attachContainer_Params(s *capnp.Segment) (Conmon_attachContainer_Params, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_attachContainer_Params(st), err +} + +func ReadRootConmon_attachContainer_Params(msg *capnp.Message) (Conmon_attachContainer_Params, error) { + root, err := msg.Root() + return Conmon_attachContainer_Params(root.Struct()), err +} + +func (s Conmon_attachContainer_Params) String() string { + str, _ := text.Marshal(0xaa2f3c8ad1c3af24, capnp.Struct(s)) + return str +} + +func (s Conmon_attachContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_attachContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_attachContainer_Params { + return Conmon_attachContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_attachContainer_Params) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_attachContainer_Params) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_attachContainer_Params) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_attachContainer_Params) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_attachContainer_Params) Request() (Conmon_AttachRequest, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_AttachRequest(p.Struct()), err +} + +func (s Conmon_attachContainer_Params) HasRequest() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_attachContainer_Params) SetRequest(v Conmon_AttachRequest) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewRequest sets the request field to a newly +// allocated Conmon_AttachRequest struct, preferring placement in s's segment. +func (s Conmon_attachContainer_Params) NewRequest() (Conmon_AttachRequest, error) { + ss, err := NewConmon_AttachRequest(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_AttachRequest{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_attachContainer_Params_List is a list of Conmon_attachContainer_Params. +type Conmon_attachContainer_Params_List = capnp.StructList[Conmon_attachContainer_Params] + +// NewConmon_attachContainer_Params creates a new list of Conmon_attachContainer_Params. +func NewConmon_attachContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_attachContainer_Params_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_attachContainer_Params](l), err +} + +// Conmon_attachContainer_Params_Future is a wrapper for a Conmon_attachContainer_Params promised by a client call. +type Conmon_attachContainer_Params_Future struct{ *capnp.Future } + +func (f Conmon_attachContainer_Params_Future) Struct() (Conmon_attachContainer_Params, error) { + p, err := f.Future.Ptr() + return Conmon_attachContainer_Params(p.Struct()), err +} +func (p Conmon_attachContainer_Params_Future) Request() Conmon_AttachRequest_Future { + return Conmon_AttachRequest_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_attachContainer_Results capnp.Struct + +// Conmon_attachContainer_Results_TypeID is the unique identifier for the type Conmon_attachContainer_Results. +const Conmon_attachContainer_Results_TypeID = 0xc5e65eec3dcf5b10 + +func NewConmon_attachContainer_Results(s *capnp.Segment) (Conmon_attachContainer_Results, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_attachContainer_Results(st), err +} + +func NewRootConmon_attachContainer_Results(s *capnp.Segment) (Conmon_attachContainer_Results, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_attachContainer_Results(st), err +} + +func ReadRootConmon_attachContainer_Results(msg *capnp.Message) (Conmon_attachContainer_Results, error) { + root, err := msg.Root() + return Conmon_attachContainer_Results(root.Struct()), err +} + +func (s Conmon_attachContainer_Results) String() string { + str, _ := text.Marshal(0xc5e65eec3dcf5b10, capnp.Struct(s)) + return str +} + +func (s Conmon_attachContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_attachContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_attachContainer_Results { + return Conmon_attachContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_attachContainer_Results) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_attachContainer_Results) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_attachContainer_Results) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_attachContainer_Results) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_attachContainer_Results) Response() (Conmon_AttachResponse, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_AttachResponse(p.Struct()), err +} + +func (s Conmon_attachContainer_Results) HasResponse() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_attachContainer_Results) SetResponse(v Conmon_AttachResponse) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewResponse sets the response field to a newly +// allocated Conmon_AttachResponse struct, preferring placement in s's segment. +func (s Conmon_attachContainer_Results) NewResponse() (Conmon_AttachResponse, error) { + ss, err := NewConmon_AttachResponse(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_AttachResponse{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_attachContainer_Results_List is a list of Conmon_attachContainer_Results. +type Conmon_attachContainer_Results_List = capnp.StructList[Conmon_attachContainer_Results] + +// NewConmon_attachContainer_Results creates a new list of Conmon_attachContainer_Results. +func NewConmon_attachContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_attachContainer_Results_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_attachContainer_Results](l), err +} + +// Conmon_attachContainer_Results_Future is a wrapper for a Conmon_attachContainer_Results promised by a client call. +type Conmon_attachContainer_Results_Future struct{ *capnp.Future } + +func (f Conmon_attachContainer_Results_Future) Struct() (Conmon_attachContainer_Results, error) { + p, err := f.Future.Ptr() + return Conmon_attachContainer_Results(p.Struct()), err +} +func (p Conmon_attachContainer_Results_Future) Response() Conmon_AttachResponse_Future { + return Conmon_AttachResponse_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_reopenLogContainer_Params capnp.Struct + +// Conmon_reopenLogContainer_Params_TypeID is the unique identifier for the type Conmon_reopenLogContainer_Params. +const Conmon_reopenLogContainer_Params_TypeID = 0xe5ea916eb0c31336 + +func NewConmon_reopenLogContainer_Params(s *capnp.Segment) (Conmon_reopenLogContainer_Params, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_reopenLogContainer_Params(st), err +} + +func NewRootConmon_reopenLogContainer_Params(s *capnp.Segment) (Conmon_reopenLogContainer_Params, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_reopenLogContainer_Params(st), err +} + +func ReadRootConmon_reopenLogContainer_Params(msg *capnp.Message) (Conmon_reopenLogContainer_Params, error) { + root, err := msg.Root() + return Conmon_reopenLogContainer_Params(root.Struct()), err +} + +func (s Conmon_reopenLogContainer_Params) String() string { + str, _ := text.Marshal(0xe5ea916eb0c31336, capnp.Struct(s)) + return str +} + +func (s Conmon_reopenLogContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_reopenLogContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_reopenLogContainer_Params { + return Conmon_reopenLogContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_reopenLogContainer_Params) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_reopenLogContainer_Params) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_reopenLogContainer_Params) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_reopenLogContainer_Params) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_reopenLogContainer_Params) Request() (Conmon_ReopenLogRequest, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_ReopenLogRequest(p.Struct()), err +} + +func (s Conmon_reopenLogContainer_Params) HasRequest() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_reopenLogContainer_Params) SetRequest(v Conmon_ReopenLogRequest) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewRequest sets the request field to a newly +// allocated Conmon_ReopenLogRequest struct, preferring placement in s's segment. +func (s Conmon_reopenLogContainer_Params) NewRequest() (Conmon_ReopenLogRequest, error) { + ss, err := NewConmon_ReopenLogRequest(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_ReopenLogRequest{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_reopenLogContainer_Params_List is a list of Conmon_reopenLogContainer_Params. +type Conmon_reopenLogContainer_Params_List = capnp.StructList[Conmon_reopenLogContainer_Params] + +// NewConmon_reopenLogContainer_Params creates a new list of Conmon_reopenLogContainer_Params. +func NewConmon_reopenLogContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_reopenLogContainer_Params_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_reopenLogContainer_Params](l), err +} + +// Conmon_reopenLogContainer_Params_Future is a wrapper for a Conmon_reopenLogContainer_Params promised by a client call. +type Conmon_reopenLogContainer_Params_Future struct{ *capnp.Future } + +func (f Conmon_reopenLogContainer_Params_Future) Struct() (Conmon_reopenLogContainer_Params, error) { + p, err := f.Future.Ptr() + return Conmon_reopenLogContainer_Params(p.Struct()), err +} +func (p Conmon_reopenLogContainer_Params_Future) Request() Conmon_ReopenLogRequest_Future { + return Conmon_ReopenLogRequest_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_reopenLogContainer_Results capnp.Struct + +// Conmon_reopenLogContainer_Results_TypeID is the unique identifier for the type Conmon_reopenLogContainer_Results. +const Conmon_reopenLogContainer_Results_TypeID = 0xa0ef8355b64ee985 + +func NewConmon_reopenLogContainer_Results(s *capnp.Segment) (Conmon_reopenLogContainer_Results, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_reopenLogContainer_Results(st), err +} + +func NewRootConmon_reopenLogContainer_Results(s *capnp.Segment) (Conmon_reopenLogContainer_Results, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_reopenLogContainer_Results(st), err +} + +func ReadRootConmon_reopenLogContainer_Results(msg *capnp.Message) (Conmon_reopenLogContainer_Results, error) { + root, err := msg.Root() + return Conmon_reopenLogContainer_Results(root.Struct()), err +} + +func (s Conmon_reopenLogContainer_Results) String() string { + str, _ := text.Marshal(0xa0ef8355b64ee985, capnp.Struct(s)) + return str +} + +func (s Conmon_reopenLogContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_reopenLogContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_reopenLogContainer_Results { + return Conmon_reopenLogContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +} -func (f Conmon_execSyncContainer_Results_Future) Struct() (Conmon_execSyncContainer_Results, error) { +func (s Conmon_reopenLogContainer_Results) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_reopenLogContainer_Results) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_reopenLogContainer_Results) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_reopenLogContainer_Results) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_reopenLogContainer_Results) Response() (Conmon_ReopenLogResponse, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_ReopenLogResponse(p.Struct()), err +} + +func (s Conmon_reopenLogContainer_Results) HasResponse() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_reopenLogContainer_Results) SetResponse(v Conmon_ReopenLogResponse) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewResponse sets the response field to a newly +// allocated Conmon_ReopenLogResponse struct, preferring placement in s's segment. +func (s Conmon_reopenLogContainer_Results) NewResponse() (Conmon_ReopenLogResponse, error) { + ss, err := NewConmon_ReopenLogResponse(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_ReopenLogResponse{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_reopenLogContainer_Results_List is a list of Conmon_reopenLogContainer_Results. +type Conmon_reopenLogContainer_Results_List = capnp.StructList[Conmon_reopenLogContainer_Results] + +// NewConmon_reopenLogContainer_Results creates a new list of Conmon_reopenLogContainer_Results. +func NewConmon_reopenLogContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_reopenLogContainer_Results_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_reopenLogContainer_Results](l), err +} + +// Conmon_reopenLogContainer_Results_Future is a wrapper for a Conmon_reopenLogContainer_Results promised by a client call. +type Conmon_reopenLogContainer_Results_Future struct{ *capnp.Future } + +func (f Conmon_reopenLogContainer_Results_Future) Struct() (Conmon_reopenLogContainer_Results, error) { p, err := f.Future.Ptr() - return Conmon_execSyncContainer_Results(p.Struct()), err + return Conmon_reopenLogContainer_Results(p.Struct()), err } -func (p Conmon_execSyncContainer_Results_Future) Response() Conmon_ExecSyncContainerResponse_Future { - return Conmon_ExecSyncContainerResponse_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_reopenLogContainer_Results_Future) Response() Conmon_ReopenLogResponse_Future { + return Conmon_ReopenLogResponse_Future{Future: p.Future.Field(0, nil)} } -type Conmon_attachContainer_Params capnp.Struct +type Conmon_setWindowSizeContainer_Params capnp.Struct -// Conmon_attachContainer_Params_TypeID is the unique identifier for the type Conmon_attachContainer_Params. -const Conmon_attachContainer_Params_TypeID = 0xaa2f3c8ad1c3af24 +// Conmon_setWindowSizeContainer_Params_TypeID is the unique identifier for the type Conmon_setWindowSizeContainer_Params. +const Conmon_setWindowSizeContainer_Params_TypeID = 0xc76ccd4502bb61e7 -func NewConmon_attachContainer_Params(s *capnp.Segment) (Conmon_attachContainer_Params, error) { +func NewConmon_setWindowSizeContainer_Params(s *capnp.Segment) (Conmon_setWindowSizeContainer_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_attachContainer_Params(st), err + return Conmon_setWindowSizeContainer_Params(st), err +} + +func NewRootConmon_setWindowSizeContainer_Params(s *capnp.Segment) (Conmon_setWindowSizeContainer_Params, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_setWindowSizeContainer_Params(st), err +} + +func ReadRootConmon_setWindowSizeContainer_Params(msg *capnp.Message) (Conmon_setWindowSizeContainer_Params, error) { + root, err := msg.Root() + return Conmon_setWindowSizeContainer_Params(root.Struct()), err +} + +func (s Conmon_setWindowSizeContainer_Params) String() string { + str, _ := text.Marshal(0xc76ccd4502bb61e7, capnp.Struct(s)) + return str +} + +func (s Conmon_setWindowSizeContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_setWindowSizeContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_setWindowSizeContainer_Params { + return Conmon_setWindowSizeContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_setWindowSizeContainer_Params) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_setWindowSizeContainer_Params) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_setWindowSizeContainer_Params) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_setWindowSizeContainer_Params) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_setWindowSizeContainer_Params) Request() (Conmon_SetWindowSizeRequest, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_SetWindowSizeRequest(p.Struct()), err +} + +func (s Conmon_setWindowSizeContainer_Params) HasRequest() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_setWindowSizeContainer_Params) SetRequest(v Conmon_SetWindowSizeRequest) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewRequest sets the request field to a newly +// allocated Conmon_SetWindowSizeRequest struct, preferring placement in s's segment. +func (s Conmon_setWindowSizeContainer_Params) NewRequest() (Conmon_SetWindowSizeRequest, error) { + ss, err := NewConmon_SetWindowSizeRequest(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_SetWindowSizeRequest{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_setWindowSizeContainer_Params_List is a list of Conmon_setWindowSizeContainer_Params. +type Conmon_setWindowSizeContainer_Params_List = capnp.StructList[Conmon_setWindowSizeContainer_Params] + +// NewConmon_setWindowSizeContainer_Params creates a new list of Conmon_setWindowSizeContainer_Params. +func NewConmon_setWindowSizeContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_setWindowSizeContainer_Params_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_setWindowSizeContainer_Params](l), err +} + +// Conmon_setWindowSizeContainer_Params_Future is a wrapper for a Conmon_setWindowSizeContainer_Params promised by a client call. +type Conmon_setWindowSizeContainer_Params_Future struct{ *capnp.Future } + +func (f Conmon_setWindowSizeContainer_Params_Future) Struct() (Conmon_setWindowSizeContainer_Params, error) { + p, err := f.Future.Ptr() + return Conmon_setWindowSizeContainer_Params(p.Struct()), err +} +func (p Conmon_setWindowSizeContainer_Params_Future) Request() Conmon_SetWindowSizeRequest_Future { + return Conmon_SetWindowSizeRequest_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_setWindowSizeContainer_Results capnp.Struct + +// Conmon_setWindowSizeContainer_Results_TypeID is the unique identifier for the type Conmon_setWindowSizeContainer_Results. +const Conmon_setWindowSizeContainer_Results_TypeID = 0xe00e522611477055 + +func NewConmon_setWindowSizeContainer_Results(s *capnp.Segment) (Conmon_setWindowSizeContainer_Results, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_setWindowSizeContainer_Results(st), err +} + +func NewRootConmon_setWindowSizeContainer_Results(s *capnp.Segment) (Conmon_setWindowSizeContainer_Results, error) { + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_setWindowSizeContainer_Results(st), err +} + +func ReadRootConmon_setWindowSizeContainer_Results(msg *capnp.Message) (Conmon_setWindowSizeContainer_Results, error) { + root, err := msg.Root() + return Conmon_setWindowSizeContainer_Results(root.Struct()), err +} + +func (s Conmon_setWindowSizeContainer_Results) String() string { + str, _ := text.Marshal(0xe00e522611477055, capnp.Struct(s)) + return str +} + +func (s Conmon_setWindowSizeContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { + return capnp.Struct(s).EncodeAsPtr(seg) +} + +func (Conmon_setWindowSizeContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_setWindowSizeContainer_Results { + return Conmon_setWindowSizeContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +} + +func (s Conmon_setWindowSizeContainer_Results) ToPtr() capnp.Ptr { + return capnp.Struct(s).ToPtr() +} +func (s Conmon_setWindowSizeContainer_Results) IsValid() bool { + return capnp.Struct(s).IsValid() +} + +func (s Conmon_setWindowSizeContainer_Results) Message() *capnp.Message { + return capnp.Struct(s).Message() +} + +func (s Conmon_setWindowSizeContainer_Results) Segment() *capnp.Segment { + return capnp.Struct(s).Segment() +} +func (s Conmon_setWindowSizeContainer_Results) Response() (Conmon_SetWindowSizeResponse, error) { + p, err := capnp.Struct(s).Ptr(0) + return Conmon_SetWindowSizeResponse(p.Struct()), err +} + +func (s Conmon_setWindowSizeContainer_Results) HasResponse() bool { + return capnp.Struct(s).HasPtr(0) +} + +func (s Conmon_setWindowSizeContainer_Results) SetResponse(v Conmon_SetWindowSizeResponse) error { + return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) +} + +// NewResponse sets the response field to a newly +// allocated Conmon_SetWindowSizeResponse struct, preferring placement in s's segment. +func (s Conmon_setWindowSizeContainer_Results) NewResponse() (Conmon_SetWindowSizeResponse, error) { + ss, err := NewConmon_SetWindowSizeResponse(capnp.Struct(s).Segment()) + if err != nil { + return Conmon_SetWindowSizeResponse{}, err + } + err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) + return ss, err +} + +// Conmon_setWindowSizeContainer_Results_List is a list of Conmon_setWindowSizeContainer_Results. +type Conmon_setWindowSizeContainer_Results_List = capnp.StructList[Conmon_setWindowSizeContainer_Results] + +// NewConmon_setWindowSizeContainer_Results creates a new list of Conmon_setWindowSizeContainer_Results. +func NewConmon_setWindowSizeContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_setWindowSizeContainer_Results_List, error) { + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + return capnp.StructList[Conmon_setWindowSizeContainer_Results](l), err +} + +// Conmon_setWindowSizeContainer_Results_Future is a wrapper for a Conmon_setWindowSizeContainer_Results promised by a client call. +type Conmon_setWindowSizeContainer_Results_Future struct{ *capnp.Future } + +func (f Conmon_setWindowSizeContainer_Results_Future) Struct() (Conmon_setWindowSizeContainer_Results, error) { + p, err := f.Future.Ptr() + return Conmon_setWindowSizeContainer_Results(p.Struct()), err +} +func (p Conmon_setWindowSizeContainer_Results_Future) Response() Conmon_SetWindowSizeResponse_Future { + return Conmon_SetWindowSizeResponse_Future{Future: p.Future.Field(0, nil)} +} + +type Conmon_createNamespaces_Params capnp.Struct + +// Conmon_createNamespaces_Params_TypeID is the unique identifier for the type Conmon_createNamespaces_Params. +const Conmon_createNamespaces_Params_TypeID = 0x8b4c03a0662a38dc + +func NewConmon_createNamespaces_Params(s *capnp.Segment) (Conmon_createNamespaces_Params, error) { + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + return Conmon_createNamespaces_Params(st), err } -func NewRootConmon_attachContainer_Params(s *capnp.Segment) (Conmon_attachContainer_Params, error) { +func NewRootConmon_createNamespaces_Params(s *capnp.Segment) (Conmon_createNamespaces_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_attachContainer_Params(st), err + return Conmon_createNamespaces_Params(st), err } -func ReadRootConmon_attachContainer_Params(msg *capnp.Message) (Conmon_attachContainer_Params, error) { +func ReadRootConmon_createNamespaces_Params(msg *capnp.Message) (Conmon_createNamespaces_Params, error) { root, err := msg.Root() - return Conmon_attachContainer_Params(root.Struct()), err + return Conmon_createNamespaces_Params(root.Struct()), err } -func (s Conmon_attachContainer_Params) String() string { - str, _ := text.Marshal(0xaa2f3c8ad1c3af24, capnp.Struct(s)) +func (s Conmon_createNamespaces_Params) String() string { + str, _ := text.Marshal(0x8b4c03a0662a38dc, capnp.Struct(s)) return str } -func (s Conmon_attachContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_createNamespaces_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_attachContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_attachContainer_Params { - return Conmon_attachContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_createNamespaces_Params) DecodeFromPtr(p capnp.Ptr) Conmon_createNamespaces_Params { + return Conmon_createNamespaces_Params(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_attachContainer_Params) ToPtr() capnp.Ptr { +func (s Conmon_createNamespaces_Params) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_attachContainer_Params) IsValid() bool { +func (s Conmon_createNamespaces_Params) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_attachContainer_Params) Message() *capnp.Message { +func (s Conmon_createNamespaces_Params) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_attachContainer_Params) Segment() *capnp.Segment { +func (s Conmon_createNamespaces_Params) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_attachContainer_Params) Request() (Conmon_AttachRequest, error) { +func (s Conmon_createNamespaces_Params) Request() (Conmon_CreateNamespacesRequest, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_AttachRequest(p.Struct()), err + return Conmon_CreateNamespacesRequest(p.Struct()), err } -func (s Conmon_attachContainer_Params) HasRequest() bool { +func (s Conmon_createNamespaces_Params) HasRequest() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_attachContainer_Params) SetRequest(v Conmon_AttachRequest) error { +func (s Conmon_createNamespaces_Params) SetRequest(v Conmon_CreateNamespacesRequest) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewRequest sets the request field to a newly -// allocated Conmon_AttachRequest struct, preferring placement in s's segment. -func (s Conmon_attachContainer_Params) NewRequest() (Conmon_AttachRequest, error) { - ss, err := NewConmon_AttachRequest(capnp.Struct(s).Segment()) +// allocated Conmon_CreateNamespacesRequest struct, preferring placement in s's segment. +func (s Conmon_createNamespaces_Params) NewRequest() (Conmon_CreateNamespacesRequest, error) { + ss, err := NewConmon_CreateNamespacesRequest(capnp.Struct(s).Segment()) if err != nil { - return Conmon_AttachRequest{}, err + return Conmon_CreateNamespacesRequest{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_attachContainer_Params_List is a list of Conmon_attachContainer_Params. -type Conmon_attachContainer_Params_List = capnp.StructList[Conmon_attachContainer_Params] +// Conmon_createNamespaces_Params_List is a list of Conmon_createNamespaces_Params. +type Conmon_createNamespaces_Params_List = capnp.StructList[Conmon_createNamespaces_Params] -// NewConmon_attachContainer_Params creates a new list of Conmon_attachContainer_Params. -func NewConmon_attachContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_attachContainer_Params_List, error) { +// NewConmon_createNamespaces_Params creates a new list of Conmon_createNamespaces_Params. +func NewConmon_createNamespaces_Params_List(s *capnp.Segment, sz int32) (Conmon_createNamespaces_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_attachContainer_Params](l), err + return capnp.StructList[Conmon_createNamespaces_Params](l), err } -// Conmon_attachContainer_Params_Future is a wrapper for a Conmon_attachContainer_Params promised by a client call. -type Conmon_attachContainer_Params_Future struct{ *capnp.Future } +// Conmon_createNamespaces_Params_Future is a wrapper for a Conmon_createNamespaces_Params promised by a client call. +type Conmon_createNamespaces_Params_Future struct{ *capnp.Future } -func (f Conmon_attachContainer_Params_Future) Struct() (Conmon_attachContainer_Params, error) { +func (f Conmon_createNamespaces_Params_Future) Struct() (Conmon_createNamespaces_Params, error) { p, err := f.Future.Ptr() - return Conmon_attachContainer_Params(p.Struct()), err + return Conmon_createNamespaces_Params(p.Struct()), err } -func (p Conmon_attachContainer_Params_Future) Request() Conmon_AttachRequest_Future { - return Conmon_AttachRequest_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_createNamespaces_Params_Future) Request() Conmon_CreateNamespacesRequest_Future { + return Conmon_CreateNamespacesRequest_Future{Future: p.Future.Field(0, nil)} } -type Conmon_attachContainer_Results capnp.Struct +type Conmon_createNamespaces_Results capnp.Struct -// Conmon_attachContainer_Results_TypeID is the unique identifier for the type Conmon_attachContainer_Results. -const Conmon_attachContainer_Results_TypeID = 0xc5e65eec3dcf5b10 +// Conmon_createNamespaces_Results_TypeID is the unique identifier for the type Conmon_createNamespaces_Results. +const Conmon_createNamespaces_Results_TypeID = 0x8aef91973dc8a4f5 -func NewConmon_attachContainer_Results(s *capnp.Segment) (Conmon_attachContainer_Results, error) { +func NewConmon_createNamespaces_Results(s *capnp.Segment) (Conmon_createNamespaces_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_attachContainer_Results(st), err + return Conmon_createNamespaces_Results(st), err } -func NewRootConmon_attachContainer_Results(s *capnp.Segment) (Conmon_attachContainer_Results, error) { +func NewRootConmon_createNamespaces_Results(s *capnp.Segment) (Conmon_createNamespaces_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_attachContainer_Results(st), err + return Conmon_createNamespaces_Results(st), err } -func ReadRootConmon_attachContainer_Results(msg *capnp.Message) (Conmon_attachContainer_Results, error) { +func ReadRootConmon_createNamespaces_Results(msg *capnp.Message) (Conmon_createNamespaces_Results, error) { root, err := msg.Root() - return Conmon_attachContainer_Results(root.Struct()), err + return Conmon_createNamespaces_Results(root.Struct()), err } -func (s Conmon_attachContainer_Results) String() string { - str, _ := text.Marshal(0xc5e65eec3dcf5b10, capnp.Struct(s)) +func (s Conmon_createNamespaces_Results) String() string { + str, _ := text.Marshal(0x8aef91973dc8a4f5, capnp.Struct(s)) return str } -func (s Conmon_attachContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_createNamespaces_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_attachContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_attachContainer_Results { - return Conmon_attachContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_createNamespaces_Results) DecodeFromPtr(p capnp.Ptr) Conmon_createNamespaces_Results { + return Conmon_createNamespaces_Results(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_attachContainer_Results) ToPtr() capnp.Ptr { +func (s Conmon_createNamespaces_Results) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_attachContainer_Results) IsValid() bool { +func (s Conmon_createNamespaces_Results) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_attachContainer_Results) Message() *capnp.Message { +func (s Conmon_createNamespaces_Results) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_attachContainer_Results) Segment() *capnp.Segment { +func (s Conmon_createNamespaces_Results) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_attachContainer_Results) Response() (Conmon_AttachResponse, error) { +func (s Conmon_createNamespaces_Results) Response() (Conmon_CreateNamespacesResponse, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_AttachResponse(p.Struct()), err + return Conmon_CreateNamespacesResponse(p.Struct()), err } -func (s Conmon_attachContainer_Results) HasResponse() bool { +func (s Conmon_createNamespaces_Results) HasResponse() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_attachContainer_Results) SetResponse(v Conmon_AttachResponse) error { +func (s Conmon_createNamespaces_Results) SetResponse(v Conmon_CreateNamespacesResponse) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewResponse sets the response field to a newly -// allocated Conmon_AttachResponse struct, preferring placement in s's segment. -func (s Conmon_attachContainer_Results) NewResponse() (Conmon_AttachResponse, error) { - ss, err := NewConmon_AttachResponse(capnp.Struct(s).Segment()) +// allocated Conmon_CreateNamespacesResponse struct, preferring placement in s's segment. +func (s Conmon_createNamespaces_Results) NewResponse() (Conmon_CreateNamespacesResponse, error) { + ss, err := NewConmon_CreateNamespacesResponse(capnp.Struct(s).Segment()) if err != nil { - return Conmon_AttachResponse{}, err + return Conmon_CreateNamespacesResponse{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_attachContainer_Results_List is a list of Conmon_attachContainer_Results. -type Conmon_attachContainer_Results_List = capnp.StructList[Conmon_attachContainer_Results] +// Conmon_createNamespaces_Results_List is a list of Conmon_createNamespaces_Results. +type Conmon_createNamespaces_Results_List = capnp.StructList[Conmon_createNamespaces_Results] -// NewConmon_attachContainer_Results creates a new list of Conmon_attachContainer_Results. -func NewConmon_attachContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_attachContainer_Results_List, error) { +// NewConmon_createNamespaces_Results creates a new list of Conmon_createNamespaces_Results. +func NewConmon_createNamespaces_Results_List(s *capnp.Segment, sz int32) (Conmon_createNamespaces_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_attachContainer_Results](l), err + return capnp.StructList[Conmon_createNamespaces_Results](l), err } -// Conmon_attachContainer_Results_Future is a wrapper for a Conmon_attachContainer_Results promised by a client call. -type Conmon_attachContainer_Results_Future struct{ *capnp.Future } +// Conmon_createNamespaces_Results_Future is a wrapper for a Conmon_createNamespaces_Results promised by a client call. +type Conmon_createNamespaces_Results_Future struct{ *capnp.Future } -func (f Conmon_attachContainer_Results_Future) Struct() (Conmon_attachContainer_Results, error) { +func (f Conmon_createNamespaces_Results_Future) Struct() (Conmon_createNamespaces_Results, error) { p, err := f.Future.Ptr() - return Conmon_attachContainer_Results(p.Struct()), err + return Conmon_createNamespaces_Results(p.Struct()), err } -func (p Conmon_attachContainer_Results_Future) Response() Conmon_AttachResponse_Future { - return Conmon_AttachResponse_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_createNamespaces_Results_Future) Response() Conmon_CreateNamespacesResponse_Future { + return Conmon_CreateNamespacesResponse_Future{Future: p.Future.Field(0, nil)} } -type Conmon_reopenLogContainer_Params capnp.Struct +type Conmon_startFdSocket_Params capnp.Struct -// Conmon_reopenLogContainer_Params_TypeID is the unique identifier for the type Conmon_reopenLogContainer_Params. -const Conmon_reopenLogContainer_Params_TypeID = 0xe5ea916eb0c31336 +// Conmon_startFdSocket_Params_TypeID is the unique identifier for the type Conmon_startFdSocket_Params. +const Conmon_startFdSocket_Params_TypeID = 0xce733f0914c80b6b -func NewConmon_reopenLogContainer_Params(s *capnp.Segment) (Conmon_reopenLogContainer_Params, error) { +func NewConmon_startFdSocket_Params(s *capnp.Segment) (Conmon_startFdSocket_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_reopenLogContainer_Params(st), err + return Conmon_startFdSocket_Params(st), err } -func NewRootConmon_reopenLogContainer_Params(s *capnp.Segment) (Conmon_reopenLogContainer_Params, error) { +func NewRootConmon_startFdSocket_Params(s *capnp.Segment) (Conmon_startFdSocket_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_reopenLogContainer_Params(st), err + return Conmon_startFdSocket_Params(st), err } -func ReadRootConmon_reopenLogContainer_Params(msg *capnp.Message) (Conmon_reopenLogContainer_Params, error) { +func ReadRootConmon_startFdSocket_Params(msg *capnp.Message) (Conmon_startFdSocket_Params, error) { root, err := msg.Root() - return Conmon_reopenLogContainer_Params(root.Struct()), err + return Conmon_startFdSocket_Params(root.Struct()), err } -func (s Conmon_reopenLogContainer_Params) String() string { - str, _ := text.Marshal(0xe5ea916eb0c31336, capnp.Struct(s)) +func (s Conmon_startFdSocket_Params) String() string { + str, _ := text.Marshal(0xce733f0914c80b6b, capnp.Struct(s)) return str } -func (s Conmon_reopenLogContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_startFdSocket_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_reopenLogContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_reopenLogContainer_Params { - return Conmon_reopenLogContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_startFdSocket_Params) DecodeFromPtr(p capnp.Ptr) Conmon_startFdSocket_Params { + return Conmon_startFdSocket_Params(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_reopenLogContainer_Params) ToPtr() capnp.Ptr { +func (s Conmon_startFdSocket_Params) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_reopenLogContainer_Params) IsValid() bool { +func (s Conmon_startFdSocket_Params) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_reopenLogContainer_Params) Message() *capnp.Message { +func (s Conmon_startFdSocket_Params) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_reopenLogContainer_Params) Segment() *capnp.Segment { +func (s Conmon_startFdSocket_Params) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_reopenLogContainer_Params) Request() (Conmon_ReopenLogRequest, error) { +func (s Conmon_startFdSocket_Params) Request() (Conmon_StartFdSocketRequest, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_ReopenLogRequest(p.Struct()), err + return Conmon_StartFdSocketRequest(p.Struct()), err } -func (s Conmon_reopenLogContainer_Params) HasRequest() bool { +func (s Conmon_startFdSocket_Params) HasRequest() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_reopenLogContainer_Params) SetRequest(v Conmon_ReopenLogRequest) error { +func (s Conmon_startFdSocket_Params) SetRequest(v Conmon_StartFdSocketRequest) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewRequest sets the request field to a newly -// allocated Conmon_ReopenLogRequest struct, preferring placement in s's segment. -func (s Conmon_reopenLogContainer_Params) NewRequest() (Conmon_ReopenLogRequest, error) { - ss, err := NewConmon_ReopenLogRequest(capnp.Struct(s).Segment()) +// allocated Conmon_StartFdSocketRequest struct, preferring placement in s's segment. +func (s Conmon_startFdSocket_Params) NewRequest() (Conmon_StartFdSocketRequest, error) { + ss, err := NewConmon_StartFdSocketRequest(capnp.Struct(s).Segment()) if err != nil { - return Conmon_ReopenLogRequest{}, err + return Conmon_StartFdSocketRequest{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_reopenLogContainer_Params_List is a list of Conmon_reopenLogContainer_Params. -type Conmon_reopenLogContainer_Params_List = capnp.StructList[Conmon_reopenLogContainer_Params] +// Conmon_startFdSocket_Params_List is a list of Conmon_startFdSocket_Params. +type Conmon_startFdSocket_Params_List = capnp.StructList[Conmon_startFdSocket_Params] -// NewConmon_reopenLogContainer_Params creates a new list of Conmon_reopenLogContainer_Params. -func NewConmon_reopenLogContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_reopenLogContainer_Params_List, error) { +// NewConmon_startFdSocket_Params creates a new list of Conmon_startFdSocket_Params. +func NewConmon_startFdSocket_Params_List(s *capnp.Segment, sz int32) (Conmon_startFdSocket_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_reopenLogContainer_Params](l), err + return capnp.StructList[Conmon_startFdSocket_Params](l), err } -// Conmon_reopenLogContainer_Params_Future is a wrapper for a Conmon_reopenLogContainer_Params promised by a client call. -type Conmon_reopenLogContainer_Params_Future struct{ *capnp.Future } +// Conmon_startFdSocket_Params_Future is a wrapper for a Conmon_startFdSocket_Params promised by a client call. +type Conmon_startFdSocket_Params_Future struct{ *capnp.Future } -func (f Conmon_reopenLogContainer_Params_Future) Struct() (Conmon_reopenLogContainer_Params, error) { +func (f Conmon_startFdSocket_Params_Future) Struct() (Conmon_startFdSocket_Params, error) { p, err := f.Future.Ptr() - return Conmon_reopenLogContainer_Params(p.Struct()), err + return Conmon_startFdSocket_Params(p.Struct()), err } -func (p Conmon_reopenLogContainer_Params_Future) Request() Conmon_ReopenLogRequest_Future { - return Conmon_ReopenLogRequest_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_startFdSocket_Params_Future) Request() Conmon_StartFdSocketRequest_Future { + return Conmon_StartFdSocketRequest_Future{Future: p.Future.Field(0, nil)} } -type Conmon_reopenLogContainer_Results capnp.Struct +type Conmon_startFdSocket_Results capnp.Struct -// Conmon_reopenLogContainer_Results_TypeID is the unique identifier for the type Conmon_reopenLogContainer_Results. -const Conmon_reopenLogContainer_Results_TypeID = 0xa0ef8355b64ee985 +// Conmon_startFdSocket_Results_TypeID is the unique identifier for the type Conmon_startFdSocket_Results. +const Conmon_startFdSocket_Results_TypeID = 0xf4e3e92ae0815f15 -func NewConmon_reopenLogContainer_Results(s *capnp.Segment) (Conmon_reopenLogContainer_Results, error) { +func NewConmon_startFdSocket_Results(s *capnp.Segment) (Conmon_startFdSocket_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_reopenLogContainer_Results(st), err + return Conmon_startFdSocket_Results(st), err } -func NewRootConmon_reopenLogContainer_Results(s *capnp.Segment) (Conmon_reopenLogContainer_Results, error) { +func NewRootConmon_startFdSocket_Results(s *capnp.Segment) (Conmon_startFdSocket_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_reopenLogContainer_Results(st), err + return Conmon_startFdSocket_Results(st), err } -func ReadRootConmon_reopenLogContainer_Results(msg *capnp.Message) (Conmon_reopenLogContainer_Results, error) { +func ReadRootConmon_startFdSocket_Results(msg *capnp.Message) (Conmon_startFdSocket_Results, error) { root, err := msg.Root() - return Conmon_reopenLogContainer_Results(root.Struct()), err + return Conmon_startFdSocket_Results(root.Struct()), err } -func (s Conmon_reopenLogContainer_Results) String() string { - str, _ := text.Marshal(0xa0ef8355b64ee985, capnp.Struct(s)) +func (s Conmon_startFdSocket_Results) String() string { + str, _ := text.Marshal(0xf4e3e92ae0815f15, capnp.Struct(s)) return str } -func (s Conmon_reopenLogContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_startFdSocket_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_reopenLogContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_reopenLogContainer_Results { - return Conmon_reopenLogContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_startFdSocket_Results) DecodeFromPtr(p capnp.Ptr) Conmon_startFdSocket_Results { + return Conmon_startFdSocket_Results(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_reopenLogContainer_Results) ToPtr() capnp.Ptr { +func (s Conmon_startFdSocket_Results) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_reopenLogContainer_Results) IsValid() bool { +func (s Conmon_startFdSocket_Results) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_reopenLogContainer_Results) Message() *capnp.Message { +func (s Conmon_startFdSocket_Results) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_reopenLogContainer_Results) Segment() *capnp.Segment { +func (s Conmon_startFdSocket_Results) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_reopenLogContainer_Results) Response() (Conmon_ReopenLogResponse, error) { +func (s Conmon_startFdSocket_Results) Response() (Conmon_StartFdSocketResponse, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_ReopenLogResponse(p.Struct()), err + return Conmon_StartFdSocketResponse(p.Struct()), err } -func (s Conmon_reopenLogContainer_Results) HasResponse() bool { +func (s Conmon_startFdSocket_Results) HasResponse() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_reopenLogContainer_Results) SetResponse(v Conmon_ReopenLogResponse) error { +func (s Conmon_startFdSocket_Results) SetResponse(v Conmon_StartFdSocketResponse) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewResponse sets the response field to a newly -// allocated Conmon_ReopenLogResponse struct, preferring placement in s's segment. -func (s Conmon_reopenLogContainer_Results) NewResponse() (Conmon_ReopenLogResponse, error) { - ss, err := NewConmon_ReopenLogResponse(capnp.Struct(s).Segment()) +// allocated Conmon_StartFdSocketResponse struct, preferring placement in s's segment. +func (s Conmon_startFdSocket_Results) NewResponse() (Conmon_StartFdSocketResponse, error) { + ss, err := NewConmon_StartFdSocketResponse(capnp.Struct(s).Segment()) if err != nil { - return Conmon_ReopenLogResponse{}, err + return Conmon_StartFdSocketResponse{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_reopenLogContainer_Results_List is a list of Conmon_reopenLogContainer_Results. -type Conmon_reopenLogContainer_Results_List = capnp.StructList[Conmon_reopenLogContainer_Results] +// Conmon_startFdSocket_Results_List is a list of Conmon_startFdSocket_Results. +type Conmon_startFdSocket_Results_List = capnp.StructList[Conmon_startFdSocket_Results] -// NewConmon_reopenLogContainer_Results creates a new list of Conmon_reopenLogContainer_Results. -func NewConmon_reopenLogContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_reopenLogContainer_Results_List, error) { +// NewConmon_startFdSocket_Results creates a new list of Conmon_startFdSocket_Results. +func NewConmon_startFdSocket_Results_List(s *capnp.Segment, sz int32) (Conmon_startFdSocket_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_reopenLogContainer_Results](l), err + return capnp.StructList[Conmon_startFdSocket_Results](l), err } -// Conmon_reopenLogContainer_Results_Future is a wrapper for a Conmon_reopenLogContainer_Results promised by a client call. -type Conmon_reopenLogContainer_Results_Future struct{ *capnp.Future } +// Conmon_startFdSocket_Results_Future is a wrapper for a Conmon_startFdSocket_Results promised by a client call. +type Conmon_startFdSocket_Results_Future struct{ *capnp.Future } -func (f Conmon_reopenLogContainer_Results_Future) Struct() (Conmon_reopenLogContainer_Results, error) { +func (f Conmon_startFdSocket_Results_Future) Struct() (Conmon_startFdSocket_Results, error) { p, err := f.Future.Ptr() - return Conmon_reopenLogContainer_Results(p.Struct()), err + return Conmon_startFdSocket_Results(p.Struct()), err } -func (p Conmon_reopenLogContainer_Results_Future) Response() Conmon_ReopenLogResponse_Future { - return Conmon_ReopenLogResponse_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_startFdSocket_Results_Future) Response() Conmon_StartFdSocketResponse_Future { + return Conmon_StartFdSocketResponse_Future{Future: p.Future.Field(0, nil)} } -type Conmon_setWindowSizeContainer_Params capnp.Struct +type Conmon_serveExecContainer_Params capnp.Struct -// Conmon_setWindowSizeContainer_Params_TypeID is the unique identifier for the type Conmon_setWindowSizeContainer_Params. -const Conmon_setWindowSizeContainer_Params_TypeID = 0xc76ccd4502bb61e7 +// Conmon_serveExecContainer_Params_TypeID is the unique identifier for the type Conmon_serveExecContainer_Params. +const Conmon_serveExecContainer_Params_TypeID = 0x90a3950a51412b8b -func NewConmon_setWindowSizeContainer_Params(s *capnp.Segment) (Conmon_setWindowSizeContainer_Params, error) { +func NewConmon_serveExecContainer_Params(s *capnp.Segment) (Conmon_serveExecContainer_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_setWindowSizeContainer_Params(st), err + return Conmon_serveExecContainer_Params(st), err } -func NewRootConmon_setWindowSizeContainer_Params(s *capnp.Segment) (Conmon_setWindowSizeContainer_Params, error) { +func NewRootConmon_serveExecContainer_Params(s *capnp.Segment) (Conmon_serveExecContainer_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_setWindowSizeContainer_Params(st), err + return Conmon_serveExecContainer_Params(st), err } -func ReadRootConmon_setWindowSizeContainer_Params(msg *capnp.Message) (Conmon_setWindowSizeContainer_Params, error) { +func ReadRootConmon_serveExecContainer_Params(msg *capnp.Message) (Conmon_serveExecContainer_Params, error) { root, err := msg.Root() - return Conmon_setWindowSizeContainer_Params(root.Struct()), err + return Conmon_serveExecContainer_Params(root.Struct()), err } -func (s Conmon_setWindowSizeContainer_Params) String() string { - str, _ := text.Marshal(0xc76ccd4502bb61e7, capnp.Struct(s)) +func (s Conmon_serveExecContainer_Params) String() string { + str, _ := text.Marshal(0x90a3950a51412b8b, capnp.Struct(s)) return str } -func (s Conmon_setWindowSizeContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_serveExecContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_setWindowSizeContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_setWindowSizeContainer_Params { - return Conmon_setWindowSizeContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_serveExecContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_serveExecContainer_Params { + return Conmon_serveExecContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_setWindowSizeContainer_Params) ToPtr() capnp.Ptr { +func (s Conmon_serveExecContainer_Params) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_setWindowSizeContainer_Params) IsValid() bool { +func (s Conmon_serveExecContainer_Params) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_setWindowSizeContainer_Params) Message() *capnp.Message { +func (s Conmon_serveExecContainer_Params) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_setWindowSizeContainer_Params) Segment() *capnp.Segment { +func (s Conmon_serveExecContainer_Params) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_setWindowSizeContainer_Params) Request() (Conmon_SetWindowSizeRequest, error) { +func (s Conmon_serveExecContainer_Params) Request() (Conmon_ServeExecContainerRequest, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_SetWindowSizeRequest(p.Struct()), err + return Conmon_ServeExecContainerRequest(p.Struct()), err } -func (s Conmon_setWindowSizeContainer_Params) HasRequest() bool { +func (s Conmon_serveExecContainer_Params) HasRequest() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_setWindowSizeContainer_Params) SetRequest(v Conmon_SetWindowSizeRequest) error { +func (s Conmon_serveExecContainer_Params) SetRequest(v Conmon_ServeExecContainerRequest) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewRequest sets the request field to a newly -// allocated Conmon_SetWindowSizeRequest struct, preferring placement in s's segment. -func (s Conmon_setWindowSizeContainer_Params) NewRequest() (Conmon_SetWindowSizeRequest, error) { - ss, err := NewConmon_SetWindowSizeRequest(capnp.Struct(s).Segment()) +// allocated Conmon_ServeExecContainerRequest struct, preferring placement in s's segment. +func (s Conmon_serveExecContainer_Params) NewRequest() (Conmon_ServeExecContainerRequest, error) { + ss, err := NewConmon_ServeExecContainerRequest(capnp.Struct(s).Segment()) if err != nil { - return Conmon_SetWindowSizeRequest{}, err + return Conmon_ServeExecContainerRequest{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_setWindowSizeContainer_Params_List is a list of Conmon_setWindowSizeContainer_Params. -type Conmon_setWindowSizeContainer_Params_List = capnp.StructList[Conmon_setWindowSizeContainer_Params] +// Conmon_serveExecContainer_Params_List is a list of Conmon_serveExecContainer_Params. +type Conmon_serveExecContainer_Params_List = capnp.StructList[Conmon_serveExecContainer_Params] -// NewConmon_setWindowSizeContainer_Params creates a new list of Conmon_setWindowSizeContainer_Params. -func NewConmon_setWindowSizeContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_setWindowSizeContainer_Params_List, error) { +// NewConmon_serveExecContainer_Params creates a new list of Conmon_serveExecContainer_Params. +func NewConmon_serveExecContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_serveExecContainer_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_setWindowSizeContainer_Params](l), err + return capnp.StructList[Conmon_serveExecContainer_Params](l), err } -// Conmon_setWindowSizeContainer_Params_Future is a wrapper for a Conmon_setWindowSizeContainer_Params promised by a client call. -type Conmon_setWindowSizeContainer_Params_Future struct{ *capnp.Future } +// Conmon_serveExecContainer_Params_Future is a wrapper for a Conmon_serveExecContainer_Params promised by a client call. +type Conmon_serveExecContainer_Params_Future struct{ *capnp.Future } -func (f Conmon_setWindowSizeContainer_Params_Future) Struct() (Conmon_setWindowSizeContainer_Params, error) { +func (f Conmon_serveExecContainer_Params_Future) Struct() (Conmon_serveExecContainer_Params, error) { p, err := f.Future.Ptr() - return Conmon_setWindowSizeContainer_Params(p.Struct()), err + return Conmon_serveExecContainer_Params(p.Struct()), err } -func (p Conmon_setWindowSizeContainer_Params_Future) Request() Conmon_SetWindowSizeRequest_Future { - return Conmon_SetWindowSizeRequest_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_serveExecContainer_Params_Future) Request() Conmon_ServeExecContainerRequest_Future { + return Conmon_ServeExecContainerRequest_Future{Future: p.Future.Field(0, nil)} } -type Conmon_setWindowSizeContainer_Results capnp.Struct +type Conmon_serveExecContainer_Results capnp.Struct -// Conmon_setWindowSizeContainer_Results_TypeID is the unique identifier for the type Conmon_setWindowSizeContainer_Results. -const Conmon_setWindowSizeContainer_Results_TypeID = 0xe00e522611477055 +// Conmon_serveExecContainer_Results_TypeID is the unique identifier for the type Conmon_serveExecContainer_Results. +const Conmon_serveExecContainer_Results_TypeID = 0xdebaeed2a782ac80 -func NewConmon_setWindowSizeContainer_Results(s *capnp.Segment) (Conmon_setWindowSizeContainer_Results, error) { +func NewConmon_serveExecContainer_Results(s *capnp.Segment) (Conmon_serveExecContainer_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_setWindowSizeContainer_Results(st), err + return Conmon_serveExecContainer_Results(st), err } -func NewRootConmon_setWindowSizeContainer_Results(s *capnp.Segment) (Conmon_setWindowSizeContainer_Results, error) { +func NewRootConmon_serveExecContainer_Results(s *capnp.Segment) (Conmon_serveExecContainer_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_setWindowSizeContainer_Results(st), err + return Conmon_serveExecContainer_Results(st), err } -func ReadRootConmon_setWindowSizeContainer_Results(msg *capnp.Message) (Conmon_setWindowSizeContainer_Results, error) { +func ReadRootConmon_serveExecContainer_Results(msg *capnp.Message) (Conmon_serveExecContainer_Results, error) { root, err := msg.Root() - return Conmon_setWindowSizeContainer_Results(root.Struct()), err + return Conmon_serveExecContainer_Results(root.Struct()), err } -func (s Conmon_setWindowSizeContainer_Results) String() string { - str, _ := text.Marshal(0xe00e522611477055, capnp.Struct(s)) +func (s Conmon_serveExecContainer_Results) String() string { + str, _ := text.Marshal(0xdebaeed2a782ac80, capnp.Struct(s)) return str } -func (s Conmon_setWindowSizeContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_serveExecContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_setWindowSizeContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_setWindowSizeContainer_Results { - return Conmon_setWindowSizeContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_serveExecContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_serveExecContainer_Results { + return Conmon_serveExecContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_setWindowSizeContainer_Results) ToPtr() capnp.Ptr { +func (s Conmon_serveExecContainer_Results) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_setWindowSizeContainer_Results) IsValid() bool { +func (s Conmon_serveExecContainer_Results) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_setWindowSizeContainer_Results) Message() *capnp.Message { +func (s Conmon_serveExecContainer_Results) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_setWindowSizeContainer_Results) Segment() *capnp.Segment { +func (s Conmon_serveExecContainer_Results) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_setWindowSizeContainer_Results) Response() (Conmon_SetWindowSizeResponse, error) { +func (s Conmon_serveExecContainer_Results) Response() (Conmon_ServeExecContainerResponse, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_SetWindowSizeResponse(p.Struct()), err + return Conmon_ServeExecContainerResponse(p.Struct()), err } -func (s Conmon_setWindowSizeContainer_Results) HasResponse() bool { +func (s Conmon_serveExecContainer_Results) HasResponse() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_setWindowSizeContainer_Results) SetResponse(v Conmon_SetWindowSizeResponse) error { +func (s Conmon_serveExecContainer_Results) SetResponse(v Conmon_ServeExecContainerResponse) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewResponse sets the response field to a newly -// allocated Conmon_SetWindowSizeResponse struct, preferring placement in s's segment. -func (s Conmon_setWindowSizeContainer_Results) NewResponse() (Conmon_SetWindowSizeResponse, error) { - ss, err := NewConmon_SetWindowSizeResponse(capnp.Struct(s).Segment()) +// allocated Conmon_ServeExecContainerResponse struct, preferring placement in s's segment. +func (s Conmon_serveExecContainer_Results) NewResponse() (Conmon_ServeExecContainerResponse, error) { + ss, err := NewConmon_ServeExecContainerResponse(capnp.Struct(s).Segment()) if err != nil { - return Conmon_SetWindowSizeResponse{}, err + return Conmon_ServeExecContainerResponse{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_setWindowSizeContainer_Results_List is a list of Conmon_setWindowSizeContainer_Results. -type Conmon_setWindowSizeContainer_Results_List = capnp.StructList[Conmon_setWindowSizeContainer_Results] +// Conmon_serveExecContainer_Results_List is a list of Conmon_serveExecContainer_Results. +type Conmon_serveExecContainer_Results_List = capnp.StructList[Conmon_serveExecContainer_Results] -// NewConmon_setWindowSizeContainer_Results creates a new list of Conmon_setWindowSizeContainer_Results. -func NewConmon_setWindowSizeContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_setWindowSizeContainer_Results_List, error) { +// NewConmon_serveExecContainer_Results creates a new list of Conmon_serveExecContainer_Results. +func NewConmon_serveExecContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_serveExecContainer_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_setWindowSizeContainer_Results](l), err + return capnp.StructList[Conmon_serveExecContainer_Results](l), err } -// Conmon_setWindowSizeContainer_Results_Future is a wrapper for a Conmon_setWindowSizeContainer_Results promised by a client call. -type Conmon_setWindowSizeContainer_Results_Future struct{ *capnp.Future } +// Conmon_serveExecContainer_Results_Future is a wrapper for a Conmon_serveExecContainer_Results promised by a client call. +type Conmon_serveExecContainer_Results_Future struct{ *capnp.Future } -func (f Conmon_setWindowSizeContainer_Results_Future) Struct() (Conmon_setWindowSizeContainer_Results, error) { +func (f Conmon_serveExecContainer_Results_Future) Struct() (Conmon_serveExecContainer_Results, error) { p, err := f.Future.Ptr() - return Conmon_setWindowSizeContainer_Results(p.Struct()), err + return Conmon_serveExecContainer_Results(p.Struct()), err } -func (p Conmon_setWindowSizeContainer_Results_Future) Response() Conmon_SetWindowSizeResponse_Future { - return Conmon_SetWindowSizeResponse_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_serveExecContainer_Results_Future) Response() Conmon_ServeExecContainerResponse_Future { + return Conmon_ServeExecContainerResponse_Future{Future: p.Future.Field(0, nil)} } -type Conmon_createNamespaces_Params capnp.Struct +type Conmon_serveAttachContainer_Params capnp.Struct -// Conmon_createNamespaces_Params_TypeID is the unique identifier for the type Conmon_createNamespaces_Params. -const Conmon_createNamespaces_Params_TypeID = 0x8b4c03a0662a38dc +// Conmon_serveAttachContainer_Params_TypeID is the unique identifier for the type Conmon_serveAttachContainer_Params. +const Conmon_serveAttachContainer_Params_TypeID = 0xa3cb406c522dcab1 -func NewConmon_createNamespaces_Params(s *capnp.Segment) (Conmon_createNamespaces_Params, error) { +func NewConmon_serveAttachContainer_Params(s *capnp.Segment) (Conmon_serveAttachContainer_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createNamespaces_Params(st), err + return Conmon_serveAttachContainer_Params(st), err } -func NewRootConmon_createNamespaces_Params(s *capnp.Segment) (Conmon_createNamespaces_Params, error) { +func NewRootConmon_serveAttachContainer_Params(s *capnp.Segment) (Conmon_serveAttachContainer_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createNamespaces_Params(st), err + return Conmon_serveAttachContainer_Params(st), err } -func ReadRootConmon_createNamespaces_Params(msg *capnp.Message) (Conmon_createNamespaces_Params, error) { +func ReadRootConmon_serveAttachContainer_Params(msg *capnp.Message) (Conmon_serveAttachContainer_Params, error) { root, err := msg.Root() - return Conmon_createNamespaces_Params(root.Struct()), err + return Conmon_serveAttachContainer_Params(root.Struct()), err } -func (s Conmon_createNamespaces_Params) String() string { - str, _ := text.Marshal(0x8b4c03a0662a38dc, capnp.Struct(s)) +func (s Conmon_serveAttachContainer_Params) String() string { + str, _ := text.Marshal(0xa3cb406c522dcab1, capnp.Struct(s)) return str } -func (s Conmon_createNamespaces_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_serveAttachContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_createNamespaces_Params) DecodeFromPtr(p capnp.Ptr) Conmon_createNamespaces_Params { - return Conmon_createNamespaces_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_serveAttachContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_serveAttachContainer_Params { + return Conmon_serveAttachContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_createNamespaces_Params) ToPtr() capnp.Ptr { +func (s Conmon_serveAttachContainer_Params) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_createNamespaces_Params) IsValid() bool { +func (s Conmon_serveAttachContainer_Params) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_createNamespaces_Params) Message() *capnp.Message { +func (s Conmon_serveAttachContainer_Params) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_createNamespaces_Params) Segment() *capnp.Segment { +func (s Conmon_serveAttachContainer_Params) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_createNamespaces_Params) Request() (Conmon_CreateNamespacesRequest, error) { +func (s Conmon_serveAttachContainer_Params) Request() (Conmon_ServeAttachContainerRequest, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_CreateNamespacesRequest(p.Struct()), err + return Conmon_ServeAttachContainerRequest(p.Struct()), err } -func (s Conmon_createNamespaces_Params) HasRequest() bool { +func (s Conmon_serveAttachContainer_Params) HasRequest() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_createNamespaces_Params) SetRequest(v Conmon_CreateNamespacesRequest) error { +func (s Conmon_serveAttachContainer_Params) SetRequest(v Conmon_ServeAttachContainerRequest) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewRequest sets the request field to a newly -// allocated Conmon_CreateNamespacesRequest struct, preferring placement in s's segment. -func (s Conmon_createNamespaces_Params) NewRequest() (Conmon_CreateNamespacesRequest, error) { - ss, err := NewConmon_CreateNamespacesRequest(capnp.Struct(s).Segment()) +// allocated Conmon_ServeAttachContainerRequest struct, preferring placement in s's segment. +func (s Conmon_serveAttachContainer_Params) NewRequest() (Conmon_ServeAttachContainerRequest, error) { + ss, err := NewConmon_ServeAttachContainerRequest(capnp.Struct(s).Segment()) if err != nil { - return Conmon_CreateNamespacesRequest{}, err + return Conmon_ServeAttachContainerRequest{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_createNamespaces_Params_List is a list of Conmon_createNamespaces_Params. -type Conmon_createNamespaces_Params_List = capnp.StructList[Conmon_createNamespaces_Params] +// Conmon_serveAttachContainer_Params_List is a list of Conmon_serveAttachContainer_Params. +type Conmon_serveAttachContainer_Params_List = capnp.StructList[Conmon_serveAttachContainer_Params] -// NewConmon_createNamespaces_Params creates a new list of Conmon_createNamespaces_Params. -func NewConmon_createNamespaces_Params_List(s *capnp.Segment, sz int32) (Conmon_createNamespaces_Params_List, error) { +// NewConmon_serveAttachContainer_Params creates a new list of Conmon_serveAttachContainer_Params. +func NewConmon_serveAttachContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_serveAttachContainer_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_createNamespaces_Params](l), err + return capnp.StructList[Conmon_serveAttachContainer_Params](l), err } -// Conmon_createNamespaces_Params_Future is a wrapper for a Conmon_createNamespaces_Params promised by a client call. -type Conmon_createNamespaces_Params_Future struct{ *capnp.Future } +// Conmon_serveAttachContainer_Params_Future is a wrapper for a Conmon_serveAttachContainer_Params promised by a client call. +type Conmon_serveAttachContainer_Params_Future struct{ *capnp.Future } -func (f Conmon_createNamespaces_Params_Future) Struct() (Conmon_createNamespaces_Params, error) { +func (f Conmon_serveAttachContainer_Params_Future) Struct() (Conmon_serveAttachContainer_Params, error) { p, err := f.Future.Ptr() - return Conmon_createNamespaces_Params(p.Struct()), err + return Conmon_serveAttachContainer_Params(p.Struct()), err } -func (p Conmon_createNamespaces_Params_Future) Request() Conmon_CreateNamespacesRequest_Future { - return Conmon_CreateNamespacesRequest_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_serveAttachContainer_Params_Future) Request() Conmon_ServeAttachContainerRequest_Future { + return Conmon_ServeAttachContainerRequest_Future{Future: p.Future.Field(0, nil)} } -type Conmon_createNamespaces_Results capnp.Struct +type Conmon_serveAttachContainer_Results capnp.Struct -// Conmon_createNamespaces_Results_TypeID is the unique identifier for the type Conmon_createNamespaces_Results. -const Conmon_createNamespaces_Results_TypeID = 0x8aef91973dc8a4f5 +// Conmon_serveAttachContainer_Results_TypeID is the unique identifier for the type Conmon_serveAttachContainer_Results. +const Conmon_serveAttachContainer_Results_TypeID = 0xedd2e5b018f17bbb -func NewConmon_createNamespaces_Results(s *capnp.Segment) (Conmon_createNamespaces_Results, error) { +func NewConmon_serveAttachContainer_Results(s *capnp.Segment) (Conmon_serveAttachContainer_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createNamespaces_Results(st), err + return Conmon_serveAttachContainer_Results(st), err } -func NewRootConmon_createNamespaces_Results(s *capnp.Segment) (Conmon_createNamespaces_Results, error) { +func NewRootConmon_serveAttachContainer_Results(s *capnp.Segment) (Conmon_serveAttachContainer_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_createNamespaces_Results(st), err + return Conmon_serveAttachContainer_Results(st), err } -func ReadRootConmon_createNamespaces_Results(msg *capnp.Message) (Conmon_createNamespaces_Results, error) { +func ReadRootConmon_serveAttachContainer_Results(msg *capnp.Message) (Conmon_serveAttachContainer_Results, error) { root, err := msg.Root() - return Conmon_createNamespaces_Results(root.Struct()), err + return Conmon_serveAttachContainer_Results(root.Struct()), err } -func (s Conmon_createNamespaces_Results) String() string { - str, _ := text.Marshal(0x8aef91973dc8a4f5, capnp.Struct(s)) +func (s Conmon_serveAttachContainer_Results) String() string { + str, _ := text.Marshal(0xedd2e5b018f17bbb, capnp.Struct(s)) return str } -func (s Conmon_createNamespaces_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_serveAttachContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_createNamespaces_Results) DecodeFromPtr(p capnp.Ptr) Conmon_createNamespaces_Results { - return Conmon_createNamespaces_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_serveAttachContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_serveAttachContainer_Results { + return Conmon_serveAttachContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_createNamespaces_Results) ToPtr() capnp.Ptr { +func (s Conmon_serveAttachContainer_Results) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_createNamespaces_Results) IsValid() bool { +func (s Conmon_serveAttachContainer_Results) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_createNamespaces_Results) Message() *capnp.Message { +func (s Conmon_serveAttachContainer_Results) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_createNamespaces_Results) Segment() *capnp.Segment { +func (s Conmon_serveAttachContainer_Results) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_createNamespaces_Results) Response() (Conmon_CreateNamespacesResponse, error) { +func (s Conmon_serveAttachContainer_Results) Response() (Conmon_ServeAttachContainerResponse, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_CreateNamespacesResponse(p.Struct()), err + return Conmon_ServeAttachContainerResponse(p.Struct()), err } -func (s Conmon_createNamespaces_Results) HasResponse() bool { +func (s Conmon_serveAttachContainer_Results) HasResponse() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_createNamespaces_Results) SetResponse(v Conmon_CreateNamespacesResponse) error { +func (s Conmon_serveAttachContainer_Results) SetResponse(v Conmon_ServeAttachContainerResponse) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewResponse sets the response field to a newly -// allocated Conmon_CreateNamespacesResponse struct, preferring placement in s's segment. -func (s Conmon_createNamespaces_Results) NewResponse() (Conmon_CreateNamespacesResponse, error) { - ss, err := NewConmon_CreateNamespacesResponse(capnp.Struct(s).Segment()) +// allocated Conmon_ServeAttachContainerResponse struct, preferring placement in s's segment. +func (s Conmon_serveAttachContainer_Results) NewResponse() (Conmon_ServeAttachContainerResponse, error) { + ss, err := NewConmon_ServeAttachContainerResponse(capnp.Struct(s).Segment()) if err != nil { - return Conmon_CreateNamespacesResponse{}, err + return Conmon_ServeAttachContainerResponse{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_createNamespaces_Results_List is a list of Conmon_createNamespaces_Results. -type Conmon_createNamespaces_Results_List = capnp.StructList[Conmon_createNamespaces_Results] +// Conmon_serveAttachContainer_Results_List is a list of Conmon_serveAttachContainer_Results. +type Conmon_serveAttachContainer_Results_List = capnp.StructList[Conmon_serveAttachContainer_Results] -// NewConmon_createNamespaces_Results creates a new list of Conmon_createNamespaces_Results. -func NewConmon_createNamespaces_Results_List(s *capnp.Segment, sz int32) (Conmon_createNamespaces_Results_List, error) { +// NewConmon_serveAttachContainer_Results creates a new list of Conmon_serveAttachContainer_Results. +func NewConmon_serveAttachContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_serveAttachContainer_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_createNamespaces_Results](l), err + return capnp.StructList[Conmon_serveAttachContainer_Results](l), err } -// Conmon_createNamespaces_Results_Future is a wrapper for a Conmon_createNamespaces_Results promised by a client call. -type Conmon_createNamespaces_Results_Future struct{ *capnp.Future } +// Conmon_serveAttachContainer_Results_Future is a wrapper for a Conmon_serveAttachContainer_Results promised by a client call. +type Conmon_serveAttachContainer_Results_Future struct{ *capnp.Future } -func (f Conmon_createNamespaces_Results_Future) Struct() (Conmon_createNamespaces_Results, error) { +func (f Conmon_serveAttachContainer_Results_Future) Struct() (Conmon_serveAttachContainer_Results, error) { p, err := f.Future.Ptr() - return Conmon_createNamespaces_Results(p.Struct()), err + return Conmon_serveAttachContainer_Results(p.Struct()), err } -func (p Conmon_createNamespaces_Results_Future) Response() Conmon_CreateNamespacesResponse_Future { - return Conmon_CreateNamespacesResponse_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_serveAttachContainer_Results_Future) Response() Conmon_ServeAttachContainerResponse_Future { + return Conmon_ServeAttachContainerResponse_Future{Future: p.Future.Field(0, nil)} } -type Conmon_startFdSocket_Params capnp.Struct +type Conmon_servePortForwardContainer_Params capnp.Struct -// Conmon_startFdSocket_Params_TypeID is the unique identifier for the type Conmon_startFdSocket_Params. -const Conmon_startFdSocket_Params_TypeID = 0xce733f0914c80b6b +// Conmon_servePortForwardContainer_Params_TypeID is the unique identifier for the type Conmon_servePortForwardContainer_Params. +const Conmon_servePortForwardContainer_Params_TypeID = 0x9d82529754851252 -func NewConmon_startFdSocket_Params(s *capnp.Segment) (Conmon_startFdSocket_Params, error) { +func NewConmon_servePortForwardContainer_Params(s *capnp.Segment) (Conmon_servePortForwardContainer_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_startFdSocket_Params(st), err + return Conmon_servePortForwardContainer_Params(st), err } -func NewRootConmon_startFdSocket_Params(s *capnp.Segment) (Conmon_startFdSocket_Params, error) { +func NewRootConmon_servePortForwardContainer_Params(s *capnp.Segment) (Conmon_servePortForwardContainer_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_startFdSocket_Params(st), err + return Conmon_servePortForwardContainer_Params(st), err } -func ReadRootConmon_startFdSocket_Params(msg *capnp.Message) (Conmon_startFdSocket_Params, error) { +func ReadRootConmon_servePortForwardContainer_Params(msg *capnp.Message) (Conmon_servePortForwardContainer_Params, error) { root, err := msg.Root() - return Conmon_startFdSocket_Params(root.Struct()), err + return Conmon_servePortForwardContainer_Params(root.Struct()), err } -func (s Conmon_startFdSocket_Params) String() string { - str, _ := text.Marshal(0xce733f0914c80b6b, capnp.Struct(s)) +func (s Conmon_servePortForwardContainer_Params) String() string { + str, _ := text.Marshal(0x9d82529754851252, capnp.Struct(s)) return str } -func (s Conmon_startFdSocket_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_servePortForwardContainer_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_startFdSocket_Params) DecodeFromPtr(p capnp.Ptr) Conmon_startFdSocket_Params { - return Conmon_startFdSocket_Params(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_servePortForwardContainer_Params) DecodeFromPtr(p capnp.Ptr) Conmon_servePortForwardContainer_Params { + return Conmon_servePortForwardContainer_Params(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_startFdSocket_Params) ToPtr() capnp.Ptr { +func (s Conmon_servePortForwardContainer_Params) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_startFdSocket_Params) IsValid() bool { +func (s Conmon_servePortForwardContainer_Params) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_startFdSocket_Params) Message() *capnp.Message { +func (s Conmon_servePortForwardContainer_Params) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_startFdSocket_Params) Segment() *capnp.Segment { +func (s Conmon_servePortForwardContainer_Params) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_startFdSocket_Params) Request() (Conmon_StartFdSocketRequest, error) { +func (s Conmon_servePortForwardContainer_Params) Request() (Conmon_ServePortForwardContainerRequest, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_StartFdSocketRequest(p.Struct()), err + return Conmon_ServePortForwardContainerRequest(p.Struct()), err } -func (s Conmon_startFdSocket_Params) HasRequest() bool { +func (s Conmon_servePortForwardContainer_Params) HasRequest() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_startFdSocket_Params) SetRequest(v Conmon_StartFdSocketRequest) error { +func (s Conmon_servePortForwardContainer_Params) SetRequest(v Conmon_ServePortForwardContainerRequest) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewRequest sets the request field to a newly -// allocated Conmon_StartFdSocketRequest struct, preferring placement in s's segment. -func (s Conmon_startFdSocket_Params) NewRequest() (Conmon_StartFdSocketRequest, error) { - ss, err := NewConmon_StartFdSocketRequest(capnp.Struct(s).Segment()) +// allocated Conmon_ServePortForwardContainerRequest struct, preferring placement in s's segment. +func (s Conmon_servePortForwardContainer_Params) NewRequest() (Conmon_ServePortForwardContainerRequest, error) { + ss, err := NewConmon_ServePortForwardContainerRequest(capnp.Struct(s).Segment()) if err != nil { - return Conmon_StartFdSocketRequest{}, err + return Conmon_ServePortForwardContainerRequest{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_startFdSocket_Params_List is a list of Conmon_startFdSocket_Params. -type Conmon_startFdSocket_Params_List = capnp.StructList[Conmon_startFdSocket_Params] +// Conmon_servePortForwardContainer_Params_List is a list of Conmon_servePortForwardContainer_Params. +type Conmon_servePortForwardContainer_Params_List = capnp.StructList[Conmon_servePortForwardContainer_Params] -// NewConmon_startFdSocket_Params creates a new list of Conmon_startFdSocket_Params. -func NewConmon_startFdSocket_Params_List(s *capnp.Segment, sz int32) (Conmon_startFdSocket_Params_List, error) { +// NewConmon_servePortForwardContainer_Params creates a new list of Conmon_servePortForwardContainer_Params. +func NewConmon_servePortForwardContainer_Params_List(s *capnp.Segment, sz int32) (Conmon_servePortForwardContainer_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_startFdSocket_Params](l), err + return capnp.StructList[Conmon_servePortForwardContainer_Params](l), err } -// Conmon_startFdSocket_Params_Future is a wrapper for a Conmon_startFdSocket_Params promised by a client call. -type Conmon_startFdSocket_Params_Future struct{ *capnp.Future } +// Conmon_servePortForwardContainer_Params_Future is a wrapper for a Conmon_servePortForwardContainer_Params promised by a client call. +type Conmon_servePortForwardContainer_Params_Future struct{ *capnp.Future } -func (f Conmon_startFdSocket_Params_Future) Struct() (Conmon_startFdSocket_Params, error) { +func (f Conmon_servePortForwardContainer_Params_Future) Struct() (Conmon_servePortForwardContainer_Params, error) { p, err := f.Future.Ptr() - return Conmon_startFdSocket_Params(p.Struct()), err + return Conmon_servePortForwardContainer_Params(p.Struct()), err } -func (p Conmon_startFdSocket_Params_Future) Request() Conmon_StartFdSocketRequest_Future { - return Conmon_StartFdSocketRequest_Future{Future: p.Future.Field(0, nil)} +func (p Conmon_servePortForwardContainer_Params_Future) Request() Conmon_ServePortForwardContainerRequest_Future { + return Conmon_ServePortForwardContainerRequest_Future{Future: p.Future.Field(0, nil)} } -type Conmon_startFdSocket_Results capnp.Struct +type Conmon_servePortForwardContainer_Results capnp.Struct -// Conmon_startFdSocket_Results_TypeID is the unique identifier for the type Conmon_startFdSocket_Results. -const Conmon_startFdSocket_Results_TypeID = 0xf4e3e92ae0815f15 +// Conmon_servePortForwardContainer_Results_TypeID is the unique identifier for the type Conmon_servePortForwardContainer_Results. +const Conmon_servePortForwardContainer_Results_TypeID = 0xae5e0ae5001ebdfe -func NewConmon_startFdSocket_Results(s *capnp.Segment) (Conmon_startFdSocket_Results, error) { +func NewConmon_servePortForwardContainer_Results(s *capnp.Segment) (Conmon_servePortForwardContainer_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_startFdSocket_Results(st), err + return Conmon_servePortForwardContainer_Results(st), err } -func NewRootConmon_startFdSocket_Results(s *capnp.Segment) (Conmon_startFdSocket_Results, error) { +func NewRootConmon_servePortForwardContainer_Results(s *capnp.Segment) (Conmon_servePortForwardContainer_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) - return Conmon_startFdSocket_Results(st), err + return Conmon_servePortForwardContainer_Results(st), err } -func ReadRootConmon_startFdSocket_Results(msg *capnp.Message) (Conmon_startFdSocket_Results, error) { +func ReadRootConmon_servePortForwardContainer_Results(msg *capnp.Message) (Conmon_servePortForwardContainer_Results, error) { root, err := msg.Root() - return Conmon_startFdSocket_Results(root.Struct()), err + return Conmon_servePortForwardContainer_Results(root.Struct()), err } -func (s Conmon_startFdSocket_Results) String() string { - str, _ := text.Marshal(0xf4e3e92ae0815f15, capnp.Struct(s)) +func (s Conmon_servePortForwardContainer_Results) String() string { + str, _ := text.Marshal(0xae5e0ae5001ebdfe, capnp.Struct(s)) return str } -func (s Conmon_startFdSocket_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { +func (s Conmon_servePortForwardContainer_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr { return capnp.Struct(s).EncodeAsPtr(seg) } -func (Conmon_startFdSocket_Results) DecodeFromPtr(p capnp.Ptr) Conmon_startFdSocket_Results { - return Conmon_startFdSocket_Results(capnp.Struct{}.DecodeFromPtr(p)) +func (Conmon_servePortForwardContainer_Results) DecodeFromPtr(p capnp.Ptr) Conmon_servePortForwardContainer_Results { + return Conmon_servePortForwardContainer_Results(capnp.Struct{}.DecodeFromPtr(p)) } -func (s Conmon_startFdSocket_Results) ToPtr() capnp.Ptr { +func (s Conmon_servePortForwardContainer_Results) ToPtr() capnp.Ptr { return capnp.Struct(s).ToPtr() } -func (s Conmon_startFdSocket_Results) IsValid() bool { +func (s Conmon_servePortForwardContainer_Results) IsValid() bool { return capnp.Struct(s).IsValid() } -func (s Conmon_startFdSocket_Results) Message() *capnp.Message { +func (s Conmon_servePortForwardContainer_Results) Message() *capnp.Message { return capnp.Struct(s).Message() } -func (s Conmon_startFdSocket_Results) Segment() *capnp.Segment { +func (s Conmon_servePortForwardContainer_Results) Segment() *capnp.Segment { return capnp.Struct(s).Segment() } -func (s Conmon_startFdSocket_Results) Response() (Conmon_StartFdSocketResponse, error) { +func (s Conmon_servePortForwardContainer_Results) Response() (Conmon_ServePortForwardContainerResponse, error) { p, err := capnp.Struct(s).Ptr(0) - return Conmon_StartFdSocketResponse(p.Struct()), err + return Conmon_ServePortForwardContainerResponse(p.Struct()), err } -func (s Conmon_startFdSocket_Results) HasResponse() bool { +func (s Conmon_servePortForwardContainer_Results) HasResponse() bool { return capnp.Struct(s).HasPtr(0) } -func (s Conmon_startFdSocket_Results) SetResponse(v Conmon_StartFdSocketResponse) error { +func (s Conmon_servePortForwardContainer_Results) SetResponse(v Conmon_ServePortForwardContainerResponse) error { return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr()) } // NewResponse sets the response field to a newly -// allocated Conmon_StartFdSocketResponse struct, preferring placement in s's segment. -func (s Conmon_startFdSocket_Results) NewResponse() (Conmon_StartFdSocketResponse, error) { - ss, err := NewConmon_StartFdSocketResponse(capnp.Struct(s).Segment()) +// allocated Conmon_ServePortForwardContainerResponse struct, preferring placement in s's segment. +func (s Conmon_servePortForwardContainer_Results) NewResponse() (Conmon_ServePortForwardContainerResponse, error) { + ss, err := NewConmon_ServePortForwardContainerResponse(capnp.Struct(s).Segment()) if err != nil { - return Conmon_StartFdSocketResponse{}, err + return Conmon_ServePortForwardContainerResponse{}, err } err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr()) return ss, err } -// Conmon_startFdSocket_Results_List is a list of Conmon_startFdSocket_Results. -type Conmon_startFdSocket_Results_List = capnp.StructList[Conmon_startFdSocket_Results] +// Conmon_servePortForwardContainer_Results_List is a list of Conmon_servePortForwardContainer_Results. +type Conmon_servePortForwardContainer_Results_List = capnp.StructList[Conmon_servePortForwardContainer_Results] -// NewConmon_startFdSocket_Results creates a new list of Conmon_startFdSocket_Results. -func NewConmon_startFdSocket_Results_List(s *capnp.Segment, sz int32) (Conmon_startFdSocket_Results_List, error) { +// NewConmon_servePortForwardContainer_Results creates a new list of Conmon_servePortForwardContainer_Results. +func NewConmon_servePortForwardContainer_Results_List(s *capnp.Segment, sz int32) (Conmon_servePortForwardContainer_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) - return capnp.StructList[Conmon_startFdSocket_Results](l), err + return capnp.StructList[Conmon_servePortForwardContainer_Results](l), err } -// Conmon_startFdSocket_Results_Future is a wrapper for a Conmon_startFdSocket_Results promised by a client call. -type Conmon_startFdSocket_Results_Future struct{ *capnp.Future } +// Conmon_servePortForwardContainer_Results_Future is a wrapper for a Conmon_servePortForwardContainer_Results promised by a client call. +type Conmon_servePortForwardContainer_Results_Future struct{ *capnp.Future } -func (f Conmon_startFdSocket_Results_Future) Struct() (Conmon_startFdSocket_Results, error) { +func (f Conmon_servePortForwardContainer_Results_Future) Struct() (Conmon_servePortForwardContainer_Results, error) { p, err := f.Future.Ptr() - return Conmon_startFdSocket_Results(p.Struct()), err -} -func (p Conmon_startFdSocket_Results_Future) Response() Conmon_StartFdSocketResponse_Future { - return Conmon_StartFdSocketResponse_Future{Future: p.Future.Field(0, nil)} -} - -const schema_ffaaf7385bc4adad = "x\xda\xc4Y}p\x14\xe7y\x7f\x9e\xdd\x93V\xa7\x0f" + - "N\xdb=\x09\x10\xa8\xd2\x10HA\x0d\xe1C\xb8&\x0c" + - "\x19I\x80B!\xe0hu`ZH\\\x96\xbbE:" + - "\xb8\xdb=v\xf7\x00\x11\xa72I=v\x94\xd81*" + - "\x9e\xd8L\x99A\xb6\xa1\x80\xa1\xc6\x1fP\x83\xc1\x03\x18" + - "\xc6\x80M]h\xa1\xc6c\\0\xa6\xb6\x19\x7fQ\xbb" + - "S\xec\x81n\xe7y\xef\xf6C'\x19\x9fTw\xf2\x07" + - "\x83\xee\xd9\xdf>\xef\xc7\xf3\xf9{v\xe2\xe7\xc1\xc6\xc0" + - "\xa4\xb27\x86\x00'\xef*(\xb4\xcd\xcb\x1d\xc6\xb6\xcd" + - "\xb3\x7f\x05\xe2w\x10\xa0\x00\x05\x80\xfa\xf9\xc2\xbb\x08(" + - ")B\x03\xa0\xfd_O\x9d\xf8\xe1\xef7|\xda\xe5\x07" + - "\xac\xcf\x00\x1ee\x80\xb7\xa7\xd6-\xdf\xc2\xcf\xfb\x8d\x1f" + - "\xb0_x\x8b\x00\xa7\x19\xe0\xaf\x97\x866\xfem\xe5\x12" + - "\x06\xb0\xaf\xd7/\xbf\xf8\xf8\x07w\xfe#\x14\x08\x04\xfc" + - "Xx\x0b\xa5`\x11\xfdYP\xf4;\x04\xb4_\xfb\xe3" + - "u\x8bB\xdb\x1ex,\x07\xcd\xd4^\x0d\xbe\x8b\x12\x16" + - "\x0b\x00\xd2\xad \xa9\xbe\xff\xc3\xbb\xf6-\xfc\xd5\xa7[" + - "\xfckO*\xfeOZ\xbb\xb9\x98\x00\x8f/\xf9`e" + - "\xf3\x9c\xd0\x13\xbd\xb5\x05\x08\x17/\xde\x89\xd2\xfab\x01" + - "x\xbb\xf2\xab+O\x9d\x8fL\xdd\x01\xf2w\xb0\xcf\xa2" + - "?#\\\x9a-\xba\xaax\x0d\xa0=\xfa\x99W\xcet" + - "M\x9f\xb0\xd3\xbf\xe8\xe9\xe2\xb3\xb4\xe8e\xb6h\xd7\xdf" + - "\xab\x7fr\xe4\xc0\x8f\x09\xc0y\xda\x00\xeb\xb1\xa4\x0b\xa5" + - "\xe1%\xa4\xaa\xa2\xe4N@{\xcd\xd2\x13\xcf\xac\x93\xaf" + - "\xee\xeag{\xd5%\xdd(\xddQB\xdb\x93fM\xdc" + - "\x7f\xbe\xbenw\xee\xf68\xc2\x89\x84\x1b\xc7t\x8e)" + - "y\x06\xd0\x9e\xd2\xf3\xfc\xbe\x87?Y\xfb\x0f\x84\xe6r" + - "\x0fs\xaed\x05J\x1f\x96\x0c\x05\x90\xae3\xf4\xcf\xcf" + - "\\\xdb\xfe\xf0o\x9a\xf6\xe6\xea\xe6\x09\xfd\xeb\xd2\xa3(" + - "\xf5\x94\xd2\x9f\x9bKk\xc8:\xfc\xa5\xf7\x8a\x1fn\x9a" + - "\xb0\xaf?\xeb\x1c/;\x85\xd2\xe52\xda\xc9\xc52\xba" + - "\x07\xf7\xb98\x92\xb7w\xef>\xb6d\xea\x7f\xef\xb4\xe9" + - "\x1en\x95Ua}\xd9\x90EH\x8aC\x02'\x05E" + - "\x01\xc0\x1e\xf7\xd1\x83\xdb\x1ex:r\xa0?\xe5\xd7\xcb" + - "\x8fb\x06&\x15\x88\xa4\xfc\xd4\xbe\x1d\xd3\xbe\xba\xb2\xe6" + - "@\xee\xc6i\xfd\xfa\x1f\x88gQZH\xe8zY|" + - "\x80\x07\xb4\xcb\x97\xbc\xf1\xc3\x8f\xee\xf9\x8f\xe3~\xa3\x1d" + - "\xaf`^z\xa1\x82\xf4\xbd\xaf\xbc\xc45\x9fN\xbc\xea" + - "\x07\xdc\xaa(\xe6\x00\xa5\x8aJ\x06x\xef\x7fV\xb4\xa5" + - "&\xbc\xee\x07\xdcQ\xd9\xcd|\x8d\x01V\x96\x9c\x08\x07" + - "\x1b\xcc\x7f\xf2\x03\xd4\xca\xa3\x04H3\xc0\x8d\x8a\x97\x7f" + - "_5\xfd@/\xc0\xa3\x95l\x0f;\x18\xa0\xaa\xe9\xcc" + - "\x94\x906\xfb\x9fs.\x80\xd9\xe2t\xe5\x13(]\xad" + - "\xa4\x0b\xb8\\I\x96{\xf2\xf3\xedK\xf7n\x08\x9f\xef" + - "\xe3e\x1b\x86\xae@i\xebPB\xf6\x0c\xed\x04\xb4o" + - "\xde?\xfd\xbe\xea\xea\xf3\x17\xfa\xf5\x9fsC\xaf\xa1t" + - "\x9d\xa1?\x1e\xfa>\xa0\xbd\xe9O\xd7\xa4\xeeY6\xed" + - "\x9d\x1c4s\xca\x93\xc3\xdeB\xe9\xea0\xb6\x89a\xb4" + - "\xe3\x9b\xd3n\xbe\xbcez\xea\xdfsU\x17\xb0\x88\x1e" + - "\xde\x85R\xf5p\xfas\xf8\xf0E\xe4>\x0bS\xb3\xc5" + - "\xef\xb6\x0e\xb9\xe4\xbf\x81\x87\xaa\xfe\x88.yk\x15\xe9" + - "\x9b\xf8\xf3\xd9;\xee\x89KW\xfc\x80\x93U\x9b\x98\x99" + - "\x18\xe0\xcf\xa4W\xf6h\x1b\xae]\xede\xa6\xaak\x04" + - "\x10G\x10\xe0\xc8\x92\xfa\x96\x7f\xbb\xf2\xdd\xcf@\x1c\xcf" + - "y\xb1\x00X?iD7JsF\xd0\xde\x9bGP" + - "\xf0\x9d\xf9\xa4f\xd7kW\x7f\xfcy\xee\xde\x83\xa4s" + - "\xe1\x88M(%G\xb0D1\xe2N\x0e\xd0\xde\xb6\xea" + - "\xc9Gn\x8c\x12\xbf\xc8\x8d+v\xd4C\xd5\xef\xa2t" + - "\xa1\x9a]h\xf5\xabt\xd4\x177m\xfc\xdd\xb1\xc9\xb3" + - "\xbf\xf0o\xf4b\x0d\xcb\x12\xd7kh\xa3\x15\x7f\xb5\xfe" + - "R\xdd\x87Wz\x01\xc4\xdaS\x04\x18SK\x80\x83\xb8" + - "\xb3\xe4\xa7+>\xb8\xe1\x07\xcc\xa9eG\xfd\x19\x03\xdc" + - "\xe8y\xba\xfe\xbe\xd3\xcf\x7f\xd9O\xf6X_{\x0a\xa5" + - "\xcd\xb5\x94=\xba\xffen\xf2\x9d[/}\x95\xe3T" + - "\xcc\xf8\x1d\xb5O\xa0\xb4\xa1\x96\xee\xe4\xa1\xda50\xde" + - "\x8ek\x96jhJ\xa2pB\xca\xd0-}BT\xd7" + - "\x92\xba\xf6\xfd\xa8\x92\xd2R\xd3ff~\xa8k\xd5h" + - "\xa4C\x8b\xce\xd45K\x89k\xaa1\xbaE1\x04%" + - "i\xca\x01>\x00\x10@\x00\xb1l\x06\x80\\\xc4\xa3\x1c" + - "\xe6\xb0\xd3PW\xa5U\xd3\xc2r\xef\x0e\x01\xb1\x1c0" + - "\xaf\xe5\xa2\x86\xaaX\xea]JR5SJT5G" + - "\xb7\xaafZHX\xbd\x96\x9b\x0b \x97\xf2(\x0f\xe3" + - "\xd06T3\xa5k\xa6\x0a\x00X\xee\xd5\x93\xff\xcb\x92" + - "-\x8a\xa1\xf0\xf9\x1c\xd0\xadu\x03Xmf\xcej\xad" + - "\xa4\x8d7\xad\x16Dy\xa4\xbb\xe0\xdee\x00\xf2\x0b<" + - "\xca\x879\x14\x11\xc3H\xc2C\x8b\x01\xe4\x83<\xcao" + - "r(r\\\x189\x00\xf1\x1c!\xff\x95G\xf93\x0e" + - "E\x9e\x0f#\x0f ~L\xc2\x8fx\x8c\x14!\x87b" + - " \x10\xc6\x00\xa5R\x9c\x0b\x10\x09 \x8f\x91r\x92\x17" + - "\x14\x84\xb1\x00@*\xc3\xc9\x00\x91\"\x92\x87I^X" + - "\x18\xc6B\x00Id\xf8r\x92\x7f\x0f9\xb4\x93\xaa\xa5" + - "\xc4\x14K\x01\xe1'\x89\x18\x96\x01\x87e\x80\xb6\x96=" + - "\x0a\xf0\xaa\x89C\x00[x\xc4\x90\x97\xaf\x00Ih\xa7" + - "\xe3\xb1\xf9J*\x15\x07Aksa\xa5\xc0\xb1\x87m" + - "\xb7{\xb8L1\xd5\x16\xc5j'\x03\x93\xac\x14\xb0&" + - "\xa5\xc7\xe6\xc4\x9c_\xde\xbe\x00\x9c\x97\xcb\xbd@\xc8n" + - "`p\xb61S\xba\xa0\x99*\x19\xc7\xe7\x0d\x8b\xb3\xfe" + - "7\x96\xeb\xff\xf8\xe5^\x8f1\x80\xd5\x0dUO\xa9\xda" + - "<\xbd\xcd\x0b\xb5V\xb5\xc6L\xe7\xed\xfcn\xfb\x93\xe3" + - "\x8e\x05\xb7Y\xb4\xd5Y\x94\xce\x1a\xd23g\xcd\xebM" + - "\xf7\x9a\xfco\xcaE\xeeF\xc7\xd5\x01\xc8\xa3y\x94'" + - "r\xe8x\xf0x\x92\x8d\xe5Q\x9e\xc2a\xc8\xeaH\xa9" + - "9\x9e\x12\x02\x0c\xa5\x14\xab\xdd5m>\xf7\xa6X\x96" + - "\x12m\xef\x95\x9f\x94$\xe6\x11\xben9\x1b\xc0}\xcd" + - "l3\xf4tj\xbe\xa2)m\xaa\x01\xc0\x8e\xcc\xe2P" + - "\x9cAj\xc4\xe0\\\x80N\xb3\xc3\xb4\xd4d\xcc\x8e2" + - "\xf0r\x13\x00\xf2R\xde\xc4N\xd2\x9a1*\xe6m\x89" + - "\xbbU\xc3\x8c\xeb\x1a\xcb$&\xb2LR\xea\x9e\xbd\x99" + - "\xce\xde\xc8\xa3<\xcf3\xc3\x1cJ\x0f\x7f\xce\xa3\xbc\x80" + - "\x12\x09f\x12\x89L\x8e\xd5\xc2\xa3\x9c\xe0\xb0s\xb5j" + - ",\xd3M\x15\x118D\xf8\xba\xd0\x1fP\xe0\x05ns" + - "\x82yz\xdb,#\x14_\xad\x1ar\x00\xfdU\x1d\xeb" + - "B\x0b:R\xaa\xff*v\xf19_\x93w\xb9\xcbv\xa2\x1f" + - "\x1a2\xee\xe7\x0ax\xc7\x08\x99\xb2\xe6&\xc8V\x07\xc8" + - "\xa2.\xbeZ\x054l'\xafA\x0d\xcbl\xb6\xf3N" + - "\x81\xf3\x92\xa3\xac9\xb7\x1ft\xbc\x1el\xe7\x11\xe7{" + - "\x96Me\xb6\x93\xda\xa0&\xb3\xb6\xfb\xbb!\xa3\xd7v" + - "\x0a\x11\xb6y\x0a\xfd2G\x91\x13q\xe8\x84\\\x88\xe9" + - "\xcb\x15\x9b5\x19\xb5NI\xe7{\xf5[\xa6\x05N\xf9" + - "B\x0f\xc3\xf5\xaa\xfb\xcc}m\x0f\xe6\xdbB\xd6\xd51" + - "\xeb\xeb\xce\x16r\xc4\xce\x16\x16\xa8k-\xfa\x87\xf3\x95" + - "T\xb3f\x19\x1d\x00r-_\x00\xe0\x92Lt\x88\x90" + - "x}\x06p\xe2U\x01=F\x81\x0e\x8f\x14/\xfc\x12" + - "8\xf1\x8c\x80\x9c;\xc6A\x874\x88\xc7\xbb\x81\x13\x8f" + - "\x08\xc8\xbb\xf3\x0at8\xb0\xb8\x97\xde\xdb-`\xc0\xa5" + - "S\xe8LR\xc4\x9eM\xc0\x89\x9b\x05,p\x191:" + - "\xacM\xdcp\x008\xf1!\x01\x0b\xdd\xa1\x0f:\xe3!" + - "q}\x17p\xe2/\x04\x14\\\x1e\x8c\x0e\xc3\x11W\x19" + - "\xc0\x89q\x81j\x08\xf9a#\xda\xd1\xac3a\xd6-" + - "\xa0\x11m\x87W\xa0\xe3,h4\xa2\xed\xd4r?\xd2" + - "p\xbd \x0b\xe5U\x82\x9a\xbd,>S\xd7\x1a2\xaf" + - "\xb8\xeb\xdd\xa5\xa0cP =f\xd6>P\xc3\x0c\xd4" + - "\x88\xfe\xfa:\x80\xd4\xe6%\xf9~\xba\xb2\xb1\xdc\xb7\xde" + - "\x8f\xe6DZ\xa6\xc07:KK\xcfb\x15@d\x17" + - "u\xe9/\xa2\xc7\x16\xa4\xbd\xb8\x18 \xf2\x02\xc9\x0f#" + - "\x87\x98\xe1\x0b\xd2!\xd6\xd4\x1f$\xf1\x09\xf4\x0a\x8dt" + - "\x9c\x91\x80\xc3$\x7f\x1d\xbdZ#\x9d\xc4V\x80\xc8\x09" + - "\x92\xbf\xc7H\x03\x9f!\x0d\x97q\x05@\xe4\x12\xc9o" + - "2\xd2\x10\xc8\x90\x86/\xd9\xb27\x18\x99\xe08\x14\x85" + - "\x820qYI\xe4H^\xce\x11\x99 yQa\x18" + - "\x8b\x00\xa4qL>\x96\xe4\xb3H\x1e\x14\xc2\x18\x04\x90" + - "\x9a\xb8e\x00\x91F\x92\xff\x94\xe4\xc5Ea,\x06\x90" + - "\xfe\x92\xc9\xff\x82\xe41\x92\x97\x04\xc3X\x02 )\x1c" + - "\x9dk)\xc9\xef%yiq\x18K\x01\xa4\x0en\x06" + - "@\xc4\"\xf9#$/\xc30\x96\x11\x03\xe6\x0c\x80\xc8" + - "oI\xfe\x18\xc9\x87\x94\x84q\x08\x80\xf4(\x93o$" + - "\xf9\x1e\x92\x87J\xc3\x18\x02\x90v3=\xdbI~\x8c" + - "\xebUv\xedei-\x96P[\x14\xe0}\x05\xcdR" + - "\x8dd\\S\x12\xe4\x04\xd9.\xaa\xc6\xb4bq\xcd\xed" + - "\xa9\xd4\xb5q\x8b\x11\x1b\xec\xc3yt=\xd9LO!" + - "\xa4X\xed}\x9e&\x9c\xbc\xcd\x1b>\xca\xe1\x9b~0" + - "T4\xa1*Z:5\x13\xf8d\xac\x0f\xe1J\xe8\xcb" + - "\x94D\x93\x01|_\xbe\x15\xd5\x93IE\x8b5\x81`" + - "\xf4}8\xf8&\xa2S\xd5V\xdf\xad\xf87\x9c\x1b\x11" + - "\xd1\xde%\x08C^\xdd\xce\xb4k\xb6\x12\x8b\xc5\xad\xb8" + - "\xaeA\x8d\x92\xf8Q\xccU\x15\xccl\xae3\xa1*+" + - "\xfb\x8a\x07\xc5!ZU3\x9d\xe0\xf3%^n{\x90" + - "C$\x84\xdb\xach\xfa;\xc7\x1c\xf2b\x02|3{" + - "q\x9b\x8d\x01\xb0\x97lJ\xce\x9f\"\xb9\xdd\xd6\x00&" + - "\x1c\xa6?]:\x07\xfa\xe6\xa5\xdcvg\xc0\xa3\x9b\xc1" + - "\x9a\xcd\xed\x04\x07\xc7\x97W\xa5\x05\xd5\xcce[U\x1e" + - ";\x11\xfb\xa7[\\_\xba\xe5O&\xff\xcfL\x8b\xf5" + - "3!*\x8a\x8c\xa5\xb0\xad\xdc1\x8aQ\xd7\xf1\xf4\x1f" + - "'\x8e\xa1\xffx\xb1\xba\x0e\x00\x03b\xc5(\x00!\x9e" + - "\x8a\x0a\x9aj\x09\xa9x,\x946UCH[f^" + - "\xf6\xe9\xa7Y\xf4\xcd\x0a\xca\xddkS\xe82\x96f." + - "\xc3\xb9\xb58\xd1\xa1\x18\x8fr\xca\xc7\x91\x92$l\xe7" + - "Q\xb6\xa8t\xd5f8\xd2*z;\xc5\xa3|/\x97" + - "\xc9\xaa3\xf5\x183q\x008\x0c\x006\x98VLO" + - "[\xcee\xd2O\xd50\xdc\xbb\xb5\xe2I5\xf6\x93\xb4" + - "\xe5\xcb\xd4\x83\xab\xce\xe4[|\x9fa\xd1\x0a\x9f\xffE" + - "\xb3`\x08\x19-\xf1\x18\x16\x01\x87Ey:\x9e\xd30" + - "g{cZd\x98\xbb\xc8\xe3\xe4v\x1by\x94\xb7\xf8" + - "\xdcn\xf3b\x00\xf9\xefx\x94\xb7\xfb\xdcn\xab\x01 " + - "?\xc5\xa3\xbc\x87C\xccN\x0bww\x03\xc8{x\x94" + - "\x0fR\xdd\xe73\x1cs?9\xed\x8b<\xca\xc7\xa8\xe8" + - "\x07X\xd1\x17\x8f\xd0M\x1f\xe6Q~\xbb\xb7\xd3\x9a," + - "\xd6s* \xeb\xf0T\xd3\x84\x9a\xb8\xae\xf9\xc6u\xa6" + - "\xa5\xa7\x9a\x96[*\x1a\x11\xaa\x87\xcd:.\xff6\xe7" + - "\x0c\x83H\xba,mX\x98g\xdap\x89\xdd \x12\xef" + - "\xc0\x12\x94Ko\x07\x90\x12\xfb\x99\"\xb6(!#\xaf" + - "\x81\xbd\xcbl\x07p2\x87D\x1a\xdf_\xd0\x91B\xd5" + - "7\x10;\xcb\xb2JE\x1d\x80\xeb\xf7\x9c\xd1\x9a\xd6(" + - "\xde\xe6\x90\xe6\xe5D\xabB+L]\x1b\xd8\x98\xcb\x17" + - "gc\xdd68\xc8\xfaTw\x88\xedt\xc1\"R\xdb" + - "VJ\xe2a\xe8%\x12\xa9\x02G9\xb3\xed\x91\xac\x0d" + - "\xe62m\xf0p\x9c\x06\x10\x09\x93\xbc\x16\xbdp\x90\xaa" + - "\x99\xfa\x91$\x1f\x8b^DHc\x18\xbe\xd6\x99\x91\x8b" + - "\x85\x05\x996x\x1cR\x9b:\x96\xe4SH.\x14f" + - "\xda\xe0I\xacm\x9eH\xf2\xe9$/\x122m\xf0\x0f" + - "\x98\xfe\xa9$\x9fE\xf2`Q\xb6\x0df\xedz#\xc9" + - "\xe7!\x87v\xca\xd0\xa3\xaai\xce\x01t\xd3\x87C\xb4" + - "\x9c\x00\x13,\xa5\xcd\xf9\xbb\x81\xba\xb9\xb8\xe5kU\xe3" + - "\x89\xd8,\xc5\x02T]\x88\xa5\x18m\xaa\x071\xd2\xa6" + - "EW\x0d\x82O\xa7\x1dU\x8c6\xfdn\xd5\x80\x90\xd9" + - "G\xbc\xc0P}\xfazE\xab\x13\xc1\x83,\x16^\x89" + - "\xadu}\xf7\x0c\xe5\xba\xd73_A\x9cTwnq" + - "\xf6#\xc8%_\xad\xb8HN\xfe&\x8f\xf2\x17d\xdf" + - "\xc6L\xae\xbbN\xd1\xf6\x19\x8f\xf2M\xdf<\xedK\xca" + - "u7x\x8c\x04\xfc\x0c\x07\xe9\xea[]\x0fq\x08\xce" + - "p\xe6Q\xccC&\xa2\x8f\xe0\x8cG\"\x0e\xdf#\xf9" + - "T\xec\x9d\x1e\xc9\xe3\xf5\xb4\x15\x01^\x8d:\xe3\xc5\xce" + - "l\x9f\x9d\xdba\xf7\xc3\x1b\xfe\xc0]\xf7`\x1a\xb1\xbc" + - "\x1bLwh7\xe8\x063\x93\xbcsZ\xe6\xaf\xcf\xa9" + - "\xee m\x00\x0b\xf6\xfd\x06\xda\xaa\x9a\xa1\xfc?\xcc\xb8" + - "\x83\xc5\x01\xac\x993Y\xf6\xcdS\xf3J\x96\xce\xd0\x89" + - "\xcd\x9c\x04\xcb\xe8\xc8\xf983\xca\xfb8\xe36\x0c\xe3" + - "'{_g\x84\x95j\x87;W^\xad$\xd2n|" + - "\xffo\x00\x00\x00\xff\xff\xfe\x11AT" + return Conmon_servePortForwardContainer_Results(p.Struct()), err +} +func (p Conmon_servePortForwardContainer_Results_Future) Response() Conmon_ServePortForwardContainerResponse_Future { + return Conmon_ServePortForwardContainerResponse_Future{Future: p.Future.Field(0, nil)} +} + +const schema_ffaaf7385bc4adad = "x\xda\xc4Z}p\x14e\x9a\x7f\x9e\xeeI:\x132" + + "\x99\xb4=\xd9\xd3\x98\x18\x02\x81K\xb2f\xf9\x08\x9c@" + + "A\x91\x00\x91\x83\x057=\x83z\xc2\xaeG3\xd3\x84" + + "\x81\xc9\xcc\xd0\xdd\x01\x82z\xa8{\x9c.~\xacpP" + + "\x0a\xb5T\x89\xdf\xb0\xa0\xb8\xbb\xb8\x82\xb2%\xac\x96\x88" + + "zg\xb8\xc3\x13K<\x14X\x85\x12\x15WK\xa0\xc0" + + "\xb9z\xde\x99\xfe\x98\xce\x083\x91\xba\xfd#\x95\x99\xa7" + + "\x9f~\x9e\xf7}\xde\xe7\xf3\xf7\xce\xf0\x17\xcbZ=#" + + "|_\\\x01\x9c\xfcAQqJ\xff\xa8G{j\xe3" + + "\xd4_\x828\x18\x01\x8aP\x00h\xf9\x85\xf7c\x04\x94" + + "\x16{'\x02\xa6\xbeyb\xdf\x84\x87W\x7f\xb1\xca\xc9" + + "\xb0:\xcd\xf0$c\xf8`L\xd3\xfcG\xf9\x19\xf79" + + "\x19\xde\xf0\xbeO\x0c\x87\x19\xc3\xbf\xcc\xf5\xaf\xfd\xf7\x1f" + + "\xcda\x0c\xa9\xd3-\xf3\x0f\xaf\xff\xf4\xba?B\x91@" + + "\x8c\x17\xbc\xef\xa3tU)}\xac,\xfd5\x02\xa6\xee" + + "\xfbq\x9b\\\xba\xee\xf1\x87\x9c\xe2\xbe\x19p\x92\xc4y" + + "\xcbH\xdc\xf0\x0do^\xbb\xa1\xf9\xe9\xb5.q\x8c\xb1" + + "\xb1\x8c\xe3\xa4\xf62\x01@jc\xcco^\xb3\xfcf" + + "\xffS\xf7<\x92\x8bY)\xfb\x18\xa5;\x18s\x0fc" + + "\x0e^\xb1r\xd6\xc3\xc1\xbb7:Uo+\x1b\xc4\x01" + + "J\xaf1\x86\x95'nx\xe1\xc6_~\xf1\xa8\x93\xe1" + + "x\xd9W\xb4\xb6\xb3\x8ca\xfd\x9cO\x17\xb5O\xf3?" + + "\x96\xad\xceC|5\xbe-(\x8d\xf6\x09\xc0\xa7\x9e\xdf" + + "\xdf\x1c\x8c\xb5\xbe\xf9\xb8S\x8c\xe8;Gb\x86\xf8H" + + "\xcc\x8f\xce\x1d}\xe2\xdd\xd0\x98\xcd \x0f\xc6>\xcbn" + + "'A\xbf\xf0\xd1\xb2o\xf1-\x05L\x8d^\xfa\xfc\x82" + + "\xaf\xc6\x9f\xd8\x9ck\x8f;|_\xa1\xd4\xcb\x98\xdff" + + "\xa2\xeb\x9f\xfbs\xef\xaa\xf1\xc3\xb68u\x9f\xf2\x1d " + + "\xddXN\x0c\xab\x9eV\xff~\xcf\xae\x9f\x12\x03gK" + + "\x03l\xa9+_\x85\xd2\xd8r\x125\xba\xfc:\xc0\xd4" + + "\xd2\xb9\xfb\x9e[.\x1f\xdf\x9ac\xb3\x13\xca\xd7\xa0t" + + "c9mV\x9a2|\xe7\xbb-M\xdb\xdc{\xe1\x88" + + "o\x04\xf1Mc2\xdb\xcb\x9f\x03\xfc\xf6\xbb\xdd\xd7\x1c" + + "/\xbd\xf5Y\xe7\xd9\x977\xd1\x01\xf8\xfc\xb4\xb8Q\x9b" + + "~\xff\xc2\x83\x9f/{\x96\x84q\xee\xbd\x8e\xf0/D" + + "\xa9\xdd\xffw\x00\xd2L\xffs\x80\xa9\xdbzO>\xf3" + + "\xe0}m;\xdc\xaayvn\xfe\xbd(]\xf0\xd3\xc7" + + "\xb3\xfeZ\xf2<\xfe\xc8\xb1\xd2\x07\xdb\x86\xbd\x90\xcb\x8e" + + "u\xe2~\x94&\x88\xb4\xd0\xb1\"\xad\xc4z.V\xf3" + + "\xa9m\xdb^\x9d3\xe6\xdb-)2\xd3-b\x15\xb6" + + "D\xc5?\"\xc5\x89\xf4:'\xad\xae\x14\x00R\x8d\x9f" + + "\xdd\xfb\xd4=\xbf\x0d\xed\xca%\xbc\xa7r/\xa6\xd9\xa4" + + "\x07*I\xf8\xfe\x176\x8f;wt\xe9.\xf7\xc2\xe9" + + "\x1c[\xf6T\x1e@\xe90q\xb7\x1c\xaa\xbc\x87\x07L" + + "U\xcc\xf9\xcf\x09\x9f\xdd\xfa\x97\xd7\x9cg:\xb3\x8aE" + + "\xa0RE\xf2>Q^\xe2\xda\xdf\x8e\xbd\xeedXY" + + "UJv\xdd\xc8\x18^\x1b3\xf0\x8aM\xef\xa9\xfb\\" + + "\xabcg\xb4\xbbj\x10'\x1d\xae\xa2\xd5\x1d\xaa\"\x7f" + + "\xfb\xb7g\x87.\xf3=x\xff\xfe\x9c':\xf3\xeas" + + "(E\xaf\xa6\x8f\xea\xd5\xcc\xac\x9f\x1c\xfbnagr" + + "\xd8[N\xe5\xbf\xaa^C\xab[_M\xca\x17\x0d\xd8" + + "\x17\xf0N\xd4\xff\xc3\xc9\xb0\xb3z/1\xbc\xc1\x18\xce" + + "T\xfe\xe9\xe1\xaa\xf1\xbb\xb2\x18NT\xb3\xfd]`\x0c" + + "u\xd5\x7f\xb9K\x8bV\xbf\x93\xf3\xa0\xebjN\xa24" + + "\xa1\x86>\x8e\xady\x9dVT\xd5\xd6;\xca\x1f\x9f\xfa" + + "\x8ek\xb7\x8c{H\xedc(M\xa8e\x07]KN" + + "\xf4\xf8_\x9f\x99\xbbcu\xe0\xdd>\xf1p\xa2v!" + + "J\x17\x18\xe7\xd9\xda\x15\x80\xa9\xf3+\xc7\xdfYS\xf3" + + "\xee\xa1\x9cvi\x1ex\x12\xa5i\x03\x99\xa7\x0f\xfc\x04" + + "0\xb5\xe1\xc7K\x93\xb7\xce\x1b\xf7\xa1\x8b\x9b\x85O]" + + "\xdd\xfb(M\xa8c\x8b\xa8\xa3\x0d\xde\xb9\xf5\xee\xa7\x0f" + + "|\xbe\xeb\xc3\xac,]\xc7\x12\xcfb\xc6p~\xdc\xf9" + + "?=:>\xf9\xbfn\xddE\xc4\xb9\xaen\x15J\xdb" + + "H\\\xcb\xe6\xba\x9b\xc9\x027&\xa7\x8aC\x83\xe5G" + + "\x9c\xf2j\x06_A\x0e1z0K\xb2\xb7M\xdd|" + + "kT:\xead\xb8e\xf0\x06R\x18e\x0c\xff \xfd" + + "y{|\xf5\xc9\xe3N\x86\x07\x06\xb34\xbd\x891\xbc" + + "t\xdb\xe9+\xb7\x1f?p\xca\xc9\xb0g0G*\x0e" + + "2\x86=sZ:\xfe\xe7\xe8\xd0/Al\xe6\xec\xc0" + + "\x06l9;x\x0dJb=\xed\xdeWO\x89\xa6\xf7" + + "\xf3\xda\xado\x1e\xff\xe9_\xdd\x9b\xf3\xb2e\xd7o@" + + "it=K\x00\xf5\xd7q\x80\xa9\xa7\x16?\xfe\xd0\x99" + + "A\xe2\xd7\xee$\xc1l\xb1r\xe8\xc7(m\x1aJ\x1f" + + "7\x0ee\xde\xf0\xe2\x86\xb5\xbf~u\xe4\xd4\xaf\x9d\x0b" + + "}\xb2\x81e\xc4\x9d\x0d\xb4\xd0\xca\x7f\xbe\xebH\xd3\x89" + + "\xa3Y\x0c\x87\x1a\xf6\x13\xc3)\xc6pl\xd4'\x93\xaf" + + "\xbc\xa3\xe3\xdb\\\xb1-66q\xd2\x88F\xdaLs" + + "#1\xbf\x8c[\x06\xfc|\xe1\xa7g\xb2\x82\xb5\x91\x19" + + "Na\x0cg6\xfd\xb6\xe5\xce\xb7\x7f\x7f6GZ]" + + "\xd9\xb8\x1f\xa5M\x8d\x94V\xd7\xfc\xd7\xf4\xae\x0f/\xbc" + + "t.W\xc4\xde\xd1\xf8\x18J\xeb\x98\xce\xd5\x8dK\xa1" + + "9\x15\x8d\x1b\xaa\x16Wb\xc5\xc3\x92Z\xc2H\x0c\x0b" + + "'\xe2]\x89\xf8O\xc2J2\x9e\x1c79\xfdE]" + + "\xa6\x86C=\xf1\xf0\xe4D\xdcP\xa2qU\xab\xefP" + + "4A\xe9\xd2e\x0f\xef\x01\xf0 \x80\xe8\x9b\x04 \x97" + + "\xf0(\x078\\\xa1\xa9\x8b\xbbU\xdd\xc0\x0a\xdb\xe0\x80" + + "X\x01\x98\x97\xba\xb0\xa6*\x86z\x83\xd2\xa5\xeaI%" + + "\xac\xea\xf5AU\xef\x16bF\x96\xba\xe9\x00r\x19\x8f" + + "\xf2\x95\x1c\xa64UO&\xe2\xba\x0a\x00Xa\xd7\xf5" + + "\x1f\xa2\xb2C\xd1\x14>\x9f\x0dZ\x1dL\x01\xda&\xbb" + + "\xb4\x05I\x1a\xaf\x1b\x1d\x88r\xb5\xa5p\xc7<\x00\xf9" + + "\x0f<\xca\xafp(\"\x06\x90\x88\xbbg\x03\xc8/\xf3" + + "(\xbf\xc7\xa1\xc8q\x01\xe4\x00\xc4\x83\xc4\xf9\xdf<\xca" + + "_r(\xf2|\x00y\x00\xf1\x14\x11?\xe31T\x82" + + "\x1c\x8a\x1eO\x00=\x00R\x11N\x07\x08y\x90\xc7P" + + "\x05\xd1\x8b\x8a\x02XD\xd1\x84#\x01B%D\x0f\x10" + + "\xbd\xb88\x80\xc5\x00\x92\xc8\xf8+\x88~-r\x98\xea" + + "R\x0d%\xa2\x18\x0a\x08?\x8bE\xd0\x07\x1c\xfa\x00S" + + "\xf1\xccV\x80Wu,\x07\xec\xe0\x11\xfdvz\x04$" + + "b\xaa;\x1a\x99\xa9$\x93Q\x10\xe2\x9d\x16[\x19p" + + "\xeca\xe7\xc5\x1e\xceSt\xb5C1\x16\xd0\x01\x13\xad" + + "\x0c\xb06\x99\x88L\x8b\x98\xdf\xecu\x01\x98/W\xd8" + + "\x81\x90Y@>g\xa3\xab\xda\x12\xb5}\x99\x9a\xe5\xec" + + "~-/g\xb7j\x8d\xcb\x17\x84\x8b\xe8\x0b\x91\xbe6" + + "\xc3P\xc2\x0b,\x8dA\xd3\x9f\xc9!\x1cZ\x07\xd9Z" + + "\x85n-fm\xbe\x7f>\xa7'\x13B\\W]:" + + "fg\xe2\xaa\x81\xcb}\xac\x15v\x07\xea\xb2\xaap)" + + "\xabv$4\xe3\xfa\x84\xb6T\xd1\"\xfd\xc8$V\x1f" + + "R@\xa0ij\"\xa9\xc6g$:m}A\xb5V" + + "\xef\xce;\x97XM\xbbKi\xd1E\x94\x06M\xa5d" + + "b\x7f\"m\xe2\xfc}\xcf\xe5\x0b\xf5\x13)\x15\xe5c" + + " \xab\xf7*`\xad\x96?8\xd7*\x97X\xaa\x1a\x9b" + + "\x00\xe4z\x1e\xe5\xe1\x1c\x9a)\xa8\x99h\x0d<\xca\xa3" + + "8\xf4\x1b=I\xd5\x15\xea~@\x7fR1\x16\x14\xe4" + + "\x9e\xa1>a\x17T\xf5\xdad\xa2\xaf\x83\xfe\x90 P" + + "\\\xb6e\xa6\xc5\x11\x97c\x88" + + "6\xb4!\xf6.\xb7\x87\x14\xb1\xf7n{\x80\x17{w" + + "\xd9\xb3\x8dx0\xe8\x80W\x0ej\xf6\x0c(\x1e\xdck" + + "w\xd1\xe2\xa1\xfd\xf6,)~t\xc0NL\xe2\x09\xcd" + + "\x81\xba\x9cX\xee\x98dO\xacr\x80O\xa7\xd6\xd8\xd8" + + "\x87xz\x8bc\xa4\xf8\xe6w\x0e8\xee\xec^\xc7t" + + "{!\xe8\x00\xcb.\xec\xb7;\x00\xa9\x08\xd7\xd8\xf0\x85" + + "\xe4\xc5-6R\"\xf9\xf0w\xf6\x11I\"\xae\xb2\xfb" + + "#\xa9\x12\x0f\xd8\xd8\x94T\x83\xef\xdb\xd5K\x1a\x82\x1f" + + "\xdb@\x9e\xd4\x8c'\xed\xd2\xdf2\x1aK\x1d3UK" + + "\x1b^\x81)3\xa7\xc1\xc4\xb4c[\x04\xde<\xdet" + + "\xefcW\x16\x93\x91\xc5st\x89\x0a\xa8\xa5\xccl\x0d" + + "\xb5,_\xa7\xccw\x8a\xdc=Y\xbb{\x182\xe3\x09" + + "R\xe6#\xce\xdd\xc9\xa1\x9a2\x136\xd4\xa6u[\xdf" + + "'\xa6\xe5\xa6\xcc\xb6\x01;m\x81N\x9a)\xc8\x8ce" + + "4\x83\xd9\xcf\xe4\xb9\xc9\x99\xe2\x992\xfb>>k\xd8" + + "\xd0\x0d0K?\xda<\\Vs\xc8\x02#e\xb39" + + "\x96\x90\x09\"\xccD\x91\xb9\x04\x17\xd9\\\xc2,u\x99" + + "A\x7f8SI\xb6\xc7\x0d\xad\x07 e\xd6{\xcem" + + "G4r?#\xdd\xbc\xae\xa6\xcc~\x99\xcbn\x98\x17" + + "w\x0bi+\xe4|\x9a\xe9m\xd2\x8f;\x12\x1a\xdf\xa7" + + "z\xd86\xbf\x18O\xc6\x00\xf2\xb5|\x11\x80\x85^\xa1" + + "\x89\x88H2N\x02NjG\x01m\xec\x00M\x88J" + + "\x1a\x8bw\x03'\x8d@\x019\x0b[Gs\xe6\x97\x86" + + "\xe0\x1a\xe0\xa4:\x14\x90\xb7\x90X4\xe1;\xa9\x92\xbd" + + "\xebC\x01=\x16\xbe\x82&\xe6,!n\x00N\xbc " + + "`\x91\x85\xe7\xa1\x89\xe3\x88\xa7w\x01'\x9e\x12\xb0\xd8" + + "\x82\xe3\xd1\x04\xee\xc5\x8fV\x01'\x1e\x16P\xb0\x906" + + "4!\x0d\xb1W\x03N|C\xc0\x12\x0bwG\x13k" + + "\x12w\x93\xbe\x9d\x02z-\xc0\x1aMPG\xdc\xb6\x05" + + "8q\xb3\x80\xa5\x16h\x8e\xdf\xed\xbe\x06\x18v\xbb\xf1" + + "\x00p\xe2F\x81\x9a\x06\x0a\xd1VL\x853q\x86\x19" + + "#C+\xa6L\xbc\x01M\xd3\xa3\xd6\x8a)\xb3ys" + + "rjV\x80dXy\x95X\xf5\xac`\x98\x9c\x88O" + + "L\xbfb\xe9\xbbAA\xd3\xd7\x81\xe4\xe8\x19\xd7\x85Z" + + "\xe6\xbbLD\xda\x091\xec\x92\x9cv04\x1d\xcc\x9f" + + "\x91k\xf6%\x9c\xdbmh\xed\xf9\x0e\x00\xae\xead\xd7" + + "\xe9\x1c-M\x03w\x19\xcb\xa2;C:\xfa\xc3VS" + + "\xb5\xf4\x0d" + + "M|\x84\x0b\x01BG\x88~\x9eA\x13\x9e44q" + + "\x96\xa9=\xc3 \x0b\x8eCQ(\x0a\xa0\x00 \x89\x1c" + + "\xd1+8\x1eC\xd7\x12\xbd\xa48\x80%\x00R#\xa3" + + "7\x10}\x0a\xd1\xbdB\x00\xbd\x00R\x1b7\x0f \xd4" + + "J\xf4\x9f\x13\xbd\xb4$\x80\xa5\x00\xd2-\x8c\xfeOD" + + "\x8f\x10}\x807\x80\x03\x00$\x85\xa3}\xcd%\xfa\xed" + + "D/+\x0d`\x19\x80\xd4\xc3M\x02\x08\x19D\x7f\x88" + + "\xe8>\x0c\xa0\x0f@z\x80\xd3\x00B\xf7\x13\xfd\x11\xa2" + + "\x97\x0f\x08`9\x80\xb4\x8e\xd1\xd7\x12};\xd1\xfde" + + "\x01\xf4\x03H\xdb\x98\x9cg\x88\xfe*\x97\xd59\xa5\xe6" + + "u\xc7#1\xb5C\x01\xde\xd1\x93\x18\xaa\xd6\x15\x8d+" + + "1r\x82L\x13^\xab\x1b\x91h\xdcj\xc9\xd5eQ" + + "\x83\xc1'\xd8\x07YI$\xba\xda\xe9)\xf8\x15cA" + + "\x9f\xa71\xb3@\xf2\x9a\x03\x00p\x00\xb2\x8c+\x1cS" + + "\x95xwr2\xf0]\x91>\xb0N,1O\x89\xb5" + + "i\xc0\xf7Eu\xc2\x89\xae.%\x1ei\x03A\xeb\xfb" + + "\xb0\xff}\xe0\x0a5\xbe\xe4&\xc5\xb9`wD\x84\xb3" + + "k=\xfa\xed\xd6+\xddq\xa7\x94H$jD\x13q" + + "\xa8Ub\xd7G,Q\xde\xf4\xe2V\xc4TeQ_" + + "r\xbfF\xd0\xa0\xaaw\xc7\xf8|\xa7\x16\xab\xc3+\x00" + + "a\xd2\x9d\xcd\xbfk\xf6\xd5\x01.=\xfcZ\xfdb\xa1" + + "\xb0V\xae1\xcd,\xd5.\x9caz\x06S\x98\xe2\xc0" + + ":\xdb\x82\xf6\x0c\x95_\xaa\x8b\xab\xc6\x0dz\x87b\x00" + + "\xf6\x03}p\x83p\x99.\xd15&M\xcf\x8cD\x8f" + + "8\x16\xba\xae*3\xe8\xfc\xc6\xca~\xe2z\x9a\x9d\xd6" + + "\xf2(?\xea\x18\x936\xd2\xec\xf4\x08\x8f\xf2\x13\x8e1" + + "i\x13\x11\x7f\xc3\xa3\xfcL\x9e\xdbt\xceRY\x81>" + + "Q7\"\x89n\xc3\xf9U\xd54+\x0d\xe4\x03\x10d" + + "\x0as\xfe\xc8\x885\xe8\x14\x00\xcb\xe9\xce2g:\xe2" + + "\xa5UY\x83F\xc1\xc0~\x7f\xc3\xcd\x1a\xc2\x0a\xd0\x98" + + "\x0b\xc9J7\xc8\xe4I\x03-\xb5\xbd\xa4\xf6\x1d\x1e\xe5" + + "\xcf\x1c\x9et\x82<\xe9X\x06\xc97\xe1\xfdSd\x8e" + + "Oy\x0cy\xa8\xba\xa6\xe1}\x09q\x10\x80|\xde\xc2" + + "\xf7\xd1\xc4\xf7G\x02\x04\xa9&\x96\xb1\x1a\xca\xa5k\xa8" + + "\x17\xc7e\xc1\xfe\xc5|\xba\x86\xfa\x18\xdd\x86\xfd\x05\xcc" + + "\xd4P\xd4L\xd8\xbf\x1a\x0bw\xcb\x15\x99\xd4\xeeJ\xea" + + "\x82a\xf4\xe4.Q\x97\xf0\xdcK'\xec\x02\x81Y;" + + "\x079 \x9b*;\xdd\x88\xb9\xf1/\xae/\xfe\xe5," + + "\xcf\x97\x01\xbb\xf0\\\x0a\xac\xf5S\xd3\xcar\x12[\xca" + + "\xe8A\x0cKl\xa6\x7f\x9c8\x84\xfe\xf1bM\x13\x00" + + "z\xc4\xcaA\x00B4\x19\x16\xe2\xaa!$\xa3\x11\x7f" + + "\xb7\xaejB\xb7\xa1\xe7\xe5\xc79\xe6\\\x07D\\a" + + "\x99M!c\xccM\x1b\xc3\xb4Z\x94RZ\x84G9" + + "\xe9\x00\x8e\xba\x88\xb8\x80G\xd9\xa0\x8c80\x9d\x11\x17" + + "\xd3\xdbI\x1e\xe5\xdb\xb9t\x9f29\x11a\xc1\xe7\x01" + + "\x0e=\xb6cd\x8ci:\x86i[#\xda\xa5F~" + + "\xd6m8z\x9f\xfe\xf5\xbb\x99\xf1\xd2\xd5k/td" + + "\x86p\x86\x19\xfcZG4\x82%\xc0aI\xff\xef\x94" + + "\x0a\xbb\x86\xb0\xa0\x92\x02\xe0g\x13`\xc8\xcc\xb5\xb4\xb3" + + "+-]\xeb\xab\x1c\xd5\xc9<\xb5\x8d\xb3\xedBd\xf9" + + "\xfa\x93\x1a\x80\xfc\x04\x8f\xf2v+\xf7\x88\xdb\xd6\x00\xc8" + + "\xdby\x94_\xa6\xcc\xc3\xa7\xcb\xd8N\x8a\x94\x17y\x94" + + "_\xa5\xbc\xe3ayG\xdcC{z\x85G\xf9\x83\xec" + + "H\xd1Y\xeaw5\xb2l\xecSu\x1dj\xa3\x89\xb8" + + "\xe3nO7\x12\xc9\xb6\xf9\x86\x8aZ\x88rF{\x02" + + "\xe7\xff\xff\xa1\xcd9{'VE\x0c\xcc\xf3\xf4,\x88" + + "\xad\x80\xd33\xebpa\xf5\xca\x02\x1a\x7f\xd8\x1dY\xde" + + "\x17\x9e\x16\xc6XP;\x9a\xe3\x92+m\xd0\xec&\xe0" + + "\xfb\xb7i\xa1\x83\x05\x18\xd4\xc4\xfa\xb4\x9f\xcc\xeaI\xa2" + + "\xea\xb8\x8d9\xc02he\x13\x80\x15\xe3\x9c\x16\xec\x8e" + + "Sn\x99F\x92\xe7+aT\xfd\x0b\xf5D\xbc\xb0;" + + "\x16GNi\xb0\x86h/\x9br\xad\x8ak\xce\xd0\"" + + "\xd2\xd0WF\xe4+\xd1N\x9aR%\x95y\xbb\x10\x8b" + + "<\x97.\xffW\xb1\xc2\x1d \xfa@\xb4\xa3P\xaaa" + + "\xe2\xab\x89\xde\x80v JC\x18\xff@\xf3\x1e_," + + ".J7\x00\x8dHCn\x03\xd1G\xb1\x06\xa08\xdd" + + "\x00\x8c`C\xf7p\xa2\x8f'z\x89\x90\x1e\xa2\xc72" + + "\xf9c\x88>\x85\xe8\xde\x92\xcc\x10\xcd\x86\xfdV\xa2\xcf" + + "\xa0\x86!\xa9%\xc2\xaa\xaeO\x03\xb4R\xa5\x09\xfa\x98" + + "q-\x18J\xa7\xf9y\"5\x0cQ\xc31\xe8Fc" + + "\x91)\xd4\xc8\xab\x16\x8b\xa1h\x9d\xaa\xcd\xa2u\xeb\x06" + + "\x99\x1a\x04\x87\xccTX\xd1:\x137\xa9\x1a\xf8\xf5>" + + "\xe4Y\x9a\xea\x90\x97\x95$\xcc\xc4\xd1\xcf\xc2h\xb7\x13" + + "\x8e\xfe\x8eR\xec[\xe9_j\x98\x19\xf6\xe0\xec\xcc\x0f" + + "5\x8e8\xea\xe2a\x8a\xad\xf7x\x94\xbf\xa6\xf3mM" + + "\xa7\xd8\xd3\xe4\xfd_\xf2(\x9fwL\x0ag)\xc5\x9e" + + "\xc94\x82\x16>\x82d\xfa\xa0\xe5!&&2"}, + Tty: terminal, + Stdout: true, + Stderr: true, + }) + + Expect(err).To(Succeed()) + Expect(result.URL).NotTo(BeEmpty()) + + config := &rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}} + executor, err := remotecommand.NewWebSocketExecutor(config, "GET", result.URL) + Expect(err).NotTo(HaveOccurred()) + + stdout := &bytes.Buffer{} + stderr := &bytes.Buffer{} + + streamOptions := remotecommand.StreamOptions{ + Stdout: stdout, + Stderr: stderr, + Tty: terminal, + } + err = executor.StreamWithContext(context.Background(), streamOptions) + Expect(err).NotTo(HaveOccurred()) + + if terminal { + Expect(stdout.String()).To(Equal("stdoutstderr")) + Expect(stderr.Len()).To(BeZero()) + } else { + Expect(stdout.String()).To(Equal("stdout")) + Expect(stderr.String()).To(Equal("stderr")) + } + }) + + It(testName("should fail if container does not exist", terminal), func() { + tr = newTestRunner() + tr.createRuntimeConfigWithProcessArgs(terminal, []string{"/busybox", "sleep", "10"}, nil) + sut = tr.configGivenEnv() + + result, err := sut.ServeExecContainer(context.Background(), &client.ServeExecContainerConfig{ + ID: "wrong", + Command: []string{"/busybox", "sh", "-c", "echo -n stdout && echo -n stderr >&2"}, + Tty: terminal, + Stdout: true, + Stderr: true, + }) + + Expect(err).To(HaveOccurred()) + Expect(result).To(BeNil()) + }) + } + }) + + Describe("ServeAttachContainer", func() { + const terminal = true + + It(testName("should succeed", terminal), func() { + tr = newTestRunner() + tr.createRuntimeConfigWithProcessArgs(terminal, []string{"/busybox", "watch", "-n0.5", "echo", "test"}, nil) + sut = tr.configGivenEnv() + tr.createContainer(sut, terminal) + tr.startContainer(sut) + + result, err := sut.ServeAttachContainer(context.Background(), &client.ServeAttachContainerConfig{ + ID: tr.ctrID, + Stdin: true, + Stdout: true, + Stderr: true, + }) + + Expect(err).To(Succeed()) + Expect(result.URL).NotTo(BeEmpty()) + + config := &rest.Config{TLSClientConfig: rest.TLSClientConfig{Insecure: true}} + executor, err := remotecommand.NewWebSocketExecutor(config, "GET", result.URL) + Expect(err).NotTo(HaveOccurred()) + + stdout := &bytes.Buffer{} + stderr := &bytes.Buffer{} + + streamOptions := remotecommand.StreamOptions{ + Stdout: stdout, + Stderr: stderr, + Tty: terminal, + } + + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + + err = executor.StreamWithContext(ctx, streamOptions) + Expect(err).To(HaveOccurred()) + Expect(tr.rr.RunCommand("delete", "-f", tr.ctrID)).To(Succeed()) + Expect(stdout.String()).To(ContainSubstring("echo test")) + Expect(stderr.String()).To(BeEmpty()) + }) + + It(testName("should fail if container does not exist", terminal), func() { + tr = newTestRunner() + tr.createRuntimeConfigWithProcessArgs(terminal, []string{"/busybox", "sleep", "10"}, nil) + sut = tr.configGivenEnv() + + result, err := sut.ServeAttachContainer(context.Background(), &client.ServeAttachContainerConfig{ + ID: "wrong", + }) + + Expect(err).To(HaveOccurred()) + Expect(result).To(BeNil()) + }) + }) +}) diff --git a/pkg/client/suite_test.go b/pkg/client/suite_test.go index f70bacca6f..40caae0c67 100644 --- a/pkg/client/suite_test.go +++ b/pkg/client/suite_test.go @@ -38,7 +38,7 @@ var ( busyboxDest = filepath.Join(busyboxDestDir, "busybox") runtimePath = os.Getenv("RUNTIME_BINARY") conmonPath = os.Getenv(conmonBinaryKey) - maxRSSKB = 9500 + maxRSSKB = 12000 ) // TestConmonClient runs the created specs.