v1.9: Bump tonic, tonic-build, prost, and etcd-client (#24159)

* Bump tonic, prost, and etcd-client

* Restore doc ignores

* Restore clippy ignore

core/Cargo.toml

@@ -21,7 +21,7 @@ bs58 = "0.4.0"
 chrono = { version = "0.4.11", features = ["serde"] }
 crossbeam-channel = "0.5"
 dashmap = { version = "4.0.2", features = ["rayon", "raw-api"] }
-etcd-client = { version = "0.8.1", features = ["tls"]}
+etcd-client = { version = "0.9.0", features = ["tls"]}
 fs_extra = "1.2.0"
 histogram = "0.6.9"
 itertools = "0.10.1"

ledger/Cargo.toml

@@ -24,7 +24,7 @@ log = { version = "0.4.14" }
 num-derive = "0.3"
 num-traits = "0.2"
 num_cpus = "1.13.0"
-prost = "0.9.0"
+prost = "0.10.0"
 rand = "0.7.0"
 rand_chacha = "0.2.2"
 rayon = "1.5.1"

replica-lib/Cargo.toml

@@ -13,15 +13,15 @@ documentation = "https://docs.rs/solana-validator"
 crossbeam-channel = "0.5"
 futures-util = "0.3"
 log = "0.4.11"
-prost = "0.9.0"
+prost = "0.10.0"
 solana-rpc = { path = "../rpc", version = "=1.9.15" }
 solana-runtime = { path = "../runtime", version = "=1.9.15" }
 solana-sdk = { path = "../sdk", version = "=1.9.15" }
 tokio = { version = "1", features = ["full"] }
-tonic = { version = "0.6.1", features = ["tls", "transport"] }
+tonic = { version = "0.7.1", features = ["tls", "transport"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
 [build-dependencies]
-tonic-build = "0.6.0"
+tonic-build = "0.7.0"

replica-node/Cargo.toml

@@ -41,4 +41,4 @@ tempfile = "3.2.0"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [build-dependencies]
-tonic-build = "0.6.0"
+tonic-build = "0.7.0"

storage-bigtable/Cargo.toml

@@ -17,8 +17,8 @@ enum-iterator = "0.7.0"
 flate2 = "1.0.22"
 goauth = "0.10.0"
 log = "0.4.14"
-prost = "0.9.0"
+prost = "0.10.0"
-prost-types = "0.9.0"
+prost-types = "0.10.0"
 serde = "1.0.130"
 serde_derive = "1.0.103"
 smpl_jwt = "0.6.1"
@@ -27,7 +27,7 @@ solana-sdk = { path = "../sdk", version = "=1.9.15" }
 solana-storage-proto = { path = "../storage-proto", version = "=1.9.15" }
 solana-transaction-status = { path = "../transaction-status", version = "=1.9.15" }
 thiserror = "1.0"
-tonic = { version = "0.6.1", features = ["tls", "transport"] }
+tonic = { version = "0.7.1", features = ["tls", "transport"] }
 zstd = "0.9.0"
 
 # openssl is a dependency of the goauth and smpl_jwt crates, but explicitly

storage-bigtable/build-proto/Cargo.lock

@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "aho-corasick"
-version = "0.7.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.51"
@@ -35,6 +26,12 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b700ce4376041dcd0a327fd0097c41095743c4c8af8887265942faf1100bd040"
 
+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -47,6 +44,15 @@ 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.5.3"
@@ -78,12 +84,9 @@ checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
 
 [[package]]
 name = "heck"
-version = "0.3.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
-dependencies = [
- "unicode-segmentation",
-]
 
 [[package]]
 name = "indexmap"
@@ -125,12 +128,6 @@ dependencies = [
  "cfg-if 0.1.10",
 ]
 
-[[package]]
-name = "memchr"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
-
 [[package]]
 name = "multimap"
 version = "0.8.1"
@@ -154,19 +151,29 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
 
 [[package]]
-name = "proc-macro2"
+name = "prettyplease"
-version = "1.0.27"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038"
+checksum = "3b83ec2d0af5c5c556257ff52c9f98934e243b9fd39604bfb2a9b75ec2e97f18"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
 dependencies = [
  "unicode-xid",
 ]
 
 [[package]]
 name = "prost"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "444879275cb4fd84958b1a1d5420d15e6fcf7c235fe47f053c9c2a80aceb6001"
+checksum = "1bd5316aa8f5c82add416dfbc25116b84b748a21153f512917e8143640a71bbd"
 dependencies = [
  "bytes",
  "prost-derive",
@@ -174,11 +181,13 @@ dependencies = [
 
 [[package]]
 name = "prost-build"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62941722fb675d463659e49c4f3fe1fe792ff24fe5bbaa9c08cd3b98a1c354f5"
+checksum = "328f9f29b82409216decb172d81e936415d21245befa79cd34c3f29d87d1c50b"
 dependencies = [
  "bytes",
+ "cfg-if 1.0.0",
+ "cmake",
  "heck",
  "itertools",
  "lazy_static",
@@ -194,9 +203,9 @@ dependencies = [
 
 [[package]]
 name = "prost-derive"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9cc1a3263e07e0bf68e96268f37665207b49560d98739662cdfaae215c720fe"
+checksum = "df35198f0777b75e9ff669737c6da5136b59dba33cf5a010a6d1cc4d56defc6f"
 dependencies = [
  "anyhow",
  "itertools",
@@ -207,9 +216,9 @@ dependencies = [
 
 [[package]]
 name = "prost-types"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534b7a0e836e3c482d2693070f982e39e7611da9695d4d1f5a4b186b51faef0a"
+checksum = "926681c118ae6e512a3ccefd4abbe5521a14f4cc1e207356d4d00c0b7f2006fd"
 dependencies = [
  "bytes",
  "prost",
@@ -286,8 +295,6 @@ version = "1.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"
 dependencies = [
- "aho-corasick",
- "memchr",
  "regex-syntax",
 ]
 
@@ -308,9 +315,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "1.0.73"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f71489ff30030d2ae598524f61326b902466f72a0fb1a8564c001cc63425bcc7"
+checksum = "b683b2b825c8eef438b77c36a06dc262294da3d5a5813fac20da149241dcd44d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -353,22 +360,17 @@ dependencies = [
 
 [[package]]
 name = "tonic-build"
-version = "0.6.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88358bb1dcfeb62dcce85c63006cafb964b7be481d522b7e09589d4d1e718d2a"
+checksum = "4d17087af5c80e5d5fc8ba9878e60258065a0a757e35efe7a05b7904bece1943"
 dependencies = [
+ "prettyplease",
  "proc-macro2",
  "prost-build",
  "quote",
  "syn",
 ]
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
-
 [[package]]
 name = "unicode-xid"
 version = "0.2.1"

storage-bigtable/build-proto/Cargo.toml

@@ -12,4 +12,4 @@ version = "1.9.15"
 [workspace]
 
 [dependencies]
-tonic-build = "0.6.0"
+tonic-build = "0.7.0"

storage-bigtable/build-proto/src/main.rs

@@ -10,7 +10,6 @@ fn main() -> Result<(), std::io::Error> {
     tonic_build::configure()
         .build_client(true)
         .build_server(false)
-        .format(true)
         .out_dir(&out_dir)
         .compile(
             &[googleapis.join("google/bigtable/v2/bigtable.proto")],

storage-bigtable/proto/google.api.rs

@@ -1,5 +1,5 @@
 /// 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
+/// \[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 {
@@ -22,10 +22,10 @@ pub struct Http {
 /// 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](https://github.com/googleapis/googleapis),
+/// APIs](<https://github.com/googleapis/googleapis>),
-/// [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC
+/// [Cloud Endpoints](<https://cloud.google.com/endpoints>), [gRPC
-/// Gateway](https://github.com/grpc-ecosystem/grpc-gateway),
+/// Gateway](<https://github.com/grpc-ecosystem/grpc-gateway>),
-/// and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature
+/// and \[Envoy\](<https://github.com/envoyproxy/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
@@ -186,15 +186,15 @@ pub struct Http {
 /// 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
+///    - 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
+///  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
+///  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
@@ -221,19 +221,19 @@ pub struct Http {
 ///
 /// 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
+/// 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](https://developers.google.com/discovery/v1/reference/apis) as
+/// Document](<https://developers.google.com/discovery/v1/reference/apis>) 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.
+/// 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](https://developers.google.com/discovery/v1/reference/apis) as
+/// Document](<https://developers.google.com/discovery/v1/reference/apis>) as
 /// `{+var}`.
 ///
 /// ## Using gRPC API Service Configuration
@@ -263,10 +263,10 @@ pub struct Http {
 ///
 /// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the
 /// proto to JSON conversion must follow the [proto3
-/// specification](https://developers.google.com/protocol-buffers/docs/proto3#json).
+/// specification](<https://developers.google.com/protocol-buffers/docs/proto3#json>).
 ///
 /// While the single segment variable follows the semantics of
-/// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
+/// [RFC 6570](<https://tools.ietf.org/html/rfc6570>) 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
@@ -290,7 +290,7 @@ pub struct Http {
 pub struct HttpRule {
     /// 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
@@ -393,6 +393,16 @@ pub enum FieldBehavior {
     /// 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.
+    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.
+    NonEmptyDefault = 7,
 }
 /// A simple descriptor of a resource type.
 ///
@@ -511,7 +521,7 @@ pub struct ResourceDescriptor {
     /// 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
+    /// /\[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")]
@@ -562,14 +572,14 @@ pub struct ResourceDescriptor {
     /// '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
-    /// https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/
+    /// <https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/>
     ///
     /// Note: The plural form is required even for singleton resources. See
-    /// https://aip.dev/156
+    /// <https://aip.dev/156>
     #[prost(string, tag="5")]
     pub plural: ::prost::alloc::string::String,
     /// The same concept of the `singular` field in k8s CRD spec
-    /// https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/
+    /// <https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/>
     /// Such as "project" for the `resourcemanager.googleapis.com/Project` type.
     #[prost(string, tag="6")]
     pub singular: ::prost::alloc::string::String,

storage-bigtable/proto/google.bigtable.v2.rs

@@ -19,7 +19,7 @@ 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
+    /// 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")]
@@ -59,7 +59,7 @@ pub struct Cell {
     /// length.
     #[prost(bytes="vec", tag="2")]
     pub value: ::prost::alloc::vec::Vec<u8>,
-    /// 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>,
 }
@@ -215,10 +215,10 @@ pub mod value_range {
 /// * 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 (https://github.com/google/re2/wiki/Syntax)
+/// regex true filters use RE2 syntax (<https://github.com/google/re2/wiki/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
+/// `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.
 ///
@@ -237,10 +237,7 @@ pub mod value_range {
 pub struct RowFilter {
     /// Which of the possible RowFilter types to apply. If none are set, this
     /// RowFilter returns all cells in the input row.
-    #[prost(
+    #[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")]
-        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<row_filter::Filter>,
 }
 /// Nested message and enum types in `RowFilter`.
@@ -353,13 +350,13 @@ pub mod row_filter {
         ///               |                          |
         ///             All()                    Label(foo)
         ///               |                          |
-        ///            A,A,1,w              A,A,1,w,labels:[foo]
+        ///            A,A,1,w              A,A,1,w,labels:\[foo\]
-        ///            A,B,2,x              A,B,2,x,labels:[foo]
+        ///            A,B,2,x              A,B,2,x,labels:\[foo\]
         ///               |                          |
         ///               |                        Sink() --------------+
         ///               |                          |                  |
-        ///               +------------+      x------+          A,A,1,w,labels:[foo]
+        ///               +------------+      x------+          A,A,1,w,labels:\[foo\]
-        ///                            |                        A,B,2,x,labels:[foo]
+        ///                            |                        A,B,2,x,labels:\[foo\]
         ///                         A,A,1,w                             |
         ///                         A,B,2,x                             |
         ///                            |                                |
@@ -369,14 +366,14 @@ pub mod row_filter {
         ///                            |                                |
         ///                            +--------------------------------+
         ///                            |
-        ///                         A,A,1,w,labels:[foo]
+        ///                         A,A,1,w,labels:\[foo\]
-        ///                         A,B,2,x,labels:[foo]  // could be switched
+        ///                         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.
         ///
-        /// As with an [Interleave][google.bigtable.v2.RowFilter.Interleave],
+        /// 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
@@ -384,7 +381,7 @@ pub mod row_filter {
         /// 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].
+        /// `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
@@ -466,7 +463,7 @@ pub mod row_filter {
         /// the filter.
         ///
         /// Values must be at most 15 characters in length, and match the RE2
-        /// pattern `[a-z0-9\\-]+`
+        /// 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
@@ -491,7 +488,7 @@ pub mod mutation {
     #[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]+`
+        /// 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.
@@ -514,7 +511,7 @@ pub mod mutation {
     #[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]+`
+        /// 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.
@@ -529,13 +526,14 @@ pub mod mutation {
     #[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]+`
+        /// 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, ::prost::Message)]
-    pub struct DeleteFromRow {}
+    pub struct DeleteFromRow {
+    }
     /// Which of the possible Mutation types to apply.
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum Mutation {
@@ -558,7 +556,7 @@ pub mod mutation {
 #[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]+`
+    /// 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
@@ -668,7 +666,7 @@ pub mod read_rows_response {
         #[prost(int64, tag="4")]
         pub timestamp_micros: i64,
         /// Labels applied to the cell by a
-        /// [RowFilter][google.bigtable.v2.RowFilter].  Labels are only set
+        /// \[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>,
@@ -760,7 +758,8 @@ pub struct MutateRowRequest {
 }
 /// Response message for Bigtable.MutateRow.
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MutateRowResponse {}
+pub struct MutateRowResponse {
+}
 /// Request message for BigtableService.MutateRows.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MutateRowsRequest {
@@ -893,17 +892,17 @@ pub struct ReadModifyWriteRowResponse {
     #[prost(message, optional, tag="1")]
     pub row: ::core::option::Option<Row>,
 }
-#[doc = r" Generated client implementations."]
+/// Generated client implementations.
 pub mod bigtable_client {
-    #![allow(unused_variables, dead_code, missing_docs)]
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
     use tonic::codegen::*;
-    #[doc = " Service for reading from and writing to existing Bigtable tables."]
+    /// Service for reading from and writing to existing Bigtable tables.
     #[derive(Debug, Clone)]
     pub struct BigtableClient<T> {
         inner: tonic::client::Grpc<T>,
     }
     impl BigtableClient<tonic::transport::Channel> {
-        #[doc = r" Attempt to create a new client by connecting to a given endpoint."]
+        /// Attempt to create a new client by connecting to a given endpoint.
         pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
         where
             D: std::convert::TryInto<tonic::transport::Endpoint>,
@@ -916,8 +915,8 @@ pub mod bigtable_client {
     impl<T> BigtableClient<T>
     where
         T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::ResponseBody: Body + Send + Sync + 'static,
         T::Error: Into<StdError>,
+        T::ResponseBody: Default + Body<Data = Bytes> + Send + 'static,
         <T::ResponseBody as Body>::Error: Into<StdError> + Send,
     {
         pub fn new(inner: T) -> Self {
@@ -929,58 +928,65 @@ pub mod bigtable_client {
             interceptor: F,
         ) -> BigtableClient<InterceptedService<T, F>>
         where
-            F: FnMut(tonic::Request<()>) -> Result<tonic::Request<()>, tonic::Status>,
+            F: tonic::service::Interceptor,
-            T: Service<
+            T: tonic::codegen::Service<
                 http::Request<tonic::body::BoxBody>,
                 Response = http::Response<
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as Service<http::Request<tonic::body::BoxBody>>>::Error:
+            <T as tonic::codegen::Service<
-                Into<StdError> + Send + Sync,
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + Send + Sync,
         {
             BigtableClient::new(InterceptedService::new(inner, interceptor))
         }
-        #[doc = r" Compress requests with `gzip`."]
+        /// Compress requests with `gzip`.
-        #[doc = r""]
+        ///
-        #[doc = r" This requires the server to support it otherwise it might respond with an"]
+        /// This requires the server to support it otherwise it might respond with an
-        #[doc = r" error."]
+        /// error.
+        #[must_use]
         pub fn send_gzip(mut self) -> Self {
             self.inner = self.inner.send_gzip();
             self
         }
-        #[doc = r" Enable decompressing responses with `gzip`."]
+        /// Enable decompressing responses with `gzip`.
+        #[must_use]
         pub fn accept_gzip(mut self) -> Self {
             self.inner = self.inner.accept_gzip();
             self
         }
-        #[doc = " Streams back the contents of all requested rows in key order, optionally"]
+        /// Streams back the contents of all requested rows in key order, optionally
-        #[doc = " applying the same Reader filter to each. Depending on their size,"]
+        /// applying the same Reader filter to each. Depending on their size,
-        #[doc = " rows and cells may be broken up across multiple responses, but"]
+        /// rows and cells may be broken up across multiple responses, but
-        #[doc = " atomicity of each row will still be preserved. See the"]
+        /// atomicity of each row will still be preserved. See the
-        #[doc = " ReadRowsResponse documentation for details."]
+        /// ReadRowsResponse documentation for details.
         pub async fn read_rows(
             &mut self,
             request: impl tonic::IntoRequest<super::ReadRowsRequest>,
-        ) -> Result<tonic::Response<tonic::codec::Streaming<super::ReadRowsResponse>>, tonic::Status>
+        ) -> Result<
-        {
+                tonic::Response<tonic::codec::Streaming<super::ReadRowsResponse>>,
-            self.inner.ready().await.map_err(|e| {
+                tonic::Status,
+            > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
                     tonic::Status::new(
                         tonic::Code::Unknown,
                         format!("Service was not ready: {}", e.into()),
                     )
                 })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path =
+            let path = http::uri::PathAndQuery::from_static(
-                http::uri::PathAndQuery::from_static("/google.bigtable.v2.Bigtable/ReadRows");
+                "/google.bigtable.v2.Bigtable/ReadRows",
-            self.inner
+            );
-                .server_streaming(request.into_request(), path, codec)
+            self.inner.server_streaming(request.into_request(), path, codec).await
-                .await
         }
-        #[doc = " Returns a sample of row keys in the table. The returned row keys will"]
+        /// Returns a sample of row keys in the table. The returned row keys will
-        #[doc = " delimit contiguous sections of the table of approximately equal size,"]
+        /// delimit contiguous sections of the table of approximately equal size,
-        #[doc = " which can be used to break up the data for distributed tasks like"]
+        /// which can be used to break up the data for distributed tasks like
-        #[doc = " mapreduces."]
+        /// mapreduces.
         pub async fn sample_row_keys(
             &mut self,
             request: impl tonic::IntoRequest<super::SampleRowKeysRequest>,
@@ -988,39 +994,45 @@ pub mod bigtable_client {
                 tonic::Response<tonic::codec::Streaming<super::SampleRowKeysResponse>>,
                 tonic::Status,
             > {
-            self.inner.ready().await.map_err(|e| {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
                     tonic::Status::new(
                         tonic::Code::Unknown,
                         format!("Service was not ready: {}", e.into()),
                     )
                 })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path =
+            let path = http::uri::PathAndQuery::from_static(
-                http::uri::PathAndQuery::from_static("/google.bigtable.v2.Bigtable/SampleRowKeys");
+                "/google.bigtable.v2.Bigtable/SampleRowKeys",
-            self.inner
+            );
-                .server_streaming(request.into_request(), path, codec)
+            self.inner.server_streaming(request.into_request(), path, codec).await
-                .await
         }
-        #[doc = " Mutates a row atomically. Cells already present in the row are left"]
+        /// Mutates a row atomically. Cells already present in the row are left
-        #[doc = " unchanged unless explicitly changed by `mutation`."]
+        /// unchanged unless explicitly changed by `mutation`.
         pub async fn mutate_row(
             &mut self,
             request: impl tonic::IntoRequest<super::MutateRowRequest>,
         ) -> Result<tonic::Response<super::MutateRowResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
                     tonic::Status::new(
                         tonic::Code::Unknown,
                         format!("Service was not ready: {}", e.into()),
                     )
                 })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path =
+            let path = http::uri::PathAndQuery::from_static(
-                http::uri::PathAndQuery::from_static("/google.bigtable.v2.Bigtable/MutateRow");
+                "/google.bigtable.v2.Bigtable/MutateRow",
+            );
             self.inner.unary(request.into_request(), path, codec).await
         }
-        #[doc = " Mutates multiple rows in a batch. Each individual row is mutated"]
+        /// Mutates multiple rows in a batch. Each individual row is mutated
-        #[doc = " atomically as in MutateRow, but the entire batch is not executed"]
+        /// atomically as in MutateRow, but the entire batch is not executed
-        #[doc = " atomically."]
+        /// atomically.
         pub async fn mutate_rows(
             &mut self,
             request: impl tonic::IntoRequest<super::MutateRowsRequest>,
@@ -1028,25 +1040,30 @@ pub mod bigtable_client {
                 tonic::Response<tonic::codec::Streaming<super::MutateRowsResponse>>,
                 tonic::Status,
             > {
-            self.inner.ready().await.map_err(|e| {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
                     tonic::Status::new(
                         tonic::Code::Unknown,
                         format!("Service was not ready: {}", e.into()),
                     )
                 })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path =
+            let path = http::uri::PathAndQuery::from_static(
-                http::uri::PathAndQuery::from_static("/google.bigtable.v2.Bigtable/MutateRows");
+                "/google.bigtable.v2.Bigtable/MutateRows",
-            self.inner
+            );
-                .server_streaming(request.into_request(), path, codec)
+            self.inner.server_streaming(request.into_request(), path, codec).await
-                .await
         }
-        #[doc = " Mutates a row atomically based on the output of a predicate Reader filter."]
+        /// Mutates a row atomically based on the output of a predicate Reader filter.
         pub async fn check_and_mutate_row(
             &mut self,
             request: impl tonic::IntoRequest<super::CheckAndMutateRowRequest>,
         ) -> Result<tonic::Response<super::CheckAndMutateRowResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
                     tonic::Status::new(
                         tonic::Code::Unknown,
                         format!("Service was not ready: {}", e.into()),
@@ -1058,16 +1075,19 @@ pub mod bigtable_client {
             );
             self.inner.unary(request.into_request(), path, codec).await
         }
-        #[doc = " Modifies a row atomically on the server. The method reads the latest"]
+        /// Modifies a row atomically on the server. The method reads the latest
-        #[doc = " existing timestamp and value from the specified columns and writes a new"]
+        /// existing timestamp and value from the specified columns and writes a new
-        #[doc = " entry based on pre-defined read/modify/write rules. The new value for the"]
+        /// entry based on pre-defined read/modify/write rules. The new value for the
-        #[doc = " timestamp is the greater of the existing timestamp or the current server"]
+        /// timestamp is the greater of the existing timestamp or the current server
-        #[doc = " time. The method returns the new contents of all modified cells."]
+        /// time. The method returns the new contents of all modified cells.
         pub async fn read_modify_write_row(
             &mut self,
             request: impl tonic::IntoRequest<super::ReadModifyWriteRowRequest>,
         ) -> Result<tonic::Response<super::ReadModifyWriteRowResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
                     tonic::Status::new(
                         tonic::Code::Unknown,
                         format!("Service was not ready: {}", e.into()),

storage-bigtable/proto/google.rpc.rs

@@ -1,18 +1,18 @@
 /// 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](https://github.com/grpc). Each `Status` message contains
+/// used by \[gRPC\](<https://github.com/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](https://cloud.google.com/apis/design/errors).
+/// [API Design Guide](<https://cloud.google.com/apis/design/errors>).
 #[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.
+    /// \[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

storage-proto/Cargo.toml

@@ -12,7 +12,7 @@ edition = "2021"
 [dependencies]
 bincode = "1.3.3"
 bs58 = "0.4.0"
-prost = "0.9.0"
+prost = "0.10.0"
 serde = "1.0.130"
 solana-account-decoder = { path = "../account-decoder", version = "=1.9.15" }
 solana-sdk = { path = "../sdk", version = "=1.9.15" }
@@ -29,4 +29,4 @@ name = "solana_storage_proto"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [build-dependencies]
-tonic-build = "0.6.0"
+tonic-build = "0.7.0"

storage-proto/build.rs

@@ -11,7 +11,6 @@ fn main() -> Result<(), std::io::Error> {
     tonic_build::configure()
         .build_client(true)
         .build_server(false)
-        .format(true)
         .type_attribute(
             "TransactionErrorType",
             "#[cfg_attr(test, derive(enum_iterator::IntoEnumIterator))]",