diff --git a/Cargo.lock b/Cargo.lock index 75c92d864030..f46b12b706e9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2563,7 +2563,7 @@ dependencies = [ "datafusion-proto", "futures", "log", - "prost", + "prost 0.13.5", "semver", "tokio", ] @@ -2823,7 +2823,7 @@ dependencies = [ "datafusion-expr", "datafusion-proto-common", "object_store", - "prost", + "prost 0.13.5", ] [[package]] @@ -2834,7 +2834,7 @@ checksum = "35b7a5876ebd6b564fb9a1fd2c3a2a9686b787071a256b47e4708f0916f9e46f" dependencies = [ "arrow", "datafusion-common", - "prost", + "prost 0.13.5", ] [[package]] @@ -4392,7 +4392,7 @@ dependencies = [ "libc", "percent-encoding", "pin-project-lite", - "socket2", + "socket2 0.5.10", "tokio", "tower-service", "tracing", @@ -6091,8 +6091,8 @@ dependencies = [ "anyhow", "clap", "glam", - "prost", - "prost-build", + "prost 0.13.5", + "prost-build 0.13.5", "protoc-prebuilt", "re_build_tools", "rerun", @@ -6173,11 +6173,11 @@ dependencies = [ "opentelemetry-http", "opentelemetry-proto", "opentelemetry_sdk", - "prost", + "prost 0.13.5", "reqwest", "thiserror 2.0.12", "tokio", - "tonic", + "tonic 0.13.1", "tracing", ] @@ -6189,8 +6189,8 @@ checksum = "2e046fd7660710fe5a05e8748e70d9058dc15c94ba914e7c4faa7c728f0e8ddc" dependencies = [ "opentelemetry", "opentelemetry_sdk", - "prost", - "tonic", + "prost 0.13.5", + "tonic 0.13.1", ] [[package]] @@ -6785,7 +6785,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5" dependencies = [ "bytes", - "prost-derive", + "prost-derive 0.13.5", +] + +[[package]] +name = "prost" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7231bd9b3d3d33c86b58adbac74b5ec0ad9f496b19d22801d773636feaa95f3d" +dependencies = [ + "bytes", + "prost-derive 0.14.1", ] [[package]] @@ -6801,8 +6811,28 @@ dependencies = [ "once_cell", "petgraph 0.7.1", "prettyplease", - "prost", - "prost-types", + "prost 0.13.5", + "prost-types 0.13.5", + "regex", + "syn 2.0.104", + "tempfile", +] + +[[package]] +name = "prost-build" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac6c3320f9abac597dcbc668774ef006702672474aad53c6d596b62e487b40b1" +dependencies = [ + "heck", + "itertools 0.14.0", + "log", + "multimap", + "once_cell", + "petgraph 0.7.1", + "prettyplease", + "prost 0.14.1", + "prost-types 0.14.1", "regex", "syn 2.0.104", "tempfile", @@ -6821,14 +6851,27 @@ dependencies = [ "syn 2.0.104", ] +[[package]] +name = "prost-derive" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9120690fafc389a67ba3803df527d0ec9cbbc9cc45e4cc20b332996dfb672425" +dependencies = [ + "anyhow", + "itertools 0.14.0", + "proc-macro2", + "quote", + "syn 2.0.104", +] + [[package]] name = "prost-reflect" -version = "0.15.3" +version = "0.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37587d5a8a1b3dc9863403d084fc2254b91ab75a702207098837950767e2260b" +checksum = "3c9ae1e4084d9737646934f5ac36a8d77f9a82f962f43e267a382fde4f2a903d" dependencies = [ - "prost", - "prost-types", + "prost 0.14.1", + "prost-types 0.14.1", ] [[package]] @@ -6837,7 +6880,16 @@ version = "0.13.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16" dependencies = [ - "prost", + "prost 0.13.5", +] + +[[package]] +name = "prost-types" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9b4db3d6da204ed77bb26ba83b6122a73aeb2e87e25fbf7ad2e84c4ccbf8f72" +dependencies = [ + "prost 0.14.1", ] [[package]] @@ -7007,7 +7059,7 @@ dependencies = [ "quinn-udp", "rustc-hash 2.1.1", "rustls", - "socket2", + "socket2 0.5.10", "thiserror 2.0.12", "tokio", "tracing", @@ -7044,7 +7096,7 @@ dependencies = [ "cfg_aliases", "libc", "once_cell", - "socket2", + "socket2 0.5.10", "tracing", "windows-sys 0.59.0", ] @@ -7255,7 +7307,7 @@ dependencies = [ "serde_json", "thiserror 1.0.69", "tiny_http", - "tonic", + "tonic 0.14.2", "url", "webbrowser", ] @@ -7652,7 +7704,7 @@ dependencies = [ "re_uri", "tokio", "tokio-stream", - "tonic", + "tonic 0.14.2", "tracing", "wasm-bindgen-futures", ] @@ -7796,7 +7848,7 @@ dependencies = [ "thiserror 1.0.69", "tokio", "tokio-stream", - "tonic", + "tonic 0.14.2", "tonic-web-wasm-client", "wasm-bindgen-futures", "web-time", @@ -7827,7 +7879,7 @@ dependencies = [ "tokio", "tokio-stream", "tokio-util", - "tonic", + "tonic 0.14.2", "tonic-web", "tower-http", ] @@ -8015,7 +8067,7 @@ dependencies = [ "serde", "serde_json", "tokio", - "tonic", + "tonic 0.14.2", "tower", "tower-http", "tracing", @@ -8030,8 +8082,8 @@ version = "0.25.0-alpha.1+dev" dependencies = [ "arrow", "jiff", - "prost", - "prost-types", + "prost 0.14.1", + "prost-types 0.14.1", "pyo3", "re_arrow_util", "re_build_info", @@ -8042,7 +8094,8 @@ dependencies = [ "re_tuid", "serde", "thiserror 1.0.69", - "tonic", + "tonic 0.14.2", + "tonic-prost", "url", ] @@ -8051,9 +8104,8 @@ name = "re_protos_builder" version = "0.25.0-alpha.1+dev" dependencies = [ "camino", - "prost-build", "re_log", - "tonic-build", + "tonic-prost-build", ] [[package]] @@ -8182,7 +8234,7 @@ dependencies = [ "thiserror 1.0.69", "tokio", "tokio-stream", - "tonic", + "tonic 0.14.2", "tonic-web-wasm-client", "tower", "tracing", @@ -8358,7 +8410,7 @@ dependencies = [ "thiserror 1.0.69", "tokio", "tokio-stream", - "tonic", + "tonic 0.14.2", "tonic-web", "tower", "tower-service", @@ -9455,7 +9507,7 @@ dependencies = [ "mimalloc", "numpy", "parking_lot", - "prost-types", + "prost-types 0.14.1", "pyo3", "pyo3-build-config", "rand 0.8.5", @@ -9489,7 +9541,7 @@ dependencies = [ "thiserror 1.0.69", "tokio", "tokio-stream", - "tonic", + "tonic 0.14.2", "tracing", "url", "uuid", @@ -10173,6 +10225,16 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "socket2" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807" +dependencies = [ + "libc", + "windows-sys 0.59.0", +] + [[package]] name = "spawn_viewer" version = "0.25.0-alpha.1+dev" @@ -10713,7 +10775,7 @@ dependencies = [ "pin-project-lite", "signal-hook-registry", "slab", - "socket2", + "socket2 0.5.10", "tokio-macros", "windows-sys 0.52.0", ] @@ -10811,6 +10873,32 @@ name = "tonic" version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7e581ba15a835f4d9ea06c55ab1bd4dce26fc53752c69a04aac00703bfb49ba9" +dependencies = [ + "async-trait", + "base64 0.22.1", + "bytes", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-timeout", + "hyper-util", + "percent-encoding", + "pin-project", + "prost 0.13.5", + "tokio", + "tokio-stream", + "tower", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tonic" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb7613188ce9f7df5bfe185db26c5814347d110db17920415cf2fbcad85e7203" dependencies = [ "async-trait", "axum", @@ -10825,9 +10913,9 @@ dependencies = [ "hyper-util", "percent-encoding", "pin-project", - "prost", "rustls-native-certs", - "socket2", + "socket2 0.6.0", + "sync_wrapper", "tokio", "tokio-rustls", "tokio-stream", @@ -10839,23 +10927,48 @@ dependencies = [ [[package]] name = "tonic-build" -version = "0.13.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac6f67be712d12f0b41328db3137e0d0757645d8904b4cb7d51cd9c2279e847" +checksum = "4c40aaccc9f9eccf2cd82ebc111adc13030d23e887244bc9cfa5d1d636049de3" dependencies = [ "prettyplease", "proc-macro2", - "prost-build", - "prost-types", "quote", "syn 2.0.104", ] +[[package]] +name = "tonic-prost" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66bd50ad6ce1252d87ef024b3d64fe4c3cf54a86fb9ef4c631fdd0ded7aeaa67" +dependencies = [ + "bytes", + "prost 0.14.1", + "tonic 0.14.2", +] + +[[package]] +name = "tonic-prost-build" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4a16cba4043dc3ff43fcb3f96b4c5c154c64cbd18ca8dce2ab2c6a451d058a2" +dependencies = [ + "prettyplease", + "proc-macro2", + "prost-build 0.14.1", + "prost-types 0.14.1", + "quote", + "syn 2.0.104", + "tempfile", + "tonic-build", +] + [[package]] name = "tonic-web" -version = "0.13.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "774cad0f35370f81b6c59e3a1f5d0c3188bdb4a2a1b8b7f0921c860bfbd3aec6" +checksum = "75214f6b6bd28c19aa752ac09fdf0eea546095670906c21fe3940e180a4c43f2" dependencies = [ "base64 0.22.1", "bytes", @@ -10863,7 +10976,7 @@ dependencies = [ "http-body", "pin-project", "tokio-stream", - "tonic", + "tonic 0.14.2", "tower-layer", "tower-service", "tracing", @@ -10871,9 +10984,9 @@ dependencies = [ [[package]] name = "tonic-web-wasm-client" -version = "0.7.1" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "66e3bb7acca55e6790354be650f4042d418fcf8e2bc42ac382348f2b6bf057e5" +checksum = "898cd44be5e23e59d2956056538f1d6b3c5336629d384ffd2d92e76f87fb98ff" dependencies = [ "base64 0.22.1", "byteorder", @@ -10886,7 +10999,7 @@ dependencies = [ "js-sys", "pin-project", "thiserror 2.0.12", - "tonic", + "tonic 0.14.2", "tower-service", "wasm-bindgen", "wasm-bindgen-futures", diff --git a/Cargo.toml b/Cargo.toml index 305a6f87ddd0..bacaa0bda128 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -292,10 +292,10 @@ pollster = "0.4" prettyplease = "0.2" proc-macro2 = { version = "1.0", default-features = false } profiling = { version = "1.0.12", default-features = false } -prost = "0.13.3" -prost-build = "0.13.3" -prost-types = "0.13.3" -prost-reflect = "0.15.3" +prost = "0.14.1" +prost-build = "0.14.1" +prost-types = "0.14.1" +prost-reflect = "0.16.1" puffin = "0.19.1" puffin_http = "0.16" pyo3 = "0.24.1" @@ -344,10 +344,11 @@ tokio = { version = "1.44.2", default-features = false } tokio-stream = "0.1.16" tokio-util = { version = "0.7.12", default-features = false } toml = { version = "0.8.10", default-features = false } -tonic = { version = "0.13.1", default-features = false } -tonic-build = { version = "0.13.1", default-features = false } -tonic-web = "0.13.1" -tonic-web-wasm-client = "0.7.1" +tonic = { version = "0.14.2", default-features = false } +tonic-prost = { version = "0.14.2", default-features = false } +tonic-prost-build = { version = "0.14.2", default-features = false } +tonic-web = "0.14.2" +tonic-web-wasm-client = "0.8.0" tower = "0.5" tower-http = "0.6" tower-service = "0.3" diff --git a/crates/build/re_protos_builder/Cargo.toml b/crates/build/re_protos_builder/Cargo.toml index 6f100bcd9d49..2a5752d19b3e 100644 --- a/crates/build/re_protos_builder/Cargo.toml +++ b/crates/build/re_protos_builder/Cargo.toml @@ -26,7 +26,4 @@ re_log = { workspace = true, features = ["setup"] } # External camino.workspace = true -tonic-build = { workspace = true, default-features = false, features = [ - "prost", -] } -prost-build = { workspace = true } +tonic-prost-build = { workspace = true, default-features = false } diff --git a/crates/build/re_protos_builder/src/bin/build_re_remote_store_types.rs b/crates/build/re_protos_builder/src/bin/build_re_remote_store_types.rs index 57e5b0b3d369..94359c927d6e 100644 --- a/crates/build/re_protos_builder/src/bin/build_re_remote_store_types.rs +++ b/crates/build/re_protos_builder/src/bin/build_re_remote_store_types.rs @@ -31,8 +31,8 @@ fn main() { let mut proto_paths = std::fs::read_dir(definitions_dir_path.join(INPUT_V1ALPHA1_DIR)) .unwrap() .map(|v| { - v.unwrap() - .path() + Utf8Path::from_path(&v.unwrap().path()) + .unwrap() .strip_prefix(&definitions_dir_path) .unwrap() .to_owned() @@ -50,6 +50,6 @@ fn main() { re_protos_builder::generate_rust_code( definitions_dir_path, &proto_paths, - rust_generated_output_dir_path, + &rust_generated_output_dir_path, ); } diff --git a/crates/build/re_protos_builder/src/lib.rs b/crates/build/re_protos_builder/src/lib.rs index d13e2ec15bc7..693012dc94af 100644 --- a/crates/build/re_protos_builder/src/lib.rs +++ b/crates/build/re_protos_builder/src/lib.rs @@ -5,18 +5,15 @@ #![allow(clippy::unwrap_used, clippy::exit)] -use std::path::Path; - /// Generate rust from protobuf definitions. We rely on `tonic_build` to do the heavy lifting. /// `tonic_build` relies on `prost` which itself relies on `protoc`. /// /// Note: make sure to invoke this via `pixi run codegen-protos` in order to use the right `protoc` version. -pub fn generate_rust_code( - definitions_dir: impl AsRef, - proto_paths: &[impl AsRef], - output_dir: impl AsRef, -) { - let mut prost_config = prost_build::Config::new(); +pub fn generate_rust_code

(definitions_dir: P, proto_paths: &[P], output_dir: &P) +where + P: AsRef, +{ + let mut prost_config = tonic_prost_build::Config::new(); prost_config.enable_type_names(); // tonic doesn't expose this option prost_config.bytes([ ".rerun.common.v1alpha1", @@ -25,12 +22,12 @@ pub fn generate_rust_code( ".rerun.manifest_registry.v1alpha1", ]); - if let Err(err) = tonic_build::configure() - .out_dir(output_dir.as_ref()) + if let Err(err) = tonic_prost_build::configure() + .out_dir(output_dir) .build_client(true) .build_server(true) .build_transport(false) // Small convenience, but doesn't work on web - .compile_protos_with_config(prost_config, proto_paths, &[definitions_dir]) + .compile_with_config(prost_config, proto_paths, &[definitions_dir]) { match err.kind() { std::io::ErrorKind::Other => { diff --git a/crates/store/re_protos/Cargo.toml b/crates/store/re_protos/Cargo.toml index 76d92fa107a0..153e90223e5f 100644 --- a/crates/store/re_protos/Cargo.toml +++ b/crates/store/re_protos/Cargo.toml @@ -37,22 +37,19 @@ prost.workspace = true pyo3 = { workspace = true, optional = true } serde.workspace = true thiserror.workspace = true +tonic-prost = { workspace = true, default-features = false } url = { workspace = true, features = ["serde"] } # Native dependencies: [target.'cfg(not(target_arch = "wasm32"))'.dependencies] tonic = { workspace = true, default-features = false, features = [ "codegen", - "prost", "transport", ] } # Web dependencies: [target.'cfg(target_arch = "wasm32")'.dependencies] -tonic = { workspace = true, default-features = false, features = [ - "codegen", - "prost", -] } +tonic = { workspace = true, default-features = false, features = ["codegen"] } [lints] workspace = true diff --git a/crates/store/re_protos/src/v1alpha1/rerun.catalog.v1alpha1.rs b/crates/store/re_protos/src/v1alpha1/rerun.catalog.v1alpha1.rs new file mode 100644 index 000000000000..4e788268ff1a --- /dev/null +++ b/crates/store/re_protos/src/v1alpha1/rerun.catalog.v1alpha1.rs @@ -0,0 +1,1212 @@ +// This file is @generated by prost-build. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct FindEntriesRequest { + #[prost(message, optional, tag = "1")] + pub filter: ::core::option::Option, +} +impl ::prost::Name for FindEntriesRequest { + const NAME: &'static str = "FindEntriesRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.FindEntriesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.FindEntriesRequest".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FindEntriesResponse { + #[prost(message, repeated, tag = "1")] + pub entries: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for FindEntriesResponse { + const NAME: &'static str = "FindEntriesResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.FindEntriesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.FindEntriesResponse".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DeleteEntryRequest { + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, +} +impl ::prost::Name for DeleteEntryRequest { + const NAME: &'static str = "DeleteEntryRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.DeleteEntryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.DeleteEntryRequest".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DeleteEntryResponse {} +impl ::prost::Name for DeleteEntryResponse { + const NAME: &'static str = "DeleteEntryResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.DeleteEntryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.DeleteEntryResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UpdateEntryRequest { + /// The entry to modify. + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, + /// The new values for updatable fields. + #[prost(message, optional, tag = "2")] + pub entry_details_update: ::core::option::Option, +} +impl ::prost::Name for UpdateEntryRequest { + const NAME: &'static str = "UpdateEntryRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.UpdateEntryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.UpdateEntryRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UpdateEntryResponse { + /// The updated entry details + #[prost(message, optional, tag = "1")] + pub entry_details: ::core::option::Option, +} +impl ::prost::Name for UpdateEntryResponse { + const NAME: &'static str = "UpdateEntryResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.UpdateEntryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.UpdateEntryResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CreateDatasetEntryRequest { + /// Name of the dataset entry to create. + /// + /// The name should be a short human-readable string. It must be unique within all entries in the catalog. If an entry + /// with the same name already exists, the request will fail. + #[prost(string, optional, tag = "1")] + pub name: ::core::option::Option<::prost::alloc::string::String>, + /// If specified, create the entry using this specific ID. Use at your own risk. + #[prost(message, optional, tag = "2")] + pub id: ::core::option::Option, +} +impl ::prost::Name for CreateDatasetEntryRequest { + const NAME: &'static str = "CreateDatasetEntryRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.CreateDatasetEntryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.CreateDatasetEntryRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CreateDatasetEntryResponse { + #[prost(message, optional, tag = "1")] + pub dataset: ::core::option::Option, +} +impl ::prost::Name for CreateDatasetEntryResponse { + const NAME: &'static str = "CreateDatasetEntryResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.CreateDatasetEntryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.CreateDatasetEntryResponse".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReadDatasetEntryRequest { + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, +} +impl ::prost::Name for ReadDatasetEntryRequest { + const NAME: &'static str = "ReadDatasetEntryRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.ReadDatasetEntryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.ReadDatasetEntryRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReadDatasetEntryResponse { + #[prost(message, optional, tag = "1")] + pub dataset: ::core::option::Option, +} +impl ::prost::Name for ReadDatasetEntryResponse { + const NAME: &'static str = "ReadDatasetEntryResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.ReadDatasetEntryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.ReadDatasetEntryResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UpdateDatasetEntryRequest { + /// The dataset to modify. + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, + /// The new values. + #[prost(message, optional, tag = "2")] + pub dataset_details: ::core::option::Option, +} +impl ::prost::Name for UpdateDatasetEntryRequest { + const NAME: &'static str = "UpdateDatasetEntryRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.UpdateDatasetEntryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.UpdateDatasetEntryRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UpdateDatasetEntryResponse { + /// The updated dataset entry + #[prost(message, optional, tag = "1")] + pub dataset: ::core::option::Option, +} +impl ::prost::Name for UpdateDatasetEntryResponse { + const NAME: &'static str = "UpdateDatasetEntryResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.UpdateDatasetEntryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.UpdateDatasetEntryResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RegisterTableRequest { + /// Name of the table entry to create. + /// + /// The name should be a short human-readable string. It must be unique within all entries in the catalog. If an entry + /// with the same name already exists, the request will fail. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Information about the table to register. + /// + /// This must be encoded message of one one of the following supported types: + /// - rerun.catalog.v1alpha1.LanceTable + #[prost(message, optional, tag = "2")] + pub provider_details: ::core::option::Option<::prost_types::Any>, +} +impl ::prost::Name for RegisterTableRequest { + const NAME: &'static str = "RegisterTableRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.RegisterTableRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.RegisterTableRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RegisterTableResponse { + /// Details about the table that was created and registered. + #[prost(message, optional, tag = "1")] + pub table_entry: ::core::option::Option, +} +impl ::prost::Name for RegisterTableResponse { + const NAME: &'static str = "RegisterTableResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.RegisterTableResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.RegisterTableResponse".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReadTableEntryRequest { + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, +} +impl ::prost::Name for ReadTableEntryRequest { + const NAME: &'static str = "ReadTableEntryRequest"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.ReadTableEntryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.ReadTableEntryRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReadTableEntryResponse { + #[prost(message, optional, tag = "1")] + pub table: ::core::option::Option, +} +impl ::prost::Name for ReadTableEntryResponse { + const NAME: &'static str = "ReadTableEntryResponse"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.ReadTableEntryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.ReadTableEntryResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct EntryFilter { + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, + #[prost(string, optional, tag = "2")] + pub name: ::core::option::Option<::prost::alloc::string::String>, + #[prost(enumeration = "EntryKind", optional, tag = "3")] + pub entry_kind: ::core::option::Option, +} +impl ::prost::Name for EntryFilter { + const NAME: &'static str = "EntryFilter"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.EntryFilter".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.EntryFilter".into() + } +} +/// Minimal info about an Entry for high-level catalog summary +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct EntryDetails { + /// The EntryId is immutable + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, + /// The name of this entry. + #[prost(string, optional, tag = "2")] + pub name: ::core::option::Option<::prost::alloc::string::String>, + /// The kind of entry + #[prost(enumeration = "EntryKind", tag = "3")] + pub entry_kind: i32, + #[prost(message, optional, tag = "4")] + pub created_at: ::core::option::Option<::prost_types::Timestamp>, + #[prost(message, optional, tag = "5")] + pub updated_at: ::core::option::Option<::prost_types::Timestamp>, +} +impl ::prost::Name for EntryDetails { + const NAME: &'static str = "EntryDetails"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.EntryDetails".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.EntryDetails".into() + } +} +/// Updatable fields of an Entry +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct EntryDetailsUpdate { + /// The name of this entry. + #[prost(string, optional, tag = "2")] + pub name: ::core::option::Option<::prost::alloc::string::String>, +} +impl ::prost::Name for EntryDetailsUpdate { + const NAME: &'static str = "EntryDetailsUpdate"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.EntryDetailsUpdate".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.EntryDetailsUpdate".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DatasetDetails { + /// The blueprint dataset associated with this dataset (if any). + #[prost(message, optional, tag = "3")] + pub blueprint_dataset: ::core::option::Option, + /// The partition of the blueprint dataset corresponding to the default blueprint (if any). + #[prost(message, optional, tag = "4")] + pub default_blueprint: ::core::option::Option, +} +impl ::prost::Name for DatasetDetails { + const NAME: &'static str = "DatasetDetails"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.DatasetDetails".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.DatasetDetails".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DatasetEntry { + #[prost(message, optional, tag = "1")] + pub details: ::core::option::Option, + /// Dataset-specific information, may be update with `UpdateDatasetEntry` + #[prost(message, optional, tag = "4")] + pub dataset_details: ::core::option::Option, + /// Read-only + #[prost(message, optional, tag = "2")] + pub dataset_handle: ::core::option::Option, +} +impl ::prost::Name for DatasetEntry { + const NAME: &'static str = "DatasetEntry"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.DatasetEntry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.DatasetEntry".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct TableEntry { + #[prost(message, optional, tag = "1")] + pub details: ::core::option::Option, + /// Details specific to the table-provider + #[prost(message, optional, tag = "3")] + pub provider_details: ::core::option::Option<::prost_types::Any>, +} +impl ::prost::Name for TableEntry { + const NAME: &'static str = "TableEntry"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.TableEntry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.TableEntry".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SystemTable { + #[prost(enumeration = "SystemTableKind", tag = "1")] + pub kind: i32, +} +impl ::prost::Name for SystemTable { + const NAME: &'static str = "SystemTable"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.SystemTable".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.SystemTable".into() + } +} +/// A foreign table stored as a Lance table. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct LanceTable { + /// The URL of the Lance table. + #[prost(string, tag = "1")] + pub table_url: ::prost::alloc::string::String, +} +impl ::prost::Name for LanceTable { + const NAME: &'static str = "LanceTable"; + const PACKAGE: &'static str = "rerun.catalog.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.catalog.v1alpha1.LanceTable".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.catalog.v1alpha1.LanceTable".into() + } +} +/// What type of entry. This has strong implication on which APIs are available for this entry. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum EntryKind { + /// Always reserve unspecified as default value + Unspecified = 0, + /// Order as TYPE, TYPE_VIEW so things stay consistent as we introduce new types. + Dataset = 1, + DatasetView = 2, + Table = 3, + TableView = 4, + BlueprintDataset = 5, +} +impl EntryKind { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "ENTRY_KIND_UNSPECIFIED", + Self::Dataset => "ENTRY_KIND_DATASET", + Self::DatasetView => "ENTRY_KIND_DATASET_VIEW", + Self::Table => "ENTRY_KIND_TABLE", + Self::TableView => "ENTRY_KIND_TABLE_VIEW", + Self::BlueprintDataset => "ENTRY_KIND_BLUEPRINT_DATASET", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ENTRY_KIND_UNSPECIFIED" => Some(Self::Unspecified), + "ENTRY_KIND_DATASET" => Some(Self::Dataset), + "ENTRY_KIND_DATASET_VIEW" => Some(Self::DatasetView), + "ENTRY_KIND_TABLE" => Some(Self::Table), + "ENTRY_KIND_TABLE_VIEW" => Some(Self::TableView), + "ENTRY_KIND_BLUEPRINT_DATASET" => Some(Self::BlueprintDataset), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum SystemTableKind { + /// Always reserve unspecified as default value + Unspecified = 0, + /// Not used yet + Namespaces = 1, + /// All of the entries in the associated namespace + Entries = 2, +} +impl SystemTableKind { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "SYSTEM_TABLE_KIND_UNSPECIFIED", + Self::Namespaces => "SYSTEM_TABLE_KIND_NAMESPACES", + Self::Entries => "SYSTEM_TABLE_KIND_ENTRIES", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SYSTEM_TABLE_KIND_UNSPECIFIED" => Some(Self::Unspecified), + "SYSTEM_TABLE_KIND_NAMESPACES" => Some(Self::Namespaces), + "SYSTEM_TABLE_KIND_ENTRIES" => Some(Self::Entries), + _ => None, + } + } +} +/// Generated client implementations. +pub mod catalog_service_client { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value + )] + use tonic::codegen::http::Uri; + use tonic::codegen::*; + #[derive(Debug, Clone)] + pub struct CatalogServiceClient { + inner: tonic::client::Grpc, + } + impl CatalogServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + std::marker::Send + 'static, + ::Error: Into + std::marker::Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> CatalogServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + >>::Error: + Into + std::marker::Send + std::marker::Sync, + { + CatalogServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn find_entries( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/FindEntries", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "FindEntries", + )); + self.inner.unary(req, path, codec).await + } + pub async fn delete_entry( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/DeleteEntry", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "DeleteEntry", + )); + self.inner.unary(req, path, codec).await + } + pub async fn update_entry( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/UpdateEntry", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "UpdateEntry", + )); + self.inner.unary(req, path, codec).await + } + pub async fn create_dataset_entry( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/CreateDatasetEntry", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "CreateDatasetEntry", + )); + self.inner.unary(req, path, codec).await + } + pub async fn read_dataset_entry( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/ReadDatasetEntry", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "ReadDatasetEntry", + )); + self.inner.unary(req, path, codec).await + } + pub async fn update_dataset_entry( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/UpdateDatasetEntry", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "UpdateDatasetEntry", + )); + self.inner.unary(req, path, codec).await + } + /// Register a foreign table as a new table entry in the catalog. + pub async fn register_table( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/RegisterTable", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "RegisterTable", + )); + self.inner.unary(req, path, codec).await + } + pub async fn read_table_entry( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.catalog.v1alpha1.CatalogService/ReadTableEntry", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.catalog.v1alpha1.CatalogService", + "ReadTableEntry", + )); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod catalog_service_server { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value + )] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with CatalogServiceServer. + #[async_trait] + pub trait CatalogService: std::marker::Send + std::marker::Sync + 'static { + async fn find_entries( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn delete_entry( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn update_entry( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn create_dataset_entry( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn read_dataset_entry( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn update_dataset_entry( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Register a foreign table as a new table entry in the catalog. + async fn register_table( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn read_table_entry( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct CatalogServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl CatalogServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for CatalogServiceServer + where + T: CatalogService, + B: Body + std::marker::Send + 'static, + B::Error: Into + std::marker::Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/rerun.catalog.v1alpha1.CatalogService/FindEntries" => { + #[allow(non_camel_case_types)] + struct FindEntriesSvc(pub Arc); + impl tonic::server::UnaryService + for FindEntriesSvc + { + type Response = super::FindEntriesResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::find_entries(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = FindEntriesSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.catalog.v1alpha1.CatalogService/DeleteEntry" => { + #[allow(non_camel_case_types)] + struct DeleteEntrySvc(pub Arc); + impl tonic::server::UnaryService + for DeleteEntrySvc + { + type Response = super::DeleteEntryResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_entry(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteEntrySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.catalog.v1alpha1.CatalogService/UpdateEntry" => { + #[allow(non_camel_case_types)] + struct UpdateEntrySvc(pub Arc); + impl tonic::server::UnaryService + for UpdateEntrySvc + { + type Response = super::UpdateEntryResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_entry(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateEntrySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.catalog.v1alpha1.CatalogService/CreateDatasetEntry" => { + #[allow(non_camel_case_types)] + struct CreateDatasetEntrySvc(pub Arc); + impl + tonic::server::UnaryService + for CreateDatasetEntrySvc + { + type Response = super::CreateDatasetEntryResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_dataset_entry(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateDatasetEntrySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.catalog.v1alpha1.CatalogService/ReadDatasetEntry" => { + #[allow(non_camel_case_types)] + struct ReadDatasetEntrySvc(pub Arc); + impl + tonic::server::UnaryService + for ReadDatasetEntrySvc + { + type Response = super::ReadDatasetEntryResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::read_dataset_entry(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ReadDatasetEntrySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.catalog.v1alpha1.CatalogService/UpdateDatasetEntry" => { + #[allow(non_camel_case_types)] + struct UpdateDatasetEntrySvc(pub Arc); + impl + tonic::server::UnaryService + for UpdateDatasetEntrySvc + { + type Response = super::UpdateDatasetEntryResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_dataset_entry(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateDatasetEntrySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.catalog.v1alpha1.CatalogService/RegisterTable" => { + #[allow(non_camel_case_types)] + struct RegisterTableSvc(pub Arc); + impl tonic::server::UnaryService + for RegisterTableSvc + { + type Response = super::RegisterTableResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::register_table(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = RegisterTableSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.catalog.v1alpha1.CatalogService/ReadTableEntry" => { + #[allow(non_camel_case_types)] + struct ReadTableEntrySvc(pub Arc); + impl + tonic::server::UnaryService + for ReadTableEntrySvc + { + type Response = super::ReadTableEntryResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::read_table_entry(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ReadTableEntrySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => Box::pin(async move { + let mut response = http::Response::new(tonic::body::Body::default()); + let headers = response.headers_mut(); + headers.insert( + tonic::Status::GRPC_STATUS, + (tonic::Code::Unimplemented as i32).into(), + ); + headers.insert( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ); + Ok(response) + }), + } + } + } + impl Clone for CatalogServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + /// Generated gRPC service name + pub const SERVICE_NAME: &str = "rerun.catalog.v1alpha1.CatalogService"; + impl tonic::server::NamedService for CatalogServiceServer { + const NAME: &'static str = SERVICE_NAME; + } +} diff --git a/crates/store/re_protos/src/v1alpha1/rerun.cloud.v1alpha1.rs b/crates/store/re_protos/src/v1alpha1/rerun.cloud.v1alpha1.rs index b19680f8e126..c82ab46bc9aa 100644 --- a/crates/store/re_protos/src/v1alpha1/rerun.cloud.v1alpha1.rs +++ b/crates/store/re_protos/src/v1alpha1/rerun.cloud.v1alpha1.rs @@ -1,5 +1,5 @@ // This file is @generated by prost-build. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct VersionRequest {} impl ::prost::Name for VersionRequest { const NAME: &'static str = "VersionRequest"; @@ -11,7 +11,7 @@ impl ::prost::Name for VersionRequest { "/rerun.cloud.v1alpha1.VersionRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct VersionResponse { #[prost(message, optional, tag = "1")] pub build_info: ::core::option::Option, @@ -27,7 +27,7 @@ impl ::prost::Name for VersionResponse { } } /// Application level error - used as `details` in the `google.rpc.Status` message -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct Error { /// error code #[prost(enumeration = "ErrorCode", tag = "1")] @@ -49,7 +49,7 @@ impl ::prost::Name for Error { "/rerun.cloud.v1alpha1.Error".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DataSource { /// Where is the data for this data source stored (e.g. s3://bucket/file or file:///path/to/file)? #[prost(string, optional, tag = "1")] @@ -95,7 +95,7 @@ impl ::prost::Name for RegisterWithDatasetRequest { "/rerun.cloud.v1alpha1.RegisterWithDatasetRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct RegisterWithDatasetResponse { #[prost(message, optional, tag = "1")] pub data: ::core::option::Option, @@ -110,7 +110,7 @@ impl ::prost::Name for RegisterWithDatasetResponse { "/rerun.cloud.v1alpha1.RegisterWithDatasetResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WriteChunksRequest { #[prost(message, optional, tag = "1")] pub chunk: ::core::option::Option, @@ -125,7 +125,7 @@ impl ::prost::Name for WriteChunksRequest { "/rerun.cloud.v1alpha1.WriteChunksRequest".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct WriteChunksResponse {} impl ::prost::Name for WriteChunksResponse { const NAME: &'static str = "WriteChunksResponse"; @@ -137,7 +137,7 @@ impl ::prost::Name for WriteChunksResponse { "/rerun.cloud.v1alpha1.WriteChunksResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetPartitionTableSchemaRequest { #[prost(message, optional, tag = "1")] pub dataset_id: ::core::option::Option, @@ -152,7 +152,7 @@ impl ::prost::Name for GetPartitionTableSchemaRequest { "/rerun.cloud.v1alpha1.GetPartitionTableSchemaRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetPartitionTableSchemaResponse { #[prost(message, optional, tag = "1")] pub schema: ::core::option::Option, @@ -184,7 +184,7 @@ impl ::prost::Name for ScanPartitionTableRequest { "/rerun.cloud.v1alpha1.ScanPartitionTableRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ScanPartitionTableResponse { /// Partitions metadata as arrow RecordBatch #[prost(message, optional, tag = "1")] @@ -200,7 +200,7 @@ impl ::prost::Name for ScanPartitionTableResponse { "/rerun.cloud.v1alpha1.ScanPartitionTableResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetDatasetSchemaRequest { #[prost(message, optional, tag = "1")] pub dataset_id: ::core::option::Option, @@ -215,7 +215,7 @@ impl ::prost::Name for GetDatasetSchemaRequest { "/rerun.cloud.v1alpha1.GetDatasetSchemaRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetDatasetSchemaResponse { #[prost(message, optional, tag = "1")] pub schema: ::core::option::Option, @@ -261,7 +261,7 @@ impl ::prost::Name for CreateIndexRequest { "/rerun.cloud.v1alpha1.CreateIndexRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CreateIndexResponse { #[prost(message, optional, tag = "1")] pub data: ::core::option::Option, @@ -276,7 +276,7 @@ impl ::prost::Name for CreateIndexResponse { "/rerun.cloud.v1alpha1.CreateIndexResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReIndexRequest { #[prost(message, optional, tag = "1")] pub dataset_id: ::core::option::Option, @@ -291,7 +291,7 @@ impl ::prost::Name for ReIndexRequest { "/rerun.cloud.v1alpha1.ReIndexRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReIndexResponse { #[prost(message, optional, tag = "1")] pub data: ::core::option::Option, @@ -306,7 +306,7 @@ impl ::prost::Name for ReIndexResponse { "/rerun.cloud.v1alpha1.ReIndexResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct IndexConfig { /// what kind of index do we want to create and what are its index specific properties. #[prost(message, optional, tag = "1")] @@ -331,7 +331,7 @@ impl ::prost::Name for IndexConfig { } } /// used to define which column we want to index -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct IndexColumn { /// The path of the entity. #[prost(message, optional, tag = "1")] @@ -350,14 +350,14 @@ impl ::prost::Name for IndexColumn { "/rerun.cloud.v1alpha1.IndexColumn".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct IndexProperties { #[prost(oneof = "index_properties::Props", tags = "1, 2, 3")] pub props: ::core::option::Option, } /// Nested message and enum types in `IndexProperties`. pub mod index_properties { - #[derive(Clone, PartialEq, ::prost::Oneof)] + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] pub enum Props { #[prost(message, tag = "1")] Inverted(super::InvertedIndex), @@ -377,7 +377,7 @@ impl ::prost::Name for IndexProperties { "/rerun.cloud.v1alpha1.IndexProperties".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct InvertedIndex { #[prost(bool, optional, tag = "1")] pub store_position: ::core::option::Option, @@ -395,7 +395,7 @@ impl ::prost::Name for InvertedIndex { "/rerun.cloud.v1alpha1.InvertedIndex".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct VectorIvfPqIndex { #[prost(uint32, optional, tag = "1")] pub num_partitions: ::core::option::Option, @@ -415,7 +415,7 @@ impl ::prost::Name for VectorIvfPqIndex { } } /// TODO(zehiko) add properties as needed -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct BTreeIndex {} impl ::prost::Name for BTreeIndex { const NAME: &'static str = "BTreeIndex"; @@ -457,7 +457,7 @@ impl ::prost::Name for SearchDatasetRequest { "/rerun.cloud.v1alpha1.SearchDatasetRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SearchDatasetResponse { /// Chunks as arrow RecordBatch #[prost(message, optional, tag = "1")] @@ -473,7 +473,7 @@ impl ::prost::Name for SearchDatasetResponse { "/rerun.cloud.v1alpha1.SearchDatasetResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct IndexQueryProperties { /// specific index query properties based on the index type #[prost(oneof = "index_query_properties::Props", tags = "1, 2, 3")] @@ -482,7 +482,7 @@ pub struct IndexQueryProperties { /// Nested message and enum types in `IndexQueryProperties`. pub mod index_query_properties { /// specific index query properties based on the index type - #[derive(Clone, Copy, PartialEq, ::prost::Oneof)] + #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)] pub enum Props { #[prost(message, tag = "1")] Inverted(super::InvertedIndexQuery), @@ -503,7 +503,7 @@ impl ::prost::Name for IndexQueryProperties { } } /// TODO(zehiko) add properties as needed -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct InvertedIndexQuery {} impl ::prost::Name for InvertedIndexQuery { const NAME: &'static str = "InvertedIndexQuery"; @@ -515,7 +515,7 @@ impl ::prost::Name for InvertedIndexQuery { "/rerun.cloud.v1alpha1.InvertedIndexQuery".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct VectorIndexQuery { #[prost(uint32, optional, tag = "1")] pub top_k: ::core::option::Option, @@ -531,7 +531,7 @@ impl ::prost::Name for VectorIndexQuery { } } /// TODO(zehiko) add properties as needed -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct BTreeIndexQuery {} impl ::prost::Name for BTreeIndexQuery { const NAME: &'static str = "BTreeIndexQuery"; @@ -606,7 +606,7 @@ impl ::prost::Name for QueryDatasetRequest { "/rerun.cloud.v1alpha1.QueryDatasetRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct QueryDatasetResponse { #[prost(message, optional, tag = "1")] pub data: ::core::option::Option, @@ -621,7 +621,7 @@ impl ::prost::Name for QueryDatasetResponse { "/rerun.cloud.v1alpha1.QueryDatasetResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct Query { /// If specified, will perform a latest-at query with the given parameters. /// @@ -670,7 +670,7 @@ impl ::prost::Name for Query { /// A chunk-level latest-at query, aka `LatestAtRelevantChunks`. /// /// This has the exact same semantics as the query of the same name on our `ChunkStore`. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct QueryLatestAt { /// Which index column should we perform the query on? E.g. `log_time`. /// @@ -696,7 +696,7 @@ impl ::prost::Name for QueryLatestAt { /// / A chunk-level range query, aka `RangeRelevantChunks`. /// /// This has the exact same semantics as the query of the same name on our `ChunkStore`. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct QueryRange { /// Which index column should we perform the query on? E.g. `log_time`. #[prost(message, optional, tag = "1")] @@ -830,7 +830,7 @@ impl ::prost::Name for FetchChunksResponse { "/rerun.cloud.v1alpha1.FetchChunksResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetTableSchemaRequest { #[prost(message, optional, tag = "1")] pub table_id: ::core::option::Option, @@ -845,7 +845,7 @@ impl ::prost::Name for GetTableSchemaRequest { "/rerun.cloud.v1alpha1.GetTableSchemaRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetTableSchemaResponse { #[prost(message, optional, tag = "1")] pub schema: ::core::option::Option, @@ -860,7 +860,7 @@ impl ::prost::Name for GetTableSchemaResponse { "/rerun.cloud.v1alpha1.GetTableSchemaResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ScanTableRequest { /// TODO(jleibs): support ScanParameters iff we can plumb them into Datafusion TableProvider /// Otherwise, just wait for Arrow Flight @@ -878,7 +878,7 @@ impl ::prost::Name for ScanTableRequest { "/rerun.cloud.v1alpha1.ScanTableRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ScanTableResponse { #[prost(message, optional, tag = "1")] pub dataframe_part: ::core::option::Option, @@ -893,7 +893,7 @@ impl ::prost::Name for ScanTableResponse { "/rerun.cloud.v1alpha1.ScanTableResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct DoMaintenanceRequest { #[prost(message, optional, tag = "1")] pub dataset_id: ::core::option::Option, @@ -933,7 +933,7 @@ impl ::prost::Name for DoMaintenanceRequest { "/rerun.cloud.v1alpha1.DoMaintenanceRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DoMaintenanceResponse { #[prost(string, tag = "1")] pub report: ::prost::alloc::string::String, @@ -949,7 +949,7 @@ impl ::prost::Name for DoMaintenanceResponse { } } /// A task is a unit of work that can be submitted to the system -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct Task { /// Unique identifier for the task #[prost(message, optional, tag = "1")] @@ -989,7 +989,7 @@ impl ::prost::Name for SubmitTasksRequest { } /// `SubmitTaskResponse` contains, for each submitted task /// its submission outcome, encoded as a `RecordBatch` -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SubmitTasksResponse { #[prost(message, optional, tag = "1")] pub data: ::core::option::Option, @@ -1023,7 +1023,7 @@ impl ::prost::Name for QueryTasksRequest { } /// `QueryTasksResponse` is the response message for querying tasks status /// encoded as a record batch -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct QueryTasksResponse { #[prost(message, optional, tag = "1")] pub data: ::core::option::Option, @@ -1062,7 +1062,7 @@ impl ::prost::Name for QueryTasksOnCompletionRequest { } /// `QueryTaskOnCompletionResponse` is the response message for querying tasks status /// encoded as a record batch. This is a copy of `QueryTasksResponse`. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct QueryTasksOnCompletionResponse { #[prost(message, optional, tag = "1")] pub data: ::core::option::Option, @@ -1078,7 +1078,7 @@ impl ::prost::Name for QueryTasksOnCompletionResponse { } } /// `FetchTaskOutputRequest` is the request message for fetching task output -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct FetchTaskOutputRequest { /// Unique identifier for the task #[prost(message, optional, tag = "1")] @@ -1095,7 +1095,7 @@ impl ::prost::Name for FetchTaskOutputRequest { } } /// / `FetchTaskOutputResponse` is the response message for fetching task output -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct FetchTaskOutputResponse { /// The output of the task, encoded as a record batch #[prost(message, optional, tag = "1")] @@ -1111,7 +1111,7 @@ impl ::prost::Name for FetchTaskOutputResponse { "/rerun.cloud.v1alpha1.FetchTaskOutputResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct FindEntriesRequest { #[prost(message, optional, tag = "1")] pub filter: ::core::option::Option, @@ -1141,7 +1141,7 @@ impl ::prost::Name for FindEntriesResponse { "/rerun.cloud.v1alpha1.FindEntriesResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct DeleteEntryRequest { #[prost(message, optional, tag = "1")] pub id: ::core::option::Option, @@ -1156,7 +1156,7 @@ impl ::prost::Name for DeleteEntryRequest { "/rerun.cloud.v1alpha1.DeleteEntryRequest".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct DeleteEntryResponse {} impl ::prost::Name for DeleteEntryResponse { const NAME: &'static str = "DeleteEntryResponse"; @@ -1168,7 +1168,7 @@ impl ::prost::Name for DeleteEntryResponse { "/rerun.cloud.v1alpha1.DeleteEntryResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct UpdateEntryRequest { /// The entry to modify. #[prost(message, optional, tag = "1")] @@ -1187,7 +1187,7 @@ impl ::prost::Name for UpdateEntryRequest { "/rerun.cloud.v1alpha1.UpdateEntryRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct UpdateEntryResponse { /// The updated entry details #[prost(message, optional, tag = "1")] @@ -1203,7 +1203,7 @@ impl ::prost::Name for UpdateEntryResponse { "/rerun.cloud.v1alpha1.UpdateEntryResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CreateDatasetEntryRequest { /// Name of the dataset entry to create. /// @@ -1225,7 +1225,7 @@ impl ::prost::Name for CreateDatasetEntryRequest { "/rerun.cloud.v1alpha1.CreateDatasetEntryRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CreateDatasetEntryResponse { #[prost(message, optional, tag = "1")] pub dataset: ::core::option::Option, @@ -1240,7 +1240,7 @@ impl ::prost::Name for CreateDatasetEntryResponse { "/rerun.cloud.v1alpha1.CreateDatasetEntryResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadDatasetEntryRequest { #[prost(message, optional, tag = "1")] pub id: ::core::option::Option, @@ -1255,7 +1255,7 @@ impl ::prost::Name for ReadDatasetEntryRequest { "/rerun.cloud.v1alpha1.ReadDatasetEntryRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadDatasetEntryResponse { #[prost(message, optional, tag = "1")] pub dataset: ::core::option::Option, @@ -1270,7 +1270,7 @@ impl ::prost::Name for ReadDatasetEntryResponse { "/rerun.cloud.v1alpha1.ReadDatasetEntryResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct UpdateDatasetEntryRequest { /// The dataset to modify. #[prost(message, optional, tag = "1")] @@ -1289,7 +1289,7 @@ impl ::prost::Name for UpdateDatasetEntryRequest { "/rerun.cloud.v1alpha1.UpdateDatasetEntryRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct UpdateDatasetEntryResponse { /// The updated dataset entry #[prost(message, optional, tag = "1")] @@ -1305,7 +1305,7 @@ impl ::prost::Name for UpdateDatasetEntryResponse { "/rerun.cloud.v1alpha1.UpdateDatasetEntryResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct RegisterTableRequest { /// Name of the table entry to create. /// @@ -1330,7 +1330,7 @@ impl ::prost::Name for RegisterTableRequest { "/rerun.cloud.v1alpha1.RegisterTableRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct RegisterTableResponse { /// Details about the table that was created and registered. #[prost(message, optional, tag = "1")] @@ -1346,7 +1346,7 @@ impl ::prost::Name for RegisterTableResponse { "/rerun.cloud.v1alpha1.RegisterTableResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadTableEntryRequest { #[prost(message, optional, tag = "1")] pub id: ::core::option::Option, @@ -1361,7 +1361,7 @@ impl ::prost::Name for ReadTableEntryRequest { "/rerun.cloud.v1alpha1.ReadTableEntryRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadTableEntryResponse { #[prost(message, optional, tag = "1")] pub table: ::core::option::Option, @@ -1376,7 +1376,7 @@ impl ::prost::Name for ReadTableEntryResponse { "/rerun.cloud.v1alpha1.ReadTableEntryResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct EntryFilter { #[prost(message, optional, tag = "1")] pub id: ::core::option::Option, @@ -1396,7 +1396,7 @@ impl ::prost::Name for EntryFilter { } } /// Minimal info about an Entry for high-level catalog summary -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct EntryDetails { /// The EntryId is immutable #[prost(message, optional, tag = "1")] @@ -1423,7 +1423,7 @@ impl ::prost::Name for EntryDetails { } } /// Updatable fields of an Entry -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct EntryDetailsUpdate { /// The name of this entry. #[prost(string, optional, tag = "2")] @@ -1439,7 +1439,7 @@ impl ::prost::Name for EntryDetailsUpdate { "/rerun.cloud.v1alpha1.EntryDetailsUpdate".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DatasetDetails { /// The blueprint dataset associated with this dataset (if any). #[prost(message, optional, tag = "3")] @@ -1458,7 +1458,7 @@ impl ::prost::Name for DatasetDetails { "/rerun.cloud.v1alpha1.DatasetDetails".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DatasetEntry { #[prost(message, optional, tag = "1")] pub details: ::core::option::Option, @@ -1479,7 +1479,7 @@ impl ::prost::Name for DatasetEntry { "/rerun.cloud.v1alpha1.DatasetEntry".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct TableEntry { #[prost(message, optional, tag = "1")] pub details: ::core::option::Option, @@ -1497,7 +1497,7 @@ impl ::prost::Name for TableEntry { "/rerun.cloud.v1alpha1.TableEntry".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct SystemTable { #[prost(enumeration = "SystemTableKind", tag = "1")] pub kind: i32, @@ -1513,7 +1513,7 @@ impl ::prost::Name for SystemTable { } } /// A foreign table stored as a Lance table. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct LanceTable { /// The URL of the Lance table. #[prost(string, tag = "1")] @@ -1787,7 +1787,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/Version", ); @@ -1806,7 +1806,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/FindEntries", ); @@ -1825,7 +1825,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/DeleteEntry", ); @@ -1844,7 +1844,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/UpdateEntry", ); @@ -1863,7 +1863,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/CreateDatasetEntry", ); @@ -1882,7 +1882,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/ReadDatasetEntry", ); @@ -1901,7 +1901,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/UpdateDatasetEntry", ); @@ -1920,7 +1920,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/ReadTableEntry", ); @@ -1940,7 +1940,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/RegisterWithDataset", ); @@ -1964,7 +1964,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/WriteChunks", ); @@ -1989,7 +1989,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/GetPartitionTableSchema", ); @@ -2013,7 +2013,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/ScanPartitionTable", ); @@ -2036,7 +2036,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/GetDatasetSchema", ); @@ -2056,7 +2056,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/CreateIndex", ); @@ -2075,7 +2075,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/ReIndex", ); @@ -2097,7 +2097,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/SearchDataset", ); @@ -2132,7 +2132,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/QueryDataset", ); @@ -2161,7 +2161,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/GetChunks", ); @@ -2187,7 +2187,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/FetchChunks", ); @@ -2207,7 +2207,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/RegisterTable", ); @@ -2226,7 +2226,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/GetTableSchema", ); @@ -2247,7 +2247,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/ScanTable", ); @@ -2267,7 +2267,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/QueryTasks", ); @@ -2287,7 +2287,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/FetchTaskOutput", ); @@ -2309,7 +2309,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/QueryTasksOnCompletion", ); @@ -2329,7 +2329,7 @@ pub mod rerun_cloud_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.cloud.v1alpha1.RerunCloudService/DoMaintenance", ); @@ -2648,7 +2648,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = VersionSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2690,7 +2690,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = FindEntriesSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2732,7 +2732,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = DeleteEntrySvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2774,7 +2774,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = UpdateEntrySvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2817,7 +2817,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = CreateDatasetEntrySvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2859,7 +2859,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = ReadDatasetEntrySvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2902,7 +2902,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = UpdateDatasetEntrySvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2944,7 +2944,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = ReadTableEntrySvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -2987,7 +2987,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = RegisterWithDatasetSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3029,7 +3029,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = WriteChunksSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3074,7 +3074,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = GetPartitionTableSchemaSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3119,7 +3119,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = ScanPartitionTableSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3161,7 +3161,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = GetDatasetSchemaSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3203,7 +3203,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = CreateIndexSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3242,7 +3242,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = ReIndexSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3286,7 +3286,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = SearchDatasetSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3330,7 +3330,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = QueryDatasetSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3374,7 +3374,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = GetChunksSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3418,7 +3418,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = FetchChunksSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3460,7 +3460,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = RegisterTableSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3502,7 +3502,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = GetTableSchemaSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3546,7 +3546,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = ScanTableSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3587,7 +3587,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = QueryTasksSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3629,7 +3629,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = FetchTaskOutputSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3674,7 +3674,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = QueryTasksOnCompletionSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -3716,7 +3716,7 @@ pub mod rerun_cloud_service_server { let inner = self.inner.clone(); let fut = async move { let method = DoMaintenanceSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, diff --git a/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.ext.rs b/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.ext.rs index 0a3ff9891ee7..ebdd0f754aea 100644 --- a/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.ext.rs +++ b/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.ext.rs @@ -1,10 +1,7 @@ -use std::hash::Hasher; - use arrow::{datatypes::Schema as ArrowSchema, error::ArrowError}; use re_log_types::{RecordingId, StoreKind, TableId, external::re_types_core::ComponentDescriptor}; -use crate::v1alpha1::rerun_common_v1alpha1::TaskId; use crate::{TypeConversionError, invalid_field, missing_field}; // --- Arrow --- @@ -656,16 +653,6 @@ impl TryFrom for ComponentDescript // --- -impl Eq for TaskId {} - -impl std::hash::Hash for TaskId { - fn hash(&self, state: &mut H) { - self.id.as_str().hash(state) - } -} - -// --- - impl From for crate::common::v1alpha1::BuildInfo { fn from(build_info: re_build_info::BuildInfo) -> Self { Self { diff --git a/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.rs b/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.rs index a66e4b2bf6ee..6ac81fdc9c22 100644 --- a/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.rs +++ b/crates/store/re_protos/src/v1alpha1/rerun.common.v1alpha1.rs @@ -2,7 +2,7 @@ /// RerunChunk is arrow IPC encoded RecordBatch that has /// rerun-specific semantic constraints and can be directly /// converted to a Rerun Chunk (`re_chunk::Chunk`) -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct RerunChunk { /// encoder version used to encode the data #[prost(enumeration = "EncoderVersion", tag = "1")] @@ -23,7 +23,7 @@ impl ::prost::Name for RerunChunk { } } /// uniquely identifies a table -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct TableId { #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, @@ -39,7 +39,7 @@ impl ::prost::Name for TableId { } } /// A recording can have multiple timelines, each is identified by a name, for example `log_tick`, `log_time`, etc. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct Timeline { #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, @@ -56,7 +56,7 @@ impl ::prost::Name for Timeline { } /// A time range between start and end time points. Each 64 bit number can represent different time point data /// depending on the timeline it is associated with. Time range is inclusive for both start and end time points. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct TimeRange { #[prost(int64, tag = "1")] pub start: i64, @@ -74,7 +74,7 @@ impl ::prost::Name for TimeRange { } } /// arrow IPC serialized schema -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct Schema { #[prost(bytes = "bytes", optional, tag = "1")] pub arrow_schema: ::core::option::Option<::prost::bytes::Bytes>, @@ -89,7 +89,7 @@ impl ::prost::Name for Schema { "/rerun.common.v1alpha1.Schema".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct IndexColumnSelector { /// TODO(zehiko) we need to add support for other types of index selectors #[prost(message, optional, tag = "1")] @@ -105,7 +105,7 @@ impl ::prost::Name for IndexColumnSelector { "/rerun.common.v1alpha1.IndexColumnSelector".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct IndexRange { /// TODO(zehiko) support for other ranges for other index selectors #[prost(message, optional, tag = "1")] @@ -123,7 +123,7 @@ impl ::prost::Name for IndexRange { } /// The unique identifier of an entity, e.g. `camera/3/points` /// See <> for more on entity paths. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct EntityPath { #[prost(string, tag = "1")] pub path: ::prost::alloc::string::String, @@ -138,7 +138,7 @@ impl ::prost::Name for EntityPath { "/rerun.common.v1alpha1.EntityPath".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ApplicationId { #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, @@ -153,7 +153,7 @@ impl ::prost::Name for ApplicationId { "/rerun.common.v1alpha1.ApplicationId".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct StoreId { /// The kind of the store. #[prost(enumeration = "StoreKind", tag = "1")] @@ -176,7 +176,7 @@ impl ::prost::Name for StoreId { "/rerun.common.v1alpha1.StoreId".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct Tuid { /// Approximate nanoseconds since epoch. #[prost(fixed64, optional, tag = "1")] @@ -196,7 +196,7 @@ impl ::prost::Name for Tuid { "/rerun.common.v1alpha1.Tuid".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct EntryId { #[prost(message, optional, tag = "1")] pub id: ::core::option::Option, @@ -212,7 +212,7 @@ impl ::prost::Name for EntryId { } } /// Entry point for all ManifestRegistryService APIs -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DatasetHandle { /// Unique entry identifier (for debug purposes) #[prost(message, optional, tag = "1")] @@ -235,7 +235,7 @@ impl ::prost::Name for DatasetHandle { } } /// DataframePart is arrow IPC encoded RecordBatch -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DataframePart { /// encoder version used to encode the data #[prost(enumeration = "EncoderVersion", tag = "1")] @@ -310,7 +310,7 @@ impl ::prost::Name for ScanParameters { "/rerun.common.v1alpha1.ScanParameters".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ScanParametersOrderClause { #[prost(bool, tag = "1")] pub descending: bool, @@ -332,7 +332,7 @@ impl ::prost::Name for ScanParametersOrderClause { /// Unique identifier for a partition. Can be user defined /// which means it can be of any type. For simplicity we start /// with a string, but we will probably revisit this. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct PartitionId { #[prost(string, optional, tag = "1")] pub id: ::core::option::Option<::prost::alloc::string::String>, @@ -347,7 +347,7 @@ impl ::prost::Name for PartitionId { "/rerun.common.v1alpha1.PartitionId".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ComponentDescriptor { /// Optional name of the `Archetype` associated with this data. #[prost(string, optional, tag = "4")] @@ -371,7 +371,7 @@ impl ::prost::Name for ComponentDescriptor { } /// Unique identifier of a task submitted in the redap /// tasks subsystem -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct TaskId { #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, @@ -387,7 +387,7 @@ impl ::prost::Name for TaskId { } } /// Mirrors `re_build_info::BuildInfo`. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct BuildInfo { /// `CARGO_PKG_NAME`. #[prost(string, optional, tag = "1")] @@ -434,7 +434,7 @@ impl ::prost::Name for BuildInfo { } } /// Mirrors `re_build_info::CrateVersion`. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SemanticVersion { #[prost(fixed32, optional, tag = "1")] pub major: ::core::option::Option, @@ -447,7 +447,7 @@ pub struct SemanticVersion { } /// Nested message and enum types in `SemanticVersion`. pub mod semantic_version { - #[derive(Clone, PartialEq, ::prost::Oneof)] + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] pub enum Meta { #[prost(fixed32, tag = "4")] Rc(u32), @@ -468,7 +468,7 @@ impl ::prost::Name for SemanticVersion { } } /// Mirrors `re_build_info::DevAlpha`. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DevAlpha { #[prost(fixed32, optional, tag = "1")] pub alpha: ::core::option::Option, diff --git a/crates/store/re_protos/src/v1alpha1/rerun.log_msg.v1alpha1.rs b/crates/store/re_protos/src/v1alpha1/rerun.log_msg.v1alpha1.rs index 33261b3260ed..8274ccb75dbd 100644 --- a/crates/store/re_protos/src/v1alpha1/rerun.log_msg.v1alpha1.rs +++ b/crates/store/re_protos/src/v1alpha1/rerun.log_msg.v1alpha1.rs @@ -1,13 +1,13 @@ // This file is @generated by prost-build. /// TODO(#8631): Remove `LogMsg` -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct LogMsg { #[prost(oneof = "log_msg::Msg", tags = "1, 2, 3")] pub msg: ::core::option::Option, } /// Nested message and enum types in `LogMsg`. pub mod log_msg { - #[derive(Clone, PartialEq, ::prost::Oneof)] + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] pub enum Msg { /// A message that contains a new store info. #[prost(message, tag = "1")] @@ -31,7 +31,7 @@ impl ::prost::Name for LogMsg { } } /// Corresponds to `LogMsg::SetStoreInfo`. Used to identify a recording. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SetStoreInfo { /// A time-based UID that is used to determine how a `StoreInfo` fits in the global ordering of events. #[prost(message, optional, tag = "1")] @@ -51,7 +51,7 @@ impl ::prost::Name for SetStoreInfo { } } /// Corresponds to `LogMsg::ArrowMsg`. Used to transmit actual data. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ArrowMsg { /// The ID of the store that this message is for. #[prost(message, optional, tag = "1")] @@ -86,7 +86,7 @@ impl ::prost::Name for ArrowMsg { /// Used for activating a blueprint once it has been fully transmitted, /// because showing a blueprint before it is fully transmitted can lead to /// a confusing user experience, or inconsistent results due to heuristics. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct BlueprintActivationCommand { /// The ID of the blueprint to activate. #[prost(message, optional, tag = "1")] @@ -109,7 +109,7 @@ impl ::prost::Name for BlueprintActivationCommand { } } /// Information about a recording or blueprint. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct StoreInfo { /// User-chosen name of the application doing the logging. /// @@ -139,7 +139,7 @@ impl ::prost::Name for StoreInfo { } } /// The source of a recording or blueprint. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct StoreSource { /// Determines what is encoded in `extra`. #[prost(enumeration = "StoreSourceKind", tag = "1")] @@ -161,7 +161,7 @@ impl ::prost::Name for StoreSource { /// A newtype for `StoreSource` payload. /// /// This exists to that we can implement conversions on the newtype for convenience. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct StoreSourceExtra { #[prost(bytes = "bytes", tag = "1")] pub payload: ::prost::bytes::Bytes, @@ -177,7 +177,7 @@ impl ::prost::Name for StoreSourceExtra { } } /// Version of the Python SDK that created the recording. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct PythonVersion { #[prost(int32, tag = "1")] pub major: i32, @@ -199,7 +199,7 @@ impl ::prost::Name for PythonVersion { } } /// Information about the Rust SDK that created the recording. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CrateInfo { /// Version of the Rust compiler used to compile the SDK. #[prost(string, tag = "1")] @@ -219,7 +219,7 @@ impl ::prost::Name for CrateInfo { } } /// A recording which came from a file. -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct FileSource { #[prost(enumeration = "FileSourceKind", tag = "1")] pub kind: i32, @@ -234,7 +234,7 @@ impl ::prost::Name for FileSource { "/rerun.log_msg.v1alpha1.FileSource".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct StoreVersion { /// Crate version encoded using our custom scheme. /// diff --git a/crates/store/re_protos/src/v1alpha1/rerun.manifest_registry.v1alpha1.rs b/crates/store/re_protos/src/v1alpha1/rerun.manifest_registry.v1alpha1.rs new file mode 100644 index 000000000000..fa0454b4ca51 --- /dev/null +++ b/crates/store/re_protos/src/v1alpha1/rerun.manifest_registry.v1alpha1.rs @@ -0,0 +1,2356 @@ +// This file is @generated by prost-build. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DataSource { + /// Where is the data for this data source stored (e.g. s3://bucket/file or file:///path/to/file)? + #[prost(string, optional, tag = "1")] + pub storage_url: ::core::option::Option<::prost::alloc::string::String>, + /// / Which Partition Layer should this data source be registered to? + /// / + /// / Defaults to `base` if unspecified. + #[prost(string, optional, tag = "3")] + pub layer: ::core::option::Option<::prost::alloc::string::String>, + /// What kind of data is it (e.g. rrd, mcap, Lance, etc)? + #[prost(enumeration = "DataSourceKind", tag = "2")] + pub typ: i32, +} +impl ::prost::Name for DataSource { + const NAME: &'static str = "DataSource"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.DataSource".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.DataSource".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisterWithDatasetRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + #[prost(message, repeated, tag = "2")] + pub data_sources: ::prost::alloc::vec::Vec, + #[prost( + enumeration = "super::super::common::v1alpha1::IfDuplicateBehavior", + tag = "3" + )] + pub on_duplicate: i32, +} +impl ::prost::Name for RegisterWithDatasetRequest { + const NAME: &'static str = "RegisterWithDatasetRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.RegisterWithDatasetRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.RegisterWithDatasetRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RegisterWithDatasetResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for RegisterWithDatasetResponse { + const NAME: &'static str = "RegisterWithDatasetResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.RegisterWithDatasetResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.RegisterWithDatasetResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WriteChunksRequest { + #[prost(message, optional, tag = "1")] + pub chunk: ::core::option::Option, +} +impl ::prost::Name for WriteChunksRequest { + const NAME: &'static str = "WriteChunksRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.WriteChunksRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.WriteChunksRequest".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WriteChunksResponse {} +impl ::prost::Name for WriteChunksResponse { + const NAME: &'static str = "WriteChunksResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.WriteChunksResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.WriteChunksResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetPartitionTableSchemaRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, +} +impl ::prost::Name for GetPartitionTableSchemaRequest { + const NAME: &'static str = "GetPartitionTableSchemaRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.GetPartitionTableSchemaRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.GetPartitionTableSchemaRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetPartitionTableSchemaResponse { + #[prost(message, optional, tag = "1")] + pub schema: ::core::option::Option, +} +impl ::prost::Name for GetPartitionTableSchemaResponse { + const NAME: &'static str = "GetPartitionTableSchemaResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.GetPartitionTableSchemaResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.GetPartitionTableSchemaResponse".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScanPartitionTableRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub scan_parameters: ::core::option::Option, +} +impl ::prost::Name for ScanPartitionTableRequest { + const NAME: &'static str = "ScanPartitionTableRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.ScanPartitionTableRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.ScanPartitionTableRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ScanPartitionTableResponse { + /// Partitions metadata as arrow RecordBatch + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for ScanPartitionTableResponse { + const NAME: &'static str = "ScanPartitionTableResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.ScanPartitionTableResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.ScanPartitionTableResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetDatasetSchemaRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, +} +impl ::prost::Name for GetDatasetSchemaRequest { + const NAME: &'static str = "GetDatasetSchemaRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.GetDatasetSchemaRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.GetDatasetSchemaRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetDatasetSchemaResponse { + #[prost(message, optional, tag = "1")] + pub schema: ::core::option::Option, +} +impl ::prost::Name for GetDatasetSchemaResponse { + const NAME: &'static str = "GetDatasetSchemaResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.GetDatasetSchemaResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.GetDatasetSchemaResponse".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateIndexRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + /// List of specific partitions that will be indexed (all if left empty). + #[prost(message, repeated, tag = "2")] + pub partition_ids: ::prost::alloc::vec::Vec, + /// List of specific partition layers that will be indexed (all if left empty). + /// + /// If non-empty, this must match the length of `partition_ids`. + #[prost(string, repeated, tag = "5")] + pub partition_layers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, optional, tag = "3")] + pub config: ::core::option::Option, + /// Specify behavior when index for a partition was already created. + #[prost( + enumeration = "super::super::common::v1alpha1::IfDuplicateBehavior", + tag = "4" + )] + pub on_duplicate: i32, +} +impl ::prost::Name for CreateIndexRequest { + const NAME: &'static str = "CreateIndexRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.CreateIndexRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.CreateIndexRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct IndexConfig { + /// what kind of index do we want to create and what are its index specific properties. + #[prost(message, optional, tag = "1")] + pub properties: ::core::option::Option, + /// Component / column we want to index. + #[prost(message, optional, tag = "2")] + pub column: ::core::option::Option, + /// What is the filter index i.e. timeline for which we will query the timepoints. + /// + /// TODO(zehiko) this might go away and we might just index across all the timelines + #[prost(message, optional, tag = "3")] + pub time_index: ::core::option::Option, +} +impl ::prost::Name for IndexConfig { + const NAME: &'static str = "IndexConfig"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.IndexConfig".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.IndexConfig".into() + } +} +/// used to define which column we want to index +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct IndexColumn { + /// The path of the entity. + #[prost(message, optional, tag = "1")] + pub entity_path: ::core::option::Option, + /// Component details + #[prost(message, optional, tag = "2")] + pub component: ::core::option::Option, +} +impl ::prost::Name for IndexColumn { + const NAME: &'static str = "IndexColumn"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.IndexColumn".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.IndexColumn".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct IndexProperties { + #[prost(oneof = "index_properties::Props", tags = "1, 2, 3")] + pub props: ::core::option::Option, +} +/// Nested message and enum types in `IndexProperties`. +pub mod index_properties { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Props { + #[prost(message, tag = "1")] + Inverted(super::InvertedIndex), + #[prost(message, tag = "2")] + Vector(super::VectorIvfPqIndex), + #[prost(message, tag = "3")] + Btree(super::BTreeIndex), + } +} +impl ::prost::Name for IndexProperties { + const NAME: &'static str = "IndexProperties"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.IndexProperties".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.IndexProperties".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct InvertedIndex { + #[prost(bool, optional, tag = "1")] + pub store_position: ::core::option::Option, + /// TODO(zehiko) add other properties as needed + #[prost(string, optional, tag = "2")] + pub base_tokenizer: ::core::option::Option<::prost::alloc::string::String>, +} +impl ::prost::Name for InvertedIndex { + const NAME: &'static str = "InvertedIndex"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.InvertedIndex".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.InvertedIndex".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct VectorIvfPqIndex { + #[prost(uint32, optional, tag = "1")] + pub num_partitions: ::core::option::Option, + #[prost(uint32, optional, tag = "2")] + pub num_sub_vectors: ::core::option::Option, + #[prost(enumeration = "VectorDistanceMetric", tag = "3")] + pub distance_metrics: i32, +} +impl ::prost::Name for VectorIvfPqIndex { + const NAME: &'static str = "VectorIvfPqIndex"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.VectorIvfPqIndex".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.VectorIvfPqIndex".into() + } +} +/// TODO(zehiko) add properties as needed +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct BTreeIndex {} +impl ::prost::Name for BTreeIndex { + const NAME: &'static str = "BTreeIndex"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.BTreeIndex".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.BTreeIndex".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CreateIndexResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for CreateIndexResponse { + const NAME: &'static str = "CreateIndexResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.CreateIndexResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.CreateIndexResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReIndexRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, +} +impl ::prost::Name for ReIndexRequest { + const NAME: &'static str = "ReIndexRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.ReIndexRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.ReIndexRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReIndexResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for ReIndexResponse { + const NAME: &'static str = "ReIndexResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.ReIndexResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.ReIndexResponse".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SearchDatasetRequest { + /// Dataset for which we want to search index + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + /// Index column that is queried + #[prost(message, optional, tag = "2")] + pub column: ::core::option::Option, + /// Query data - type of data is index specific. Caller must ensure + /// to provide the right type. For vector search this should + /// be a vector of appropriate size, for inverted index this should be a string. + /// Query data is represented as a unit (single row) RecordBatch with 1 column. + #[prost(message, optional, tag = "3")] + pub query: ::core::option::Option, + /// Index type specific properties + #[prost(message, optional, tag = "4")] + pub properties: ::core::option::Option, + /// Scan parameters + #[prost(message, optional, tag = "5")] + pub scan_parameters: ::core::option::Option, +} +impl ::prost::Name for SearchDatasetRequest { + const NAME: &'static str = "SearchDatasetRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.SearchDatasetRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.SearchDatasetRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SearchDatasetResponse { + /// Chunks as arrow RecordBatch + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for SearchDatasetResponse { + const NAME: &'static str = "SearchDatasetResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.SearchDatasetResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.SearchDatasetResponse".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct IndexQueryProperties { + /// specific index query properties based on the index type + #[prost(oneof = "index_query_properties::Props", tags = "1, 2, 3")] + pub props: ::core::option::Option, +} +/// Nested message and enum types in `IndexQueryProperties`. +pub mod index_query_properties { + /// specific index query properties based on the index type + #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Props { + #[prost(message, tag = "1")] + Inverted(super::InvertedIndexQuery), + #[prost(message, tag = "2")] + Vector(super::VectorIndexQuery), + #[prost(message, tag = "3")] + Btree(super::BTreeIndexQuery), + } +} +impl ::prost::Name for IndexQueryProperties { + const NAME: &'static str = "IndexQueryProperties"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.IndexQueryProperties".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.IndexQueryProperties".into() + } +} +/// TODO(zehiko) add properties as needed +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct InvertedIndexQuery {} +impl ::prost::Name for InvertedIndexQuery { + const NAME: &'static str = "InvertedIndexQuery"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.InvertedIndexQuery".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.InvertedIndexQuery".into() + } +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct VectorIndexQuery { + #[prost(uint32, optional, tag = "1")] + pub top_k: ::core::option::Option, +} +impl ::prost::Name for VectorIndexQuery { + const NAME: &'static str = "VectorIndexQuery"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.VectorIndexQuery".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.VectorIndexQuery".into() + } +} +/// TODO(zehiko) add properties as needed +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct BTreeIndexQuery {} +impl ::prost::Name for BTreeIndexQuery { + const NAME: &'static str = "BTreeIndexQuery"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.BTreeIndexQuery".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.BTreeIndexQuery".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDatasetRequest { + /// Dataset client wants to query + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + /// Client can specify what partitions are queried. If left unspecified (empty list), + /// all partitions will be queried. + #[prost(message, repeated, tag = "2")] + pub partition_ids: ::prost::alloc::vec::Vec, + /// Client can specify specific chunk ids to include. If left unspecified (empty list), + /// all chunks that match other query parameters will be included. + #[prost(message, repeated, tag = "3")] + pub chunk_ids: ::prost::alloc::vec::Vec, + /// Which entity paths are we interested in? Leave empty, and set `select_all_entity_paths`, + /// in order to query all of them. + #[prost(message, repeated, tag = "4")] + pub entity_paths: ::prost::alloc::vec::Vec, + /// If set, the query will cover all existing entity paths. + /// + /// `entity_paths` must be empty, otherwise an error will be raised. + /// + /// Truth table: + /// ```text + /// select_all_entity_paths | entity_paths | result + /// ------------------------+----------------+-------- + /// false | \[\] | valid query, empty results (no entity paths selected) + /// false | \['foo', 'bar'\] | valid query, 'foo' & 'bar' selected + /// true | \[\] | valid query, all entity paths selected + /// true | \['foo', 'bar'\] | invalid query, error + /// ``` + #[prost(bool, tag = "7")] + pub select_all_entity_paths: bool, + /// Which components are we interested in? + /// + /// If left unspecified, all existing components are considered of interest. + /// + /// This will perform a basic fuzzy match on the available columns' descriptors. + /// The fuzzy logic is a simple case-sensitive `contains()` query. + /// For example, given a `log_tick__SeriesLines:width` index, all of the following + /// would match: `SeriesLines:width`, `Width`, `SeriesLines`, etc. + #[prost(string, repeated, tag = "10")] + pub fuzzy_descriptors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// If set, static data will be excluded from the results. + #[prost(bool, tag = "8")] + pub exclude_static_data: bool, + /// If set, temporal data will be excluded from the results. + #[prost(bool, tag = "9")] + pub exclude_temporal_data: bool, + /// Generic parameters that will influence the behavior of the Lance scanner. + #[prost(message, optional, tag = "5")] + pub scan_parameters: ::core::option::Option, + /// A chunk-level latest-at or range query, or both. + /// + /// This query is AND'd together with the `partition_ids` and `chunk_ids` filters above. + #[prost(message, optional, tag = "6")] + pub query: ::core::option::Option, +} +impl ::prost::Name for QueryDatasetRequest { + const NAME: &'static str = "QueryDatasetRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.QueryDatasetRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.QueryDatasetRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct QueryDatasetResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for QueryDatasetResponse { + const NAME: &'static str = "QueryDatasetResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.QueryDatasetResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.QueryDatasetResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Query { + /// If specified, will perform a latest-at query with the given parameters. + /// + /// You can combine this with a `QueryRange` in order to gather all the relevant chunks for + /// a full-fledged dataframe query (i.e. they get OR'd together). + #[prost(message, optional, tag = "1")] + pub latest_at: ::core::option::Option, + /// If specified, will perform a range query with the given parameters. + /// + /// You can combine this with a `QueryLatestAt` in order to gather all the relevant chunks for + /// a full-fledged dataframe query (i.e. they get OR'd together). + #[prost(message, optional, tag = "2")] + pub range: ::core::option::Option, + /// If true, `columns` will contain the entire schema. + #[prost(bool, tag = "3")] + pub columns_always_include_everything: bool, + /// If true, `columns` always includes `chunk_id`, + #[prost(bool, tag = "4")] + pub columns_always_include_chunk_ids: bool, + /// If true, `columns` always includes `byte_offset` and `byte_size`. + #[prost(bool, tag = "5")] + pub columns_always_include_byte_offsets: bool, + /// If true, `columns` always includes `entity_path`. + #[prost(bool, tag = "6")] + pub columns_always_include_entity_paths: bool, + /// If true, `columns` always includes all static component-level indexes. + #[prost(bool, tag = "7")] + pub columns_always_include_static_indexes: bool, + /// If true, `columns` always includes all temporal chunk-level indexes. + #[prost(bool, tag = "8")] + pub columns_always_include_global_indexes: bool, + /// If true, `columns` always includes all component-level indexes. + #[prost(bool, tag = "9")] + pub columns_always_include_component_indexes: bool, +} +impl ::prost::Name for Query { + const NAME: &'static str = "Query"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.Query".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.Query".into() + } +} +/// A chunk-level latest-at query, aka `LatestAtRelevantChunks`. +/// +/// This has the exact same semantics as the query of the same name on our `ChunkStore`. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct QueryLatestAt { + /// Which index column should we perform the query on? E.g. `log_time`. + /// + /// Leave this empty to query for static data. + #[prost(message, optional, tag = "1")] + pub index: ::core::option::Option, + /// What index value are we looking for? + /// + /// Leave this empty to query for static data. + #[prost(int64, optional, tag = "2")] + pub at: ::core::option::Option, +} +impl ::prost::Name for QueryLatestAt { + const NAME: &'static str = "QueryLatestAt"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.QueryLatestAt".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.QueryLatestAt".into() + } +} +/// / A chunk-level range query, aka `RangeRelevantChunks`. +/// +/// This has the exact same semantics as the query of the same name on our `ChunkStore`. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct QueryRange { + /// Which index column should we perform the query on? E.g. `log_time`. + #[prost(message, optional, tag = "1")] + pub index: ::core::option::Option, + /// What index range are we looking for? + #[prost(message, optional, tag = "2")] + pub index_range: ::core::option::Option, +} +impl ::prost::Name for QueryRange { + const NAME: &'static str = "QueryRange"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.QueryRange".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.QueryRange".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetChunksRequest { + /// Dataset for which we want to get chunks + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + /// Client can specify from which partitions to get chunks. If left unspecified (empty list), + /// data from all partition (that match other query parameters) will be included. + #[prost(message, repeated, tag = "2")] + pub partition_ids: ::prost::alloc::vec::Vec, + /// Client can specify chunk ids to include. If left unspecified (empty list), + /// all chunks (that match other query parameters) will be included. + #[prost(message, repeated, tag = "3")] + pub chunk_ids: ::prost::alloc::vec::Vec, + /// Which entity paths are we interested in? Leave empty, and set `select_all_entity_paths`, + /// in order to query all of them. + #[prost(message, repeated, tag = "4")] + pub entity_paths: ::prost::alloc::vec::Vec, + /// If set, the query will cover all existing entity paths. + /// + /// `entity_paths` must be empty, otherwise an error will be raised. + /// + /// Truth table: + /// ```text + /// select_all_entity_paths | entity_paths | result + /// ------------------------+----------------+-------- + /// false | \[\] | valid query, empty results (no entity paths selected) + /// false | \['foo', 'bar'\] | valid query, 'foo' & 'bar' selected + /// true | \[\] | valid query, all entity paths selected + /// true | \['foo', 'bar'\] | invalid query, error + /// ``` + #[prost(bool, tag = "6")] + pub select_all_entity_paths: bool, + /// Which components are we interested in? + /// + /// If left unspecified, all existing components are considered of interest. + /// + /// This will perform a basic fuzzy match on the available columns' descriptors. + /// The fuzzy logic is a simple case-sensitive `contains()` query. + /// For example, given a `log_tick__SeriesLines:width` index, all of the following + /// would match: `SeriesLines:width`, `Width`, `SeriesLines`, etc. + #[prost(string, repeated, tag = "9")] + pub fuzzy_descriptors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// If set, static data will be excluded from the results. + #[prost(bool, tag = "7")] + pub exclude_static_data: bool, + /// If set, temporal data will be excluded from the results. + #[prost(bool, tag = "8")] + pub exclude_temporal_data: bool, + /// A chunk-level latest-at or range query, or both. + /// + /// This query is AND'd together with the `partition_ids` and `chunk_ids` filters above. + #[prost(message, optional, tag = "5")] + pub query: ::core::option::Option, +} +impl ::prost::Name for GetChunksRequest { + const NAME: &'static str = "GetChunksRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.GetChunksRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.GetChunksRequest".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetChunksResponse { + /// Every gRPC response, even within the confines of a stream, involves HTTP2 overhead, which isn't + /// cheap by any means, which is why we're returning a batch of `ArrowMsg` rather than a single one. + #[prost(message, repeated, tag = "1")] + pub chunks: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GetChunksResponse { + const NAME: &'static str = "GetChunksResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.GetChunksResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.GetChunksResponse".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FetchPartitionManifestRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub id: ::core::option::Option, + #[prost(message, optional, tag = "3")] + pub scan_parameters: ::core::option::Option, +} +impl ::prost::Name for FetchPartitionManifestRequest { + const NAME: &'static str = "FetchPartitionManifestRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.FetchPartitionManifestRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.FetchPartitionManifestRequest".into() + } +} +/// TODO(cmc): this should have response extensions too. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct FetchPartitionManifestResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for FetchPartitionManifestResponse { + const NAME: &'static str = "FetchPartitionManifestResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.FetchPartitionManifestResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.FetchPartitionManifestResponse".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FetchSchemaManifestRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub scan_parameters: ::core::option::Option, +} +impl ::prost::Name for FetchSchemaManifestRequest { + const NAME: &'static str = "FetchSchemaManifestRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.FetchSchemaManifestRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.FetchSchemaManifestRequest".into() + } +} +/// TODO(cmc): this should have response extensions too. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct FetchSchemaManifestResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for FetchSchemaManifestResponse { + const NAME: &'static str = "FetchSchemaManifestResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.FetchSchemaManifestResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.FetchSchemaManifestResponse".into() + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FetchChunkManifestRequest { + /// Dataset for which we want to fetch chunk manifest + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + /// Chunk manifest is index specific + #[prost(message, optional, tag = "2")] + pub column: ::core::option::Option, + /// Scan parameters + #[prost(message, optional, tag = "3")] + pub scan_parameters: ::core::option::Option, +} +impl ::prost::Name for FetchChunkManifestRequest { + const NAME: &'static str = "FetchChunkManifestRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.FetchChunkManifestRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.FetchChunkManifestRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct FetchChunkManifestResponse { + /// Chunk manifest as arrow RecordBatches + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for FetchChunkManifestResponse { + const NAME: &'static str = "FetchChunkManifestResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.FetchChunkManifestResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.FetchChunkManifestResponse".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DoMaintenanceRequest { + #[prost(message, optional, tag = "1")] + pub entry: ::core::option::Option, + /// Create the acceleration structures for temporal queries. + /// + /// This will recreate all scalar indexes from scratch everytime. + /// + /// TODO(cmc): support incremental scalar indexing & index compaction + #[prost(bool, tag = "2")] + pub build_scalar_indexes: bool, + /// Compact the underlying Lance fragments, for all Rerun Manifests. + /// + /// Hardcoded to the default (optimal) settings. + #[prost(bool, tag = "3")] + pub compact_fragments: bool, + /// If set, all Lance fragments older than this date will be removed, for all Rerun Manifests. + #[prost(message, optional, tag = "4")] + pub cleanup_before: ::core::option::Option<::prost_types::Timestamp>, +} +impl ::prost::Name for DoMaintenanceRequest { + const NAME: &'static str = "DoMaintenanceRequest"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.DoMaintenanceRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.DoMaintenanceRequest".into() + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DoMaintenanceResponse { + #[prost(string, tag = "1")] + pub report: ::prost::alloc::string::String, +} +impl ::prost::Name for DoMaintenanceResponse { + const NAME: &'static str = "DoMaintenanceResponse"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.DoMaintenanceResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.DoMaintenanceResponse".into() + } +} +/// Application level error - used as `details` in the `google.rpc.Status` message +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Error { + /// error code + #[prost(enumeration = "ErrorCode", tag = "1")] + pub code: i32, + /// unique identifier associated with the request (e.g. recording id, recording storage url) + #[prost(string, tag = "2")] + pub id: ::prost::alloc::string::String, + /// human readable details about the error + #[prost(string, tag = "3")] + pub message: ::prost::alloc::string::String, +} +impl ::prost::Name for Error { + const NAME: &'static str = "Error"; + const PACKAGE: &'static str = "rerun.manifest_registry.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.manifest_registry.v1alpha1.Error".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.manifest_registry.v1alpha1.Error".into() + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum DataSourceKind { + Unspecified = 0, + Rrd = 1, +} +impl DataSourceKind { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "DATA_SOURCE_KIND_UNSPECIFIED", + Self::Rrd => "DATA_SOURCE_KIND_RRD", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DATA_SOURCE_KIND_UNSPECIFIED" => Some(Self::Unspecified), + "DATA_SOURCE_KIND_RRD" => Some(Self::Rrd), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum VectorDistanceMetric { + Unspecified = 0, + L2 = 1, + Cosine = 2, + Dot = 3, + Hamming = 4, +} +impl VectorDistanceMetric { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "VECTOR_DISTANCE_METRIC_UNSPECIFIED", + Self::L2 => "VECTOR_DISTANCE_METRIC_L2", + Self::Cosine => "VECTOR_DISTANCE_METRIC_COSINE", + Self::Dot => "VECTOR_DISTANCE_METRIC_DOT", + Self::Hamming => "VECTOR_DISTANCE_METRIC_HAMMING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "VECTOR_DISTANCE_METRIC_UNSPECIFIED" => Some(Self::Unspecified), + "VECTOR_DISTANCE_METRIC_L2" => Some(Self::L2), + "VECTOR_DISTANCE_METRIC_COSINE" => Some(Self::Cosine), + "VECTOR_DISTANCE_METRIC_DOT" => Some(Self::Dot), + "VECTOR_DISTANCE_METRIC_HAMMING" => Some(Self::Hamming), + _ => None, + } + } +} +/// Error codes for application level errors +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ErrorCode { + /// unused + Unspecified = 0, + /// object store access error + ObjectStoreError = 1, + /// metadata database access error + MetadataDbError = 2, + /// Encoding / decoding error + CodecError = 3, +} +impl ErrorCode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "ERROR_CODE_UNSPECIFIED", + Self::ObjectStoreError => "ERROR_CODE_OBJECT_STORE_ERROR", + Self::MetadataDbError => "ERROR_CODE_METADATA_DB_ERROR", + Self::CodecError => "ERROR_CODE_CODEC_ERROR", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ERROR_CODE_UNSPECIFIED" => Some(Self::Unspecified), + "ERROR_CODE_OBJECT_STORE_ERROR" => Some(Self::ObjectStoreError), + "ERROR_CODE_METADATA_DB_ERROR" => Some(Self::MetadataDbError), + "ERROR_CODE_CODEC_ERROR" => Some(Self::CodecError), + _ => None, + } + } +} +/// Generated client implementations. +pub mod manifest_registry_service_client { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value + )] + use tonic::codegen::http::Uri; + use tonic::codegen::*; + #[derive(Debug, Clone)] + pub struct ManifestRegistryServiceClient { + inner: tonic::client::Grpc, + } + impl ManifestRegistryServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + std::marker::Send + 'static, + ::Error: Into + std::marker::Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> ManifestRegistryServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + >>::Error: + Into + std::marker::Send + std::marker::Sync, + { + ManifestRegistryServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Register new partitions with the Dataset (asynchronously) + pub async fn register_with_dataset( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/RegisterWithDataset", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "RegisterWithDataset", + )); + self.inner.unary(req, path, codec).await + } + /// Write chunks to one or more partitions. + /// + /// The partition ID for each individual chunk is extracted from their metadata (`rerun.partition_id`). + /// + /// The destination dataset URL must be provided in the `x-rerun-dataset-url` header. + pub async fn write_chunks( + &mut self, + request: impl tonic::IntoStreamingRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/WriteChunks", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "WriteChunks", + )); + self.inner.client_streaming(req, path, codec).await + } + /// Miscellaneous maintenance operations: scalar index creation, compaction, etc. + pub async fn do_maintenance( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/DoMaintenance", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "DoMaintenance", + )); + self.inner.unary(req, path, codec).await + } + /// Returns the schema of the partition table (i.e. the dataset manifest) itself, *not* the underlying dataset. + /// + /// * To inspect the data of the partition table, use `ScanPartitionTable`. + /// * To retrieve the schema of the underlying dataset, use `GetDatasetSchema` instead. + pub async fn get_partition_table_schema( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/GetPartitionTableSchema", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "GetPartitionTableSchema", + )); + self.inner.unary(req, path, codec).await + } + /// Inspect the contents of the partition table (i.e. the dataset manifest). + /// + /// The returned data will follow the schema specified by `GetPartitionTableSchema`. + pub async fn scan_partition_table( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/ScanPartitionTable", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "ScanPartitionTable", + )); + self.inner.server_streaming(req, path, codec).await + } + /// Returns the schema of the dataset. + /// + /// This is the union of all the schemas from all the underlying partitions. It will contain all the indexes, + /// entities and components present in the dataset. + pub async fn get_dataset_schema( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/GetDatasetSchema", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "GetDatasetSchema", + )); + self.inner.unary(req, path, codec).await + } + /// Creates a custom index for a specific column (vector search, full-text search, etc). + /// + /// Index can be created for all or specific partitions. Creating an index will create a new + /// index-specific chunk manifest for the Dataset. + /// Chunk manifest contains information about individual chunk rows for all chunks containing + /// relevant index data. + pub async fn create_index( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/CreateIndex", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "CreateIndex", + )); + self.inner.unary(req, path, codec).await + } + /// Recreate an index with the same configuration but (potentially) new data. + pub async fn re_index( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/ReIndex", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "ReIndex", + )); + self.inner.unary(req, path, codec).await + } + /// Search a previously created index. + /// + /// Do a full text, vector or scalar search. Currently only an Indexed search is supported, user must first + /// call `CreateIndex` for the relevant column. + /// + /// The response is a RecordBatch with 4 columns: + /// - 'partition_id': which partition the data is from + /// - 'timepoint': represents the points in time where index query matches. + /// What time points are matched depends on the type of index that is queried. + /// For example: for vector search it might be timepoints where top-K matches are found within *each* partition in + /// the indexed entry. + /// For inverted index it might be timepoints where the query string is found in the indexed column + /// - instance column: if index column contains a batch of values (for example a list of embeddings), then each + /// instance of the batch is a separate row in the resulting RecordBatch + /// - instance_id: this is a simple element index in the batch array. For example if indexed column is a list of + /// embeddings \[a,b,c\] (where each embedding is of same length) then 'instance_id' of embedding 'a' is 0, + /// 'instance_id' of 'b' is 1, etc. + /// + /// TODO(zehiko) add support for "brute force" search. + pub async fn search_dataset( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/SearchDataset", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "SearchDataset", + )); + self.inner.server_streaming(req, path, codec).await + } + /// Perform Rerun-native queries on a dataset, returning the matching chunk IDs. + /// + /// These Rerun-native queries include: + /// * Filtering by specific partition and chunk IDs. + /// * Latest-at, range and dataframe queries. + /// * Arbitrary Lance filters. + /// + /// To fetch the actual chunks themselves, see `GetChunks`. + /// + /// Passing chunk IDs to this method effectively acts as a IF_EXIST filter. + pub async fn query_dataset( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/QueryDataset", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "QueryDataset", + )); + self.inner.server_streaming(req, path, codec).await + } + /// Perform Rerun-native queries on a dataset, returning the underlying chunks. + /// + /// These Rerun-native queries include: + /// * Filtering by specific partition and chunk IDs. + /// * Latest-at, range and dataframe queries. + /// * Arbitrary Lance filters. + /// + /// To fetch only the actual chunk IDs rather than the chunks themselves, see `QueryDataset`. + pub async fn get_chunks( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/GetChunks", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "GetChunks", + )); + self.inner.server_streaming(req, path, codec).await + } + /// Fetch the internal state of a Partition Manifest. + pub async fn fetch_partition_manifest( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/FetchPartitionManifest", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "FetchPartitionManifest", + )); + self.inner.server_streaming(req, path, codec).await + } + /// Fetch the internal state of a Schema Manifest. + pub async fn fetch_schema_manifest( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/FetchSchemaManifest", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "FetchSchemaManifest", + )); + self.inner.server_streaming(req, path, codec).await + } + /// Retrieves the chunk manifest for a specific index. + pub async fn fetch_chunk_manifest( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/FetchChunkManifest", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.manifest_registry.v1alpha1.ManifestRegistryService", + "FetchChunkManifest", + )); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod manifest_registry_service_server { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value + )] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with ManifestRegistryServiceServer. + #[async_trait] + pub trait ManifestRegistryService: std::marker::Send + std::marker::Sync + 'static { + /// Register new partitions with the Dataset (asynchronously) + async fn register_with_dataset( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Write chunks to one or more partitions. + /// + /// The partition ID for each individual chunk is extracted from their metadata (`rerun.partition_id`). + /// + /// The destination dataset URL must be provided in the `x-rerun-dataset-url` header. + async fn write_chunks( + &self, + request: tonic::Request>, + ) -> std::result::Result, tonic::Status>; + /// Miscellaneous maintenance operations: scalar index creation, compaction, etc. + async fn do_maintenance( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Returns the schema of the partition table (i.e. the dataset manifest) itself, *not* the underlying dataset. + /// + /// * To inspect the data of the partition table, use `ScanPartitionTable`. + /// * To retrieve the schema of the underlying dataset, use `GetDatasetSchema` instead. + async fn get_partition_table_schema( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the ScanPartitionTable method. + type ScanPartitionTableStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Inspect the contents of the partition table (i.e. the dataset manifest). + /// + /// The returned data will follow the schema specified by `GetPartitionTableSchema`. + async fn scan_partition_table( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Returns the schema of the dataset. + /// + /// This is the union of all the schemas from all the underlying partitions. It will contain all the indexes, + /// entities and components present in the dataset. + async fn get_dataset_schema( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Creates a custom index for a specific column (vector search, full-text search, etc). + /// + /// Index can be created for all or specific partitions. Creating an index will create a new + /// index-specific chunk manifest for the Dataset. + /// Chunk manifest contains information about individual chunk rows for all chunks containing + /// relevant index data. + async fn create_index( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Recreate an index with the same configuration but (potentially) new data. + async fn re_index( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the SearchDataset method. + type SearchDatasetStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Search a previously created index. + /// + /// Do a full text, vector or scalar search. Currently only an Indexed search is supported, user must first + /// call `CreateIndex` for the relevant column. + /// + /// The response is a RecordBatch with 4 columns: + /// - 'partition_id': which partition the data is from + /// - 'timepoint': represents the points in time where index query matches. + /// What time points are matched depends on the type of index that is queried. + /// For example: for vector search it might be timepoints where top-K matches are found within *each* partition in + /// the indexed entry. + /// For inverted index it might be timepoints where the query string is found in the indexed column + /// - instance column: if index column contains a batch of values (for example a list of embeddings), then each + /// instance of the batch is a separate row in the resulting RecordBatch + /// - instance_id: this is a simple element index in the batch array. For example if indexed column is a list of + /// embeddings \[a,b,c\] (where each embedding is of same length) then 'instance_id' of embedding 'a' is 0, + /// 'instance_id' of 'b' is 1, etc. + /// + /// TODO(zehiko) add support for "brute force" search. + async fn search_dataset( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the QueryDataset method. + type QueryDatasetStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Perform Rerun-native queries on a dataset, returning the matching chunk IDs. + /// + /// These Rerun-native queries include: + /// * Filtering by specific partition and chunk IDs. + /// * Latest-at, range and dataframe queries. + /// * Arbitrary Lance filters. + /// + /// To fetch the actual chunks themselves, see `GetChunks`. + /// + /// Passing chunk IDs to this method effectively acts as a IF_EXIST filter. + async fn query_dataset( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the GetChunks method. + type GetChunksStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Perform Rerun-native queries on a dataset, returning the underlying chunks. + /// + /// These Rerun-native queries include: + /// * Filtering by specific partition and chunk IDs. + /// * Latest-at, range and dataframe queries. + /// * Arbitrary Lance filters. + /// + /// To fetch only the actual chunk IDs rather than the chunks themselves, see `QueryDataset`. + async fn get_chunks( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the FetchPartitionManifest method. + type FetchPartitionManifestStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Fetch the internal state of a Partition Manifest. + async fn fetch_partition_manifest( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the FetchSchemaManifest method. + type FetchSchemaManifestStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Fetch the internal state of a Schema Manifest. + async fn fetch_schema_manifest( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the FetchChunkManifest method. + type FetchChunkManifestStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Retrieves the chunk manifest for a specific index. + async fn fetch_chunk_manifest( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct ManifestRegistryServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl ManifestRegistryServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for ManifestRegistryServiceServer + where + T: ManifestRegistryService, + B: Body + std::marker::Send + 'static, + B::Error: Into + std::marker::Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/RegisterWithDataset" => { + #[allow(non_camel_case_types)] + struct RegisterWithDatasetSvc(pub Arc); + impl + tonic::server::UnaryService + for RegisterWithDatasetSvc + { + type Response = super::RegisterWithDatasetResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::register_with_dataset( + &inner, request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = RegisterWithDatasetSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/WriteChunks" => { + #[allow(non_camel_case_types)] + struct WriteChunksSvc(pub Arc); + impl + tonic::server::ClientStreamingService + for WriteChunksSvc + { + type Response = super::WriteChunksResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request>, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::write_chunks(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = WriteChunksSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.client_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/DoMaintenance" => { + #[allow(non_camel_case_types)] + struct DoMaintenanceSvc(pub Arc); + impl + tonic::server::UnaryService + for DoMaintenanceSvc + { + type Response = super::DoMaintenanceResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::do_maintenance(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DoMaintenanceSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/GetPartitionTableSchema" => + { + #[allow(non_camel_case_types)] + struct GetPartitionTableSchemaSvc(pub Arc); + impl + tonic::server::UnaryService + for GetPartitionTableSchemaSvc + { + type Response = super::GetPartitionTableSchemaResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_partition_table_schema( + &inner, request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetPartitionTableSchemaSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/ScanPartitionTable" => { + #[allow(non_camel_case_types)] + struct ScanPartitionTableSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for ScanPartitionTableSvc + { + type Response = super::ScanPartitionTableResponse; + type ResponseStream = T::ScanPartitionTableStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::scan_partition_table( + &inner, request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ScanPartitionTableSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/GetDatasetSchema" => { + #[allow(non_camel_case_types)] + struct GetDatasetSchemaSvc(pub Arc); + impl + tonic::server::UnaryService + for GetDatasetSchemaSvc + { + type Response = super::GetDatasetSchemaResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_dataset_schema(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetDatasetSchemaSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/CreateIndex" => { + #[allow(non_camel_case_types)] + struct CreateIndexSvc(pub Arc); + impl + tonic::server::UnaryService + for CreateIndexSvc + { + type Response = super::CreateIndexResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_index(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateIndexSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/ReIndex" => { + #[allow(non_camel_case_types)] + struct ReIndexSvc(pub Arc); + impl + tonic::server::UnaryService for ReIndexSvc + { + type Response = super::ReIndexResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::re_index(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ReIndexSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/SearchDataset" => { + #[allow(non_camel_case_types)] + struct SearchDatasetSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for SearchDatasetSvc + { + type Response = super::SearchDatasetResponse; + type ResponseStream = T::SearchDatasetStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::search_dataset(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = SearchDatasetSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/QueryDataset" => { + #[allow(non_camel_case_types)] + struct QueryDatasetSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for QueryDatasetSvc + { + type Response = super::QueryDatasetResponse; + type ResponseStream = T::QueryDatasetStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::query_dataset(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = QueryDatasetSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/GetChunks" => { + #[allow(non_camel_case_types)] + struct GetChunksSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for GetChunksSvc + { + type Response = super::GetChunksResponse; + type ResponseStream = T::GetChunksStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_chunks(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetChunksSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/FetchPartitionManifest" => + { + #[allow(non_camel_case_types)] + struct FetchPartitionManifestSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for FetchPartitionManifestSvc + { + type Response = super::FetchPartitionManifestResponse; + type ResponseStream = T::FetchPartitionManifestStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::fetch_partition_manifest( + &inner, request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = FetchPartitionManifestSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/FetchSchemaManifest" => { + #[allow(non_camel_case_types)] + struct FetchSchemaManifestSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for FetchSchemaManifestSvc + { + type Response = super::FetchSchemaManifestResponse; + type ResponseStream = T::FetchSchemaManifestStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::fetch_schema_manifest( + &inner, request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = FetchSchemaManifestSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.manifest_registry.v1alpha1.ManifestRegistryService/FetchChunkManifest" => { + #[allow(non_camel_case_types)] + struct FetchChunkManifestSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for FetchChunkManifestSvc + { + type Response = super::FetchChunkManifestResponse; + type ResponseStream = T::FetchChunkManifestStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::fetch_chunk_manifest( + &inner, request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = FetchChunkManifestSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => Box::pin(async move { + let mut response = http::Response::new(tonic::body::Body::default()); + let headers = response.headers_mut(); + headers.insert( + tonic::Status::GRPC_STATUS, + (tonic::Code::Unimplemented as i32).into(), + ); + headers.insert( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ); + Ok(response) + }), + } + } + } + impl Clone for ManifestRegistryServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + /// Generated gRPC service name + pub const SERVICE_NAME: &str = "rerun.manifest_registry.v1alpha1.ManifestRegistryService"; + impl tonic::server::NamedService for ManifestRegistryServiceServer { + const NAME: &'static str = SERVICE_NAME; + } +} diff --git a/crates/store/re_protos/src/v1alpha1/rerun.redap_tasks.v1alpha1.rs b/crates/store/re_protos/src/v1alpha1/rerun.redap_tasks.v1alpha1.rs new file mode 100644 index 000000000000..65718ac1b722 --- /dev/null +++ b/crates/store/re_protos/src/v1alpha1/rerun.redap_tasks.v1alpha1.rs @@ -0,0 +1,649 @@ +// This file is @generated by prost-build. +/// A task is a unit of work that can be submitted to the system +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Task { + /// Unique identifier for the task + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, + /// Type of the task + #[prost(string, tag = "2")] + pub task_type: ::prost::alloc::string::String, + /// Task-type dependant data necessary to de-serialize the task + #[prost(bytes = "vec", tag = "3")] + pub task_data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Task { + const NAME: &'static str = "Task"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.Task".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.Task".into() + } +} +/// `SubmitTasksRequest` is the request message for submitting tasks +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubmitTasksRequest { + #[prost(message, repeated, tag = "1")] + pub tasks: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for SubmitTasksRequest { + const NAME: &'static str = "SubmitTasksRequest"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.SubmitTasksRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.SubmitTasksRequest".into() + } +} +/// `SubmitTaskResponse` contains, for each submitted task +/// its submission outcome, encoded as a `RecordBatch` +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SubmitTasksResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for SubmitTasksResponse { + const NAME: &'static str = "SubmitTasksResponse"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.SubmitTasksResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.SubmitTasksResponse".into() + } +} +/// `QueryTasksRequest` is the request message for querying tasks status +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTasksRequest { + /// Empty queries for all tasks if the server allows it. + #[prost(message, repeated, tag = "1")] + pub ids: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryTasksRequest { + const NAME: &'static str = "QueryTasksRequest"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.QueryTasksRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.QueryTasksRequest".into() + } +} +/// `QueryTasksResponse` is the response message for querying tasks status +/// encoded as a record batch +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct QueryTasksResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for QueryTasksResponse { + const NAME: &'static str = "QueryTasksResponse"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.QueryTasksResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.QueryTasksResponse".into() + } +} +/// `QueryTasksOnCompletionRequest` is the request message for querying tasks status. +/// This is close-to-a-copy of `QueryTasksRequest`, with the addition of a timeout. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTasksOnCompletionRequest { + /// Empty queries for all tasks if the server allows it. + #[prost(message, repeated, tag = "1")] + pub ids: ::prost::alloc::vec::Vec, + /// Time limit for the server to wait for task completion. + /// The actual maximum time may be arbitrarily capped by the server. + #[prost(message, optional, tag = "2")] + pub timeout: ::core::option::Option<::prost_types::Duration>, +} +impl ::prost::Name for QueryTasksOnCompletionRequest { + const NAME: &'static str = "QueryTasksOnCompletionRequest"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.QueryTasksOnCompletionRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.QueryTasksOnCompletionRequest".into() + } +} +/// `QueryTaskOnCompletionResponse` is the response message for querying tasks status +/// encoded as a record batch. This is a copy of `QueryTasksResponse`. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct QueryTasksOnCompletionResponse { + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for QueryTasksOnCompletionResponse { + const NAME: &'static str = "QueryTasksOnCompletionResponse"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.QueryTasksOnCompletionResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.QueryTasksOnCompletionResponse".into() + } +} +/// `FetchTaskOutputRequest` is the request message for fetching task output +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct FetchTaskOutputRequest { + /// Unique identifier for the task + #[prost(message, optional, tag = "1")] + pub id: ::core::option::Option, +} +impl ::prost::Name for FetchTaskOutputRequest { + const NAME: &'static str = "FetchTaskOutputRequest"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.FetchTaskOutputRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.FetchTaskOutputRequest".into() + } +} +/// / `FetchTaskOutputResponse` is the response message for fetching task output +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct FetchTaskOutputResponse { + /// The output of the task, encoded as a record batch + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option, +} +impl ::prost::Name for FetchTaskOutputResponse { + const NAME: &'static str = "FetchTaskOutputResponse"; + const PACKAGE: &'static str = "rerun.redap_tasks.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + "rerun.redap_tasks.v1alpha1.FetchTaskOutputResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/rerun.redap_tasks.v1alpha1.FetchTaskOutputResponse".into() + } +} +/// Generated client implementations. +pub mod tasks_service_client { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value + )] + use tonic::codegen::http::Uri; + use tonic::codegen::*; + /// `TasksService` is the service for submitting and querying persistent redap tasks. + #[derive(Debug, Clone)] + pub struct TasksServiceClient { + inner: tonic::client::Grpc, + } + impl TasksServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + std::marker::Send + 'static, + ::Error: Into + std::marker::Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> TasksServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + >>::Error: + Into + std::marker::Send + std::marker::Sync, + { + TasksServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Submit new tasks + pub async fn submit_tasks( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.redap_tasks.v1alpha1.TasksService/SubmitTasks", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.redap_tasks.v1alpha1.TasksService", + "SubmitTasks", + )); + self.inner.unary(req, path, codec).await + } + /// Query the status of submitted tasks + pub async fn query_tasks( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.redap_tasks.v1alpha1.TasksService/QueryTasks", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.redap_tasks.v1alpha1.TasksService", + "QueryTasks", + )); + self.inner.unary(req, path, codec).await + } + /// Fetch the output of a completed task + pub async fn fetch_task_output( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.redap_tasks.v1alpha1.TasksService/FetchTaskOutput", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.redap_tasks.v1alpha1.TasksService", + "FetchTaskOutput", + )); + self.inner.unary(req, path, codec).await + } + /// Query the status of submitted tasks, waiting for their completion. + /// + /// The method returns a stream of QueryResult. Each item in the stream contains + /// the status of a subset of the tasks, as they complete. + /// The server does not guarantee to immediately send one stream item as soon as a task + /// completes, but may decide to arbitrarily aggregate results into larger batches. + pub async fn query_tasks_on_completion( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/rerun.redap_tasks.v1alpha1.TasksService/QueryTasksOnCompletion", + ); + let mut req = request.into_request(); + req.extensions_mut().insert(GrpcMethod::new( + "rerun.redap_tasks.v1alpha1.TasksService", + "QueryTasksOnCompletion", + )); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod tasks_service_server { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value + )] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with TasksServiceServer. + #[async_trait] + pub trait TasksService: std::marker::Send + std::marker::Sync + 'static { + /// Submit new tasks + async fn submit_tasks( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Query the status of submitted tasks + async fn query_tasks( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Fetch the output of a completed task + async fn fetch_task_output( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the QueryTasksOnCompletion method. + type QueryTasksOnCompletionStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + std::marker::Send + + 'static; + /// Query the status of submitted tasks, waiting for their completion. + /// + /// The method returns a stream of QueryResult. Each item in the stream contains + /// the status of a subset of the tasks, as they complete. + /// The server does not guarantee to immediately send one stream item as soon as a task + /// completes, but may decide to arbitrarily aggregate results into larger batches. + async fn query_tasks_on_completion( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + /// `TasksService` is the service for submitting and querying persistent redap tasks. + #[derive(Debug)] + pub struct TasksServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl TasksServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for TasksServiceServer + where + T: TasksService, + B: Body + std::marker::Send + 'static, + B::Error: Into + std::marker::Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/rerun.redap_tasks.v1alpha1.TasksService/SubmitTasks" => { + #[allow(non_camel_case_types)] + struct SubmitTasksSvc(pub Arc); + impl tonic::server::UnaryService for SubmitTasksSvc { + type Response = super::SubmitTasksResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::submit_tasks(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = SubmitTasksSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.redap_tasks.v1alpha1.TasksService/QueryTasks" => { + #[allow(non_camel_case_types)] + struct QueryTasksSvc(pub Arc); + impl tonic::server::UnaryService for QueryTasksSvc { + type Response = super::QueryTasksResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::query_tasks(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = QueryTasksSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.redap_tasks.v1alpha1.TasksService/FetchTaskOutput" => { + #[allow(non_camel_case_types)] + struct FetchTaskOutputSvc(pub Arc); + impl tonic::server::UnaryService + for FetchTaskOutputSvc + { + type Response = super::FetchTaskOutputResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::fetch_task_output(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = FetchTaskOutputSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/rerun.redap_tasks.v1alpha1.TasksService/QueryTasksOnCompletion" => { + #[allow(non_camel_case_types)] + struct QueryTasksOnCompletionSvc(pub Arc); + impl + tonic::server::ServerStreamingService + for QueryTasksOnCompletionSvc + { + type Response = super::QueryTasksOnCompletionResponse; + type ResponseStream = T::QueryTasksOnCompletionStream; + type Future = + BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::query_tasks_on_completion(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = QueryTasksOnCompletionSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => Box::pin(async move { + let mut response = http::Response::new(tonic::body::Body::default()); + let headers = response.headers_mut(); + headers.insert( + tonic::Status::GRPC_STATUS, + (tonic::Code::Unimplemented as i32).into(), + ); + headers.insert( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ); + Ok(response) + }), + } + } + } + impl Clone for TasksServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + /// Generated gRPC service name + pub const SERVICE_NAME: &str = "rerun.redap_tasks.v1alpha1.TasksService"; + impl tonic::server::NamedService for TasksServiceServer { + const NAME: &'static str = SERVICE_NAME; + } +} diff --git a/crates/store/re_protos/src/v1alpha1/rerun.sdk_comms.v1alpha1.rs b/crates/store/re_protos/src/v1alpha1/rerun.sdk_comms.v1alpha1.rs index 301eb61594cb..ef5f23f04091 100644 --- a/crates/store/re_protos/src/v1alpha1/rerun.sdk_comms.v1alpha1.rs +++ b/crates/store/re_protos/src/v1alpha1/rerun.sdk_comms.v1alpha1.rs @@ -1,5 +1,5 @@ // This file is @generated by prost-build. -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WriteMessagesRequest { #[prost(message, optional, tag = "1")] pub log_msg: ::core::option::Option, @@ -14,7 +14,7 @@ impl ::prost::Name for WriteMessagesRequest { "/rerun.sdk_comms.v1alpha1.WriteMessagesRequest".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct WriteMessagesResponse {} impl ::prost::Name for WriteMessagesResponse { const NAME: &'static str = "WriteMessagesResponse"; @@ -26,7 +26,7 @@ impl ::prost::Name for WriteMessagesResponse { "/rerun.sdk_comms.v1alpha1.WriteMessagesResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadMessagesRequest {} impl ::prost::Name for ReadMessagesRequest { const NAME: &'static str = "ReadMessagesRequest"; @@ -38,7 +38,7 @@ impl ::prost::Name for ReadMessagesRequest { "/rerun.sdk_comms.v1alpha1.ReadMessagesRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadMessagesResponse { #[prost(message, optional, tag = "1")] pub log_msg: ::core::option::Option, @@ -53,7 +53,7 @@ impl ::prost::Name for ReadMessagesResponse { "/rerun.sdk_comms.v1alpha1.ReadMessagesResponse".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WriteTableRequest { #[prost(message, optional, tag = "1")] pub id: ::core::option::Option, @@ -70,7 +70,7 @@ impl ::prost::Name for WriteTableRequest { "/rerun.sdk_comms.v1alpha1.WriteTableRequest".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct WriteTableResponse {} impl ::prost::Name for WriteTableResponse { const NAME: &'static str = "WriteTableResponse"; @@ -82,7 +82,7 @@ impl ::prost::Name for WriteTableResponse { "/rerun.sdk_comms.v1alpha1.WriteTableResponse".into() } } -#[derive(Clone, Copy, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadTablesRequest {} impl ::prost::Name for ReadTablesRequest { const NAME: &'static str = "ReadTablesRequest"; @@ -94,7 +94,7 @@ impl ::prost::Name for ReadTablesRequest { "/rerun.sdk_comms.v1alpha1.ReadTablesRequest".into() } } -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadTablesResponse { #[prost(message, optional, tag = "1")] pub id: ::core::option::Option, @@ -209,7 +209,7 @@ pub mod message_proxy_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.sdk_comms.v1alpha1.MessageProxyService/WriteMessages", ); @@ -230,7 +230,7 @@ pub mod message_proxy_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.sdk_comms.v1alpha1.MessageProxyService/ReadMessages", ); @@ -249,7 +249,7 @@ pub mod message_proxy_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.sdk_comms.v1alpha1.MessageProxyService/WriteTable", ); @@ -270,7 +270,7 @@ pub mod message_proxy_service_client { self.inner.ready().await.map_err(|e| { tonic::Status::unknown(format!("Service was not ready: {}", e.into())) })?; - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/rerun.sdk_comms.v1alpha1.MessageProxyService/ReadTables", ); @@ -434,7 +434,7 @@ pub mod message_proxy_service_server { let inner = self.inner.clone(); let fut = async move { let method = WriteMessagesSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -478,7 +478,7 @@ pub mod message_proxy_service_server { let inner = self.inner.clone(); let fut = async move { let method = ReadMessagesSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -519,7 +519,7 @@ pub mod message_proxy_service_server { let inner = self.inner.clone(); let fut = async move { let method = WriteTableSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, @@ -563,7 +563,7 @@ pub mod message_proxy_service_server { let inner = self.inner.clone(); let fut = async move { let method = ReadTablesSvc(inner); - let codec = tonic::codec::ProstCodec::default(); + let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings,