diff --git a/Cargo.lock b/Cargo.lock index 14808c6088545d..af19891e87c1a8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -265,6 +265,15 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" +[[package]] +name = "autotools" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8138adefca3e5d2e73bfba83bd6eeaf904b26a7ac1b4a19892cfe16cc7e1701" +dependencies = [ + "cc", +] + [[package]] name = "axum" version = "0.5.1" @@ -829,15 +838,6 @@ dependencies = [ "syn 1.0.98", ] -[[package]] -name = "cmake" -version = "0.1.46" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7b858541263efe664aead4a5209a4ae5c5d2811167d4ed4ee0944503f8d2089" -dependencies = [ - "cc", -] - [[package]] name = "combine" version = "3.8.1" @@ -3439,12 +3439,12 @@ dependencies = [ [[package]] name = "prost" -version = "0.10.4" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71adf41db68aa0daaefc69bb30bcd68ded9b9abaad5d1fbb6304c4fb390e083e" +checksum = "399c3c31cdec40583bb68f0b18403400d01ec4289c383aa047560439952c4dd7" dependencies = [ "bytes", - "prost-derive 0.10.0", + "prost-derive 0.11.0", ] [[package]] @@ -3469,21 +3469,19 @@ dependencies = [ [[package]] name = "prost-build" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "328f9f29b82409216decb172d81e936415d21245befa79cd34c3f29d87d1c50b" +checksum = "d49d928704208aba2cb1fb022ce1a319bdedcb03caf51ddf82734fa903407762" dependencies = [ "bytes", - "cfg-if 1.0.0", - "cmake", "heck 0.4.0", "itertools", "lazy_static", "log", "multimap", "petgraph", - "prost 0.10.4", - "prost-types 0.10.0", + "prost 0.11.0", + "prost-types 0.11.0", "regex", "tempfile", "which", @@ -3504,9 +3502,9 @@ dependencies = [ [[package]] name = "prost-derive" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df35198f0777b75e9ff669737c6da5136b59dba33cf5a010a6d1cc4d56defc6f" +checksum = "7345d5f0e08c0536d7ac7229952590239e77abf0a0100a1b1d890add6ea96364" dependencies = [ "anyhow", "itertools", @@ -3527,12 +3525,21 @@ dependencies = [ [[package]] name = "prost-types" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "926681c118ae6e512a3ccefd4abbe5521a14f4cc1e207356d4d00c0b7f2006fd" +checksum = "d30bc806a29b347314be074ff0608ef8e547286e8ea68b061a2fe55689edc01f" dependencies = [ "bytes", - "prost 0.10.4", + "prost 0.11.0", +] + +[[package]] +name = "protobuf-src" +version = "1.0.5+3.19.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe57f68bf9767f48f8cbcbceb5da21524e2b1330a821c1c2502c447d8043f078" +dependencies = [ + "autotools", ] [[package]] @@ -5450,7 +5457,7 @@ dependencies = [ "matches", "num_cpus", "num_enum", - "prost 0.10.4", + "prost 0.11.0", "rand 0.7.3", "rand_chacha 0.2.2", "rayon", @@ -6241,8 +6248,8 @@ dependencies = [ "hyper-proxy", "log", "openssl", - "prost 0.10.4", - "prost-types 0.10.0", + "prost 0.11.0", + "prost-types 0.11.0", "serde", "serde_derive", "smpl_jwt", @@ -6252,7 +6259,7 @@ dependencies = [ "solana-transaction-status", "thiserror", "tokio", - "tonic 0.7.2", + "tonic 0.8.0", "zstd", ] @@ -6263,12 +6270,13 @@ dependencies = [ "bincode", "bs58", "enum-iterator", - "prost 0.10.4", + "prost 0.11.0", + "protobuf-src", "serde", "solana-account-decoder", "solana-sdk 1.11.5", "solana-transaction-status", - "tonic-build 0.7.2", + "tonic-build 0.8.0", ] [[package]] @@ -7288,9 +7296,9 @@ dependencies = [ [[package]] name = "tonic" -version = "0.7.2" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5be9d60db39854b30b835107500cf0aca0b0d14d6e1c3de124217c23a29c2ddb" +checksum = "498f271adc46acce75d66f639e4d35b31b2394c295c82496727dafa16d465dd2" dependencies = [ "async-stream", "async-trait", @@ -7306,8 +7314,8 @@ dependencies = [ "hyper-timeout", "percent-encoding 2.1.0", "pin-project", - "prost 0.10.4", - "prost-derive 0.10.0", + "prost 0.11.0", + "prost-derive 0.11.0", "rustls-pemfile 1.0.0", "tokio", "tokio-rustls 0.23.3", @@ -7334,13 +7342,13 @@ dependencies = [ [[package]] name = "tonic-build" -version = "0.7.2" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9263bf4c9bfaae7317c1c2faf7f18491d2fe476f70c414b73bf5d445b00ffa1" +checksum = "2fbcd2800e34e743b9ae795867d5f77b535d3a3be69fd731e39145719752df8c" dependencies = [ "prettyplease", "proc-macro2 1.0.41", - "prost-build 0.10.0", + "prost-build 0.11.0", "quote 1.0.18", "syn 1.0.98", ] diff --git a/ledger/Cargo.toml b/ledger/Cargo.toml index 86c6048808e215..580a24d1b44178 100644 --- a/ledger/Cargo.toml +++ b/ledger/Cargo.toml @@ -26,7 +26,7 @@ log = { version = "0.4.17" } lru = "0.7.7" num_cpus = "1.13.1" num_enum = "0.5.7" -prost = "0.10.4" +prost = "0.11.0" rand = "0.7.0" rand_chacha = "0.2.2" rayon = "1.5.3" diff --git a/programs/bpf/Cargo.lock b/programs/bpf/Cargo.lock index 67a00edfd4b2f0..4049f7d0d59968 100644 --- a/programs/bpf/Cargo.lock +++ b/programs/bpf/Cargo.lock @@ -251,6 +251,15 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" +[[package]] +name = "autotools" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8138adefca3e5d2e73bfba83bd6eeaf904b26a7ac1b4a19892cfe16cc7e1701" +dependencies = [ + "cc", +] + [[package]] name = "axum" version = "0.5.3" @@ -716,15 +725,6 @@ dependencies = [ "textwrap 0.15.0", ] -[[package]] -name = "cmake" -version = "0.1.46" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7b858541263efe664aead4a5209a4ae5c5d2811167d4ed4ee0944503f8d2089" -dependencies = [ - "cc", -] - [[package]] name = "combine" version = "3.8.1" @@ -3107,12 +3107,12 @@ dependencies = [ [[package]] name = "prost" -version = "0.10.4" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71adf41db68aa0daaefc69bb30bcd68ded9b9abaad5d1fbb6304c4fb390e083e" +checksum = "399c3c31cdec40583bb68f0b18403400d01ec4289c383aa047560439952c4dd7" dependencies = [ "bytes", - "prost-derive 0.10.1", + "prost-derive 0.11.0", ] [[package]] @@ -3137,21 +3137,19 @@ dependencies = [ [[package]] name = "prost-build" -version = "0.10.1" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "120fbe7988713f39d780a58cf1a7ef0d7ef66c6d87e5aa3438940c05357929f4" +checksum = "d49d928704208aba2cb1fb022ce1a319bdedcb03caf51ddf82734fa903407762" dependencies = [ "bytes", - "cfg-if 1.0.0", - "cmake", "heck 0.4.0", "itertools", "lazy_static", "log", "multimap", "petgraph", - "prost 0.10.4", - "prost-types 0.10.1", + "prost 0.11.0", + "prost-types 0.11.0", "regex", "tempfile", "which", @@ -3172,9 +3170,9 @@ dependencies = [ [[package]] name = "prost-derive" -version = "0.10.1" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b670f45da57fb8542ebdbb6105a925fe571b67f9e7ed9f47a06a84e72b4e7cc" +checksum = "7345d5f0e08c0536d7ac7229952590239e77abf0a0100a1b1d890add6ea96364" dependencies = [ "anyhow", "itertools", @@ -3195,12 +3193,21 @@ dependencies = [ [[package]] name = "prost-types" -version = "0.10.1" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2d0a014229361011dc8e69c8a1ec6c2e8d0f2af7c91e3ea3f5b2170298461e68" +checksum = "d30bc806a29b347314be074ff0608ef8e547286e8ea68b061a2fe55689edc01f" dependencies = [ "bytes", - "prost 0.10.4", + "prost 0.11.0", +] + +[[package]] +name = "protobuf-src" +version = "1.0.5+3.19.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe57f68bf9767f48f8cbcbceb5da21524e2b1330a821c1c2502c447d8043f078" +dependencies = [ + "autotools", ] [[package]] @@ -4938,7 +4945,7 @@ dependencies = [ "lru", "num_cpus", "num_enum", - "prost 0.10.4", + "prost 0.11.0", "rand 0.7.3", "rand_chacha 0.2.2", "rayon", @@ -5528,8 +5535,8 @@ dependencies = [ "hyper-proxy", "log", "openssl", - "prost 0.10.4", - "prost-types 0.10.1", + "prost 0.11.0", + "prost-types 0.11.0", "serde", "serde_derive", "smpl_jwt", @@ -5539,7 +5546,7 @@ dependencies = [ "solana-transaction-status", "thiserror", "tokio", - "tonic 0.7.2", + "tonic 0.8.0", "zstd", ] @@ -5549,12 +5556,13 @@ version = "1.11.5" dependencies = [ "bincode", "bs58", - "prost 0.10.4", + "prost 0.11.0", + "protobuf-src", "serde", "solana-account-decoder", "solana-sdk 1.11.5", "solana-transaction-status", - "tonic-build 0.7.2", + "tonic-build 0.8.0", ] [[package]] @@ -6424,9 +6432,9 @@ dependencies = [ [[package]] name = "tonic" -version = "0.7.2" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5be9d60db39854b30b835107500cf0aca0b0d14d6e1c3de124217c23a29c2ddb" +checksum = "498f271adc46acce75d66f639e4d35b31b2394c295c82496727dafa16d465dd2" dependencies = [ "async-stream", "async-trait", @@ -6442,8 +6450,8 @@ dependencies = [ "hyper-timeout", "percent-encoding 2.1.0", "pin-project", - "prost 0.10.4", - "prost-derive 0.10.1", + "prost 0.11.0", + "prost-derive 0.11.0", "rustls-pemfile 1.0.0", "tokio", "tokio-rustls 0.23.2", @@ -6470,13 +6478,13 @@ dependencies = [ [[package]] name = "tonic-build" -version = "0.7.2" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9263bf4c9bfaae7317c1c2faf7f18491d2fe476f70c414b73bf5d445b00ffa1" +checksum = "2fbcd2800e34e743b9ae795867d5f77b535d3a3be69fd731e39145719752df8c" dependencies = [ "prettyplease", "proc-macro2 1.0.41", - "prost-build 0.10.1", + "prost-build 0.11.0", "quote 1.0.18", "syn 1.0.98", ] diff --git a/storage-bigtable/Cargo.toml b/storage-bigtable/Cargo.toml index bdcf5f90557240..430324252246d4 100644 --- a/storage-bigtable/Cargo.toml +++ b/storage-bigtable/Cargo.toml @@ -22,8 +22,8 @@ http = "0.2.8" hyper = "0.14.20" hyper-proxy = "0.9.1" log = "0.4.17" -prost = "0.10.4" -prost-types = "0.10.0" +prost = "0.11.0" +prost-types = "0.11.0" serde = "1.0.138" serde_derive = "1.0.103" smpl_jwt = "0.7.1" @@ -33,7 +33,7 @@ solana-storage-proto = { path = "../storage-proto", version = "=1.11.5" } solana-transaction-status = { path = "../transaction-status", version = "=1.11.5" } thiserror = "1.0" tokio = "~1.14.1" -tonic = { version = "0.7.2", features = ["tls", "transport"] } +tonic = { version = "0.8.0", features = ["tls", "transport"] } zstd = "0.11.2" # openssl is a dependency of the goauth and smpl_jwt crates, but explicitly diff --git a/storage-bigtable/build-proto/Cargo.lock b/storage-bigtable/build-proto/Cargo.lock index e78f65a341e4f8..015ad69ca3d283 100644 --- a/storage-bigtable/build-proto/Cargo.lock +++ b/storage-bigtable/build-proto/Cargo.lock @@ -14,6 +14,15 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" +[[package]] +name = "autotools" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8138adefca3e5d2e73bfba83bd6eeaf904b26a7ac1b4a19892cfe16cc7e1701" +dependencies = [ + "cc", +] + [[package]] name = "bitflags" version = "1.2.1" @@ -38,15 +47,6 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" -[[package]] -name = "cmake" -version = "0.1.48" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8ad8cef104ac57b68b89df3208164d228503abbdce70f6880ffa3d970e7443a" -dependencies = [ - "cc", -] - [[package]] name = "either" version = "1.7.0" @@ -166,9 +166,9 @@ dependencies = [ [[package]] name = "prost" -version = "0.10.4" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71adf41db68aa0daaefc69bb30bcd68ded9b9abaad5d1fbb6304c4fb390e083e" +checksum = "399c3c31cdec40583bb68f0b18403400d01ec4289c383aa047560439952c4dd7" dependencies = [ "bytes", "prost-derive", @@ -176,13 +176,11 @@ dependencies = [ [[package]] name = "prost-build" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "328f9f29b82409216decb172d81e936415d21245befa79cd34c3f29d87d1c50b" +checksum = "d49d928704208aba2cb1fb022ce1a319bdedcb03caf51ddf82734fa903407762" dependencies = [ "bytes", - "cfg-if", - "cmake", "heck", "itertools", "lazy_static", @@ -198,9 +196,9 @@ dependencies = [ [[package]] name = "prost-derive" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df35198f0777b75e9ff669737c6da5136b59dba33cf5a010a6d1cc4d56defc6f" +checksum = "7345d5f0e08c0536d7ac7229952590239e77abf0a0100a1b1d890add6ea96364" dependencies = [ "anyhow", "itertools", @@ -211,9 +209,9 @@ dependencies = [ [[package]] name = "prost-types" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "926681c118ae6e512a3ccefd4abbe5521a14f4cc1e207356d4d00c0b7f2006fd" +checksum = "d30bc806a29b347314be074ff0608ef8e547286e8ea68b061a2fe55689edc01f" dependencies = [ "bytes", "prost", @@ -223,9 +221,19 @@ dependencies = [ name = "proto" version = "1.11.5" dependencies = [ + "protobuf-src", "tonic-build", ] +[[package]] +name = "protobuf-src" +version = "1.0.5+3.19.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe57f68bf9767f48f8cbcbceb5da21524e2b1330a821c1c2502c447d8043f078" +dependencies = [ + "autotools", +] + [[package]] name = "quote" version = "1.0.7" @@ -315,9 +323,9 @@ dependencies = [ [[package]] name = "tonic-build" -version = "0.7.2" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9263bf4c9bfaae7317c1c2faf7f18491d2fe476f70c414b73bf5d445b00ffa1" +checksum = "2fbcd2800e34e743b9ae795867d5f77b535d3a3be69fd731e39145719752df8c" dependencies = [ "prettyplease", "proc-macro2", diff --git a/storage-bigtable/build-proto/Cargo.toml b/storage-bigtable/build-proto/Cargo.toml index bd21224ae1fa4d..9388e4f4bc4a97 100644 --- a/storage-bigtable/build-proto/Cargo.toml +++ b/storage-bigtable/build-proto/Cargo.toml @@ -12,4 +12,5 @@ version = "1.11.5" [workspace] [dependencies] -tonic-build = "0.7.0" +protobuf-src = "1.0.5" +tonic-build = "0.8.0" diff --git a/storage-bigtable/build-proto/src/main.rs b/storage-bigtable/build-proto/src/main.rs index 4aa408937239fe..4e7b4b171021ad 100644 --- a/storage-bigtable/build-proto/src/main.rs +++ b/storage-bigtable/build-proto/src/main.rs @@ -1,4 +1,9 @@ fn main() -> Result<(), std::io::Error> { + const PROTOC_ENVAR: &str = "PROTOC"; + if std::env::var(PROTOC_ENVAR).is_err() { + std::env::set_var(PROTOC_ENVAR, protobuf_src::protoc()); + } + let manifest_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")); let out_dir = manifest_dir.join("../proto"); diff --git a/storage-bigtable/proto/google.api.rs b/storage-bigtable/proto/google.api.rs index 9e71b8bff88638..865e32d8527a23 100644 --- a/storage-bigtable/proto/google.api.rs +++ b/storage-bigtable/proto/google.api.rs @@ -1,665 +1,708 @@ -/// Defines the HTTP configuration for an API service. It contains a list of -/// \[HttpRule][google.api.HttpRule\], each specifying the mapping of an RPC method -/// to one or more HTTP REST API methods. +/// Defines the HTTP configuration for an API service. It contains a list of +/// \[HttpRule][google.api.HttpRule\], each specifying the mapping of an RPC method +/// to one or more HTTP REST API methods. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Http { - /// A list of HTTP configuration rules that apply to individual API methods. + /// A list of HTTP configuration rules that apply to individual API methods. /// - /// **NOTE:** All service configuration rules follow "last one wins" order. + /// **NOTE:** All service configuration rules follow "last one wins" order. #[prost(message, repeated, tag="1")] pub rules: ::prost::alloc::vec::Vec, - /// When set to true, URL path parameters will be fully URI-decoded except in - /// cases of single segment matches in reserved expansion, where "%2F" will be - /// left encoded. + /// When set to true, URL path parameters will be fully URI-decoded except in + /// cases of single segment matches in reserved expansion, where "%2F" will be + /// left encoded. /// - /// The default behavior is to not decode RFC 6570 reserved characters in multi - /// segment matches. + /// The default behavior is to not decode RFC 6570 reserved characters in multi + /// segment matches. #[prost(bool, tag="2")] pub fully_decode_reserved_expansion: bool, } -/// # gRPC Transcoding -/// -/// gRPC Transcoding is a feature for mapping between a gRPC method and one or -/// more HTTP REST endpoints. It allows developers to build a single API service -/// that supports both gRPC APIs and REST APIs. Many systems, including [Google -/// APIs](), -/// [Cloud Endpoints](), [gRPC -/// Gateway](), -/// and \[Envoy\]() proxy support this feature -/// and use it for large scale production services. -/// -/// `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies -/// how different portions of the gRPC request message are mapped to the URL -/// path, URL query parameters, and HTTP request body. It also controls how the -/// gRPC response message is mapped to the HTTP response body. `HttpRule` is -/// typically specified as an `google.api.http` annotation on the gRPC method. -/// -/// Each mapping specifies a URL path template and an HTTP method. The path -/// template may refer to one or more fields in the gRPC request message, as long -/// as each field is a non-repeated field with a primitive (non-message) type. -/// The path template controls how fields of the request message are mapped to -/// the URL path. -/// -/// Example: -/// -/// service Messaging { -/// rpc GetMessage(GetMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// get: "/v1/{name=messages/*}" -/// }; -/// } -/// } -/// message GetMessageRequest { -/// string name = 1; // Mapped to URL path. -/// } -/// message Message { -/// string text = 1; // The resource content. -/// } -/// -/// This enables an HTTP REST to gRPC mapping as below: -/// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")` -/// -/// Any fields in the request message which are not bound by the path template -/// automatically become HTTP query parameters if there is no HTTP request body. -/// For example: -/// -/// service Messaging { -/// rpc GetMessage(GetMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// get:"/v1/messages/{message_id}" -/// }; -/// } -/// } -/// message GetMessageRequest { -/// message SubMessage { -/// string subfield = 1; -/// } -/// string message_id = 1; // Mapped to URL path. -/// int64 revision = 2; // Mapped to URL query parameter `revision`. -/// SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`. -/// } -/// -/// This enables a HTTP JSON to RPC mapping as below: -/// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | -/// `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: -/// "foo"))` -/// -/// Note that fields which are mapped to URL query parameters must have a -/// primitive type or a repeated primitive type or a non-repeated message type. -/// In the case of a repeated type, the parameter can be repeated in the URL -/// as `...?param=A¶m=B`. In the case of a message type, each field of the -/// message is mapped to a separate parameter, such as -/// `...?foo.a=A&foo.b=B&foo.c=C`. -/// -/// For HTTP methods that allow a request body, the `body` field -/// specifies the mapping. Consider a REST update method on the -/// message resource collection: -/// -/// service Messaging { -/// rpc UpdateMessage(UpdateMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// patch: "/v1/messages/{message_id}" -/// body: "message" -/// }; -/// } -/// } -/// message UpdateMessageRequest { -/// string message_id = 1; // mapped to the URL -/// Message message = 2; // mapped to the body -/// } -/// -/// The following HTTP JSON to RPC mapping is enabled, where the -/// representation of the JSON in the request body is determined by -/// protos JSON encoding: -/// -/// HTTP | gRPC -/// -----|----- -/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: -/// "123456" message { text: "Hi!" })` -/// -/// The special name `*` can be used in the body mapping to define that -/// every field not bound by the path template should be mapped to the -/// request body. This enables the following alternative definition of -/// the update method: -/// -/// service Messaging { -/// rpc UpdateMessage(Message) returns (Message) { -/// option (google.api.http) = { -/// patch: "/v1/messages/{message_id}" -/// body: "*" -/// }; -/// } -/// } -/// message Message { -/// string message_id = 1; -/// string text = 2; -/// } -/// -/// -/// The following HTTP JSON to RPC mapping is enabled: -/// -/// HTTP | gRPC -/// -----|----- -/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: -/// "123456" text: "Hi!")` -/// -/// Note that when using `*` in the body mapping, it is not possible to -/// have HTTP parameters, as all fields not bound by the path end in -/// the body. This makes this option more rarely used in practice when -/// defining REST APIs. The common usage of `*` is in custom methods -/// which don't use the URL at all for transferring data. -/// -/// It is possible to define multiple HTTP methods for one RPC by using -/// the `additional_bindings` option. Example: -/// -/// service Messaging { -/// rpc GetMessage(GetMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// get: "/v1/messages/{message_id}" -/// additional_bindings { -/// get: "/v1/users/{user_id}/messages/{message_id}" -/// } -/// }; -/// } -/// } -/// message GetMessageRequest { -/// string message_id = 1; -/// string user_id = 2; -/// } -/// -/// This enables the following two alternative HTTP JSON to RPC mappings: -/// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` -/// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: -/// "123456")` -/// -/// ## Rules for HTTP mapping -/// -/// 1. Leaf request fields (recursive expansion nested messages in the request -/// message) are classified into three categories: -/// - Fields referred by the path template. They are passed via the URL path. -/// - Fields referred by the \[HttpRule.body][google.api.HttpRule.body\]. They are passed via the HTTP -/// request body. -/// - All other fields are passed via the URL query parameters, and the -/// parameter name is the field path in the request message. A repeated -/// field can be represented as multiple query parameters under the same -/// name. -/// 2. If \[HttpRule.body][google.api.HttpRule.body\] is "*", there is no URL query parameter, all fields -/// are passed via URL path and HTTP request body. -/// 3. If \[HttpRule.body][google.api.HttpRule.body\] is omitted, there is no HTTP request body, all -/// fields are passed via URL path and URL query parameters. -/// -/// ### Path template syntax -/// -/// Template = "/" Segments [ Verb ] ; -/// Segments = Segment { "/" Segment } ; -/// Segment = "*" | "**" | LITERAL | Variable ; -/// Variable = "{" FieldPath [ "=" Segments ] "}" ; -/// FieldPath = IDENT { "." IDENT } ; -/// Verb = ":" LITERAL ; -/// -/// The syntax `*` matches a single URL path segment. The syntax `**` matches -/// zero or more URL path segments, which must be the last part of the URL path -/// except the `Verb`. -/// -/// The syntax `Variable` matches part of the URL path as specified by its -/// template. A variable template must not contain other variables. If a variable -/// matches a single path segment, its template may be omitted, e.g. `{var}` -/// is equivalent to `{var=*}`. -/// -/// The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL` -/// contains any reserved character, such characters should be percent-encoded -/// before the matching. -/// -/// If a variable contains exactly one path segment, such as `"{var}"` or -/// `"{var=*}"`, when such a variable is expanded into a URL path on the client -/// side, all characters except `\[-_.~0-9a-zA-Z\]` are percent-encoded. The -/// server side does the reverse decoding. Such variables show up in the -/// [Discovery -/// Document]() as -/// `{var}`. -/// -/// If a variable contains multiple path segments, such as `"{var=foo/*}"` -/// or `"{var=**}"`, when such a variable is expanded into a URL path on the -/// client side, all characters except `\[-_.~/0-9a-zA-Z\]` are percent-encoded. -/// The server side does the reverse decoding, except "%2F" and "%2f" are left -/// unchanged. Such variables show up in the -/// [Discovery -/// Document]() as -/// `{+var}`. -/// -/// ## Using gRPC API Service Configuration -/// -/// gRPC API Service Configuration (service config) is a configuration language -/// for configuring a gRPC service to become a user-facing product. The -/// service config is simply the YAML representation of the `google.api.Service` -/// proto message. -/// -/// As an alternative to annotating your proto file, you can configure gRPC -/// transcoding in your service config YAML files. You do this by specifying a -/// `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same -/// effect as the proto annotation. This can be particularly useful if you -/// have a proto that is reused in multiple services. Note that any transcoding -/// specified in the service config will override any matching transcoding -/// configuration in the proto. -/// -/// Example: -/// -/// http: -/// rules: -/// # Selects a gRPC method and applies HttpRule to it. -/// - selector: example.v1.Messaging.GetMessage -/// get: /v1/messages/{message_id}/{sub.subfield} -/// -/// ## Special notes -/// -/// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the -/// proto to JSON conversion must follow the [proto3 -/// specification](). -/// -/// While the single segment variable follows the semantics of -/// [RFC 6570]() Section 3.2.2 Simple String -/// Expansion, the multi segment variable **does not** follow RFC 6570 Section -/// 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion -/// does not expand special characters like `?` and `#`, which would lead -/// to invalid URLs. As the result, gRPC Transcoding uses a custom encoding -/// for multi segment variables. -/// -/// The path variables **must not** refer to any repeated or mapped field, -/// because client libraries are not capable of handling such variable expansion. -/// -/// The path variables **must not** capture the leading "/" character. The reason -/// is that the most common use case "{var}" does not capture the leading "/" -/// character. For consistency, all path variables must share the same behavior. -/// -/// Repeated message fields must not be mapped to URL query parameters, because -/// no client library can support such complicated mapping. -/// -/// If an API needs to use a JSON array for request or response body, it can map -/// the request or response body to a repeated field. However, some gRPC -/// Transcoding implementations may not support this feature. +/// # gRPC Transcoding +/// +/// gRPC Transcoding is a feature for mapping between a gRPC method and one or +/// more HTTP REST endpoints. It allows developers to build a single API service +/// that supports both gRPC APIs and REST APIs. Many systems, including [Google +/// APIs](), +/// [Cloud Endpoints](), [gRPC +/// Gateway](), +/// and \[Envoy\]() proxy support this feature +/// and use it for large scale production services. +/// +/// `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies +/// how different portions of the gRPC request message are mapped to the URL +/// path, URL query parameters, and HTTP request body. It also controls how the +/// gRPC response message is mapped to the HTTP response body. `HttpRule` is +/// typically specified as an `google.api.http` annotation on the gRPC method. +/// +/// Each mapping specifies a URL path template and an HTTP method. The path +/// template may refer to one or more fields in the gRPC request message, as long +/// as each field is a non-repeated field with a primitive (non-message) type. +/// The path template controls how fields of the request message are mapped to +/// the URL path. +/// +/// Example: +/// +/// service Messaging { +/// rpc GetMessage(GetMessageRequest) returns (Message) { +/// option (google.api.http) = { +/// get: "/v1/{name=messages/*}" +/// }; +/// } +/// } +/// message GetMessageRequest { +/// string name = 1; // Mapped to URL path. +/// } +/// message Message { +/// string text = 1; // The resource content. +/// } +/// +/// This enables an HTTP REST to gRPC mapping as below: +/// +/// HTTP | gRPC +/// -----|----- +/// `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")` +/// +/// Any fields in the request message which are not bound by the path template +/// automatically become HTTP query parameters if there is no HTTP request body. +/// For example: +/// +/// service Messaging { +/// rpc GetMessage(GetMessageRequest) returns (Message) { +/// option (google.api.http) = { +/// get:"/v1/messages/{message_id}" +/// }; +/// } +/// } +/// message GetMessageRequest { +/// message SubMessage { +/// string subfield = 1; +/// } +/// string message_id = 1; // Mapped to URL path. +/// int64 revision = 2; // Mapped to URL query parameter `revision`. +/// SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`. +/// } +/// +/// This enables a HTTP JSON to RPC mapping as below: +/// +/// HTTP | gRPC +/// -----|----- +/// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | +/// `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: +/// "foo"))` +/// +/// Note that fields which are mapped to URL query parameters must have a +/// primitive type or a repeated primitive type or a non-repeated message type. +/// In the case of a repeated type, the parameter can be repeated in the URL +/// as `...?param=A¶m=B`. In the case of a message type, each field of the +/// message is mapped to a separate parameter, such as +/// `...?foo.a=A&foo.b=B&foo.c=C`. +/// +/// For HTTP methods that allow a request body, the `body` field +/// specifies the mapping. Consider a REST update method on the +/// message resource collection: +/// +/// service Messaging { +/// rpc UpdateMessage(UpdateMessageRequest) returns (Message) { +/// option (google.api.http) = { +/// patch: "/v1/messages/{message_id}" +/// body: "message" +/// }; +/// } +/// } +/// message UpdateMessageRequest { +/// string message_id = 1; // mapped to the URL +/// Message message = 2; // mapped to the body +/// } +/// +/// The following HTTP JSON to RPC mapping is enabled, where the +/// representation of the JSON in the request body is determined by +/// protos JSON encoding: +/// +/// HTTP | gRPC +/// -----|----- +/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: +/// "123456" message { text: "Hi!" })` +/// +/// The special name `*` can be used in the body mapping to define that +/// every field not bound by the path template should be mapped to the +/// request body. This enables the following alternative definition of +/// the update method: +/// +/// service Messaging { +/// rpc UpdateMessage(Message) returns (Message) { +/// option (google.api.http) = { +/// patch: "/v1/messages/{message_id}" +/// body: "*" +/// }; +/// } +/// } +/// message Message { +/// string message_id = 1; +/// string text = 2; +/// } +/// +/// +/// The following HTTP JSON to RPC mapping is enabled: +/// +/// HTTP | gRPC +/// -----|----- +/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: +/// "123456" text: "Hi!")` +/// +/// Note that when using `*` in the body mapping, it is not possible to +/// have HTTP parameters, as all fields not bound by the path end in +/// the body. This makes this option more rarely used in practice when +/// defining REST APIs. The common usage of `*` is in custom methods +/// which don't use the URL at all for transferring data. +/// +/// It is possible to define multiple HTTP methods for one RPC by using +/// the `additional_bindings` option. Example: +/// +/// service Messaging { +/// rpc GetMessage(GetMessageRequest) returns (Message) { +/// option (google.api.http) = { +/// get: "/v1/messages/{message_id}" +/// additional_bindings { +/// get: "/v1/users/{user_id}/messages/{message_id}" +/// } +/// }; +/// } +/// } +/// message GetMessageRequest { +/// string message_id = 1; +/// string user_id = 2; +/// } +/// +/// This enables the following two alternative HTTP JSON to RPC mappings: +/// +/// HTTP | gRPC +/// -----|----- +/// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` +/// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: +/// "123456")` +/// +/// ## Rules for HTTP mapping +/// +/// 1. Leaf request fields (recursive expansion nested messages in the request +/// message) are classified into three categories: +/// - Fields referred by the path template. They are passed via the URL path. +/// - Fields referred by the \[HttpRule.body][google.api.HttpRule.body\]. They are passed via the HTTP +/// request body. +/// - All other fields are passed via the URL query parameters, and the +/// parameter name is the field path in the request message. A repeated +/// field can be represented as multiple query parameters under the same +/// name. +/// 2. If \[HttpRule.body][google.api.HttpRule.body\] is "*", there is no URL query parameter, all fields +/// are passed via URL path and HTTP request body. +/// 3. If \[HttpRule.body][google.api.HttpRule.body\] is omitted, there is no HTTP request body, all +/// fields are passed via URL path and URL query parameters. +/// +/// ### Path template syntax +/// +/// Template = "/" Segments [ Verb ] ; +/// Segments = Segment { "/" Segment } ; +/// Segment = "*" | "**" | LITERAL | Variable ; +/// Variable = "{" FieldPath [ "=" Segments ] "}" ; +/// FieldPath = IDENT { "." IDENT } ; +/// Verb = ":" LITERAL ; +/// +/// The syntax `*` matches a single URL path segment. The syntax `**` matches +/// zero or more URL path segments, which must be the last part of the URL path +/// except the `Verb`. +/// +/// The syntax `Variable` matches part of the URL path as specified by its +/// template. A variable template must not contain other variables. If a variable +/// matches a single path segment, its template may be omitted, e.g. `{var}` +/// is equivalent to `{var=*}`. +/// +/// The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL` +/// contains any reserved character, such characters should be percent-encoded +/// before the matching. +/// +/// If a variable contains exactly one path segment, such as `"{var}"` or +/// `"{var=*}"`, when such a variable is expanded into a URL path on the client +/// side, all characters except `\[-_.~0-9a-zA-Z\]` are percent-encoded. The +/// server side does the reverse decoding. Such variables show up in the +/// [Discovery +/// Document]() as +/// `{var}`. +/// +/// If a variable contains multiple path segments, such as `"{var=foo/*}"` +/// or `"{var=**}"`, when such a variable is expanded into a URL path on the +/// client side, all characters except `\[-_.~/0-9a-zA-Z\]` are percent-encoded. +/// The server side does the reverse decoding, except "%2F" and "%2f" are left +/// unchanged. Such variables show up in the +/// [Discovery +/// Document]() as +/// `{+var}`. +/// +/// ## Using gRPC API Service Configuration +/// +/// gRPC API Service Configuration (service config) is a configuration language +/// for configuring a gRPC service to become a user-facing product. The +/// service config is simply the YAML representation of the `google.api.Service` +/// proto message. +/// +/// As an alternative to annotating your proto file, you can configure gRPC +/// transcoding in your service config YAML files. You do this by specifying a +/// `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same +/// effect as the proto annotation. This can be particularly useful if you +/// have a proto that is reused in multiple services. Note that any transcoding +/// specified in the service config will override any matching transcoding +/// configuration in the proto. +/// +/// Example: +/// +/// http: +/// rules: +/// # Selects a gRPC method and applies HttpRule to it. +/// - selector: example.v1.Messaging.GetMessage +/// get: /v1/messages/{message_id}/{sub.subfield} +/// +/// ## Special notes +/// +/// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the +/// proto to JSON conversion must follow the [proto3 +/// specification](). +/// +/// While the single segment variable follows the semantics of +/// [RFC 6570]() Section 3.2.2 Simple String +/// Expansion, the multi segment variable **does not** follow RFC 6570 Section +/// 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion +/// does not expand special characters like `?` and `#`, which would lead +/// to invalid URLs. As the result, gRPC Transcoding uses a custom encoding +/// for multi segment variables. +/// +/// The path variables **must not** refer to any repeated or mapped field, +/// because client libraries are not capable of handling such variable expansion. +/// +/// The path variables **must not** capture the leading "/" character. The reason +/// is that the most common use case "{var}" does not capture the leading "/" +/// character. For consistency, all path variables must share the same behavior. +/// +/// Repeated message fields must not be mapped to URL query parameters, because +/// no client library can support such complicated mapping. +/// +/// If an API needs to use a JSON array for request or response body, it can map +/// the request or response body to a repeated field. However, some gRPC +/// Transcoding implementations may not support this feature. #[derive(Clone, PartialEq, ::prost::Message)] pub struct HttpRule { - /// Selects a method to which this rule applies. + /// Selects a method to which this rule applies. /// - /// Refer to \[selector][google.api.DocumentationRule.selector\] for syntax details. + /// Refer to \[selector][google.api.DocumentationRule.selector\] for syntax details. #[prost(string, tag="1")] pub selector: ::prost::alloc::string::String, - /// The name of the request field whose value is mapped to the HTTP request - /// body, or `*` for mapping all request fields not captured by the path - /// pattern to the HTTP body, or omitted for not having any HTTP request body. + /// The name of the request field whose value is mapped to the HTTP request + /// body, or `*` for mapping all request fields not captured by the path + /// pattern to the HTTP body, or omitted for not having any HTTP request body. /// - /// NOTE: the referred field must be present at the top-level of the request - /// message type. + /// NOTE: the referred field must be present at the top-level of the request + /// message type. #[prost(string, tag="7")] pub body: ::prost::alloc::string::String, - /// Optional. The name of the response field whose value is mapped to the HTTP - /// response body. When omitted, the entire response message will be used - /// as the HTTP response body. + /// Optional. The name of the response field whose value is mapped to the HTTP + /// response body. When omitted, the entire response message will be used + /// as the HTTP response body. /// - /// NOTE: The referred field must be present at the top-level of the response - /// message type. + /// NOTE: The referred field must be present at the top-level of the response + /// message type. #[prost(string, tag="12")] pub response_body: ::prost::alloc::string::String, - /// Additional HTTP bindings for the selector. Nested bindings must - /// not contain an `additional_bindings` field themselves (that is, - /// the nesting may only be one level deep). + /// Additional HTTP bindings for the selector. Nested bindings must + /// not contain an `additional_bindings` field themselves (that is, + /// the nesting may only be one level deep). #[prost(message, repeated, tag="11")] pub additional_bindings: ::prost::alloc::vec::Vec, - /// Determines the URL pattern is matched by this rules. This pattern can be - /// used with any of the {get|put|post|delete|patch} methods. A custom method - /// can be defined using the 'custom' field. + /// Determines the URL pattern is matched by this rules. This pattern can be + /// used with any of the {get|put|post|delete|patch} methods. A custom method + /// can be defined using the 'custom' field. #[prost(oneof="http_rule::Pattern", tags="2, 3, 4, 5, 6, 8")] pub pattern: ::core::option::Option, } /// Nested message and enum types in `HttpRule`. pub mod http_rule { - /// Determines the URL pattern is matched by this rules. This pattern can be - /// used with any of the {get|put|post|delete|patch} methods. A custom method - /// can be defined using the 'custom' field. + /// Determines the URL pattern is matched by this rules. This pattern can be + /// used with any of the {get|put|post|delete|patch} methods. A custom method + /// can be defined using the 'custom' field. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Pattern { - /// Maps to HTTP GET. Used for listing and getting information about - /// resources. + /// Maps to HTTP GET. Used for listing and getting information about + /// resources. #[prost(string, tag="2")] Get(::prost::alloc::string::String), - /// Maps to HTTP PUT. Used for replacing a resource. + /// Maps to HTTP PUT. Used for replacing a resource. #[prost(string, tag="3")] Put(::prost::alloc::string::String), - /// Maps to HTTP POST. Used for creating a resource or performing an action. + /// Maps to HTTP POST. Used for creating a resource or performing an action. #[prost(string, tag="4")] Post(::prost::alloc::string::String), - /// Maps to HTTP DELETE. Used for deleting a resource. + /// Maps to HTTP DELETE. Used for deleting a resource. #[prost(string, tag="5")] Delete(::prost::alloc::string::String), - /// Maps to HTTP PATCH. Used for updating a resource. + /// Maps to HTTP PATCH. Used for updating a resource. #[prost(string, tag="6")] Patch(::prost::alloc::string::String), - /// The custom pattern is used for specifying an HTTP method that is not - /// included in the `pattern` field, such as HEAD, or "*" to leave the - /// HTTP method unspecified for this rule. The wild-card rule is useful - /// for services that provide content to Web (HTML) clients. + /// The custom pattern is used for specifying an HTTP method that is not + /// included in the `pattern` field, such as HEAD, or "*" to leave the + /// HTTP method unspecified for this rule. The wild-card rule is useful + /// for services that provide content to Web (HTML) clients. #[prost(message, tag="8")] Custom(super::CustomHttpPattern), } } -/// A custom pattern is used for defining custom HTTP verb. +/// A custom pattern is used for defining custom HTTP verb. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CustomHttpPattern { - /// The name of this custom HTTP verb. + /// The name of this custom HTTP verb. #[prost(string, tag="1")] pub kind: ::prost::alloc::string::String, - /// The path matched by this custom verb. + /// The path matched by this custom verb. #[prost(string, tag="2")] pub path: ::prost::alloc::string::String, } -/// An indicator of the behavior of a given field (for example, that a field -/// is required in requests, or given as output but ignored as input). -/// This **does not** change the behavior in protocol buffers itself; it only -/// denotes the behavior and may affect how API tooling handles the field. +/// An indicator of the behavior of a given field (for example, that a field +/// is required in requests, or given as output but ignored as input). +/// This **does not** change the behavior in protocol buffers itself; it only +/// denotes the behavior and may affect how API tooling handles the field. /// -/// Note: This enum **may** receive new values in the future. +/// Note: This enum **may** receive new values in the future. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum FieldBehavior { - /// Conventional default for enums. Do not use this. + /// Conventional default for enums. Do not use this. Unspecified = 0, - /// Specifically denotes a field as optional. - /// While all fields in protocol buffers are optional, this may be specified - /// for emphasis if appropriate. + /// Specifically denotes a field as optional. + /// While all fields in protocol buffers are optional, this may be specified + /// for emphasis if appropriate. Optional = 1, - /// Denotes a field as required. - /// This indicates that the field **must** be provided as part of the request, - /// and failure to do so will cause an error (usually `INVALID_ARGUMENT`). + /// Denotes a field as required. + /// This indicates that the field **must** be provided as part of the request, + /// and failure to do so will cause an error (usually `INVALID_ARGUMENT`). Required = 2, - /// Denotes a field as output only. - /// This indicates that the field is provided in responses, but including the - /// field in a request does nothing (the server *must* ignore it and - /// *must not* throw an error as a result of the field's presence). + /// Denotes a field as output only. + /// This indicates that the field is provided in responses, but including the + /// field in a request does nothing (the server *must* ignore it and + /// *must not* throw an error as a result of the field's presence). OutputOnly = 3, - /// Denotes a field as input only. - /// This indicates that the field is provided in requests, and the - /// corresponding field is not included in output. + /// Denotes a field as input only. + /// This indicates that the field is provided in requests, and the + /// corresponding field is not included in output. InputOnly = 4, - /// Denotes a field as immutable. - /// This indicates that the field may be set once in a request to create a - /// resource, but may not be changed thereafter. + /// Denotes a field as immutable. + /// This indicates that the field may be set once in a request to create a + /// resource, but may not be changed thereafter. Immutable = 5, - /// Denotes that a (repeated) field is an unordered list. - /// This indicates that the service may provide the elements of the list - /// in any arbitrary order, rather than the order the user originally - /// provided. Additionally, the list's order may or may not be stable. + /// Denotes that a (repeated) field is an unordered list. + /// This indicates that the service may provide the elements of the list + /// in any arbitrary order, rather than the order the user originally + /// provided. Additionally, the list's order may or may not be stable. UnorderedList = 6, - /// Denotes that this field returns a non-empty default value if not set. - /// This indicates that if the user provides the empty value in a request, - /// a non-empty value will be returned. The user will not be aware of what - /// non-empty value to expect. + /// Denotes that this field returns a non-empty default value if not set. + /// This indicates that if the user provides the empty value in a request, + /// a non-empty value will be returned. The user will not be aware of what + /// non-empty value to expect. NonEmptyDefault = 7, } -/// A simple descriptor of a resource type. -/// -/// ResourceDescriptor annotates a resource message (either by means of a -/// protobuf annotation or use in the service config), and associates the -/// resource's schema, the resource type, and the pattern of the resource name. -/// -/// Example: -/// -/// message Topic { -/// // Indicates this message defines a resource schema. -/// // Declares the resource type in the format of {service}/{kind}. -/// // For Kubernetes resources, the format is {api group}/{kind}. -/// option (google.api.resource) = { -/// type: "pubsub.googleapis.com/Topic" -/// name_descriptor: { -/// pattern: "projects/{project}/topics/{topic}" -/// parent_type: "cloudresourcemanager.googleapis.com/Project" -/// parent_name_extractor: "projects/{project}" -/// } -/// }; -/// } -/// -/// The ResourceDescriptor Yaml config will look like: -/// -/// resources: -/// - type: "pubsub.googleapis.com/Topic" -/// name_descriptor: -/// - pattern: "projects/{project}/topics/{topic}" -/// parent_type: "cloudresourcemanager.googleapis.com/Project" -/// parent_name_extractor: "projects/{project}" -/// -/// Sometimes, resources have multiple patterns, typically because they can -/// live under multiple parents. -/// -/// Example: -/// -/// message LogEntry { -/// option (google.api.resource) = { -/// type: "logging.googleapis.com/LogEntry" -/// name_descriptor: { -/// pattern: "projects/{project}/logs/{log}" -/// parent_type: "cloudresourcemanager.googleapis.com/Project" -/// parent_name_extractor: "projects/{project}" -/// } -/// name_descriptor: { -/// pattern: "folders/{folder}/logs/{log}" -/// parent_type: "cloudresourcemanager.googleapis.com/Folder" -/// parent_name_extractor: "folders/{folder}" -/// } -/// name_descriptor: { -/// pattern: "organizations/{organization}/logs/{log}" -/// parent_type: "cloudresourcemanager.googleapis.com/Organization" -/// parent_name_extractor: "organizations/{organization}" -/// } -/// name_descriptor: { -/// pattern: "billingAccounts/{billing_account}/logs/{log}" -/// parent_type: "billing.googleapis.com/BillingAccount" -/// parent_name_extractor: "billingAccounts/{billing_account}" -/// } -/// }; -/// } -/// -/// The ResourceDescriptor Yaml config will look like: -/// -/// resources: -/// - type: 'logging.googleapis.com/LogEntry' -/// name_descriptor: -/// - pattern: "projects/{project}/logs/{log}" -/// parent_type: "cloudresourcemanager.googleapis.com/Project" -/// parent_name_extractor: "projects/{project}" -/// - pattern: "folders/{folder}/logs/{log}" -/// parent_type: "cloudresourcemanager.googleapis.com/Folder" -/// parent_name_extractor: "folders/{folder}" -/// - pattern: "organizations/{organization}/logs/{log}" -/// parent_type: "cloudresourcemanager.googleapis.com/Organization" -/// parent_name_extractor: "organizations/{organization}" -/// - pattern: "billingAccounts/{billing_account}/logs/{log}" -/// parent_type: "billing.googleapis.com/BillingAccount" -/// parent_name_extractor: "billingAccounts/{billing_account}" -/// -/// For flexible resources, the resource name doesn't contain parent names, but -/// the resource itself has parents for policy evaluation. -/// -/// Example: -/// -/// message Shelf { -/// option (google.api.resource) = { -/// type: "library.googleapis.com/Shelf" -/// name_descriptor: { -/// pattern: "shelves/{shelf}" -/// parent_type: "cloudresourcemanager.googleapis.com/Project" -/// } -/// name_descriptor: { -/// pattern: "shelves/{shelf}" -/// parent_type: "cloudresourcemanager.googleapis.com/Folder" -/// } -/// }; -/// } -/// -/// The ResourceDescriptor Yaml config will look like: -/// -/// resources: -/// - type: 'library.googleapis.com/Shelf' -/// name_descriptor: -/// - pattern: "shelves/{shelf}" -/// parent_type: "cloudresourcemanager.googleapis.com/Project" -/// - pattern: "shelves/{shelf}" -/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +impl FieldBehavior { + /// 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 { + FieldBehavior::Unspecified => "FIELD_BEHAVIOR_UNSPECIFIED", + FieldBehavior::Optional => "OPTIONAL", + FieldBehavior::Required => "REQUIRED", + FieldBehavior::OutputOnly => "OUTPUT_ONLY", + FieldBehavior::InputOnly => "INPUT_ONLY", + FieldBehavior::Immutable => "IMMUTABLE", + FieldBehavior::UnorderedList => "UNORDERED_LIST", + FieldBehavior::NonEmptyDefault => "NON_EMPTY_DEFAULT", + } + } +} +/// A simple descriptor of a resource type. +/// +/// ResourceDescriptor annotates a resource message (either by means of a +/// protobuf annotation or use in the service config), and associates the +/// resource's schema, the resource type, and the pattern of the resource name. +/// +/// Example: +/// +/// message Topic { +/// // Indicates this message defines a resource schema. +/// // Declares the resource type in the format of {service}/{kind}. +/// // For Kubernetes resources, the format is {api group}/{kind}. +/// option (google.api.resource) = { +/// type: "pubsub.googleapis.com/Topic" +/// name_descriptor: { +/// pattern: "projects/{project}/topics/{topic}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// } +/// }; +/// } +/// +/// The ResourceDescriptor Yaml config will look like: +/// +/// resources: +/// - type: "pubsub.googleapis.com/Topic" +/// name_descriptor: +/// - pattern: "projects/{project}/topics/{topic}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// +/// Sometimes, resources have multiple patterns, typically because they can +/// live under multiple parents. +/// +/// Example: +/// +/// message LogEntry { +/// option (google.api.resource) = { +/// type: "logging.googleapis.com/LogEntry" +/// name_descriptor: { +/// pattern: "projects/{project}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// } +/// name_descriptor: { +/// pattern: "folders/{folder}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +/// parent_name_extractor: "folders/{folder}" +/// } +/// name_descriptor: { +/// pattern: "organizations/{organization}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Organization" +/// parent_name_extractor: "organizations/{organization}" +/// } +/// name_descriptor: { +/// pattern: "billingAccounts/{billing_account}/logs/{log}" +/// parent_type: "billing.googleapis.com/BillingAccount" +/// parent_name_extractor: "billingAccounts/{billing_account}" +/// } +/// }; +/// } +/// +/// The ResourceDescriptor Yaml config will look like: +/// +/// resources: +/// - type: 'logging.googleapis.com/LogEntry' +/// name_descriptor: +/// - pattern: "projects/{project}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// - pattern: "folders/{folder}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +/// parent_name_extractor: "folders/{folder}" +/// - pattern: "organizations/{organization}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Organization" +/// parent_name_extractor: "organizations/{organization}" +/// - pattern: "billingAccounts/{billing_account}/logs/{log}" +/// parent_type: "billing.googleapis.com/BillingAccount" +/// parent_name_extractor: "billingAccounts/{billing_account}" +/// +/// For flexible resources, the resource name doesn't contain parent names, but +/// the resource itself has parents for policy evaluation. +/// +/// Example: +/// +/// message Shelf { +/// option (google.api.resource) = { +/// type: "library.googleapis.com/Shelf" +/// name_descriptor: { +/// pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// } +/// name_descriptor: { +/// pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +/// } +/// }; +/// } +/// +/// The ResourceDescriptor Yaml config will look like: +/// +/// resources: +/// - type: 'library.googleapis.com/Shelf' +/// name_descriptor: +/// - pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// - pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResourceDescriptor { - /// The resource type. It must be in the format of - /// {service_name}/{resource_type_kind}. The `resource_type_kind` must be - /// singular and must not include version numbers. + /// The resource type. It must be in the format of + /// {service_name}/{resource_type_kind}. The `resource_type_kind` must be + /// singular and must not include version numbers. /// - /// Example: `storage.googleapis.com/Bucket` + /// Example: `storage.googleapis.com/Bucket` /// - /// The value of the resource_type_kind must follow the regular expression - /// /\[A-Za-z][a-zA-Z0-9\]+/. It should start with an upper case character and - /// should use PascalCase (UpperCamelCase). The maximum number of - /// characters allowed for the `resource_type_kind` is 100. + /// The value of the resource_type_kind must follow the regular expression + /// /\[A-Za-z][a-zA-Z0-9\]+/. It should start with an upper case character and + /// should use PascalCase (UpperCamelCase). The maximum number of + /// characters allowed for the `resource_type_kind` is 100. #[prost(string, tag="1")] pub r#type: ::prost::alloc::string::String, - /// Optional. The relative resource name pattern associated with this resource - /// type. The DNS prefix of the full resource name shouldn't be specified here. + /// Optional. The relative resource name pattern associated with this resource + /// type. The DNS prefix of the full resource name shouldn't be specified here. /// - /// The path pattern must follow the syntax, which aligns with HTTP binding - /// syntax: + /// The path pattern must follow the syntax, which aligns with HTTP binding + /// syntax: /// - /// Template = Segment { "/" Segment } ; - /// Segment = LITERAL | Variable ; - /// Variable = "{" LITERAL "}" ; + /// Template = Segment { "/" Segment } ; + /// Segment = LITERAL | Variable ; + /// Variable = "{" LITERAL "}" ; /// - /// Examples: + /// Examples: /// - /// - "projects/{project}/topics/{topic}" - /// - "projects/{project}/knowledgeBases/{knowledge_base}" + /// - "projects/{project}/topics/{topic}" + /// - "projects/{project}/knowledgeBases/{knowledge_base}" /// - /// The components in braces correspond to the IDs for each resource in the - /// hierarchy. It is expected that, if multiple patterns are provided, - /// the same component name (e.g. "project") refers to IDs of the same - /// type of resource. + /// The components in braces correspond to the IDs for each resource in the + /// hierarchy. It is expected that, if multiple patterns are provided, + /// the same component name (e.g. "project") refers to IDs of the same + /// type of resource. #[prost(string, repeated, tag="2")] pub pattern: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - /// Optional. The field on the resource that designates the resource name - /// field. If omitted, this is assumed to be "name". + /// Optional. The field on the resource that designates the resource name + /// field. If omitted, this is assumed to be "name". #[prost(string, tag="3")] pub name_field: ::prost::alloc::string::String, - /// Optional. The historical or future-looking state of the resource pattern. + /// Optional. The historical or future-looking state of the resource pattern. /// - /// Example: + /// Example: /// - /// // The InspectTemplate message originally only supported resource - /// // names with organization, and project was added later. - /// message InspectTemplate { - /// option (google.api.resource) = { - /// type: "dlp.googleapis.com/InspectTemplate" - /// pattern: - /// "organizations/{organization}/inspectTemplates/{inspect_template}" - /// pattern: "projects/{project}/inspectTemplates/{inspect_template}" - /// history: ORIGINALLY_SINGLE_PATTERN - /// }; - /// } + /// // The InspectTemplate message originally only supported resource + /// // names with organization, and project was added later. + /// message InspectTemplate { + /// option (google.api.resource) = { + /// type: "dlp.googleapis.com/InspectTemplate" + /// pattern: + /// "organizations/{organization}/inspectTemplates/{inspect_template}" + /// pattern: "projects/{project}/inspectTemplates/{inspect_template}" + /// history: ORIGINALLY_SINGLE_PATTERN + /// }; + /// } #[prost(enumeration="resource_descriptor::History", tag="4")] pub history: i32, - /// The plural name used in the resource name and permission names, such as - /// 'projects' for the resource name of 'projects/{project}' and the permission - /// name of 'cloudresourcemanager.googleapis.com/projects.get'. It is the same - /// concept of the `plural` field in k8s CRD spec - /// + /// The plural name used in the resource name and permission names, such as + /// 'projects' for the resource name of 'projects/{project}' and the permission + /// name of 'cloudresourcemanager.googleapis.com/projects.get'. It is the same + /// concept of the `plural` field in k8s CRD spec + /// /// - /// Note: The plural form is required even for singleton resources. See - /// + /// Note: The plural form is required even for singleton resources. See + /// #[prost(string, tag="5")] pub plural: ::prost::alloc::string::String, - /// The same concept of the `singular` field in k8s CRD spec - /// - /// Such as "project" for the `resourcemanager.googleapis.com/Project` type. + /// The same concept of the `singular` field in k8s CRD spec + /// + /// Such as "project" for the `resourcemanager.googleapis.com/Project` type. #[prost(string, tag="6")] pub singular: ::prost::alloc::string::String, - /// Style flag(s) for this resource. - /// These indicate that a resource is expected to conform to a given - /// style. See the specific style flags for additional information. + /// Style flag(s) for this resource. + /// These indicate that a resource is expected to conform to a given + /// style. See the specific style flags for additional information. #[prost(enumeration="resource_descriptor::Style", repeated, tag="10")] pub style: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `ResourceDescriptor`. pub mod resource_descriptor { - /// A description of the historical or future-looking state of the - /// resource pattern. + /// A description of the historical or future-looking state of the + /// resource pattern. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum History { - /// The "unset" value. + /// The "unset" value. Unspecified = 0, - /// The resource originally had one pattern and launched as such, and - /// additional patterns were added later. + /// The resource originally had one pattern and launched as such, and + /// additional patterns were added later. OriginallySinglePattern = 1, - /// The resource has one pattern, but the API owner expects to add more - /// later. (This is the inverse of ORIGINALLY_SINGLE_PATTERN, and prevents - /// that from being necessary once there are multiple patterns.) + /// The resource has one pattern, but the API owner expects to add more + /// later. (This is the inverse of ORIGINALLY_SINGLE_PATTERN, and prevents + /// that from being necessary once there are multiple patterns.) FutureMultiPattern = 2, } - /// A flag representing a specific style that a resource claims to conform to. + impl History { + /// 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 { + History::Unspecified => "HISTORY_UNSPECIFIED", + History::OriginallySinglePattern => "ORIGINALLY_SINGLE_PATTERN", + History::FutureMultiPattern => "FUTURE_MULTI_PATTERN", + } + } + } + /// A flag representing a specific style that a resource claims to conform to. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Style { - /// The unspecified value. Do not use. + /// The unspecified value. Do not use. Unspecified = 0, - /// This resource is intended to be "declarative-friendly". + /// This resource is intended to be "declarative-friendly". /// - /// Declarative-friendly resources must be more strictly consistent, and - /// setting this to true communicates to tools that this resource should - /// adhere to declarative-friendly expectations. + /// Declarative-friendly resources must be more strictly consistent, and + /// setting this to true communicates to tools that this resource should + /// adhere to declarative-friendly expectations. /// - /// Note: This is used by the API linter (linter.aip.dev) to enable - /// additional checks. + /// Note: This is used by the API linter (linter.aip.dev) to enable + /// additional checks. DeclarativeFriendly = 1, } + impl Style { + /// 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 { + Style::Unspecified => "STYLE_UNSPECIFIED", + Style::DeclarativeFriendly => "DECLARATIVE_FRIENDLY", + } + } + } } -/// Defines a proto annotation that describes a string field that refers to -/// an API resource. +/// Defines a proto annotation that describes a string field that refers to +/// an API resource. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResourceReference { - /// The resource type that the annotated field references. + /// The resource type that the annotated field references. /// - /// Example: + /// Example: /// - /// message Subscription { - /// string topic = 2 [(google.api.resource_reference) = { - /// type: "pubsub.googleapis.com/Topic" - /// }]; - /// } + /// message Subscription { + /// string topic = 2 [(google.api.resource_reference) = { + /// type: "pubsub.googleapis.com/Topic" + /// }]; + /// } /// - /// Occasionally, a field may reference an arbitrary resource. In this case, - /// APIs use the special value * in their resource reference. + /// Occasionally, a field may reference an arbitrary resource. In this case, + /// APIs use the special value * in their resource reference. /// - /// Example: + /// Example: /// - /// message GetIamPolicyRequest { - /// string resource = 2 [(google.api.resource_reference) = { - /// type: "*" - /// }]; - /// } + /// message GetIamPolicyRequest { + /// string resource = 2 [(google.api.resource_reference) = { + /// type: "*" + /// }]; + /// } #[prost(string, tag="1")] pub r#type: ::prost::alloc::string::String, - /// The resource type of a child collection that the annotated field - /// references. This is useful for annotating the `parent` field that - /// doesn't have a fixed resource type. + /// The resource type of a child collection that the annotated field + /// references. This is useful for annotating the `parent` field that + /// doesn't have a fixed resource type. /// - /// Example: + /// Example: /// - /// message ListLogEntriesRequest { - /// string parent = 1 [(google.api.resource_reference) = { - /// child_type: "logging.googleapis.com/LogEntry" - /// }; - /// } + /// message ListLogEntriesRequest { + /// string parent = 1 [(google.api.resource_reference) = { + /// child_type: "logging.googleapis.com/LogEntry" + /// }; + /// } #[prost(string, tag="2")] pub child_type: ::prost::alloc::string::String, } diff --git a/storage-bigtable/proto/google.bigtable.v2.rs b/storage-bigtable/proto/google.bigtable.v2.rs index 558dd7ac850f46..d980dfa4d739de 100644 --- a/storage-bigtable/proto/google.bigtable.v2.rs +++ b/storage-bigtable/proto/google.bigtable.v2.rs @@ -1,893 +1,893 @@ -/// Specifies the complete (requested) contents of a single row of a table. -/// Rows which exceed 256MiB in size cannot be read in full. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies the complete (requested) contents of a single row of a table. +/// Rows which exceed 256MiB in size cannot be read in full. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct Row { - /// The unique key which identifies this row within its table. This is the same - /// key that's used to identify the row in, for example, a MutateRowRequest. - /// May contain any non-empty byte string up to 4KiB in length. + /// The unique key which identifies this row within its table. This is the same + /// key that's used to identify the row in, for example, a MutateRowRequest. + /// May contain any non-empty byte string up to 4KiB in length. #[prost(bytes="vec", tag="1")] pub key: ::prost::alloc::vec::Vec, - /// May be empty, but only if the entire row is empty. - /// The mutual ordering of column families is not specified. + /// May be empty, but only if the entire row is empty. + /// The mutual ordering of column families is not specified. #[prost(message, repeated, tag="2")] pub families: ::prost::alloc::vec::Vec, } -/// Specifies (some of) the contents of a single row/column family intersection -/// of a table. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies (some of) the contents of a single row/column family intersection +/// of a table. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct Family { - /// The unique key which identifies this family within its row. This is the - /// same key that's used to identify the family in, for example, a RowFilter - /// which sets its "family_name_regex_filter" field. - /// Must match `\[-_.a-zA-Z0-9\]+`, except that AggregatingRowProcessors may - /// produce cells in a sentinel family with an empty name. - /// Must be no greater than 64 characters in length. + /// The unique key which identifies this family within its row. This is the + /// same key that's used to identify the family in, for example, a RowFilter + /// which sets its "family_name_regex_filter" field. + /// Must match `\[-_.a-zA-Z0-9\]+`, except that AggregatingRowProcessors may + /// produce cells in a sentinel family with an empty name. + /// Must be no greater than 64 characters in length. #[prost(string, tag="1")] pub name: ::prost::alloc::string::String, - /// Must not be empty. Sorted in order of increasing "qualifier". + /// Must not be empty. Sorted in order of increasing "qualifier". #[prost(message, repeated, tag="2")] pub columns: ::prost::alloc::vec::Vec, } -/// Specifies (some of) the contents of a single row/column intersection of a -/// table. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies (some of) the contents of a single row/column intersection of a +/// table. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct Column { - /// The unique key which identifies this column within its family. This is the - /// same key that's used to identify the column in, for example, a RowFilter - /// which sets its `column_qualifier_regex_filter` field. - /// May contain any byte string, including the empty string, up to 16kiB in - /// length. + /// The unique key which identifies this column within its family. This is the + /// same key that's used to identify the column in, for example, a RowFilter + /// which sets its `column_qualifier_regex_filter` field. + /// May contain any byte string, including the empty string, up to 16kiB in + /// length. #[prost(bytes="vec", tag="1")] pub qualifier: ::prost::alloc::vec::Vec, - /// Must not be empty. Sorted in order of decreasing "timestamp_micros". + /// Must not be empty. Sorted in order of decreasing "timestamp_micros". #[prost(message, repeated, tag="2")] pub cells: ::prost::alloc::vec::Vec, } -/// Specifies (some of) the contents of a single row/column/timestamp of a table. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies (some of) the contents of a single row/column/timestamp of a table. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct Cell { - /// The cell's stored timestamp, which also uniquely identifies it within - /// its column. - /// Values are always expressed in microseconds, but individual tables may set - /// a coarser granularity to further restrict the allowed values. For - /// example, a table which specifies millisecond granularity will only allow - /// values of `timestamp_micros` which are multiples of 1000. + /// The cell's stored timestamp, which also uniquely identifies it within + /// its column. + /// Values are always expressed in microseconds, but individual tables may set + /// a coarser granularity to further restrict the allowed values. For + /// example, a table which specifies millisecond granularity will only allow + /// values of `timestamp_micros` which are multiples of 1000. #[prost(int64, tag="1")] pub timestamp_micros: i64, - /// The value stored in the cell. - /// May contain any byte string, including the empty string, up to 100MiB in - /// length. + /// The value stored in the cell. + /// May contain any byte string, including the empty string, up to 100MiB in + /// length. #[prost(bytes="vec", tag="2")] pub value: ::prost::alloc::vec::Vec, - /// Labels applied to the cell by a \[RowFilter][google.bigtable.v2.RowFilter\]. + /// Labels applied to the cell by a \[RowFilter][google.bigtable.v2.RowFilter\]. #[prost(string, repeated, tag="3")] pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } -/// Specifies a contiguous range of rows. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies a contiguous range of rows. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct RowRange { - /// The row key at which to start the range. - /// If neither field is set, interpreted as the empty string, inclusive. + /// The row key at which to start the range. + /// If neither field is set, interpreted as the empty string, inclusive. #[prost(oneof="row_range::StartKey", tags="1, 2")] pub start_key: ::core::option::Option, - /// The row key at which to end the range. - /// If neither field is set, interpreted as the infinite row key, exclusive. + /// The row key at which to end the range. + /// If neither field is set, interpreted as the infinite row key, exclusive. #[prost(oneof="row_range::EndKey", tags="3, 4")] pub end_key: ::core::option::Option, } /// Nested message and enum types in `RowRange`. pub mod row_range { - /// The row key at which to start the range. - /// If neither field is set, interpreted as the empty string, inclusive. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// The row key at which to start the range. + /// If neither field is set, interpreted as the empty string, inclusive. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum StartKey { - /// Used when giving an inclusive lower bound for the range. + /// Used when giving an inclusive lower bound for the range. #[prost(bytes, tag="1")] StartKeyClosed(::prost::alloc::vec::Vec), - /// Used when giving an exclusive lower bound for the range. + /// Used when giving an exclusive lower bound for the range. #[prost(bytes, tag="2")] StartKeyOpen(::prost::alloc::vec::Vec), } - /// The row key at which to end the range. - /// If neither field is set, interpreted as the infinite row key, exclusive. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// The row key at which to end the range. + /// If neither field is set, interpreted as the infinite row key, exclusive. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum EndKey { - /// Used when giving an exclusive upper bound for the range. + /// Used when giving an exclusive upper bound for the range. #[prost(bytes, tag="3")] EndKeyOpen(::prost::alloc::vec::Vec), - /// Used when giving an inclusive upper bound for the range. + /// Used when giving an inclusive upper bound for the range. #[prost(bytes, tag="4")] EndKeyClosed(::prost::alloc::vec::Vec), } } -/// Specifies a non-contiguous set of rows. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies a non-contiguous set of rows. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct RowSet { - /// Single rows included in the set. + /// Single rows included in the set. #[prost(bytes="vec", repeated, tag="1")] pub row_keys: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, - /// Contiguous row ranges included in the set. + /// Contiguous row ranges included in the set. #[prost(message, repeated, tag="2")] pub row_ranges: ::prost::alloc::vec::Vec, } -/// Specifies a contiguous range of columns within a single column family. -/// The range spans from <column_family>:<start_qualifier> to -/// <column_family>:<end_qualifier>, where both bounds can be either -/// inclusive or exclusive. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies a contiguous range of columns within a single column family. +/// The range spans from <column_family>:<start_qualifier> to +/// <column_family>:<end_qualifier>, where both bounds can be either +/// inclusive or exclusive. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ColumnRange { - /// The name of the column family within which this range falls. + /// The name of the column family within which this range falls. #[prost(string, tag="1")] pub family_name: ::prost::alloc::string::String, - /// The column qualifier at which to start the range (within `column_family`). - /// If neither field is set, interpreted as the empty string, inclusive. + /// The column qualifier at which to start the range (within `column_family`). + /// If neither field is set, interpreted as the empty string, inclusive. #[prost(oneof="column_range::StartQualifier", tags="2, 3")] pub start_qualifier: ::core::option::Option, - /// The column qualifier at which to end the range (within `column_family`). - /// If neither field is set, interpreted as the infinite string, exclusive. + /// The column qualifier at which to end the range (within `column_family`). + /// If neither field is set, interpreted as the infinite string, exclusive. #[prost(oneof="column_range::EndQualifier", tags="4, 5")] pub end_qualifier: ::core::option::Option, } /// Nested message and enum types in `ColumnRange`. pub mod column_range { - /// The column qualifier at which to start the range (within `column_family`). - /// If neither field is set, interpreted as the empty string, inclusive. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// The column qualifier at which to start the range (within `column_family`). + /// If neither field is set, interpreted as the empty string, inclusive. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum StartQualifier { - /// Used when giving an inclusive lower bound for the range. + /// Used when giving an inclusive lower bound for the range. #[prost(bytes, tag="2")] StartQualifierClosed(::prost::alloc::vec::Vec), - /// Used when giving an exclusive lower bound for the range. + /// Used when giving an exclusive lower bound for the range. #[prost(bytes, tag="3")] StartQualifierOpen(::prost::alloc::vec::Vec), } - /// The column qualifier at which to end the range (within `column_family`). - /// If neither field is set, interpreted as the infinite string, exclusive. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// The column qualifier at which to end the range (within `column_family`). + /// If neither field is set, interpreted as the infinite string, exclusive. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum EndQualifier { - /// Used when giving an inclusive upper bound for the range. + /// Used when giving an inclusive upper bound for the range. #[prost(bytes, tag="4")] EndQualifierClosed(::prost::alloc::vec::Vec), - /// Used when giving an exclusive upper bound for the range. + /// Used when giving an exclusive upper bound for the range. #[prost(bytes, tag="5")] EndQualifierOpen(::prost::alloc::vec::Vec), } } -/// Specified a contiguous range of microsecond timestamps. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specified a contiguous range of microsecond timestamps. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct TimestampRange { - /// Inclusive lower bound. If left empty, interpreted as 0. + /// Inclusive lower bound. If left empty, interpreted as 0. #[prost(int64, tag="1")] pub start_timestamp_micros: i64, - /// Exclusive upper bound. If left empty, interpreted as infinity. + /// Exclusive upper bound. If left empty, interpreted as infinity. #[prost(int64, tag="2")] pub end_timestamp_micros: i64, } -/// Specifies a contiguous range of raw byte values. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies a contiguous range of raw byte values. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ValueRange { - /// The value at which to start the range. - /// If neither field is set, interpreted as the empty string, inclusive. + /// The value at which to start the range. + /// If neither field is set, interpreted as the empty string, inclusive. #[prost(oneof="value_range::StartValue", tags="1, 2")] pub start_value: ::core::option::Option, - /// The value at which to end the range. - /// If neither field is set, interpreted as the infinite string, exclusive. + /// The value at which to end the range. + /// If neither field is set, interpreted as the infinite string, exclusive. #[prost(oneof="value_range::EndValue", tags="3, 4")] pub end_value: ::core::option::Option, } /// Nested message and enum types in `ValueRange`. pub mod value_range { - /// The value at which to start the range. - /// If neither field is set, interpreted as the empty string, inclusive. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// The value at which to start the range. + /// If neither field is set, interpreted as the empty string, inclusive. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum StartValue { - /// Used when giving an inclusive lower bound for the range. + /// Used when giving an inclusive lower bound for the range. #[prost(bytes, tag="1")] StartValueClosed(::prost::alloc::vec::Vec), - /// Used when giving an exclusive lower bound for the range. + /// Used when giving an exclusive lower bound for the range. #[prost(bytes, tag="2")] StartValueOpen(::prost::alloc::vec::Vec), } - /// The value at which to end the range. - /// If neither field is set, interpreted as the infinite string, exclusive. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// The value at which to end the range. + /// If neither field is set, interpreted as the infinite string, exclusive. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum EndValue { - /// Used when giving an inclusive upper bound for the range. + /// Used when giving an inclusive upper bound for the range. #[prost(bytes, tag="3")] EndValueClosed(::prost::alloc::vec::Vec), - /// Used when giving an exclusive upper bound for the range. + /// Used when giving an exclusive upper bound for the range. #[prost(bytes, tag="4")] EndValueOpen(::prost::alloc::vec::Vec), } } -/// Takes a row as input and produces an alternate view of the row based on -/// specified rules. For example, a RowFilter might trim down a row to include -/// just the cells from columns matching a given regular expression, or might -/// return all the cells of a row but not their values. More complicated filters -/// can be composed out of these components to express requests such as, "within -/// every column of a particular family, give just the two most recent cells -/// which are older than timestamp X." +/// Takes a row as input and produces an alternate view of the row based on +/// specified rules. For example, a RowFilter might trim down a row to include +/// just the cells from columns matching a given regular expression, or might +/// return all the cells of a row but not their values. More complicated filters +/// can be composed out of these components to express requests such as, "within +/// every column of a particular family, give just the two most recent cells +/// which are older than timestamp X." /// -/// There are two broad categories of RowFilters (true filters and transformers), -/// as well as two ways to compose simple filters into more complex ones -/// (chains and interleaves). They work as follows: +/// There are two broad categories of RowFilters (true filters and transformers), +/// as well as two ways to compose simple filters into more complex ones +/// (chains and interleaves). They work as follows: /// -/// * True filters alter the input row by excluding some of its cells wholesale -/// from the output row. An example of a true filter is the `value_regex_filter`, -/// which excludes cells whose values don't match the specified pattern. All -/// regex true filters use RE2 syntax () -/// in raw byte mode (RE2::Latin1), and are evaluated as full matches. An -/// important point to keep in mind is that `RE2(.)` is equivalent by default to -/// `RE2(\[^\n\])`, meaning that it does not match newlines. When attempting to -/// match an arbitrary byte, you should therefore use the escape sequence `\C`, -/// which may need to be further escaped as `\\C` in your client language. +/// * True filters alter the input row by excluding some of its cells wholesale +/// from the output row. An example of a true filter is the `value_regex_filter`, +/// which excludes cells whose values don't match the specified pattern. All +/// regex true filters use RE2 syntax () +/// in raw byte mode (RE2::Latin1), and are evaluated as full matches. An +/// important point to keep in mind is that `RE2(.)` is equivalent by default to +/// `RE2(\[^\n\])`, meaning that it does not match newlines. When attempting to +/// match an arbitrary byte, you should therefore use the escape sequence `\C`, +/// which may need to be further escaped as `\\C` in your client language. /// -/// * Transformers alter the input row by changing the values of some of its -/// cells in the output, without excluding them completely. Currently, the only -/// supported transformer is the `strip_value_transformer`, which replaces every -/// cell's value with the empty string. +/// * Transformers alter the input row by changing the values of some of its +/// cells in the output, without excluding them completely. Currently, the only +/// supported transformer is the `strip_value_transformer`, which replaces every +/// cell's value with the empty string. /// -/// * Chains and interleaves are described in more detail in the -/// RowFilter.Chain and RowFilter.Interleave documentation. +/// * Chains and interleaves are described in more detail in the +/// RowFilter.Chain and RowFilter.Interleave documentation. /// -/// The total serialized size of a RowFilter message must not -/// exceed 4096 bytes, and RowFilters may not be nested within each other -/// (in Chains or Interleaves) to a depth of more than 20. +/// The total serialized size of a RowFilter message must not +/// exceed 4096 bytes, and RowFilters may not be nested within each other +/// (in Chains or Interleaves) to a depth of more than 20. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RowFilter { - /// Which of the possible RowFilter types to apply. If none are set, this - /// RowFilter returns all cells in the input row. + /// Which of the possible RowFilter types to apply. If none are set, this + /// RowFilter returns all cells in the input row. #[prost(oneof="row_filter::Filter", tags="1, 2, 3, 16, 17, 18, 4, 14, 5, 6, 7, 8, 9, 15, 10, 11, 12, 13, 19")] pub filter: ::core::option::Option, } /// Nested message and enum types in `RowFilter`. pub mod row_filter { - /// A RowFilter which sends rows through several RowFilters in sequence. + /// A RowFilter which sends rows through several RowFilters in sequence. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Chain { - /// The elements of "filters" are chained together to process the input row: - /// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row - /// The full chain is executed atomically. + /// The elements of "filters" are chained together to process the input row: + /// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row + /// The full chain is executed atomically. #[prost(message, repeated, tag="1")] pub filters: ::prost::alloc::vec::Vec, } - /// A RowFilter which sends each row to each of several component - /// RowFilters and interleaves the results. + /// A RowFilter which sends each row to each of several component + /// RowFilters and interleaves the results. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Interleave { - /// The elements of "filters" all process a copy of the input row, and the - /// results are pooled, sorted, and combined into a single output row. - /// If multiple cells are produced with the same column and timestamp, - /// they will all appear in the output row in an unspecified mutual order. - /// Consider the following example, with three filters: + /// The elements of "filters" all process a copy of the input row, and the + /// results are pooled, sorted, and combined into a single output row. + /// If multiple cells are produced with the same column and timestamp, + /// they will all appear in the output row in an unspecified mutual order. + /// Consider the following example, with three filters: ///```ignore - /// input row - /// | - /// ----------------------------------------------------- - /// | | | - /// f(0) f(1) f(2) - /// | | | - /// 1: foo,bar,10,x foo,bar,10,z far,bar,7,a - /// 2: foo,blah,11,z far,blah,5,x far,blah,5,x - /// | | | - /// ----------------------------------------------------- - /// | - /// 1: foo,bar,10,z // could have switched with #2 - /// 2: foo,bar,10,x // could have switched with #1 - /// 3: foo,blah,11,z - /// 4: far,bar,7,a - /// 5: far,blah,5,x // identical to #6 - /// 6: far,blah,5,x // identical to #5 + /// input row + /// | + /// ----------------------------------------------------- + /// | | | + /// f(0) f(1) f(2) + /// | | | + /// 1: foo,bar,10,x foo,bar,10,z far,bar,7,a + /// 2: foo,blah,11,z far,blah,5,x far,blah,5,x + /// | | | + /// ----------------------------------------------------- + /// | + /// 1: foo,bar,10,z // could have switched with #2 + /// 2: foo,bar,10,x // could have switched with #1 + /// 3: foo,blah,11,z + /// 4: far,bar,7,a + /// 5: far,blah,5,x // identical to #6 + /// 6: far,blah,5,x // identical to #5 /// - /// All interleaved filters are executed atomically. + /// All interleaved filters are executed atomically. #[prost(message, repeated, tag="1")] pub filters: ::prost::alloc::vec::Vec, } - /// A RowFilter which evaluates one of two possible RowFilters, depending on - /// whether or not a predicate RowFilter outputs any cells from the input row. + /// A RowFilter which evaluates one of two possible RowFilters, depending on + /// whether or not a predicate RowFilter outputs any cells from the input row. /// - /// IMPORTANT NOTE: The predicate filter does not execute atomically with the - /// true and false filters, which may lead to inconsistent or unexpected - /// results. Additionally, Condition filters have poor performance, especially - /// when filters are set for the false condition. + /// IMPORTANT NOTE: The predicate filter does not execute atomically with the + /// true and false filters, which may lead to inconsistent or unexpected + /// results. Additionally, Condition filters have poor performance, especially + /// when filters are set for the false condition. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Condition { - /// If `predicate_filter` outputs any cells, then `true_filter` will be - /// evaluated on the input row. Otherwise, `false_filter` will be evaluated. + /// If `predicate_filter` outputs any cells, then `true_filter` will be + /// evaluated on the input row. Otherwise, `false_filter` will be evaluated. #[prost(message, optional, boxed, tag="1")] pub predicate_filter: ::core::option::Option<::prost::alloc::boxed::Box>, - /// The filter to apply to the input row if `predicate_filter` returns any - /// results. If not provided, no results will be returned in the true case. + /// The filter to apply to the input row if `predicate_filter` returns any + /// results. If not provided, no results will be returned in the true case. #[prost(message, optional, boxed, tag="2")] pub true_filter: ::core::option::Option<::prost::alloc::boxed::Box>, - /// The filter to apply to the input row if `predicate_filter` does not - /// return any results. If not provided, no results will be returned in the - /// false case. + /// The filter to apply to the input row if `predicate_filter` does not + /// return any results. If not provided, no results will be returned in the + /// false case. #[prost(message, optional, boxed, tag="3")] pub false_filter: ::core::option::Option<::prost::alloc::boxed::Box>, } - /// Which of the possible RowFilter types to apply. If none are set, this - /// RowFilter returns all cells in the input row. + /// Which of the possible RowFilter types to apply. If none are set, this + /// RowFilter returns all cells in the input row. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Filter { - /// Applies several RowFilters to the data in sequence, progressively - /// narrowing the results. + /// Applies several RowFilters to the data in sequence, progressively + /// narrowing the results. #[prost(message, tag="1")] Chain(Chain), - /// Applies several RowFilters to the data in parallel and combines the - /// results. + /// Applies several RowFilters to the data in parallel and combines the + /// results. #[prost(message, tag="2")] Interleave(Interleave), - /// Applies one of two possible RowFilters to the data based on the output of - /// a predicate RowFilter. + /// Applies one of two possible RowFilters to the data based on the output of + /// a predicate RowFilter. #[prost(message, tag="3")] Condition(::prost::alloc::boxed::Box), - /// ADVANCED USE ONLY. - /// Hook for introspection into the RowFilter. Outputs all cells directly to - /// the output of the read rather than to any parent filter. Consider the - /// following example: + /// ADVANCED USE ONLY. + /// Hook for introspection into the RowFilter. Outputs all cells directly to + /// the output of the read rather than to any parent filter. Consider the + /// following example: ///```ignore - /// Chain( - /// FamilyRegex("A"), - /// Interleave( - /// All(), - /// Chain(Label("foo"), Sink()) - /// ), - /// QualifierRegex("B") - /// ) + /// Chain( + /// FamilyRegex("A"), + /// Interleave( + /// All(), + /// Chain(Label("foo"), Sink()) + /// ), + /// QualifierRegex("B") + /// ) /// - /// A,A,1,w - /// A,B,2,x - /// B,B,4,z - /// | - /// FamilyRegex("A") - /// | - /// A,A,1,w - /// A,B,2,x - /// | - /// +------------+-------------+ - /// | | - /// All() Label(foo) - /// | | - /// A,A,1,w A,A,1,w,labels:\[foo\] - /// A,B,2,x A,B,2,x,labels:\[foo\] - /// | | - /// | Sink() --------------+ - /// | | | - /// +------------+ x------+ A,A,1,w,labels:\[foo\] - /// | A,B,2,x,labels:\[foo\] - /// A,A,1,w | - /// A,B,2,x | - /// | | - /// QualifierRegex("B") | - /// | | - /// A,B,2,x | - /// | | - /// +--------------------------------+ - /// | - /// A,A,1,w,labels:\[foo\] - /// A,B,2,x,labels:\[foo\] // could be switched - /// A,B,2,x // could be switched + /// A,A,1,w + /// A,B,2,x + /// B,B,4,z + /// | + /// FamilyRegex("A") + /// | + /// A,A,1,w + /// A,B,2,x + /// | + /// +------------+-------------+ + /// | | + /// All() Label(foo) + /// | | + /// A,A,1,w A,A,1,w,labels:\[foo\] + /// A,B,2,x A,B,2,x,labels:\[foo\] + /// | | + /// | Sink() --------------+ + /// | | | + /// +------------+ x------+ A,A,1,w,labels:\[foo\] + /// | A,B,2,x,labels:\[foo\] + /// A,A,1,w | + /// A,B,2,x | + /// | | + /// QualifierRegex("B") | + /// | | + /// A,B,2,x | + /// | | + /// +--------------------------------+ + /// | + /// A,A,1,w,labels:\[foo\] + /// A,B,2,x,labels:\[foo\] // could be switched + /// A,B,2,x // could be switched /// - /// Despite being excluded by the qualifier filter, a copy of every cell - /// that reaches the sink is present in the final result. + /// Despite being excluded by the qualifier filter, a copy of every cell + /// that reaches the sink is present in the final result. /// - /// As with an \[Interleave][google.bigtable.v2.RowFilter.Interleave\], - /// duplicate cells are possible, and appear in an unspecified mutual order. - /// In this case we have a duplicate with column "A:B" and timestamp 2, - /// because one copy passed through the all filter while the other was - /// passed through the label and sink. Note that one copy has label "foo", - /// while the other does not. + /// As with an \[Interleave][google.bigtable.v2.RowFilter.Interleave\], + /// duplicate cells are possible, and appear in an unspecified mutual order. + /// In this case we have a duplicate with column "A:B" and timestamp 2, + /// because one copy passed through the all filter while the other was + /// passed through the label and sink. Note that one copy has label "foo", + /// while the other does not. /// - /// Cannot be used within the `predicate_filter`, `true_filter`, or - /// `false_filter` of a \[Condition][google.bigtable.v2.RowFilter.Condition\]. + /// Cannot be used within the `predicate_filter`, `true_filter`, or + /// `false_filter` of a \[Condition][google.bigtable.v2.RowFilter.Condition\]. #[prost(bool, tag="16")] Sink(bool), - /// Matches all cells, regardless of input. Functionally equivalent to - /// leaving `filter` unset, but included for completeness. + /// Matches all cells, regardless of input. Functionally equivalent to + /// leaving `filter` unset, but included for completeness. #[prost(bool, tag="17")] PassAllFilter(bool), - /// Does not match any cells, regardless of input. Useful for temporarily - /// disabling just part of a filter. + /// Does not match any cells, regardless of input. Useful for temporarily + /// disabling just part of a filter. #[prost(bool, tag="18")] BlockAllFilter(bool), - /// Matches only cells from rows whose keys satisfy the given RE2 regex. In - /// other words, passes through the entire row when the key matches, and - /// otherwise produces an empty row. - /// Note that, since row keys can contain arbitrary bytes, the `\C` escape - /// sequence must be used if a true wildcard is desired. The `.` character - /// will not match the new line character `\n`, which may be present in a - /// binary key. + /// Matches only cells from rows whose keys satisfy the given RE2 regex. In + /// other words, passes through the entire row when the key matches, and + /// otherwise produces an empty row. + /// Note that, since row keys can contain arbitrary bytes, the `\C` escape + /// sequence must be used if a true wildcard is desired. The `.` character + /// will not match the new line character `\n`, which may be present in a + /// binary key. #[prost(bytes, tag="4")] RowKeyRegexFilter(::prost::alloc::vec::Vec), - /// Matches all cells from a row with probability p, and matches no cells - /// from the row with probability 1-p. + /// Matches all cells from a row with probability p, and matches no cells + /// from the row with probability 1-p. #[prost(double, tag="14")] RowSampleFilter(f64), - /// Matches only cells from columns whose families satisfy the given RE2 - /// regex. For technical reasons, the regex must not contain the `:` - /// character, even if it is not being used as a literal. - /// Note that, since column families cannot contain the new line character - /// `\n`, it is sufficient to use `.` as a full wildcard when matching - /// column family names. + /// Matches only cells from columns whose families satisfy the given RE2 + /// regex. For technical reasons, the regex must not contain the `:` + /// character, even if it is not being used as a literal. + /// Note that, since column families cannot contain the new line character + /// `\n`, it is sufficient to use `.` as a full wildcard when matching + /// column family names. #[prost(string, tag="5")] FamilyNameRegexFilter(::prost::alloc::string::String), - /// Matches only cells from columns whose qualifiers satisfy the given RE2 - /// regex. - /// Note that, since column qualifiers can contain arbitrary bytes, the `\C` - /// escape sequence must be used if a true wildcard is desired. The `.` - /// character will not match the new line character `\n`, which may be - /// present in a binary qualifier. + /// Matches only cells from columns whose qualifiers satisfy the given RE2 + /// regex. + /// Note that, since column qualifiers can contain arbitrary bytes, the `\C` + /// escape sequence must be used if a true wildcard is desired. The `.` + /// character will not match the new line character `\n`, which may be + /// present in a binary qualifier. #[prost(bytes, tag="6")] ColumnQualifierRegexFilter(::prost::alloc::vec::Vec), - /// Matches only cells from columns within the given range. + /// Matches only cells from columns within the given range. #[prost(message, tag="7")] ColumnRangeFilter(super::ColumnRange), - /// Matches only cells with timestamps within the given range. + /// Matches only cells with timestamps within the given range. #[prost(message, tag="8")] TimestampRangeFilter(super::TimestampRange), - /// Matches only cells with values that satisfy the given regular expression. - /// Note that, since cell values can contain arbitrary bytes, the `\C` escape - /// sequence must be used if a true wildcard is desired. The `.` character - /// will not match the new line character `\n`, which may be present in a - /// binary value. + /// Matches only cells with values that satisfy the given regular expression. + /// Note that, since cell values can contain arbitrary bytes, the `\C` escape + /// sequence must be used if a true wildcard is desired. The `.` character + /// will not match the new line character `\n`, which may be present in a + /// binary value. #[prost(bytes, tag="9")] ValueRegexFilter(::prost::alloc::vec::Vec), - /// Matches only cells with values that fall within the given range. + /// Matches only cells with values that fall within the given range. #[prost(message, tag="15")] ValueRangeFilter(super::ValueRange), - /// Skips the first N cells of each row, matching all subsequent cells. - /// If duplicate cells are present, as is possible when using an Interleave, - /// each copy of the cell is counted separately. + /// Skips the first N cells of each row, matching all subsequent cells. + /// If duplicate cells are present, as is possible when using an Interleave, + /// each copy of the cell is counted separately. #[prost(int32, tag="10")] CellsPerRowOffsetFilter(i32), - /// Matches only the first N cells of each row. - /// If duplicate cells are present, as is possible when using an Interleave, - /// each copy of the cell is counted separately. + /// Matches only the first N cells of each row. + /// If duplicate cells are present, as is possible when using an Interleave, + /// each copy of the cell is counted separately. #[prost(int32, tag="11")] CellsPerRowLimitFilter(i32), - /// Matches only the most recent N cells within each column. For example, - /// if N=2, this filter would match column `foo:bar` at timestamps 10 and 9, - /// skip all earlier cells in `foo:bar`, and then begin matching again in - /// column `foo:bar2`. - /// If duplicate cells are present, as is possible when using an Interleave, - /// each copy of the cell is counted separately. + /// Matches only the most recent N cells within each column. For example, + /// if N=2, this filter would match column `foo:bar` at timestamps 10 and 9, + /// skip all earlier cells in `foo:bar`, and then begin matching again in + /// column `foo:bar2`. + /// If duplicate cells are present, as is possible when using an Interleave, + /// each copy of the cell is counted separately. #[prost(int32, tag="12")] CellsPerColumnLimitFilter(i32), - /// Replaces each cell's value with the empty string. + /// Replaces each cell's value with the empty string. #[prost(bool, tag="13")] StripValueTransformer(bool), - /// Applies the given label to all cells in the output row. This allows - /// the client to determine which results were produced from which part of - /// the filter. + /// Applies the given label to all cells in the output row. This allows + /// the client to determine which results were produced from which part of + /// the filter. /// - /// Values must be at most 15 characters in length, and match the RE2 - /// pattern `\[a-z0-9\\-\]+` + /// Values must be at most 15 characters in length, and match the RE2 + /// pattern `\[a-z0-9\\-\]+` /// - /// Due to a technical limitation, it is not currently possible to apply - /// multiple labels to a cell. As a result, a Chain may have no more than - /// one sub-filter which contains a `apply_label_transformer`. It is okay for - /// an Interleave to contain multiple `apply_label_transformers`, as they - /// will be applied to separate copies of the input. This may be relaxed in - /// the future. + /// Due to a technical limitation, it is not currently possible to apply + /// multiple labels to a cell. As a result, a Chain may have no more than + /// one sub-filter which contains a `apply_label_transformer`. It is okay for + /// an Interleave to contain multiple `apply_label_transformers`, as they + /// will be applied to separate copies of the input. This may be relaxed in + /// the future. #[prost(string, tag="19")] ApplyLabelTransformer(::prost::alloc::string::String), } } -/// Specifies a particular change to be made to the contents of a row. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies a particular change to be made to the contents of a row. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct Mutation { - /// Which of the possible Mutation types to apply. + /// Which of the possible Mutation types to apply. #[prost(oneof="mutation::Mutation", tags="1, 2, 3, 4")] pub mutation: ::core::option::Option, } /// Nested message and enum types in `Mutation`. pub mod mutation { - /// A Mutation which sets the value of the specified cell. - #[derive(Clone, PartialEq, Eq, ::prost::Message)] + /// A Mutation which sets the value of the specified cell. + #[derive(Clone, PartialEq, ::prost::Message)] pub struct SetCell { - /// The name of the family into which new data should be written. - /// Must match `\[-_.a-zA-Z0-9\]+` + /// The name of the family into which new data should be written. + /// Must match `\[-_.a-zA-Z0-9\]+` #[prost(string, tag="1")] pub family_name: ::prost::alloc::string::String, - /// The qualifier of the column into which new data should be written. - /// Can be any byte string, including the empty string. + /// The qualifier of the column into which new data should be written. + /// Can be any byte string, including the empty string. #[prost(bytes="vec", tag="2")] pub column_qualifier: ::prost::alloc::vec::Vec, - /// The timestamp of the cell into which new data should be written. - /// Use -1 for current Bigtable server time. - /// Otherwise, the client should set this value itself, noting that the - /// default value is a timestamp of zero if the field is left unspecified. - /// Values must match the granularity of the table (e.g. micros, millis). + /// The timestamp of the cell into which new data should be written. + /// Use -1 for current Bigtable server time. + /// Otherwise, the client should set this value itself, noting that the + /// default value is a timestamp of zero if the field is left unspecified. + /// Values must match the granularity of the table (e.g. micros, millis). #[prost(int64, tag="3")] pub timestamp_micros: i64, - /// The value to be written into the specified cell. + /// The value to be written into the specified cell. #[prost(bytes="vec", tag="4")] pub value: ::prost::alloc::vec::Vec, } - /// A Mutation which deletes cells from the specified column, optionally - /// restricting the deletions to a given timestamp range. - #[derive(Clone, PartialEq, Eq, ::prost::Message)] + /// A Mutation which deletes cells from the specified column, optionally + /// restricting the deletions to a given timestamp range. + #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteFromColumn { - /// The name of the family from which cells should be deleted. - /// Must match `\[-_.a-zA-Z0-9\]+` + /// The name of the family from which cells should be deleted. + /// Must match `\[-_.a-zA-Z0-9\]+` #[prost(string, tag="1")] pub family_name: ::prost::alloc::string::String, - /// The qualifier of the column from which cells should be deleted. - /// Can be any byte string, including the empty string. + /// The qualifier of the column from which cells should be deleted. + /// Can be any byte string, including the empty string. #[prost(bytes="vec", tag="2")] pub column_qualifier: ::prost::alloc::vec::Vec, - /// The range of timestamps within which cells should be deleted. + /// The range of timestamps within which cells should be deleted. #[prost(message, optional, tag="3")] pub time_range: ::core::option::Option, } - /// A Mutation which deletes all cells from the specified column family. - #[derive(Clone, PartialEq, Eq, ::prost::Message)] + /// A Mutation which deletes all cells from the specified column family. + #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteFromFamily { - /// The name of the family from which cells should be deleted. - /// Must match `\[-_.a-zA-Z0-9\]+` + /// The name of the family from which cells should be deleted. + /// Must match `\[-_.a-zA-Z0-9\]+` #[prost(string, tag="1")] pub family_name: ::prost::alloc::string::String, } - /// A Mutation which deletes all cells from the containing row. - #[derive(Clone, PartialEq, Eq, ::prost::Message)] + /// A Mutation which deletes all cells from the containing row. + #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteFromRow { } - /// Which of the possible Mutation types to apply. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// Which of the possible Mutation types to apply. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Mutation { - /// Set a cell's value. + /// Set a cell's value. #[prost(message, tag="1")] SetCell(SetCell), - /// Deletes cells from a column. + /// Deletes cells from a column. #[prost(message, tag="2")] DeleteFromColumn(DeleteFromColumn), - /// Deletes cells from a column family. + /// Deletes cells from a column family. #[prost(message, tag="3")] DeleteFromFamily(DeleteFromFamily), - /// Deletes cells from the entire row. + /// Deletes cells from the entire row. #[prost(message, tag="4")] DeleteFromRow(DeleteFromRow), } } -/// Specifies an atomic read/modify/write operation on the latest value of the -/// specified column. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Specifies an atomic read/modify/write operation on the latest value of the +/// specified column. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadModifyWriteRule { - /// The name of the family to which the read/modify/write should be applied. - /// Must match `\[-_.a-zA-Z0-9\]+` + /// The name of the family to which the read/modify/write should be applied. + /// Must match `\[-_.a-zA-Z0-9\]+` #[prost(string, tag="1")] pub family_name: ::prost::alloc::string::String, - /// The qualifier of the column to which the read/modify/write should be - /// applied. - /// Can be any byte string, including the empty string. + /// The qualifier of the column to which the read/modify/write should be + /// applied. + /// Can be any byte string, including the empty string. #[prost(bytes="vec", tag="2")] pub column_qualifier: ::prost::alloc::vec::Vec, - /// The rule used to determine the column's new latest value from its current - /// latest value. + /// The rule used to determine the column's new latest value from its current + /// latest value. #[prost(oneof="read_modify_write_rule::Rule", tags="3, 4")] pub rule: ::core::option::Option, } /// Nested message and enum types in `ReadModifyWriteRule`. pub mod read_modify_write_rule { - /// The rule used to determine the column's new latest value from its current - /// latest value. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// The rule used to determine the column's new latest value from its current + /// latest value. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Rule { - /// Rule specifying that `append_value` be appended to the existing value. - /// If the targeted cell is unset, it will be treated as containing the - /// empty string. + /// Rule specifying that `append_value` be appended to the existing value. + /// If the targeted cell is unset, it will be treated as containing the + /// empty string. #[prost(bytes, tag="3")] AppendValue(::prost::alloc::vec::Vec), - /// Rule specifying that `increment_amount` be added to the existing value. - /// If the targeted cell is unset, it will be treated as containing a zero. - /// Otherwise, the targeted cell must contain an 8-byte value (interpreted - /// as a 64-bit big-endian signed integer), or the entire request will fail. + /// Rule specifying that `increment_amount` be added to the existing value. + /// If the targeted cell is unset, it will be treated as containing a zero. + /// Otherwise, the targeted cell must contain an 8-byte value (interpreted + /// as a 64-bit big-endian signed integer), or the entire request will fail. #[prost(int64, tag="4")] IncrementAmount(i64), } } -/// Request message for Bigtable.ReadRows. +/// Request message for Bigtable.ReadRows. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadRowsRequest { - /// Required. The unique name of the table from which to read. - /// Values are of the form - /// `projects//instances//tables/`. + /// Required. The unique name of the table from which to read. + /// Values are of the form + /// `projects//instances//tables/
`. #[prost(string, tag="1")] pub table_name: ::prost::alloc::string::String, - /// This value specifies routing for replication. If not specified, the - /// "default" application profile will be used. + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. #[prost(string, tag="5")] pub app_profile_id: ::prost::alloc::string::String, - /// The row keys and/or ranges to read. If not specified, reads from all rows. + /// The row keys and/or ranges to read. If not specified, reads from all rows. #[prost(message, optional, tag="2")] pub rows: ::core::option::Option, - /// The filter to apply to the contents of the specified row(s). If unset, - /// reads the entirety of each row. + /// The filter to apply to the contents of the specified row(s). If unset, + /// reads the entirety of each row. #[prost(message, optional, tag="3")] pub filter: ::core::option::Option, - /// The read will terminate after committing to N rows' worth of results. The - /// default (zero) is to return all results. + /// The read will terminate after committing to N rows' worth of results. The + /// default (zero) is to return all results. #[prost(int64, tag="4")] pub rows_limit: i64, } -/// Response message for Bigtable.ReadRows. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Response message for Bigtable.ReadRows. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadRowsResponse { - /// A collection of a row's contents as part of the read request. + /// A collection of a row's contents as part of the read request. #[prost(message, repeated, tag="1")] pub chunks: ::prost::alloc::vec::Vec, - /// Optionally the server might return the row key of the last row it - /// has scanned. The client can use this to construct a more - /// efficient retry request if needed: any row keys or portions of - /// ranges less than this row key can be dropped from the request. - /// This is primarily useful for cases where the server has read a - /// lot of data that was filtered out since the last committed row - /// key, allowing the client to skip that work on a retry. + /// Optionally the server might return the row key of the last row it + /// has scanned. The client can use this to construct a more + /// efficient retry request if needed: any row keys or portions of + /// ranges less than this row key can be dropped from the request. + /// This is primarily useful for cases where the server has read a + /// lot of data that was filtered out since the last committed row + /// key, allowing the client to skip that work on a retry. #[prost(bytes="vec", tag="2")] pub last_scanned_row_key: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `ReadRowsResponse`. pub mod read_rows_response { - /// Specifies a piece of a row's contents returned as part of the read - /// response stream. - #[derive(Clone, PartialEq, Eq, ::prost::Message)] + /// Specifies a piece of a row's contents returned as part of the read + /// response stream. + #[derive(Clone, PartialEq, ::prost::Message)] pub struct CellChunk { - /// The row key for this chunk of data. If the row key is empty, - /// this CellChunk is a continuation of the same row as the previous - /// CellChunk in the response stream, even if that CellChunk was in a - /// previous ReadRowsResponse message. + /// The row key for this chunk of data. If the row key is empty, + /// this CellChunk is a continuation of the same row as the previous + /// CellChunk in the response stream, even if that CellChunk was in a + /// previous ReadRowsResponse message. #[prost(bytes="vec", tag="1")] pub row_key: ::prost::alloc::vec::Vec, - /// The column family name for this chunk of data. If this message - /// is not present this CellChunk is a continuation of the same column - /// family as the previous CellChunk. The empty string can occur as a - /// column family name in a response so clients must check - /// explicitly for the presence of this message, not just for - /// `family_name.value` being non-empty. + /// The column family name for this chunk of data. If this message + /// is not present this CellChunk is a continuation of the same column + /// family as the previous CellChunk. The empty string can occur as a + /// column family name in a response so clients must check + /// explicitly for the presence of this message, not just for + /// `family_name.value` being non-empty. #[prost(message, optional, tag="2")] pub family_name: ::core::option::Option<::prost::alloc::string::String>, - /// The column qualifier for this chunk of data. If this message - /// is not present, this CellChunk is a continuation of the same column - /// as the previous CellChunk. Column qualifiers may be empty so - /// clients must check for the presence of this message, not just - /// for `qualifier.value` being non-empty. + /// The column qualifier for this chunk of data. If this message + /// is not present, this CellChunk is a continuation of the same column + /// as the previous CellChunk. Column qualifiers may be empty so + /// clients must check for the presence of this message, not just + /// for `qualifier.value` being non-empty. #[prost(message, optional, tag="3")] pub qualifier: ::core::option::Option<::prost::alloc::vec::Vec>, - /// The cell's stored timestamp, which also uniquely identifies it - /// within its column. Values are always expressed in - /// microseconds, but individual tables may set a coarser - /// granularity to further restrict the allowed values. For - /// example, a table which specifies millisecond granularity will - /// only allow values of `timestamp_micros` which are multiples of - /// 1000. Timestamps are only set in the first CellChunk per cell - /// (for cells split into multiple chunks). + /// The cell's stored timestamp, which also uniquely identifies it + /// within its column. Values are always expressed in + /// microseconds, but individual tables may set a coarser + /// granularity to further restrict the allowed values. For + /// example, a table which specifies millisecond granularity will + /// only allow values of `timestamp_micros` which are multiples of + /// 1000. Timestamps are only set in the first CellChunk per cell + /// (for cells split into multiple chunks). #[prost(int64, tag="4")] pub timestamp_micros: i64, - /// Labels applied to the cell by a - /// \[RowFilter][google.bigtable.v2.RowFilter\]. Labels are only set - /// on the first CellChunk per cell. + /// Labels applied to the cell by a + /// \[RowFilter][google.bigtable.v2.RowFilter\]. Labels are only set + /// on the first CellChunk per cell. #[prost(string, repeated, tag="5")] pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - /// The value stored in the cell. Cell values can be split across - /// multiple CellChunks. In that case only the value field will be - /// set in CellChunks after the first: the timestamp and labels - /// will only be present in the first CellChunk, even if the first - /// CellChunk came in a previous ReadRowsResponse. + /// The value stored in the cell. Cell values can be split across + /// multiple CellChunks. In that case only the value field will be + /// set in CellChunks after the first: the timestamp and labels + /// will only be present in the first CellChunk, even if the first + /// CellChunk came in a previous ReadRowsResponse. #[prost(bytes="vec", tag="6")] pub value: ::prost::alloc::vec::Vec, - /// If this CellChunk is part of a chunked cell value and this is - /// not the final chunk of that cell, value_size will be set to the - /// total length of the cell value. The client can use this size - /// to pre-allocate memory to hold the full cell value. + /// If this CellChunk is part of a chunked cell value and this is + /// not the final chunk of that cell, value_size will be set to the + /// total length of the cell value. The client can use this size + /// to pre-allocate memory to hold the full cell value. #[prost(int32, tag="7")] pub value_size: i32, - /// Signals to the client concerning previous CellChunks received. + /// Signals to the client concerning previous CellChunks received. #[prost(oneof="cell_chunk::RowStatus", tags="8, 9")] pub row_status: ::core::option::Option, } /// Nested message and enum types in `CellChunk`. pub mod cell_chunk { - /// Signals to the client concerning previous CellChunks received. - #[derive(Clone, PartialEq, Eq, ::prost::Oneof)] + /// Signals to the client concerning previous CellChunks received. + #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum RowStatus { - /// Indicates that the client should drop all previous chunks for - /// `row_key`, as it will be re-read from the beginning. + /// Indicates that the client should drop all previous chunks for + /// `row_key`, as it will be re-read from the beginning. #[prost(bool, tag="8")] ResetRow(bool), - /// Indicates that the client can safely process all previous chunks for - /// `row_key`, as its data has been fully read. + /// Indicates that the client can safely process all previous chunks for + /// `row_key`, as its data has been fully read. #[prost(bool, tag="9")] CommitRow(bool), } } } -/// Request message for Bigtable.SampleRowKeys. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Request message for Bigtable.SampleRowKeys. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct SampleRowKeysRequest { - /// Required. The unique name of the table from which to sample row keys. - /// Values are of the form - /// `projects//instances//tables/
`. + /// Required. The unique name of the table from which to sample row keys. + /// Values are of the form + /// `projects//instances//tables/
`. #[prost(string, tag="1")] pub table_name: ::prost::alloc::string::String, - /// This value specifies routing for replication. If not specified, the - /// "default" application profile will be used. + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. #[prost(string, tag="2")] pub app_profile_id: ::prost::alloc::string::String, } -/// Response message for Bigtable.SampleRowKeys. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Response message for Bigtable.SampleRowKeys. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct SampleRowKeysResponse { - /// Sorted streamed sequence of sample row keys in the table. The table might - /// have contents before the first row key in the list and after the last one, - /// but a key containing the empty string indicates "end of table" and will be - /// the last response given, if present. - /// Note that row keys in this list may not have ever been written to or read - /// from, and users should therefore not make any assumptions about the row key - /// structure that are specific to their use case. + /// Sorted streamed sequence of sample row keys in the table. The table might + /// have contents before the first row key in the list and after the last one, + /// but a key containing the empty string indicates "end of table" and will be + /// the last response given, if present. + /// Note that row keys in this list may not have ever been written to or read + /// from, and users should therefore not make any assumptions about the row key + /// structure that are specific to their use case. #[prost(bytes="vec", tag="1")] pub row_key: ::prost::alloc::vec::Vec, - /// Approximate total storage space used by all rows in the table which precede - /// `row_key`. Buffering the contents of all rows between two subsequent - /// samples would require space roughly equal to the difference in their - /// `offset_bytes` fields. + /// Approximate total storage space used by all rows in the table which precede + /// `row_key`. Buffering the contents of all rows between two subsequent + /// samples would require space roughly equal to the difference in their + /// `offset_bytes` fields. #[prost(int64, tag="2")] pub offset_bytes: i64, } -/// Request message for Bigtable.MutateRow. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Request message for Bigtable.MutateRow. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct MutateRowRequest { - /// Required. The unique name of the table to which the mutation should be applied. - /// Values are of the form - /// `projects//instances//tables/
`. + /// Required. The unique name of the table to which the mutation should be applied. + /// Values are of the form + /// `projects//instances//tables/
`. #[prost(string, tag="1")] pub table_name: ::prost::alloc::string::String, - /// This value specifies routing for replication. If not specified, the - /// "default" application profile will be used. + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. #[prost(string, tag="4")] pub app_profile_id: ::prost::alloc::string::String, - /// Required. The key of the row to which the mutation should be applied. + /// Required. The key of the row to which the mutation should be applied. #[prost(bytes="vec", tag="2")] pub row_key: ::prost::alloc::vec::Vec, - /// Required. Changes to be atomically applied to the specified row. Entries are applied - /// in order, meaning that earlier mutations can be masked by later ones. - /// Must contain at least one entry and at most 100000. + /// Required. Changes to be atomically applied to the specified row. Entries are applied + /// in order, meaning that earlier mutations can be masked by later ones. + /// Must contain at least one entry and at most 100000. #[prost(message, repeated, tag="3")] pub mutations: ::prost::alloc::vec::Vec, } -/// Response message for Bigtable.MutateRow. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Response message for Bigtable.MutateRow. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct MutateRowResponse { } -/// Request message for BigtableService.MutateRows. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Request message for BigtableService.MutateRows. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct MutateRowsRequest { - /// Required. The unique name of the table to which the mutations should be applied. + /// Required. The unique name of the table to which the mutations should be applied. #[prost(string, tag="1")] pub table_name: ::prost::alloc::string::String, - /// This value specifies routing for replication. If not specified, the - /// "default" application profile will be used. + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. #[prost(string, tag="3")] pub app_profile_id: ::prost::alloc::string::String, - /// Required. The row keys and corresponding mutations to be applied in bulk. - /// Each entry is applied as an atomic mutation, but the entries may be - /// applied in arbitrary order (even between entries for the same row). - /// At least one entry must be specified, and in total the entries can - /// contain at most 100000 mutations. + /// Required. The row keys and corresponding mutations to be applied in bulk. + /// Each entry is applied as an atomic mutation, but the entries may be + /// applied in arbitrary order (even between entries for the same row). + /// At least one entry must be specified, and in total the entries can + /// contain at most 100000 mutations. #[prost(message, repeated, tag="2")] pub entries: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `MutateRowsRequest`. pub mod mutate_rows_request { - /// A mutation for a given row. - #[derive(Clone, PartialEq, Eq, ::prost::Message)] + /// A mutation for a given row. + #[derive(Clone, PartialEq, ::prost::Message)] pub struct Entry { - /// The key of the row to which the `mutations` should be applied. + /// The key of the row to which the `mutations` should be applied. #[prost(bytes="vec", tag="1")] pub row_key: ::prost::alloc::vec::Vec, - /// Required. Changes to be atomically applied to the specified row. Mutations are - /// applied in order, meaning that earlier mutations can be masked by - /// later ones. - /// You must specify at least one mutation. + /// Required. Changes to be atomically applied to the specified row. Mutations are + /// applied in order, meaning that earlier mutations can be masked by + /// later ones. + /// You must specify at least one mutation. #[prost(message, repeated, tag="2")] pub mutations: ::prost::alloc::vec::Vec, } } -/// Response message for BigtableService.MutateRows. +/// Response message for BigtableService.MutateRows. #[derive(Clone, PartialEq, ::prost::Message)] pub struct MutateRowsResponse { - /// One or more results for Entries from the batch request. + /// One or more results for Entries from the batch request. #[prost(message, repeated, tag="1")] pub entries: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `MutateRowsResponse`. pub mod mutate_rows_response { - /// The result of applying a passed mutation in the original request. + /// The result of applying a passed mutation in the original request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Entry { - /// The index into the original request's `entries` list of the Entry - /// for which a result is being reported. + /// The index into the original request's `entries` list of the Entry + /// for which a result is being reported. #[prost(int64, tag="1")] pub index: i64, - /// The result of the request Entry identified by `index`. - /// Depending on how requests are batched during execution, it is possible - /// for one Entry to fail due to an error with another Entry. In the event - /// that this occurs, the same error will be reported for both entries. + /// The result of the request Entry identified by `index`. + /// Depending on how requests are batched during execution, it is possible + /// for one Entry to fail due to an error with another Entry. In the event + /// that this occurs, the same error will be reported for both entries. #[prost(message, optional, tag="2")] pub status: ::core::option::Option, } } -/// Request message for Bigtable.CheckAndMutateRow. +/// Request message for Bigtable.CheckAndMutateRow. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CheckAndMutateRowRequest { - /// Required. The unique name of the table to which the conditional mutation should be - /// applied. - /// Values are of the form - /// `projects//instances//tables/
`. + /// Required. The unique name of the table to which the conditional mutation should be + /// applied. + /// Values are of the form + /// `projects//instances//tables/
`. #[prost(string, tag="1")] pub table_name: ::prost::alloc::string::String, - /// This value specifies routing for replication. If not specified, the - /// "default" application profile will be used. + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. #[prost(string, tag="7")] pub app_profile_id: ::prost::alloc::string::String, - /// Required. The key of the row to which the conditional mutation should be applied. + /// Required. The key of the row to which the conditional mutation should be applied. #[prost(bytes="vec", tag="2")] pub row_key: ::prost::alloc::vec::Vec, - /// The filter to be applied to the contents of the specified row. Depending - /// on whether or not any results are yielded, either `true_mutations` or - /// `false_mutations` will be executed. If unset, checks that the row contains - /// any values at all. + /// The filter to be applied to the contents of the specified row. Depending + /// on whether or not any results are yielded, either `true_mutations` or + /// `false_mutations` will be executed. If unset, checks that the row contains + /// any values at all. #[prost(message, optional, tag="6")] pub predicate_filter: ::core::option::Option, - /// Changes to be atomically applied to the specified row if `predicate_filter` - /// yields at least one cell when applied to `row_key`. Entries are applied in - /// order, meaning that earlier mutations can be masked by later ones. - /// Must contain at least one entry if `false_mutations` is empty, and at most - /// 100000. + /// Changes to be atomically applied to the specified row if `predicate_filter` + /// yields at least one cell when applied to `row_key`. Entries are applied in + /// order, meaning that earlier mutations can be masked by later ones. + /// Must contain at least one entry if `false_mutations` is empty, and at most + /// 100000. #[prost(message, repeated, tag="4")] pub true_mutations: ::prost::alloc::vec::Vec, - /// Changes to be atomically applied to the specified row if `predicate_filter` - /// does not yield any cells when applied to `row_key`. Entries are applied in - /// order, meaning that earlier mutations can be masked by later ones. - /// Must contain at least one entry if `true_mutations` is empty, and at most - /// 100000. + /// Changes to be atomically applied to the specified row if `predicate_filter` + /// does not yield any cells when applied to `row_key`. Entries are applied in + /// order, meaning that earlier mutations can be masked by later ones. + /// Must contain at least one entry if `true_mutations` is empty, and at most + /// 100000. #[prost(message, repeated, tag="5")] pub false_mutations: ::prost::alloc::vec::Vec, } -/// Response message for Bigtable.CheckAndMutateRow. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Response message for Bigtable.CheckAndMutateRow. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct CheckAndMutateRowResponse { - /// Whether or not the request's `predicate_filter` yielded any results for - /// the specified row. + /// Whether or not the request's `predicate_filter` yielded any results for + /// the specified row. #[prost(bool, tag="1")] pub predicate_matched: bool, } -/// Request message for Bigtable.ReadModifyWriteRow. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Request message for Bigtable.ReadModifyWriteRow. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadModifyWriteRowRequest { - /// Required. The unique name of the table to which the read/modify/write rules should be - /// applied. - /// Values are of the form - /// `projects//instances//tables/
`. + /// Required. The unique name of the table to which the read/modify/write rules should be + /// applied. + /// Values are of the form + /// `projects//instances//tables/
`. #[prost(string, tag="1")] pub table_name: ::prost::alloc::string::String, - /// This value specifies routing for replication. If not specified, the - /// "default" application profile will be used. + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. #[prost(string, tag="4")] pub app_profile_id: ::prost::alloc::string::String, - /// Required. The key of the row to which the read/modify/write rules should be applied. + /// Required. The key of the row to which the read/modify/write rules should be applied. #[prost(bytes="vec", tag="2")] pub row_key: ::prost::alloc::vec::Vec, - /// Required. Rules specifying how the specified row's contents are to be transformed - /// into writes. Entries are applied in order, meaning that earlier rules will - /// affect the results of later ones. + /// Required. Rules specifying how the specified row's contents are to be transformed + /// into writes. Entries are applied in order, meaning that earlier rules will + /// affect the results of later ones. #[prost(message, repeated, tag="3")] pub rules: ::prost::alloc::vec::Vec, } -/// Response message for Bigtable.ReadModifyWriteRow. -#[derive(Clone, PartialEq, Eq, ::prost::Message)] +/// Response message for Bigtable.ReadModifyWriteRow. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadModifyWriteRowResponse { - /// A Row containing the new contents of all cells modified by the request. + /// A Row containing the new contents of all cells modified by the request. #[prost(message, optional, tag="1")] pub row: ::core::option::Option, } @@ -895,6 +895,7 @@ pub struct ReadModifyWriteRowResponse { pub mod bigtable_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; + use tonic::codegen::http::Uri; /// Service for reading from and writing to existing Bigtable tables. #[derive(Debug, Clone)] pub struct BigtableClient { @@ -922,6 +923,10 @@ pub mod bigtable_client { 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, @@ -941,19 +946,19 @@ pub mod bigtable_client { { BigtableClient::new(InterceptedService::new(inner, interceptor)) } - /// Compress requests with `gzip`. + /// 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_gzip(mut self) -> Self { - self.inner = self.inner.send_gzip(); + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); self } - /// Enable decompressing responses with `gzip`. + /// Enable decompressing responses. #[must_use] - pub fn accept_gzip(mut self) -> Self { - self.inner = self.inner.accept_gzip(); + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); self } /// Streams back the contents of all requested rows in key order, optionally diff --git a/storage-bigtable/proto/google.protobuf.rs b/storage-bigtable/proto/google.protobuf.rs index 8b137891791fe9..e69de29bb2d1d6 100644 --- a/storage-bigtable/proto/google.protobuf.rs +++ b/storage-bigtable/proto/google.protobuf.rs @@ -1 +0,0 @@ - diff --git a/storage-bigtable/proto/google.rpc.rs b/storage-bigtable/proto/google.rpc.rs index 07dabd8cb6778c..98d137bb3bc9be 100644 --- a/storage-bigtable/proto/google.rpc.rs +++ b/storage-bigtable/proto/google.rpc.rs @@ -1,22 +1,22 @@ -/// The `Status` type defines a logical error model that is suitable for -/// different programming environments, including REST APIs and RPC APIs. It is -/// used by \[gRPC\](). Each `Status` message contains -/// three pieces of data: error code, error message, and error details. +/// The `Status` type defines a logical error model that is suitable for +/// different programming environments, including REST APIs and RPC APIs. It is +/// used by \[gRPC\](). Each `Status` message contains +/// three pieces of data: error code, error message, and error details. /// -/// You can find out more about this error model and how to work with it in the -/// [API Design Guide](). +/// You can find out more about this error model and how to work with it in the +/// [API Design Guide](). #[derive(Clone, PartialEq, ::prost::Message)] pub struct Status { - /// The status code, which should be an enum value of \[google.rpc.Code][google.rpc.Code\]. + /// The status code, which should be an enum value of \[google.rpc.Code][google.rpc.Code\]. #[prost(int32, tag="1")] pub code: i32, - /// A developer-facing error message, which should be in English. Any - /// user-facing error message should be localized and sent in the - /// \[google.rpc.Status.details][google.rpc.Status.details\] field, or localized by the client. + /// A developer-facing error message, which should be in English. Any + /// user-facing error message should be localized and sent in the + /// \[google.rpc.Status.details][google.rpc.Status.details\] field, or localized by the client. #[prost(string, tag="2")] pub message: ::prost::alloc::string::String, - /// A list of messages that carry the error details. There is a common set of - /// message types for APIs to use. + /// A list of messages that carry the error details. There is a common set of + /// message types for APIs to use. #[prost(message, repeated, tag="3")] pub details: ::prost::alloc::vec::Vec<::prost_types::Any>, } diff --git a/storage-proto/Cargo.toml b/storage-proto/Cargo.toml index 93b251105341c2..e5963d5c15e936 100644 --- a/storage-proto/Cargo.toml +++ b/storage-proto/Cargo.toml @@ -12,7 +12,7 @@ edition = "2021" [dependencies] bincode = "1.3.3" bs58 = "0.4.0" -prost = "0.10.4" +prost = "0.11.0" serde = "1.0.138" solana-account-decoder = { path = "../account-decoder", version = "=1.11.5" } solana-sdk = { path = "../sdk", version = "=1.11.5" } @@ -29,4 +29,5 @@ name = "solana_storage_proto" targets = ["x86_64-unknown-linux-gnu"] [build-dependencies] -tonic-build = "0.7.2" +protobuf-src = "1.0.5" +tonic-build = "0.8.0" diff --git a/storage-proto/build.rs b/storage-proto/build.rs index b1ea9903d4fb11..e5e17400a4feeb 100644 --- a/storage-proto/build.rs +++ b/storage-proto/build.rs @@ -1,4 +1,9 @@ fn main() -> Result<(), std::io::Error> { + const PROTOC_ENVAR: &str = "PROTOC"; + if std::env::var(PROTOC_ENVAR).is_err() { + std::env::set_var(PROTOC_ENVAR, protobuf_src::protoc()); + } + let proto_base_path = std::path::PathBuf::from("proto"); let proto_files = ["confirmed_block.proto", "transaction_by_addr.proto"]; let mut protos = Vec::new();