From 54dae6ba2c1b715f56ddaaaa650c07e5396ad1c6 Mon Sep 17 00:00:00 2001 From: Michael Vines Date: Mon, 20 Jul 2020 11:57:50 -0700 Subject: [PATCH] Add build-proto/build.sh output --- storage-bigtable/proto/google.api.rs | 632 +++++++++++ storage-bigtable/proto/google.bigtable.v2.rs | 1057 ++++++++++++++++++ storage-bigtable/proto/google.protobuf.rs | 1 + storage-bigtable/proto/google.rpc.rs | 22 + 4 files changed, 1712 insertions(+) create mode 100644 storage-bigtable/proto/google.api.rs create mode 100644 storage-bigtable/proto/google.bigtable.v2.rs create mode 100644 storage-bigtable/proto/google.protobuf.rs create mode 100644 storage-bigtable/proto/google.rpc.rs diff --git a/storage-bigtable/proto/google.api.rs b/storage-bigtable/proto/google.api.rs new file mode 100644 index 0000000000..a9f7d00700 --- /dev/null +++ b/storage-bigtable/proto/google.api.rs @@ -0,0 +1,632 @@ +/// 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. + /// + /// **NOTE:** All service configuration rules follow "last one wins" order. + #[prost(message, repeated, tag = "1")] + pub rules: ::std::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. + /// + /// 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](https://github.com/googleapis/googleapis), +/// [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC +/// Gateway](https://github.com/grpc-ecosystem/grpc-gateway), +/// 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 +/// 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](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. +/// 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 +/// `{+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](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 +/// 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. + /// + /// Refer to [selector][google.api.DocumentationRule.selector] for syntax details. + #[prost(string, tag = "1")] + pub selector: std::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. + /// + /// NOTE: the referred field must be present at the top-level of the request + /// message type. + #[prost(string, tag = "7")] + pub body: std::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. + /// + /// NOTE: The referred field must be present at the top-level of the response + /// message type. + #[prost(string, tag = "12")] + pub response_body: std::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). + #[prost(message, repeated, tag = "11")] + pub additional_bindings: ::std::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. + #[prost(oneof = "http_rule::Pattern", tags = "2, 3, 4, 5, 6, 8")] + pub pattern: ::std::option::Option, +} +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. + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Pattern { + /// Maps to HTTP GET. Used for listing and getting information about + /// resources. + #[prost(string, tag = "2")] + Get(std::string::String), + /// Maps to HTTP PUT. Used for replacing a resource. + #[prost(string, tag = "3")] + Put(std::string::String), + /// Maps to HTTP POST. Used for creating a resource or performing an action. + #[prost(string, tag = "4")] + Post(std::string::String), + /// Maps to HTTP DELETE. Used for deleting a resource. + #[prost(string, tag = "5")] + Delete(std::string::String), + /// Maps to HTTP PATCH. Used for updating a resource. + #[prost(string, tag = "6")] + Patch(std::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. + #[prost(message, tag = "8")] + Custom(super::CustomHttpPattern), + } +} +/// 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. + #[prost(string, tag = "1")] + pub kind: std::string::String, + /// The path matched by this custom verb. + #[prost(string, tag = "2")] + pub path: std::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. +/// +/// 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. + Unspecified = 0, + /// 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`). + 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). + 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. + 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. + Immutable = 5, +} +/// 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. + /// + /// 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. + #[prost(string, tag = "1")] + pub r#type: std::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. + /// + /// The path pattern must follow the syntax, which aligns with HTTP binding + /// syntax: + /// + /// Template = Segment { "/" Segment } ; + /// Segment = LITERAL | Variable ; + /// Variable = "{" LITERAL "}" ; + /// + /// Examples: + /// + /// - "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. + #[prost(string, repeated, tag = "2")] + pub pattern: ::std::vec::Vec, + /// 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: std::string::String, + /// Optional. The historical or future-looking state of the resource pattern. + /// + /// 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 + /// }; + /// } + #[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 + /// 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 + #[prost(string, tag = "5")] + pub plural: std::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/ + /// Such as "project" for the `resourcemanager.googleapis.com/Project` type. + #[prost(string, tag = "6")] + pub singular: std::string::String, +} +pub mod resource_descriptor { + /// 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. + Unspecified = 0, + /// 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.) + FutureMultiPattern = 2, + } +} +/// 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. + /// + /// Example: + /// + /// 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. + /// + /// Example: + /// + /// message GetIamPolicyRequest { + /// string resource = 2 [(google.api.resource_reference) = { + /// type: "*" + /// }]; + /// } + #[prost(string, tag = "1")] + pub r#type: std::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. + /// + /// Example: + /// + /// message ListLogEntriesRequest { + /// string parent = 1 [(google.api.resource_reference) = { + /// child_type: "logging.googleapis.com/LogEntry" + /// }; + /// } + #[prost(string, tag = "2")] + pub child_type: std::string::String, +} diff --git a/storage-bigtable/proto/google.bigtable.v2.rs b/storage-bigtable/proto/google.bigtable.v2.rs new file mode 100644 index 0000000000..2a6a0bbea0 --- /dev/null +++ b/storage-bigtable/proto/google.bigtable.v2.rs @@ -0,0 +1,1057 @@ +/// 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. + #[prost(bytes, tag = "1")] + pub key: std::vec::Vec, + /// 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: ::std::vec::Vec, +} +/// 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. + #[prost(string, tag = "1")] + pub name: std::string::String, + /// Must not be empty. Sorted in order of increasing "qualifier". + #[prost(message, repeated, tag = "2")] + pub columns: ::std::vec::Vec, +} +/// 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. + #[prost(bytes, tag = "1")] + pub qualifier: std::vec::Vec, + /// Must not be empty. Sorted in order of decreasing "timestamp_micros". + #[prost(message, repeated, tag = "2")] + pub cells: ::std::vec::Vec, +} +/// 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. + #[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. + #[prost(bytes, tag = "2")] + pub value: std::vec::Vec, + /// Labels applied to the cell by a [RowFilter][google.bigtable.v2.RowFilter]. + #[prost(string, repeated, tag = "3")] + pub labels: ::std::vec::Vec, +} +/// 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. + #[prost(oneof = "row_range::StartKey", tags = "1, 2")] + pub start_key: ::std::option::Option, + /// 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: ::std::option::Option, +} +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, ::prost::Oneof)] + pub enum StartKey { + /// Used when giving an inclusive lower bound for the range. + #[prost(bytes, tag = "1")] + StartKeyClosed(std::vec::Vec), + /// Used when giving an exclusive lower bound for the range. + #[prost(bytes, tag = "2")] + StartKeyOpen(std::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, ::prost::Oneof)] + pub enum EndKey { + /// Used when giving an exclusive upper bound for the range. + #[prost(bytes, tag = "3")] + EndKeyOpen(std::vec::Vec), + /// Used when giving an inclusive upper bound for the range. + #[prost(bytes, tag = "4")] + EndKeyClosed(std::vec::Vec), + } +} +/// Specifies a non-contiguous set of rows. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RowSet { + /// Single rows included in the set. + #[prost(bytes, repeated, tag = "1")] + pub row_keys: ::std::vec::Vec>, + /// Contiguous row ranges included in the set. + #[prost(message, repeated, tag = "2")] + pub row_ranges: ::std::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, ::prost::Message)] +pub struct ColumnRange { + /// The name of the column family within which this range falls. + #[prost(string, tag = "1")] + pub family_name: std::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. + #[prost(oneof = "column_range::StartQualifier", tags = "2, 3")] + pub start_qualifier: ::std::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. + #[prost(oneof = "column_range::EndQualifier", tags = "4, 5")] + pub end_qualifier: ::std::option::Option, +} +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, ::prost::Oneof)] + pub enum StartQualifier { + /// Used when giving an inclusive lower bound for the range. + #[prost(bytes, tag = "2")] + StartQualifierClosed(std::vec::Vec), + /// Used when giving an exclusive lower bound for the range. + #[prost(bytes, tag = "3")] + StartQualifierOpen(std::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, ::prost::Oneof)] + pub enum EndQualifier { + /// Used when giving an inclusive upper bound for the range. + #[prost(bytes, tag = "4")] + EndQualifierClosed(std::vec::Vec), + /// Used when giving an exclusive upper bound for the range. + #[prost(bytes, tag = "5")] + EndQualifierOpen(std::vec::Vec), + } +} +/// Specified a contiguous range of microsecond timestamps. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TimestampRange { + /// 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. + #[prost(int64, tag = "2")] + pub end_timestamp_micros: i64, +} +/// 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. + #[prost(oneof = "value_range::StartValue", tags = "1, 2")] + pub start_value: ::std::option::Option, + /// 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: ::std::option::Option, +} +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, ::prost::Oneof)] + pub enum StartValue { + /// Used when giving an inclusive lower bound for the range. + #[prost(bytes, tag = "1")] + StartValueClosed(std::vec::Vec), + /// Used when giving an exclusive lower bound for the range. + #[prost(bytes, tag = "2")] + StartValueOpen(std::vec::Vec), + } + /// 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. + #[prost(bytes, tag = "3")] + EndValueClosed(std::vec::Vec), + /// Used when giving an exclusive upper bound for the range. + #[prost(bytes, tag = "4")] + EndValueOpen(std::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." +/// +/// 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 (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 +/// 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. +/// +/// * 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. +#[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. + #[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: ::std::option::Option, +} +pub mod row_filter { + /// 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. + #[prost(message, repeated, tag = "1")] + pub filters: ::std::vec::Vec, + } + /// 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: + /// + /// 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. + #[prost(message, repeated, tag = "1")] + pub filters: ::std::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. + /// + /// 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. + #[prost(message, optional, boxed, tag = "1")] + pub predicate_filter: ::std::option::Option<::std::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. + #[prost(message, optional, boxed, tag = "2")] + pub true_filter: ::std::option::Option<::std::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. + #[prost(message, optional, boxed, tag = "3")] + pub false_filter: ::std::option::Option<::std::boxed::Box>, + } + /// 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. + #[prost(message, tag = "1")] + Chain(Chain), + /// 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. + #[prost(message, tag = "3")] + Condition(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: + /// + /// 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 + /// + /// 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. + /// + /// 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. + #[prost(bool, tag = "17")] + PassAllFilter(bool), + /// 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. + #[prost(bytes, tag = "4")] + RowKeyRegexFilter(std::vec::Vec), + /// 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. + #[prost(string, tag = "5")] + FamilyNameRegexFilter(std::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. + #[prost(bytes, tag = "6")] + ColumnQualifierRegexFilter(std::vec::Vec), + /// 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. + #[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. + #[prost(bytes, tag = "9")] + ValueRegexFilter(std::vec::Vec), + /// 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. + #[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. + #[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. + #[prost(int32, tag = "12")] + CellsPerColumnLimitFilter(i32), + /// 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. + /// + /// 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. + #[prost(string, tag = "19")] + ApplyLabelTransformer(std::string::String), + } +} +/// 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. + #[prost(oneof = "mutation::Mutation", tags = "1, 2, 3, 4")] + pub mutation: ::std::option::Option, +} +pub mod mutation { + /// 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]+` + #[prost(string, tag = "1")] + pub family_name: std::string::String, + /// The qualifier of the column into which new data should be written. + /// Can be any byte string, including the empty string. + #[prost(bytes, tag = "2")] + pub column_qualifier: std::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). + #[prost(int64, tag = "3")] + pub timestamp_micros: i64, + /// The value to be written into the specified cell. + #[prost(bytes, tag = "4")] + pub value: std::vec::Vec, + } + /// 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]+` + #[prost(string, tag = "1")] + pub family_name: std::string::String, + /// The qualifier of the column from which cells should be deleted. + /// Can be any byte string, including the empty string. + #[prost(bytes, tag = "2")] + pub column_qualifier: std::vec::Vec, + /// The range of timestamps within which cells should be deleted. + #[prost(message, optional, tag = "3")] + pub time_range: ::std::option::Option, + } + /// 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]+` + #[prost(string, tag = "1")] + pub family_name: std::string::String, + } + /// 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, ::prost::Oneof)] + pub enum Mutation { + /// Set a cell's value. + #[prost(message, tag = "1")] + SetCell(SetCell), + /// Deletes cells from a column. + #[prost(message, tag = "2")] + DeleteFromColumn(DeleteFromColumn), + /// Deletes cells from a column family. + #[prost(message, tag = "3")] + DeleteFromFamily(DeleteFromFamily), + /// 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, ::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]+` + #[prost(string, tag = "1")] + pub family_name: std::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. + #[prost(bytes, tag = "2")] + pub column_qualifier: std::vec::Vec, + /// 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: ::std::option::Option, +} +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, ::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. + #[prost(bytes, tag = "3")] + AppendValue(std::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. + #[prost(int64, tag = "4")] + IncrementAmount(i64), + } +} +/// 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/`. + #[prost(string, tag = "1")] + pub table_name: std::string::String, + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. + #[prost(string, tag = "5")] + pub app_profile_id: std::string::String, + /// The row keys and/or ranges to read. If not specified, reads from all rows. + #[prost(message, optional, tag = "2")] + pub rows: ::std::option::Option, + /// 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: ::std::option::Option, + /// 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, ::prost::Message)] +pub struct ReadRowsResponse { + /// A collection of a row's contents as part of the read request. + #[prost(message, repeated, tag = "1")] + pub chunks: ::std::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. + #[prost(bytes, tag = "2")] + pub last_scanned_row_key: std::vec::Vec, +} +pub mod read_rows_response { + /// 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. + #[prost(bytes, tag = "1")] + pub row_key: std::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. + #[prost(message, optional, tag = "2")] + pub family_name: ::std::option::Option<::std::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. + #[prost(message, optional, tag = "3")] + pub qualifier: ::std::option::Option<::std::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). + #[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. + #[prost(string, repeated, tag = "5")] + pub labels: ::std::vec::Vec, + /// 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, tag = "6")] + pub value: std::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. + #[prost(int32, tag = "7")] + pub value_size: i32, + /// Signals to the client concerning previous CellChunks received. + #[prost(oneof = "cell_chunk::RowStatus", tags = "8, 9")] + pub row_status: ::std::option::Option, + } + pub mod cell_chunk { + /// 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. + #[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. + #[prost(bool, tag = "9")] + CommitRow(bool), + } + } +} +/// 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/
`. + #[prost(string, tag = "1")] + pub table_name: std::string::String, + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. + #[prost(string, tag = "2")] + pub app_profile_id: std::string::String, +} +/// 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. + #[prost(bytes, tag = "1")] + pub row_key: std::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. + #[prost(int64, tag = "2")] + pub offset_bytes: i64, +} +/// 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/
`. + #[prost(string, tag = "1")] + pub table_name: std::string::String, + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. + #[prost(string, tag = "4")] + pub app_profile_id: std::string::String, + /// Required. The key of the row to which the mutation should be applied. + #[prost(bytes, tag = "2")] + pub row_key: std::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. + #[prost(message, repeated, tag = "3")] + pub mutations: ::std::vec::Vec, +} +/// Response message for Bigtable.MutateRow. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MutateRowResponse {} +/// 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. + #[prost(string, tag = "1")] + pub table_name: std::string::String, + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. + #[prost(string, tag = "3")] + pub app_profile_id: std::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. + #[prost(message, repeated, tag = "2")] + pub entries: ::std::vec::Vec, +} +pub mod mutate_rows_request { + /// 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. + #[prost(bytes, tag = "1")] + pub row_key: std::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. + #[prost(message, repeated, tag = "2")] + pub mutations: ::std::vec::Vec, + } +} +/// Response message for BigtableService.MutateRows. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MutateRowsResponse { + /// One or more results for Entries from the batch request. + #[prost(message, repeated, tag = "1")] + pub entries: ::std::vec::Vec, +} +pub mod mutate_rows_response { + /// 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. + #[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. + #[prost(message, optional, tag = "2")] + pub status: ::std::option::Option, + } +} +/// 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/
`. + #[prost(string, tag = "1")] + pub table_name: std::string::String, + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. + #[prost(string, tag = "7")] + pub app_profile_id: std::string::String, + /// Required. The key of the row to which the conditional mutation should be applied. + #[prost(bytes, tag = "2")] + pub row_key: std::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. + #[prost(message, optional, tag = "6")] + pub predicate_filter: ::std::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. + #[prost(message, repeated, tag = "4")] + pub true_mutations: ::std::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. + #[prost(message, repeated, tag = "5")] + pub false_mutations: ::std::vec::Vec, +} +/// 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. + #[prost(bool, tag = "1")] + pub predicate_matched: bool, +} +/// 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/
`. + #[prost(string, tag = "1")] + pub table_name: std::string::String, + /// This value specifies routing for replication. If not specified, the + /// "default" application profile will be used. + #[prost(string, tag = "4")] + pub app_profile_id: std::string::String, + /// Required. The key of the row to which the read/modify/write rules should be applied. + #[prost(bytes, tag = "2")] + pub row_key: std::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. + #[prost(message, repeated, tag = "3")] + pub rules: ::std::vec::Vec, +} +/// 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. + #[prost(message, optional, tag = "1")] + pub row: ::std::option::Option, +} +#[doc = r" Generated client implementations."] +pub mod bigtable_client { + #![allow(unused_variables, dead_code, missing_docs)] + use tonic::codegen::*; + #[doc = " Service for reading from and writing to existing Bigtable tables."] + pub struct BigtableClient { + inner: tonic::client::Grpc, + } + impl BigtableClient { + #[doc = r" Attempt to create a new client by connecting to a given endpoint."] + pub async fn connect(dst: D) -> Result + where + D: std::convert::TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl BigtableClient + where + T: tonic::client::GrpcService, + T::ResponseBody: Body + HttpBody + Send + 'static, + T::Error: Into, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_interceptor(inner: T, interceptor: impl Into) -> Self { + let inner = tonic::client::Grpc::with_interceptor(inner, interceptor); + Self { inner } + } + #[doc = " Streams back the contents of all requested rows in key order, optionally"] + #[doc = " applying the same Reader filter to each. Depending on their size,"] + #[doc = " rows and cells may be broken up across multiple responses, but"] + #[doc = " atomicity of each row will still be preserved. See the"] + #[doc = " ReadRowsResponse documentation for details."] + pub async fn read_rows( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result>, 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 = + http::uri::PathAndQuery::from_static("/google.bigtable.v2.Bigtable/ReadRows"); + self.inner + .server_streaming(request.into_request(), path, codec) + .await + } + #[doc = " 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,"] + #[doc = " which can be used to break up the data for distributed tasks like"] + #[doc = " mapreduces."] + pub async fn sample_row_keys( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result< + tonic::Response>, + 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 = + http::uri::PathAndQuery::from_static("/google.bigtable.v2.Bigtable/SampleRowKeys"); + self.inner + .server_streaming(request.into_request(), path, codec) + .await + } + #[doc = " Mutates a row atomically. Cells already present in the row are left"] + #[doc = " unchanged unless explicitly changed by `mutation`."] + pub async fn mutate_row( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, 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 = + http::uri::PathAndQuery::from_static("/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"] + #[doc = " atomically as in MutateRow, but the entire batch is not executed"] + #[doc = " atomically."] + pub async fn mutate_rows( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result< + tonic::Response>, + 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 = + http::uri::PathAndQuery::from_static("/google.bigtable.v2.Bigtable/MutateRows"); + self.inner + .server_streaming(request.into_request(), path, codec) + .await + } + #[doc = " 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, + ) -> Result, 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 = http::uri::PathAndQuery::from_static( + "/google.bigtable.v2.Bigtable/CheckAndMutateRow", + ); + self.inner.unary(request.into_request(), path, codec).await + } + #[doc = " 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"] + #[doc = " 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"] + #[doc = " time. The method returns the new contents of all modified cells."] + pub async fn read_modify_write_row( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, 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 = http::uri::PathAndQuery::from_static( + "/google.bigtable.v2.Bigtable/ReadModifyWriteRow", + ); + self.inner.unary(request.into_request(), path, codec).await + } + } + impl Clone for BigtableClient { + fn clone(&self) -> Self { + Self { + inner: self.inner.clone(), + } + } + } + impl std::fmt::Debug for BigtableClient { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "BigtableClient {{ ... }}") + } + } +} diff --git a/storage-bigtable/proto/google.protobuf.rs b/storage-bigtable/proto/google.protobuf.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/storage-bigtable/proto/google.protobuf.rs @@ -0,0 +1 @@ + diff --git a/storage-bigtable/proto/google.rpc.rs b/storage-bigtable/proto/google.rpc.rs new file mode 100644 index 0000000000..37900a4d58 --- /dev/null +++ b/storage-bigtable/proto/google.rpc.rs @@ -0,0 +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](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). +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Status { + /// 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. + #[prost(string, tag = "2")] + pub message: std::string::String, + /// 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: ::std::vec::Vec<::prost_types::Any>, +}