mirrors/ceph-csi
1
0
Fork 0
mirror of https://github.com/ceph/ceph-csi.git synced 2025-06-13 10:33:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

vendor files

Browse Source
This commit is contained in:
Serguei Bezverkhi
2018-01-09 13:57:14 -05:00
parent 558bc6c02a
commit 7b24313bd6
16547 changed files with 4527373 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
vendor/google.golang.org/genproto/.travis.yml generated vendored Normal file
View File

@ -0,0 +1,12 @@
language: go
go:
- 1.6
- 1.7
- 1.8
go_import_path: google.golang.org/genproto
script:
- go test -v ./...
- if [[ "$TRAVIS_BRANCH" == "master" && "$TRAVIS_PULL_REQUEST" == "false" ]]; then
go get -u -v cloud.google.com/go/...;
fi

27
vendor/google.golang.org/genproto/CONTRIBUTING.md generated vendored Normal file
View File

@ -0,0 +1,27 @@
Want to contribute? Great! First, read this page (including the small print at the end).
### Before you contribute
Before we can use your code, you must sign the
[Google Individual Contributor License Agreement]
(https://cla.developers.google.com/about/google-individual)
(CLA), which you can do online. The CLA is necessary mainly because you own the
copyright to your changes, even after your contribution becomes part of our
codebase, so we need your permission to use and distribute your code. We also
need to be sure of various other things—for instance that you'll tell us if you
know that your code infringes on other people's patents. You don't have to sign
the CLA until after you've submitted your code for review and a member has
approved it, but you must do it before we can put your code into our codebase.
Before you start working on a larger contribution, you should get in touch with
us first through the issue tracker with your idea so that we can help out and
possibly guide you. Coordinating up front makes it much easier to avoid
frustration later on.
### Code reviews
All submissions, including submissions by project members, require review. We
use Github pull requests for this purpose.
### The small print
Contributions made by corporations are covered by a different agreement than
the one above, the
[Software Grant and Corporate Contributor License Agreement]
(https://cla.developers.google.com/about/google-corporate).

202
vendor/google.golang.org/genproto/LICENSE generated vendored Normal file
View File

@ -0,0 +1,202 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

28
vendor/google.golang.org/genproto/README.md generated vendored Normal file
View File

@ -0,0 +1,28 @@
Go generated proto packages
===========================
[![Build Status](https://travis-ci.org/google/go-genproto.svg?branch=master)](https://travis-ci.org/google/go-genproto)
[![GoDoc](https://godoc.org/google.golang.org/genproto?status.svg)](https://godoc.org/google.golang.org/genproto)
> **IMPORTANT** This repository is currently experimental. The structure
> of the contained packages is subject to change. Please see the original
> source repositories (listed below) to find out the status of the each
> protocol buffer's associated service.
This repository contains the generated Go packages for common protocol buffer
types, and the generated [gRPC][1] code necessary for interacting with Google's gRPC
APIs.
There are two sources for the proto files used in this repository:
1. [google/protobuf][2]: the code in the `protobuf` and `ptypes` subdirectories
is derived from this repo. The messages in `protobuf` are used to describe
protocol buffer messages themselves. The messages under `ptypes` define the
common well-known types.
2. [googleapis/googleapis][3]: the code in the `googleapis` is derived from this
repo. The packages here contain types specifically for interacting with Google
APIs.
[1]: http://grpc.io
[2]: https://github.com/google/protobuf/
[3]: https://github.com/googleapis/googleapis/

64
vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go generated vendored Normal file
View File

@ -0,0 +1,64 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/annotations.proto
/*
Package annotations is a generated protocol buffer package.
It is generated from these files:
google/api/annotations.proto
google/api/http.proto
It has these top-level messages:
Http
HttpRule
CustomHttpPattern
*/
package annotations
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
var E_Http = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.MethodOptions)(nil),
ExtensionType: (*HttpRule)(nil),
Field: 72295728,
Name: "google.api.http",
Tag: "bytes,72295728,opt,name=http",
Filename: "google/api/annotations.proto",
}
func init() {
proto.RegisterExtension(E_Http)
}
func init() { proto.RegisterFile("google/api/annotations.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 208 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb, 0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc,
0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0xc8, 0xea, 0x25, 0x16, 0x64,
0x4a, 0x89, 0x22, 0xa9, 0xcc, 0x28, 0x29, 0x29, 0x80, 0x28, 0x91, 0x52, 0x80, 0x0a, 0x83, 0x79,
0x49, 0xa5, 0x69, 0xfa, 0x29, 0xa9, 0xc5, 0xc9, 0x45, 0x99, 0x05, 0x25, 0xf9, 0x45, 0x10, 0x15,
0x56, 0xde, 0x5c, 0x2c, 0x20, 0xf5, 0x42, 0x72, 0x7a, 0x50, 0xd3, 0x60, 0x4a, 0xf5, 0x7c, 0x53,
0x4b, 0x32, 0xf2, 0x53, 0xfc, 0x0b, 0xc0, 0x56, 0x4a, 0x6c, 0x38, 0xb5, 0x47, 0x49, 0x81, 0x51,
0x83, 0xdb, 0x48, 0x44, 0x0f, 0x61, 0xad, 0x9e, 0x47, 0x49, 0x49, 0x41, 0x50, 0x69, 0x4e, 0x6a,
0x10, 0xd8, 0x10, 0xa7, 0x3c, 0x2e, 0xbe, 0xe4, 0xfc, 0x5c, 0x24, 0x05, 0x4e, 0x02, 0x8e, 0x08,
0x67, 0x07, 0x80, 0x4c, 0x0e, 0x60, 0x8c, 0x72, 0x84, 0xca, 0xa7, 0xe7, 0xe7, 0x24, 0xe6, 0xa5,
0xeb, 0xe5, 0x17, 0xa5, 0xeb, 0xa7, 0xa7, 0xe6, 0x81, 0xed, 0xd5, 0x87, 0x48, 0x25, 0x16, 0x64,
0x16, 0xa3, 0x7b, 0xda, 0x1a, 0x89, 0xbd, 0x88, 0x89, 0xc5, 0xdd, 0x31, 0xc0, 0x33, 0x89, 0x0d,
0xac, 0xc9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x29, 0x19, 0x62, 0x28, 0x01, 0x00, 0x00,
}

566
vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go generated vendored Normal file
View File

@ -0,0 +1,566 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/http.proto
package annotations
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Defines the HTTP configuration for a 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.
type Http struct {
// A list of HTTP configuration rules that apply to individual API methods.
//
// **NOTE:** All service configuration rules follow "last one wins" order.
Rules []*HttpRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *Http) Reset() { *m = Http{} }
func (m *Http) String() string { return proto.CompactTextString(m) }
func (*Http) ProtoMessage() {}
func (*Http) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
func (m *Http) GetRules() []*HttpRule {
if m != nil {
return m.Rules
}
return nil
}
// `HttpRule` defines the mapping of an RPC method to one or more HTTP
// REST APIs. The mapping determines what portions of the request
// message are populated from the path, query parameters, or body of
// the HTTP request. The mapping is typically specified as an
// `google.api.http` annotation, see "google/api/annotations.proto"
// for details.
//
// The mapping consists of a field specifying the path template and
// method kind. The path template can refer to fields in the request
// message, as in the example below which describes a REST GET
// operation on a resource collection of messages:
//
//
// service Messaging {
// rpc GetMessage(GetMessageRequest) returns (Message) {
// option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}";
// }
// }
// message GetMessageRequest {
// message SubMessage {
// string subfield = 1;
// }
// string message_id = 1; // mapped to the URL
// SubMessage sub = 2; // `sub.subfield` is url-mapped
// }
// message Message {
// string text = 1; // content of the resource
// }
//
// The same http annotation can alternatively be expressed inside the
// `GRPC API Configuration` YAML file.
//
// http:
// rules:
// - selector: <proto_package_name>.Messaging.GetMessage
// get: /v1/messages/{message_id}/{sub.subfield}
//
// This definition enables an automatic, bidrectional mapping of HTTP
// JSON to RPC. Example:
//
// HTTP | RPC
// -----|-----
// `GET /v1/messages/123456/foo` | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))`
//
// In general, not only fields but also field paths can be referenced
// from a path pattern. Fields mapped to the path pattern cannot be
// repeated and must have a primitive (non-message) type.
//
// Any fields in the request message which are not bound by the path
// pattern automatically become (optional) HTTP query
// parameters. Assume the following definition of the request message:
//
//
// message GetMessageRequest {
// message SubMessage {
// string subfield = 1;
// }
// string message_id = 1; // mapped to the URL
// int64 revision = 2; // becomes a parameter
// SubMessage sub = 3; // `sub.subfield` becomes a parameter
// }
//
//
// This enables a HTTP JSON to RPC mapping as below:
//
// HTTP | RPC
// -----|-----
// `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 HTTP parameters must have a
// primitive type or a repeated primitive type. Message types are not
// allowed. In the case of a repeated type, the parameter can be
// repeated in the URL, as in `...?param=A&param=B`.
//
// For HTTP method kinds which 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) = {
// put: "/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 | RPC
// -----|-----
// `PUT /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) = {
// put: "/v1/messages/{message_id}"
// body: "*"
// };
// }
// }
// message Message {
// string message_id = 1;
// string text = 2;
// }
//
//
// The following HTTP JSON to RPC mapping is enabled:
//
// HTTP | RPC
// -----|-----
// `PUT /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 of
// 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 | RPC
// -----|-----
// `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
//
// The rules for mapping HTTP path, query parameters, and body fields
// to the request message are as follows:
//
// 1. The `body` field specifies either `*` or a field path, or is
// omitted. If omitted, it assumes there is no HTTP body.
// 2. Leaf fields (recursive expansion of nested messages in the
// request) can be classified into three types:
// (a) Matched in the URL template.
// (b) Covered by body (if body is `*`, everything except (a) fields;
// else everything under the body field)
// (c) All other fields.
// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
// 4. Any body sent with an HTTP request can contain only (b) fields.
//
// The syntax of the path template is as follows:
//
// Template = "/" Segments [ Verb ] ;
// Segments = Segment { "/" Segment } ;
// Segment = "*" | "**" | LITERAL | Variable ;
// Variable = "{" FieldPath [ "=" Segments ] "}" ;
// FieldPath = IDENT { "." IDENT } ;
// Verb = ":" LITERAL ;
//
// The syntax `*` matches a single path segment. It follows the semantics of
// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
// Expansion.
//
// The syntax `**` matches zero or more path segments. It follows the semantics
// of [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.3 Reserved
// Expansion. NOTE: it must be the last segment in the path except the Verb.
//
// The syntax `LITERAL` matches literal text in the URL path.
//
// The syntax `Variable` matches the entire path as specified by its template;
// this nested template must not contain further variables. If a variable
// matches a single path segment, its template may be omitted, e.g. `{var}`
// is equivalent to `{var=*}`.
//
// NOTE: the field paths in variables and in the `body` must not refer to
// repeated fields or map fields.
//
// Use CustomHttpPattern to specify any HTTP method that is not included in the
// `pattern` field, such as HEAD, or "*" to leave the HTTP method unspecified for
// a given URL path rule. The wild-card rule is useful for services that provide
// content to Web (HTML) clients.
type HttpRule struct {
// Selects methods to which this rule applies.
//
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// 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.
//
// Types that are valid to be assigned to Pattern:
// *HttpRule_Get
// *HttpRule_Put
// *HttpRule_Post
// *HttpRule_Delete
// *HttpRule_Patch
// *HttpRule_Custom
Pattern isHttpRule_Pattern `protobuf_oneof:"pattern"`
// The name of the request field whose value is mapped to the HTTP body, or
// `*` for mapping all fields not captured by the path pattern to the HTTP
// body. NOTE: the referred field must not be a repeated field and must be
// present at the top-level of request message type.
Body string `protobuf:"bytes,7,opt,name=body" json:"body,omitempty"`
// 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).
AdditionalBindings []*HttpRule `protobuf:"bytes,11,rep,name=additional_bindings,json=additionalBindings" json:"additional_bindings,omitempty"`
}
func (m *HttpRule) Reset() { *m = HttpRule{} }
func (m *HttpRule) String() string { return proto.CompactTextString(m) }
func (*HttpRule) ProtoMessage() {}
func (*HttpRule) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
type isHttpRule_Pattern interface {
isHttpRule_Pattern()
}
type HttpRule_Get struct {
Get string `protobuf:"bytes,2,opt,name=get,oneof"`
}
type HttpRule_Put struct {
Put string `protobuf:"bytes,3,opt,name=put,oneof"`
}
type HttpRule_Post struct {
Post string `protobuf:"bytes,4,opt,name=post,oneof"`
}
type HttpRule_Delete struct {
Delete string `protobuf:"bytes,5,opt,name=delete,oneof"`
}
type HttpRule_Patch struct {
Patch string `protobuf:"bytes,6,opt,name=patch,oneof"`
}
type HttpRule_Custom struct {
Custom *CustomHttpPattern `protobuf:"bytes,8,opt,name=custom,oneof"`
}
func (*HttpRule_Get) isHttpRule_Pattern() {}
func (*HttpRule_Put) isHttpRule_Pattern() {}
func (*HttpRule_Post) isHttpRule_Pattern() {}
func (*HttpRule_Delete) isHttpRule_Pattern() {}
func (*HttpRule_Patch) isHttpRule_Pattern() {}
func (*HttpRule_Custom) isHttpRule_Pattern() {}
func (m *HttpRule) GetPattern() isHttpRule_Pattern {
if m != nil {
return m.Pattern
}
return nil
}
func (m *HttpRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *HttpRule) GetGet() string {
if x, ok := m.GetPattern().(*HttpRule_Get); ok {
return x.Get
}
return ""
}
func (m *HttpRule) GetPut() string {
if x, ok := m.GetPattern().(*HttpRule_Put); ok {
return x.Put
}
return ""
}
func (m *HttpRule) GetPost() string {
if x, ok := m.GetPattern().(*HttpRule_Post); ok {
return x.Post
}
return ""
}
func (m *HttpRule) GetDelete() string {
if x, ok := m.GetPattern().(*HttpRule_Delete); ok {
return x.Delete
}
return ""
}
func (m *HttpRule) GetPatch() string {
if x, ok := m.GetPattern().(*HttpRule_Patch); ok {
return x.Patch
}
return ""
}
func (m *HttpRule) GetCustom() *CustomHttpPattern {
if x, ok := m.GetPattern().(*HttpRule_Custom); ok {
return x.Custom
}
return nil
}
func (m *HttpRule) GetBody() string {
if m != nil {
return m.Body
}
return ""
}
func (m *HttpRule) GetAdditionalBindings() []*HttpRule {
if m != nil {
return m.AdditionalBindings
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*HttpRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _HttpRule_OneofMarshaler, _HttpRule_OneofUnmarshaler, _HttpRule_OneofSizer, []interface{}{
(*HttpRule_Get)(nil),
(*HttpRule_Put)(nil),
(*HttpRule_Post)(nil),
(*HttpRule_Delete)(nil),
(*HttpRule_Patch)(nil),
(*HttpRule_Custom)(nil),
}
}
func _HttpRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*HttpRule)
// pattern
switch x := m.Pattern.(type) {
case *HttpRule_Get:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Get)
case *HttpRule_Put:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Put)
case *HttpRule_Post:
b.EncodeVarint(4<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Post)
case *HttpRule_Delete:
b.EncodeVarint(5<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Delete)
case *HttpRule_Patch:
b.EncodeVarint(6<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Patch)
case *HttpRule_Custom:
b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Custom); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("HttpRule.Pattern has unexpected type %T", x)
}
return nil
}
func _HttpRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*HttpRule)
switch tag {
case 2: // pattern.get
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Get{x}
return true, err
case 3: // pattern.put
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Put{x}
return true, err
case 4: // pattern.post
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Post{x}
return true, err
case 5: // pattern.delete
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Delete{x}
return true, err
case 6: // pattern.patch
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pattern = &HttpRule_Patch{x}
return true, err
case 8: // pattern.custom
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(CustomHttpPattern)
err := b.DecodeMessage(msg)
m.Pattern = &HttpRule_Custom{msg}
return true, err
default:
return false, nil
}
}
func _HttpRule_OneofSizer(msg proto.Message) (n int) {
m := msg.(*HttpRule)
// pattern
switch x := m.Pattern.(type) {
case *HttpRule_Get:
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.Get)))
n += len(x.Get)
case *HttpRule_Put:
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.Put)))
n += len(x.Put)
case *HttpRule_Post:
n += proto.SizeVarint(4<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.Post)))
n += len(x.Post)
case *HttpRule_Delete:
n += proto.SizeVarint(5<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.Delete)))
n += len(x.Delete)
case *HttpRule_Patch:
n += proto.SizeVarint(6<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.Patch)))
n += len(x.Patch)
case *HttpRule_Custom:
s := proto.Size(x.Custom)
n += proto.SizeVarint(8<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// A custom pattern is used for defining custom HTTP verb.
type CustomHttpPattern struct {
// The name of this custom HTTP verb.
Kind string `protobuf:"bytes,1,opt,name=kind" json:"kind,omitempty"`
// The path matched by this custom verb.
Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
}
func (m *CustomHttpPattern) Reset() { *m = CustomHttpPattern{} }
func (m *CustomHttpPattern) String() string { return proto.CompactTextString(m) }
func (*CustomHttpPattern) ProtoMessage() {}
func (*CustomHttpPattern) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
func (m *CustomHttpPattern) GetKind() string {
if m != nil {
return m.Kind
}
return ""
}
func (m *CustomHttpPattern) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func init() {
proto.RegisterType((*Http)(nil), "google.api.Http")
proto.RegisterType((*HttpRule)(nil), "google.api.HttpRule")
proto.RegisterType((*CustomHttpPattern)(nil), "google.api.CustomHttpPattern")
}
func init() { proto.RegisterFile("google/api/http.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 359 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xcf, 0x6a, 0xe3, 0x30,
0x10, 0xc6, 0xd7, 0x89, 0xe3, 0x24, 0x13, 0x58, 0x58, 0x6d, 0x76, 0x11, 0x85, 0x42, 0xc8, 0x29,
0xf4, 0x60, 0x43, 0x7a, 0xe8, 0x21, 0xa7, 0xb8, 0x94, 0xa6, 0xb7, 0xe0, 0x63, 0x2f, 0x45, 0xb1,
0x85, 0xa2, 0xd6, 0x91, 0x84, 0x3d, 0x3e, 0xf4, 0x75, 0xfa, 0x0e, 0x7d, 0xb7, 0x1e, 0x8b, 0xfe,
0xa4, 0x09, 0x14, 0x7a, 0x9b, 0xef, 0x37, 0x9f, 0x34, 0xa3, 0x19, 0xc1, 0x3f, 0xa1, 0xb5, 0xa8,
0x79, 0xc6, 0x8c, 0xcc, 0xf6, 0x88, 0x26, 0x35, 0x8d, 0x46, 0x4d, 0xc0, 0xe3, 0x94, 0x19, 0x39,
0x5f, 0x42, 0xbc, 0x41, 0x34, 0xe4, 0x0a, 0x06, 0x4d, 0x57, 0xf3, 0x96, 0x46, 0xb3, 0xfe, 0x62,
0xb2, 0x9c, 0xa6, 0x27, 0x4f, 0x6a, 0x0d, 0x45, 0x57, 0xf3, 0xc2, 0x5b, 0xe6, 0xef, 0x3d, 0x18,
0x1d, 0x19, 0xb9, 0x80, 0x51, 0xcb, 0x6b, 0x5e, 0xa2, 0x6e, 0x68, 0x34, 0x8b, 0x16, 0xe3, 0xe2,
0x4b, 0x13, 0x02, 0x7d, 0xc1, 0x91, 0xf6, 0x2c, 0xde, 0xfc, 0x2a, 0xac, 0xb0, 0xcc, 0x74, 0x48,
0xfb, 0x47, 0x66, 0x3a, 0x24, 0x53, 0x88, 0x8d, 0x6e, 0x91, 0xc6, 0x01, 0x3a, 0x45, 0x28, 0x24,
0x15, 0xaf, 0x39, 0x72, 0x3a, 0x08, 0x3c, 0x68, 0xf2, 0x1f, 0x06, 0x86, 0x61, 0xb9, 0xa7, 0x49,
0x48, 0x78, 0x49, 0x6e, 0x20, 0x29, 0xbb, 0x16, 0xf5, 0x81, 0x8e, 0x66, 0xd1, 0x62, 0xb2, 0xbc,
0x3c, 0x7f, 0xc5, 0xad, 0xcb, 0xd8, 0xbe, 0xb7, 0x0c, 0x91, 0x37, 0xca, 0x5e, 0xe8, 0xed, 0x84,
0x40, 0xbc, 0xd3, 0xd5, 0x2b, 0x1d, 0xba, 0x07, 0xb8, 0x98, 0xdc, 0xc1, 0x5f, 0x56, 0x55, 0x12,
0xa5, 0x56, 0xac, 0x7e, 0xda, 0x49, 0x55, 0x49, 0x25, 0x5a, 0x3a, 0xf9, 0x61, 0x3e, 0xe4, 0x74,
0x20, 0x0f, 0xfe, 0x7c, 0x0c, 0x43, 0xe3, 0xeb, 0xcd, 0x57, 0xf0, 0xe7, 0x5b, 0x13, 0xb6, 0xf4,
0x8b, 0x54, 0x55, 0x98, 0x9d, 0x8b, 0x2d, 0x33, 0x0c, 0xf7, 0x7e, 0x70, 0x85, 0x8b, 0xf3, 0x67,
0xf8, 0x5d, 0xea, 0xc3, 0x59, 0xd9, 0x7c, 0xec, 0xae, 0xb1, 0x1b, 0xdd, 0x46, 0x8f, 0xeb, 0x90,
0x10, 0xba, 0x66, 0x4a, 0xa4, 0xba, 0x11, 0x99, 0xe0, 0xca, 0xed, 0x3b, 0xf3, 0x29, 0x66, 0x64,
0xeb, 0x7e, 0x02, 0x53, 0x4a, 0x23, 0xb3, 0x6d, 0xb6, 0xab, 0xb3, 0xf8, 0x23, 0x8a, 0xde, 0x7a,
0xf1, 0xfd, 0x7a, 0xfb, 0xb0, 0x4b, 0xdc, 0xb9, 0xeb, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x68,
0x15, 0x60, 0x5b, 0x40, 0x02, 0x00, 0x00,
}

80
vendor/google.golang.org/genproto/googleapis/api/authorization_config.pb.go generated vendored Normal file
View File

@ -0,0 +1,80 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/experimental/authorization_config.proto
/*
Package api is a generated protocol buffer package.
It is generated from these files:
google/api/experimental/authorization_config.proto
google/api/experimental/experimental.proto
It has these top-level messages:
AuthorizationConfig
Experimental
*/
package api
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Configuration of authorization.
//
// This section determines the authorization provider, if unspecified, then no
// authorization check will be done.
//
// Example:
//
// experimental:
// authorization:
// provider: firebaserules.googleapis.com
type AuthorizationConfig struct {
// The name of the authorization provider, such as
// firebaserules.googleapis.com.
Provider string `protobuf:"bytes,1,opt,name=provider" json:"provider,omitempty"`
}
func (m *AuthorizationConfig) Reset() { *m = AuthorizationConfig{} }
func (m *AuthorizationConfig) String() string { return proto.CompactTextString(m) }
func (*AuthorizationConfig) ProtoMessage() {}
func (*AuthorizationConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *AuthorizationConfig) GetProvider() string {
if m != nil {
return m.Provider
}
return ""
}
func init() {
proto.RegisterType((*AuthorizationConfig)(nil), "google.api.AuthorizationConfig")
}
func init() { proto.RegisterFile("google/api/experimental/authorization_config.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 180 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x4a, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xad, 0x28, 0x48, 0x2d, 0xca, 0xcc, 0x4d, 0xcd,
0x2b, 0x49, 0xcc, 0xd1, 0x4f, 0x2c, 0x2d, 0xc9, 0xc8, 0x2f, 0xca, 0xac, 0x4a, 0x2c, 0xc9, 0xcc,
0xcf, 0x8b, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2,
0x82, 0xe8, 0xd1, 0x4b, 0x2c, 0xc8, 0x54, 0x32, 0xe4, 0x12, 0x76, 0x44, 0x56, 0xe9, 0x0c, 0x56,
0x28, 0x24, 0xc5, 0xc5, 0x51, 0x50, 0x94, 0x5f, 0x96, 0x99, 0x92, 0x5a, 0x24, 0xc1, 0xa8, 0xc0,
0xa8, 0xc1, 0x19, 0x04, 0xe7, 0x3b, 0x25, 0x71, 0xf1, 0x25, 0xe7, 0xe7, 0xea, 0x21, 0x0c, 0x71,
0x92, 0xc0, 0x62, 0x44, 0x00, 0xc8, 0xaa, 0x00, 0xc6, 0x28, 0x5d, 0xa8, 0xba, 0xf4, 0xfc, 0x9c,
0xc4, 0xbc, 0x74, 0xbd, 0xfc, 0xa2, 0x74, 0xfd, 0xf4, 0xd4, 0x3c, 0xb0, 0x43, 0xf4, 0x21, 0x52,
0x89, 0x05, 0x99, 0xc5, 0x20, 0xf7, 0x5b, 0x27, 0x16, 0x64, 0x2e, 0x62, 0x62, 0x71, 0x77, 0x0c,
0xf0, 0x4c, 0x62, 0x03, 0x2b, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x52, 0x27, 0x0c, 0xba,
0xdf, 0x00, 0x00, 0x00,
}

189
vendor/google.golang.org/genproto/googleapis/api/configchange/config_change.pb.go generated vendored Normal file
View File

@ -0,0 +1,189 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/config_change.proto
/*
Package configchange is a generated protocol buffer package.
It is generated from these files:
google/api/config_change.proto
It has these top-level messages:
ConfigChange
Advice
*/
package configchange
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Classifies set of possible modifications to an object in the service
// configuration.
type ChangeType int32
const (
// No value was provided.
ChangeType_CHANGE_TYPE_UNSPECIFIED ChangeType = 0
// The changed object exists in the 'new' service configuration, but not
// in the 'old' service configuration.
ChangeType_ADDED ChangeType = 1
// The changed object exists in the 'old' service configuration, but not
// in the 'new' service configuration.
ChangeType_REMOVED ChangeType = 2
// The changed object exists in both service configurations, but its value
// is different.
ChangeType_MODIFIED ChangeType = 3
)
var ChangeType_name = map[int32]string{
0: "CHANGE_TYPE_UNSPECIFIED",
1: "ADDED",
2: "REMOVED",
3: "MODIFIED",
}
var ChangeType_value = map[string]int32{
"CHANGE_TYPE_UNSPECIFIED": 0,
"ADDED": 1,
"REMOVED": 2,
"MODIFIED": 3,
}
func (x ChangeType) String() string {
return proto.EnumName(ChangeType_name, int32(x))
}
func (ChangeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
// Output generated from semantically comparing two versions of a service
// configuration.
//
// Includes detailed information about a field that have changed with
// applicable advice about potential consequences for the change, such as
// backwards-incompatibility.
type ConfigChange struct {
// Object hierarchy path to the change, with levels separated by a '.'
// character. For repeated fields, an applicable unique identifier field is
// used for the index (usually selector, name, or id). For maps, the term
// 'key' is used. If the field has no unique identifier, the numeric index
// is used.
// Examples:
// - visibility.rules[selector=="google.LibraryService.CreateBook"].restriction
// - quota.metric_rules[selector=="google"].metric_costs[key=="reads"].value
// - logging.producer_destinations[0]
Element string `protobuf:"bytes,1,opt,name=element" json:"element,omitempty"`
// Value of the changed object in the old Service configuration,
// in JSON format. This field will not be populated if ChangeType == ADDED.
OldValue string `protobuf:"bytes,2,opt,name=old_value,json=oldValue" json:"old_value,omitempty"`
// Value of the changed object in the new Service configuration,
// in JSON format. This field will not be populated if ChangeType == REMOVED.
NewValue string `protobuf:"bytes,3,opt,name=new_value,json=newValue" json:"new_value,omitempty"`
// The type for this change, either ADDED, REMOVED, or MODIFIED.
ChangeType ChangeType `protobuf:"varint,4,opt,name=change_type,json=changeType,enum=google.api.ChangeType" json:"change_type,omitempty"`
// Collection of advice provided for this change, useful for determining the
// possible impact of this change.
Advices []*Advice `protobuf:"bytes,5,rep,name=advices" json:"advices,omitempty"`
}
func (m *ConfigChange) Reset() { *m = ConfigChange{} }
func (m *ConfigChange) String() string { return proto.CompactTextString(m) }
func (*ConfigChange) ProtoMessage() {}
func (*ConfigChange) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *ConfigChange) GetElement() string {
if m != nil {
return m.Element
}
return ""
}
func (m *ConfigChange) GetOldValue() string {
if m != nil {
return m.OldValue
}
return ""
}
func (m *ConfigChange) GetNewValue() string {
if m != nil {
return m.NewValue
}
return ""
}
func (m *ConfigChange) GetChangeType() ChangeType {
if m != nil {
return m.ChangeType
}
return ChangeType_CHANGE_TYPE_UNSPECIFIED
}
func (m *ConfigChange) GetAdvices() []*Advice {
if m != nil {
return m.Advices
}
return nil
}
// Generated advice about this change, used for providing more
// information about how a change will affect the existing service.
type Advice struct {
// Useful description for why this advice was applied and what actions should
// be taken to mitigate any implied risks.
Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"`
}
func (m *Advice) Reset() { *m = Advice{} }
func (m *Advice) String() string { return proto.CompactTextString(m) }
func (*Advice) ProtoMessage() {}
func (*Advice) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *Advice) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*ConfigChange)(nil), "google.api.ConfigChange")
proto.RegisterType((*Advice)(nil), "google.api.Advice")
proto.RegisterEnum("google.api.ChangeType", ChangeType_name, ChangeType_value)
}
func init() { proto.RegisterFile("google/api/config_change.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 338 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x91, 0xcd, 0x4e, 0xc2, 0x40,
0x14, 0x85, 0x2d, 0xff, 0xdc, 0x12, 0x82, 0xb3, 0xd0, 0x26, 0x24, 0xa6, 0x61, 0x45, 0x88, 0x69,
0x13, 0x5c, 0xb8, 0x70, 0x55, 0xda, 0x8a, 0x2c, 0x80, 0xa6, 0x22, 0x89, 0x6e, 0x9a, 0xb1, 0x1d,
0xc7, 0x49, 0xca, 0xcc, 0x08, 0x15, 0xc2, 0xeb, 0xf8, 0x36, 0xbe, 0x95, 0xa1, 0x03, 0xd2, 0xdd,
0x9c, 0xf9, 0xce, 0xcd, 0x3d, 0x39, 0x17, 0x6e, 0xa8, 0x10, 0x34, 0x25, 0x36, 0x96, 0xcc, 0x8e,
0x05, 0xff, 0x60, 0x34, 0x8a, 0x3f, 0x31, 0xa7, 0xc4, 0x92, 0x6b, 0x91, 0x09, 0x04, 0x8a, 0x5b,
0x58, 0xb2, 0xde, 0xaf, 0x06, 0x2d, 0x37, 0xf7, 0xb8, 0xb9, 0x05, 0x19, 0x50, 0x27, 0x29, 0x59,
0x11, 0x9e, 0x19, 0x9a, 0xa9, 0xf5, 0x9b, 0xe1, 0x49, 0xa2, 0x2e, 0x34, 0x45, 0x9a, 0x44, 0x5b,
0x9c, 0x7e, 0x13, 0xa3, 0x94, 0xb3, 0x86, 0x48, 0x93, 0xe5, 0x41, 0x1f, 0x20, 0x27, 0xbb, 0x23,
0x2c, 0x2b, 0xc8, 0xc9, 0x4e, 0xc1, 0x7b, 0xd0, 0x55, 0x80, 0x28, 0xdb, 0x4b, 0x62, 0x54, 0x4c,
0xad, 0xdf, 0x1e, 0x5e, 0x59, 0xe7, 0x18, 0x96, 0x5a, 0xbe, 0xd8, 0x4b, 0x12, 0x42, 0xfc, 0xff,
0x46, 0xb7, 0x50, 0xc7, 0xc9, 0x96, 0xc5, 0x64, 0x63, 0x54, 0xcd, 0x72, 0x5f, 0x1f, 0xa2, 0xe2,
0x90, 0x93, 0xa3, 0xf0, 0x64, 0xe9, 0x0d, 0xa0, 0xa6, 0xbe, 0x90, 0x09, 0x7a, 0x42, 0x36, 0xf1,
0x9a, 0xc9, 0x8c, 0x09, 0x7e, 0x0c, 0x5b, 0xfc, 0x1a, 0xcc, 0x01, 0xce, 0x3b, 0x51, 0x17, 0xae,
0xdd, 0x27, 0x67, 0x36, 0xf6, 0xa3, 0xc5, 0x6b, 0xe0, 0x47, 0x2f, 0xb3, 0xe7, 0xc0, 0x77, 0x27,
0x8f, 0x13, 0xdf, 0xeb, 0x5c, 0xa0, 0x26, 0x54, 0x1d, 0xcf, 0xf3, 0xbd, 0x8e, 0x86, 0x74, 0xa8,
0x87, 0xfe, 0x74, 0xbe, 0xf4, 0xbd, 0x4e, 0x09, 0xb5, 0xa0, 0x31, 0x9d, 0x7b, 0xca, 0x55, 0x1e,
0x7d, 0x41, 0x3b, 0x16, 0xab, 0x42, 0xbc, 0xd1, 0x65, 0xb1, 0xd7, 0xe0, 0xd0, 0x7c, 0xa0, 0xbd,
0xb9, 0x47, 0x03, 0x15, 0x29, 0xe6, 0xd4, 0x12, 0x6b, 0x6a, 0x53, 0xc2, 0xf3, 0xbb, 0xd8, 0x0a,
0x61, 0xc9, 0x36, 0x85, 0xd3, 0xa9, 0x36, 0x1e, 0x8a, 0xe2, 0xa7, 0x54, 0x19, 0x3b, 0xc1, 0xe4,
0xbd, 0x96, 0x8f, 0xdd, 0xfd, 0x05, 0x00, 0x00, 0xff, 0xff, 0x46, 0x8b, 0xd3, 0xf5, 0xf0, 0x01,
0x00, 0x00,
}

506
vendor/google.golang.org/genproto/googleapis/api/distribution/distribution.pb.go generated vendored Normal file
View File

@ -0,0 +1,506 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/distribution.proto
/*
Package distribution is a generated protocol buffer package.
It is generated from these files:
google/api/distribution.proto
It has these top-level messages:
Distribution
*/
package distribution
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import _ "github.com/golang/protobuf/ptypes/any"
import _ "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Distribution contains summary statistics for a population of values and,
// optionally, a histogram representing the distribution of those values across
// a specified set of histogram buckets.
//
// The summary statistics are the count, mean, sum of the squared deviation from
// the mean, the minimum, and the maximum of the set of population of values.
//
// The histogram is based on a sequence of buckets and gives a count of values
// that fall into each bucket. The boundaries of the buckets are given either
// explicitly or by specifying parameters for a method of computing them
// (buckets of fixed width or buckets of exponentially increasing width).
//
// Although it is not forbidden, it is generally a bad idea to include
// non-finite values (infinities or NaNs) in the population of values, as this
// will render the `mean` and `sum_of_squared_deviation` fields meaningless.
type Distribution struct {
// The number of values in the population. Must be non-negative.
Count int64 `protobuf:"varint,1,opt,name=count" json:"count,omitempty"`
// The arithmetic mean of the values in the population. If `count` is zero
// then this field must be zero.
Mean float64 `protobuf:"fixed64,2,opt,name=mean" json:"mean,omitempty"`
// The sum of squared deviations from the mean of the values in the
// population. For values x_i this is:
//
// Sum[i=1..n]((x_i - mean)^2)
//
// Knuth, "The Art of Computer Programming", Vol. 2, page 323, 3rd edition
// describes Welford's method for accumulating this sum in one pass.
//
// If `count` is zero then this field must be zero.
SumOfSquaredDeviation float64 `protobuf:"fixed64,3,opt,name=sum_of_squared_deviation,json=sumOfSquaredDeviation" json:"sum_of_squared_deviation,omitempty"`
// If specified, contains the range of the population values. The field
// must not be present if the `count` is zero.
Range *Distribution_Range `protobuf:"bytes,4,opt,name=range" json:"range,omitempty"`
// Defines the histogram bucket boundaries.
BucketOptions *Distribution_BucketOptions `protobuf:"bytes,6,opt,name=bucket_options,json=bucketOptions" json:"bucket_options,omitempty"`
// If `bucket_options` is given, then the sum of the values in `bucket_counts`
// must equal the value in `count`. If `bucket_options` is not given, no
// `bucket_counts` fields may be given.
//
// Bucket counts are given in order under the numbering scheme described
// above (the underflow bucket has number 0; the finite buckets, if any,
// have numbers 1 through N-2; the overflow bucket has number N-1).
//
// The size of `bucket_counts` must be no greater than N as defined in
// `bucket_options`.
//
// Any suffix of trailing zero bucket_count fields may be omitted.
BucketCounts []int64 `protobuf:"varint,7,rep,packed,name=bucket_counts,json=bucketCounts" json:"bucket_counts,omitempty"`
}
func (m *Distribution) Reset() { *m = Distribution{} }
func (m *Distribution) String() string { return proto.CompactTextString(m) }
func (*Distribution) ProtoMessage() {}
func (*Distribution) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Distribution) GetCount() int64 {
if m != nil {
return m.Count
}
return 0
}
func (m *Distribution) GetMean() float64 {
if m != nil {
return m.Mean
}
return 0
}
func (m *Distribution) GetSumOfSquaredDeviation() float64 {
if m != nil {
return m.SumOfSquaredDeviation
}
return 0
}
func (m *Distribution) GetRange() *Distribution_Range {
if m != nil {
return m.Range
}
return nil
}
func (m *Distribution) GetBucketOptions() *Distribution_BucketOptions {
if m != nil {
return m.BucketOptions
}
return nil
}
func (m *Distribution) GetBucketCounts() []int64 {
if m != nil {
return m.BucketCounts
}
return nil
}
// The range of the population values.
type Distribution_Range struct {
// The minimum of the population values.
Min float64 `protobuf:"fixed64,1,opt,name=min" json:"min,omitempty"`
// The maximum of the population values.
Max float64 `protobuf:"fixed64,2,opt,name=max" json:"max,omitempty"`
}
func (m *Distribution_Range) Reset() { *m = Distribution_Range{} }
func (m *Distribution_Range) String() string { return proto.CompactTextString(m) }
func (*Distribution_Range) ProtoMessage() {}
func (*Distribution_Range) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }
func (m *Distribution_Range) GetMin() float64 {
if m != nil {
return m.Min
}
return 0
}
func (m *Distribution_Range) GetMax() float64 {
if m != nil {
return m.Max
}
return 0
}
// A Distribution may optionally contain a histogram of the values in the
// population. The histogram is given in `bucket_counts` as counts of values
// that fall into one of a sequence of non-overlapping buckets. The sequence
// of buckets is described by `bucket_options`.
//
// A bucket specifies an inclusive lower bound and exclusive upper bound for
// the values that are counted for that bucket. The upper bound of a bucket
// is strictly greater than the lower bound.
//
// The sequence of N buckets for a Distribution consists of an underflow
// bucket (number 0), zero or more finite buckets (number 1 through N - 2) and
// an overflow bucket (number N - 1). The buckets are contiguous: the lower
// bound of bucket i (i > 0) is the same as the upper bound of bucket i - 1.
// The buckets span the whole range of finite values: lower bound of the
// underflow bucket is -infinity and the upper bound of the overflow bucket is
// +infinity. The finite buckets are so-called because both bounds are
// finite.
//
// `BucketOptions` describes bucket boundaries in one of three ways. Two
// describe the boundaries by giving parameters for a formula to generate
// boundaries and one gives the bucket boundaries explicitly.
//
// If `bucket_boundaries` is not given, then no `bucket_counts` may be given.
type Distribution_BucketOptions struct {
// Exactly one of these three fields must be set.
//
// Types that are valid to be assigned to Options:
// *Distribution_BucketOptions_LinearBuckets
// *Distribution_BucketOptions_ExponentialBuckets
// *Distribution_BucketOptions_ExplicitBuckets
Options isDistribution_BucketOptions_Options `protobuf_oneof:"options"`
}
func (m *Distribution_BucketOptions) Reset() { *m = Distribution_BucketOptions{} }
func (m *Distribution_BucketOptions) String() string { return proto.CompactTextString(m) }
func (*Distribution_BucketOptions) ProtoMessage() {}
func (*Distribution_BucketOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 1} }
type isDistribution_BucketOptions_Options interface {
isDistribution_BucketOptions_Options()
}
type Distribution_BucketOptions_LinearBuckets struct {
LinearBuckets *Distribution_BucketOptions_Linear `protobuf:"bytes,1,opt,name=linear_buckets,json=linearBuckets,oneof"`
}
type Distribution_BucketOptions_ExponentialBuckets struct {
ExponentialBuckets *Distribution_BucketOptions_Exponential `protobuf:"bytes,2,opt,name=exponential_buckets,json=exponentialBuckets,oneof"`
}
type Distribution_BucketOptions_ExplicitBuckets struct {
ExplicitBuckets *Distribution_BucketOptions_Explicit `protobuf:"bytes,3,opt,name=explicit_buckets,json=explicitBuckets,oneof"`
}
func (*Distribution_BucketOptions_LinearBuckets) isDistribution_BucketOptions_Options() {}
func (*Distribution_BucketOptions_ExponentialBuckets) isDistribution_BucketOptions_Options() {}
func (*Distribution_BucketOptions_ExplicitBuckets) isDistribution_BucketOptions_Options() {}
func (m *Distribution_BucketOptions) GetOptions() isDistribution_BucketOptions_Options {
if m != nil {
return m.Options
}
return nil
}
func (m *Distribution_BucketOptions) GetLinearBuckets() *Distribution_BucketOptions_Linear {
if x, ok := m.GetOptions().(*Distribution_BucketOptions_LinearBuckets); ok {
return x.LinearBuckets
}
return nil
}
func (m *Distribution_BucketOptions) GetExponentialBuckets() *Distribution_BucketOptions_Exponential {
if x, ok := m.GetOptions().(*Distribution_BucketOptions_ExponentialBuckets); ok {
return x.ExponentialBuckets
}
return nil
}
func (m *Distribution_BucketOptions) GetExplicitBuckets() *Distribution_BucketOptions_Explicit {
if x, ok := m.GetOptions().(*Distribution_BucketOptions_ExplicitBuckets); ok {
return x.ExplicitBuckets
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Distribution_BucketOptions) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Distribution_BucketOptions_OneofMarshaler, _Distribution_BucketOptions_OneofUnmarshaler, _Distribution_BucketOptions_OneofSizer, []interface{}{
(*Distribution_BucketOptions_LinearBuckets)(nil),
(*Distribution_BucketOptions_ExponentialBuckets)(nil),
(*Distribution_BucketOptions_ExplicitBuckets)(nil),
}
}
func _Distribution_BucketOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Distribution_BucketOptions)
// options
switch x := m.Options.(type) {
case *Distribution_BucketOptions_LinearBuckets:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.LinearBuckets); err != nil {
return err
}
case *Distribution_BucketOptions_ExponentialBuckets:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ExponentialBuckets); err != nil {
return err
}
case *Distribution_BucketOptions_ExplicitBuckets:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ExplicitBuckets); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Distribution_BucketOptions.Options has unexpected type %T", x)
}
return nil
}
func _Distribution_BucketOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Distribution_BucketOptions)
switch tag {
case 1: // options.linear_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_BucketOptions_Linear)
err := b.DecodeMessage(msg)
m.Options = &Distribution_BucketOptions_LinearBuckets{msg}
return true, err
case 2: // options.exponential_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_BucketOptions_Exponential)
err := b.DecodeMessage(msg)
m.Options = &Distribution_BucketOptions_ExponentialBuckets{msg}
return true, err
case 3: // options.explicit_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_BucketOptions_Explicit)
err := b.DecodeMessage(msg)
m.Options = &Distribution_BucketOptions_ExplicitBuckets{msg}
return true, err
default:
return false, nil
}
}
func _Distribution_BucketOptions_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Distribution_BucketOptions)
// options
switch x := m.Options.(type) {
case *Distribution_BucketOptions_LinearBuckets:
s := proto.Size(x.LinearBuckets)
n += proto.SizeVarint(1<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *Distribution_BucketOptions_ExponentialBuckets:
s := proto.Size(x.ExponentialBuckets)
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *Distribution_BucketOptions_ExplicitBuckets:
s := proto.Size(x.ExplicitBuckets)
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Specify a sequence of buckets that all have the same width (except
// overflow and underflow). Each bucket represents a constant absolute
// uncertainty on the specific value in the bucket.
//
// Defines `num_finite_buckets + 2` (= N) buckets with these boundaries for
// bucket `i`:
//
// Upper bound (0 <= i < N-1): offset + (width * i).
// Lower bound (1 <= i < N): offset + (width * (i - 1)).
type Distribution_BucketOptions_Linear struct {
// Must be greater than 0.
NumFiniteBuckets int32 `protobuf:"varint,1,opt,name=num_finite_buckets,json=numFiniteBuckets" json:"num_finite_buckets,omitempty"`
// Must be greater than 0.
Width float64 `protobuf:"fixed64,2,opt,name=width" json:"width,omitempty"`
// Lower bound of the first bucket.
Offset float64 `protobuf:"fixed64,3,opt,name=offset" json:"offset,omitempty"`
}
func (m *Distribution_BucketOptions_Linear) Reset() { *m = Distribution_BucketOptions_Linear{} }
func (m *Distribution_BucketOptions_Linear) String() string { return proto.CompactTextString(m) }
func (*Distribution_BucketOptions_Linear) ProtoMessage() {}
func (*Distribution_BucketOptions_Linear) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{0, 1, 0}
}
func (m *Distribution_BucketOptions_Linear) GetNumFiniteBuckets() int32 {
if m != nil {
return m.NumFiniteBuckets
}
return 0
}
func (m *Distribution_BucketOptions_Linear) GetWidth() float64 {
if m != nil {
return m.Width
}
return 0
}
func (m *Distribution_BucketOptions_Linear) GetOffset() float64 {
if m != nil {
return m.Offset
}
return 0
}
// Specify a sequence of buckets that have a width that is proportional to
// the value of the lower bound. Each bucket represents a constant relative
// uncertainty on a specific value in the bucket.
//
// Defines `num_finite_buckets + 2` (= N) buckets with these boundaries for
// bucket i:
//
// Upper bound (0 <= i < N-1): scale * (growth_factor ^ i).
// Lower bound (1 <= i < N): scale * (growth_factor ^ (i - 1)).
type Distribution_BucketOptions_Exponential struct {
// Must be greater than 0.
NumFiniteBuckets int32 `protobuf:"varint,1,opt,name=num_finite_buckets,json=numFiniteBuckets" json:"num_finite_buckets,omitempty"`
// Must be greater than 1.
GrowthFactor float64 `protobuf:"fixed64,2,opt,name=growth_factor,json=growthFactor" json:"growth_factor,omitempty"`
// Must be greater than 0.
Scale float64 `protobuf:"fixed64,3,opt,name=scale" json:"scale,omitempty"`
}
func (m *Distribution_BucketOptions_Exponential) Reset() {
*m = Distribution_BucketOptions_Exponential{}
}
func (m *Distribution_BucketOptions_Exponential) String() string { return proto.CompactTextString(m) }
func (*Distribution_BucketOptions_Exponential) ProtoMessage() {}
func (*Distribution_BucketOptions_Exponential) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{0, 1, 1}
}
func (m *Distribution_BucketOptions_Exponential) GetNumFiniteBuckets() int32 {
if m != nil {
return m.NumFiniteBuckets
}
return 0
}
func (m *Distribution_BucketOptions_Exponential) GetGrowthFactor() float64 {
if m != nil {
return m.GrowthFactor
}
return 0
}
func (m *Distribution_BucketOptions_Exponential) GetScale() float64 {
if m != nil {
return m.Scale
}
return 0
}
// A set of buckets with arbitrary widths.
//
// Defines `size(bounds) + 1` (= N) buckets with these boundaries for
// bucket i:
//
// Upper bound (0 <= i < N-1): bounds[i]
// Lower bound (1 <= i < N); bounds[i - 1]
//
// There must be at least one element in `bounds`. If `bounds` has only one
// element, there are no finite buckets, and that single element is the
// common boundary of the overflow and underflow buckets.
type Distribution_BucketOptions_Explicit struct {
// The values must be monotonically increasing.
Bounds []float64 `protobuf:"fixed64,1,rep,packed,name=bounds" json:"bounds,omitempty"`
}
func (m *Distribution_BucketOptions_Explicit) Reset() { *m = Distribution_BucketOptions_Explicit{} }
func (m *Distribution_BucketOptions_Explicit) String() string { return proto.CompactTextString(m) }
func (*Distribution_BucketOptions_Explicit) ProtoMessage() {}
func (*Distribution_BucketOptions_Explicit) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{0, 1, 2}
}
func (m *Distribution_BucketOptions_Explicit) GetBounds() []float64 {
if m != nil {
return m.Bounds
}
return nil
}
func init() {
proto.RegisterType((*Distribution)(nil), "google.api.Distribution")
proto.RegisterType((*Distribution_Range)(nil), "google.api.Distribution.Range")
proto.RegisterType((*Distribution_BucketOptions)(nil), "google.api.Distribution.BucketOptions")
proto.RegisterType((*Distribution_BucketOptions_Linear)(nil), "google.api.Distribution.BucketOptions.Linear")
proto.RegisterType((*Distribution_BucketOptions_Exponential)(nil), "google.api.Distribution.BucketOptions.Exponential")
proto.RegisterType((*Distribution_BucketOptions_Explicit)(nil), "google.api.Distribution.BucketOptions.Explicit")
}
func init() { proto.RegisterFile("google/api/distribution.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 544 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x5d, 0x6f, 0xd3, 0x30,
0x14, 0x5d, 0x96, 0xb5, 0x85, 0xdb, 0x0f, 0x8a, 0x19, 0x28, 0x44, 0x7c, 0x54, 0x9b, 0x84, 0x2a,
0x01, 0x89, 0x54, 0x90, 0x78, 0xe0, 0xad, 0x1b, 0x53, 0x1f, 0x40, 0x9b, 0x8c, 0xc4, 0x03, 0x42,
0x8a, 0x9c, 0xc4, 0xc9, 0x0c, 0x89, 0x1d, 0x62, 0x67, 0x2b, 0xef, 0xfc, 0x29, 0xfe, 0x1d, 0x8a,
0xed, 0x6e, 0x19, 0x08, 0xa9, 0xbc, 0xf9, 0xde, 0x73, 0x7c, 0xce, 0xb9, 0x57, 0x71, 0xe0, 0x71,
0x2e, 0x44, 0x5e, 0xd0, 0x90, 0x54, 0x2c, 0x4c, 0x99, 0x54, 0x35, 0x8b, 0x1b, 0xc5, 0x04, 0x0f,
0xaa, 0x5a, 0x28, 0x81, 0xc0, 0xc0, 0x01, 0xa9, 0x98, 0xff, 0xa8, 0x43, 0x25, 0x9c, 0x0b, 0x45,
0x5a, 0xa2, 0x34, 0x4c, 0xff, 0xa1, 0x45, 0x75, 0x15, 0x37, 0x59, 0x48, 0xf8, 0x0f, 0x0b, 0x3d,
0xfd, 0x13, 0x52, 0xac, 0xa4, 0x52, 0x91, 0xb2, 0x32, 0x84, 0x83, 0x9f, 0x03, 0x18, 0x1d, 0x77,
0xcc, 0xd1, 0x3e, 0xf4, 0x12, 0xd1, 0x70, 0xe5, 0x39, 0x33, 0x67, 0xee, 0x62, 0x53, 0x20, 0x04,
0x7b, 0x25, 0x25, 0xdc, 0xdb, 0x9d, 0x39, 0x73, 0x07, 0xeb, 0x33, 0x7a, 0x03, 0x9e, 0x6c, 0xca,
0x48, 0x64, 0x91, 0xfc, 0xde, 0x90, 0x9a, 0xa6, 0x51, 0x4a, 0x2f, 0x98, 0x4e, 0xe6, 0xb9, 0x9a,
0x77, 0x5f, 0x36, 0xe5, 0x69, 0xf6, 0xd1, 0xa0, 0xc7, 0x1b, 0x10, 0xbd, 0x86, 0x5e, 0x4d, 0x78,
0x4e, 0xbd, 0xbd, 0x99, 0x33, 0x1f, 0x2e, 0x9e, 0x04, 0xd7, 0x93, 0x06, 0xdd, 0x2c, 0x01, 0x6e,
0x59, 0xd8, 0x90, 0xd1, 0x07, 0x98, 0xc4, 0x4d, 0xf2, 0x8d, 0xaa, 0x48, 0x54, 0x7a, 0x7a, 0xaf,
0xaf, 0xaf, 0x3f, 0xfb, 0xe7, 0xf5, 0xa5, 0xa6, 0x9f, 0x1a, 0x36, 0x1e, 0xc7, 0xdd, 0x12, 0x1d,
0x82, 0x6d, 0x44, 0x7a, 0x42, 0xe9, 0x0d, 0x66, 0xee, 0xdc, 0xc5, 0x23, 0xd3, 0x3c, 0xd2, 0x3d,
0xff, 0x39, 0xf4, 0x74, 0x06, 0x34, 0x05, 0xb7, 0x64, 0x5c, 0xef, 0xc4, 0xc1, 0xed, 0x51, 0x77,
0xc8, 0xda, 0x2e, 0xa4, 0x3d, 0xfa, 0xbf, 0xf6, 0x60, 0x7c, 0xc3, 0x12, 0x7d, 0x82, 0x49, 0xc1,
0x38, 0x25, 0x75, 0x64, 0x54, 0xa5, 0x16, 0x18, 0x2e, 0x5e, 0x6e, 0x17, 0x39, 0x78, 0xaf, 0x2f,
0xaf, 0x76, 0xf0, 0xd8, 0xc8, 0x18, 0x54, 0x22, 0x0a, 0xf7, 0xe8, 0xba, 0x12, 0x9c, 0x72, 0xc5,
0x48, 0x71, 0x25, 0xbe, 0xab, 0xc5, 0x17, 0x5b, 0x8a, 0xbf, 0xbb, 0x56, 0x58, 0xed, 0x60, 0xd4,
0x11, 0xdc, 0xd8, 0x7c, 0x81, 0x29, 0x5d, 0x57, 0x05, 0x4b, 0x98, 0xba, 0xf2, 0x70, 0xb5, 0x47,
0xb8, 0xbd, 0x87, 0xbe, 0xbe, 0xda, 0xc1, 0x77, 0x36, 0x52, 0x56, 0xdd, 0x4f, 0xa1, 0x6f, 0xe6,
0x43, 0x2f, 0x00, 0xf1, 0xa6, 0x8c, 0x32, 0xc6, 0x99, 0xa2, 0x37, 0x56, 0xd5, 0xc3, 0x53, 0xde,
0x94, 0x27, 0x1a, 0xd8, 0xa4, 0xda, 0x87, 0xde, 0x25, 0x4b, 0xd5, 0xb9, 0x5d, 0xbd, 0x29, 0xd0,
0x03, 0xe8, 0x8b, 0x2c, 0x93, 0x54, 0xd9, 0x4f, 0xcf, 0x56, 0xfe, 0x05, 0x0c, 0x3b, 0x83, 0xfe,
0xa7, 0xd5, 0x21, 0x8c, 0xf3, 0x5a, 0x5c, 0xaa, 0xf3, 0x28, 0x23, 0x89, 0x12, 0xb5, 0xb5, 0x1c,
0x99, 0xe6, 0x89, 0xee, 0xb5, 0x79, 0x64, 0x42, 0x0a, 0x6a, 0x8d, 0x4d, 0xe1, 0x1f, 0xc0, 0xad,
0xcd, 0xf0, 0x6d, 0xb6, 0x58, 0x34, 0x3c, 0x6d, 0x8d, 0xdc, 0x36, 0x9b, 0xa9, 0x96, 0xb7, 0x61,
0x60, 0x3f, 0xe5, 0xe5, 0x57, 0x98, 0x24, 0xa2, 0xec, 0x6c, 0x75, 0x79, 0xb7, 0xbb, 0xd6, 0xb3,
0xf6, 0xad, 0x9e, 0x39, 0x9f, 0x8f, 0x2c, 0x21, 0x17, 0x05, 0xe1, 0x79, 0x20, 0xea, 0x3c, 0xcc,
0x29, 0xd7, 0x2f, 0x39, 0x34, 0x10, 0xa9, 0x98, 0xfc, 0xeb, 0x8f, 0xf2, 0xb6, 0x5b, 0xc4, 0x7d,
0xcd, 0x7f, 0xf5, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x88, 0x8e, 0xc5, 0x4b, 0x80, 0x04, 0x00, 0x00,
}

56
vendor/google.golang.org/genproto/googleapis/api/experimental.pb.go generated vendored Normal file
View File

@ -0,0 +1,56 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/experimental/experimental.proto
package api
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Experimental service configuration. These configuration options can
// only be used by whitelisted users.
type Experimental struct {
// Authorization configuration.
Authorization *AuthorizationConfig `protobuf:"bytes,8,opt,name=authorization" json:"authorization,omitempty"`
}
func (m *Experimental) Reset() { *m = Experimental{} }
func (m *Experimental) String() string { return proto.CompactTextString(m) }
func (*Experimental) ProtoMessage() {}
func (*Experimental) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
func (m *Experimental) GetAuthorization() *AuthorizationConfig {
if m != nil {
return m.Authorization
}
return nil
}
func init() {
proto.RegisterType((*Experimental)(nil), "google.api.Experimental")
}
func init() { proto.RegisterFile("google/api/experimental/experimental.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 204 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x4a, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xad, 0x28, 0x48, 0x2d, 0xca, 0xcc, 0x4d, 0xcd,
0x2b, 0x49, 0xcc, 0x41, 0xe1, 0xe8, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x71, 0x41, 0xd4, 0xea,
0x25, 0x16, 0x64, 0x4a, 0xc9, 0x20, 0xe9, 0x4b, 0xcc, 0xcb, 0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc,
0xcf, 0x2b, 0x86, 0xa8, 0x94, 0x32, 0xc2, 0x65, 0x6a, 0x62, 0x69, 0x49, 0x46, 0x7e, 0x51, 0x66,
0x15, 0x58, 0x75, 0x7c, 0x72, 0x7e, 0x5e, 0x5a, 0x66, 0x3a, 0x44, 0x8f, 0x52, 0x28, 0x17, 0x8f,
0x2b, 0x92, 0x52, 0x21, 0x57, 0x2e, 0x5e, 0x14, 0xd5, 0x12, 0x1c, 0x0a, 0x8c, 0x1a, 0xdc, 0x46,
0xf2, 0x7a, 0x08, 0x57, 0xe8, 0x39, 0x22, 0x2b, 0x70, 0x06, 0x9b, 0x16, 0x84, 0xaa, 0xcb, 0x29,
0x9a, 0x8b, 0x2f, 0x39, 0x3f, 0x17, 0x49, 0x93, 0x93, 0x20, 0xb2, 0x35, 0x01, 0x20, 0xbb, 0x03,
0x18, 0xa3, 0x74, 0xa1, 0x0a, 0xd2, 0xf3, 0x73, 0x12, 0xf3, 0xd2, 0xf5, 0xf2, 0x8b, 0xd2, 0xf5,
0xd3, 0x53, 0xf3, 0xc0, 0x2e, 0xd3, 0x87, 0x48, 0x25, 0x16, 0x64, 0x16, 0x83, 0x3c, 0x64, 0x9d,
0x58, 0x90, 0xb9, 0x88, 0x89, 0xc5, 0xdd, 0x31, 0xc0, 0x33, 0x89, 0x0d, 0xac, 0xc0, 0x18, 0x10,
0x00, 0x00, 0xff, 0xff, 0xa0, 0x95, 0x20, 0xe5, 0x46, 0x01, 0x00, 0x00,
}

114
vendor/google.golang.org/genproto/googleapis/api/httpbody/httpbody.pb.go generated vendored Normal file
View File

@ -0,0 +1,114 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/httpbody.proto
/*
Package httpbody is a generated protocol buffer package.
It is generated from these files:
google/api/httpbody.proto
It has these top-level messages:
HttpBody
*/
package httpbody
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Message that represents an arbitrary HTTP body. It should only be used for
// payload formats that can't be represented as JSON, such as raw binary or
// an HTML page.
//
//
// This message can be used both in streaming and non-streaming API methods in
// the request as well as the response.
//
// It can be used as a top-level request field, which is convenient if one
// wants to extract parameters from either the URL or HTTP template into the
// request fields and also want access to the raw HTTP body.
//
// Example:
//
// message GetResourceRequest {
// // A unique request id.
// string request_id = 1;
//
// // The raw HTTP body is bound to this field.
// google.api.HttpBody http_body = 2;
// }
//
// service ResourceService {
// rpc GetResource(GetResourceRequest) returns (google.api.HttpBody);
// rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty);
// }
//
// Example with streaming methods:
//
// service CaldavService {
// rpc GetCalendar(stream google.api.HttpBody)
// returns (stream google.api.HttpBody);
// rpc UpdateCalendar(stream google.api.HttpBody)
// returns (stream google.api.HttpBody);
// }
//
// Use of this type only changes how the request and response bodies are
// handled, all other features will continue to work unchanged.
type HttpBody struct {
// The HTTP Content-Type string representing the content type of the body.
ContentType string `protobuf:"bytes,1,opt,name=content_type,json=contentType" json:"content_type,omitempty"`
// HTTP body binary data.
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *HttpBody) Reset() { *m = HttpBody{} }
func (m *HttpBody) String() string { return proto.CompactTextString(m) }
func (*HttpBody) ProtoMessage() {}
func (*HttpBody) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *HttpBody) GetContentType() string {
if m != nil {
return m.ContentType
}
return ""
}
func (m *HttpBody) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func init() {
proto.RegisterType((*HttpBody)(nil), "google.api.HttpBody")
}
func init() { proto.RegisterFile("google/api/httpbody.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 181 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0xcf, 0x28, 0x29, 0x29, 0x48, 0xca, 0x4f, 0xa9, 0xd4,
0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0x48, 0xe9, 0x25, 0x16, 0x64, 0x2a, 0x39, 0x72,
0x71, 0x78, 0x94, 0x94, 0x14, 0x38, 0xe5, 0xa7, 0x54, 0x0a, 0x29, 0x72, 0xf1, 0x24, 0xe7, 0xe7,
0x95, 0xa4, 0xe6, 0x95, 0xc4, 0x97, 0x54, 0x16, 0xa4, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06,
0x71, 0x43, 0xc5, 0x42, 0x2a, 0x0b, 0x52, 0x85, 0x84, 0xb8, 0x58, 0x52, 0x12, 0x4b, 0x12, 0x25,
0x98, 0x14, 0x18, 0x35, 0x78, 0x82, 0xc0, 0x6c, 0xa7, 0x54, 0x2e, 0xbe, 0xe4, 0xfc, 0x5c, 0x3d,
0x84, 0xa1, 0x4e, 0xbc, 0x30, 0x23, 0x03, 0x40, 0xf6, 0x05, 0x30, 0x46, 0x59, 0x43, 0x25, 0xd3,
0xf3, 0x73, 0x12, 0xf3, 0xd2, 0xf5, 0xf2, 0x8b, 0xd2, 0xf5, 0xd3, 0x53, 0xf3, 0xc0, 0xae, 0xd1,
0x87, 0x48, 0x25, 0x16, 0x64, 0x16, 0xa3, 0xb8, 0xd5, 0x1a, 0xc6, 0x58, 0xc4, 0xc4, 0xe2, 0xee,
0x18, 0xe0, 0x99, 0xc4, 0x06, 0x56, 0x6e, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x3a, 0xdf,
0x30, 0xd9, 0x00, 0x00, 0x00,
}

119
vendor/google.golang.org/genproto/googleapis/api/label/label.pb.go generated vendored Normal file
View File

@ -0,0 +1,119 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/label.proto
/*
Package label is a generated protocol buffer package.
It is generated from these files:
google/api/label.proto
It has these top-level messages:
LabelDescriptor
*/
package label
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Value types that can be used as label values.
type LabelDescriptor_ValueType int32
const (
// A variable-length string. This is the default.
LabelDescriptor_STRING LabelDescriptor_ValueType = 0
// Boolean; true or false.
LabelDescriptor_BOOL LabelDescriptor_ValueType = 1
// A 64-bit signed integer.
LabelDescriptor_INT64 LabelDescriptor_ValueType = 2
)
var LabelDescriptor_ValueType_name = map[int32]string{
0: "STRING",
1: "BOOL",
2: "INT64",
}
var LabelDescriptor_ValueType_value = map[string]int32{
"STRING": 0,
"BOOL": 1,
"INT64": 2,
}
func (x LabelDescriptor_ValueType) String() string {
return proto.EnumName(LabelDescriptor_ValueType_name, int32(x))
}
func (LabelDescriptor_ValueType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }
// A description of a label.
type LabelDescriptor struct {
// The label key.
Key string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
// The type of data that can be assigned to the label.
ValueType LabelDescriptor_ValueType `protobuf:"varint,2,opt,name=value_type,json=valueType,enum=google.api.LabelDescriptor_ValueType" json:"value_type,omitempty"`
// A human-readable description for the label.
Description string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
}
func (m *LabelDescriptor) Reset() { *m = LabelDescriptor{} }
func (m *LabelDescriptor) String() string { return proto.CompactTextString(m) }
func (*LabelDescriptor) ProtoMessage() {}
func (*LabelDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *LabelDescriptor) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
func (m *LabelDescriptor) GetValueType() LabelDescriptor_ValueType {
if m != nil {
return m.ValueType
}
return LabelDescriptor_STRING
}
func (m *LabelDescriptor) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*LabelDescriptor)(nil), "google.api.LabelDescriptor")
proto.RegisterEnum("google.api.LabelDescriptor_ValueType", LabelDescriptor_ValueType_name, LabelDescriptor_ValueType_value)
}
func init() { proto.RegisterFile("google/api/label.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 252 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4b, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0xcf, 0x49, 0x4c, 0x4a, 0xcd, 0xd1, 0x2b, 0x28, 0xca,
0x2f, 0xc9, 0x17, 0xe2, 0x82, 0x88, 0xeb, 0x25, 0x16, 0x64, 0x2a, 0xed, 0x64, 0xe4, 0xe2, 0xf7,
0x01, 0xc9, 0xb9, 0xa4, 0x16, 0x27, 0x17, 0x65, 0x16, 0x94, 0xe4, 0x17, 0x09, 0x09, 0x70, 0x31,
0x67, 0xa7, 0x56, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06, 0x81, 0x98, 0x42, 0x2e, 0x5c, 0x5c,
0x65, 0x89, 0x39, 0xa5, 0xa9, 0xf1, 0x25, 0x95, 0x05, 0xa9, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x7c,
0x46, 0xaa, 0x7a, 0x08, 0x63, 0xf4, 0xd0, 0x8c, 0xd0, 0x0b, 0x03, 0xa9, 0x0e, 0xa9, 0x2c, 0x48,
0x0d, 0xe2, 0x2c, 0x83, 0x31, 0x85, 0x14, 0xb8, 0xb8, 0x53, 0xa0, 0x4a, 0x32, 0xf3, 0xf3, 0x24,
0x98, 0xc1, 0xe6, 0x23, 0x0b, 0x29, 0xe9, 0x70, 0x71, 0xc2, 0x75, 0x0a, 0x71, 0x71, 0xb1, 0x05,
0x87, 0x04, 0x79, 0xfa, 0xb9, 0x0b, 0x30, 0x08, 0x71, 0x70, 0xb1, 0x38, 0xf9, 0xfb, 0xfb, 0x08,
0x30, 0x0a, 0x71, 0x72, 0xb1, 0x7a, 0xfa, 0x85, 0x98, 0x99, 0x08, 0x30, 0x39, 0xc5, 0x73, 0xf1,
0x25, 0xe7, 0xe7, 0x22, 0x39, 0xc3, 0x89, 0x0b, 0xec, 0x8e, 0x00, 0x90, 0x2f, 0x03, 0x18, 0xa3,
0x4c, 0xa1, 0x32, 0xe9, 0xf9, 0x39, 0x89, 0x79, 0xe9, 0x7a, 0xf9, 0x45, 0xe9, 0xfa, 0xe9, 0xa9,
0x79, 0xe0, 0x30, 0xd0, 0x87, 0x48, 0x25, 0x16, 0x64, 0x16, 0x23, 0x82, 0xc7, 0x1a, 0x4c, 0xfe,
0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xe2, 0xee, 0x18, 0xe0, 0x99, 0xc4, 0x06, 0x56, 0x6b, 0x0c, 0x08,
0x00, 0x00, 0xff, 0xff, 0x57, 0x04, 0xaa, 0x1f, 0x49, 0x01, 0x00, 0x00,
}

358
vendor/google.golang.org/genproto/googleapis/api/metric/metric.pb.go generated vendored Normal file
View File

@ -0,0 +1,358 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/metric.proto
/*
Package metric is a generated protocol buffer package.
It is generated from these files:
google/api/metric.proto
It has these top-level messages:
MetricDescriptor
Metric
*/
package metric
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_api "google.golang.org/genproto/googleapis/api/label"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// The kind of measurement. It describes how the data is reported.
type MetricDescriptor_MetricKind int32
const (
// Do not use this default value.
MetricDescriptor_METRIC_KIND_UNSPECIFIED MetricDescriptor_MetricKind = 0
// An instantaneous measurement of a value.
MetricDescriptor_GAUGE MetricDescriptor_MetricKind = 1
// The change in a value during a time interval.
MetricDescriptor_DELTA MetricDescriptor_MetricKind = 2
// A value accumulated over a time interval. Cumulative
// measurements in a time series should have the same start time
// and increasing end times, until an event resets the cumulative
// value to zero and sets a new start time for the following
// points.
MetricDescriptor_CUMULATIVE MetricDescriptor_MetricKind = 3
)
var MetricDescriptor_MetricKind_name = map[int32]string{
0: "METRIC_KIND_UNSPECIFIED",
1: "GAUGE",
2: "DELTA",
3: "CUMULATIVE",
}
var MetricDescriptor_MetricKind_value = map[string]int32{
"METRIC_KIND_UNSPECIFIED": 0,
"GAUGE": 1,
"DELTA": 2,
"CUMULATIVE": 3,
}
func (x MetricDescriptor_MetricKind) String() string {
return proto.EnumName(MetricDescriptor_MetricKind_name, int32(x))
}
func (MetricDescriptor_MetricKind) EnumDescriptor() ([]byte, []int) {
return fileDescriptor0, []int{0, 0}
}
// The value type of a metric.
type MetricDescriptor_ValueType int32
const (
// Do not use this default value.
MetricDescriptor_VALUE_TYPE_UNSPECIFIED MetricDescriptor_ValueType = 0
// The value is a boolean.
// This value type can be used only if the metric kind is `GAUGE`.
MetricDescriptor_BOOL MetricDescriptor_ValueType = 1
// The value is a signed 64-bit integer.
MetricDescriptor_INT64 MetricDescriptor_ValueType = 2
// The value is a double precision floating point number.
MetricDescriptor_DOUBLE MetricDescriptor_ValueType = 3
// The value is a text string.
// This value type can be used only if the metric kind is `GAUGE`.
MetricDescriptor_STRING MetricDescriptor_ValueType = 4
// The value is a [`Distribution`][google.api.Distribution].
MetricDescriptor_DISTRIBUTION MetricDescriptor_ValueType = 5
// The value is money.
MetricDescriptor_MONEY MetricDescriptor_ValueType = 6
)
var MetricDescriptor_ValueType_name = map[int32]string{
0: "VALUE_TYPE_UNSPECIFIED",
1: "BOOL",
2: "INT64",
3: "DOUBLE",
4: "STRING",
5: "DISTRIBUTION",
6: "MONEY",
}
var MetricDescriptor_ValueType_value = map[string]int32{
"VALUE_TYPE_UNSPECIFIED": 0,
"BOOL": 1,
"INT64": 2,
"DOUBLE": 3,
"STRING": 4,
"DISTRIBUTION": 5,
"MONEY": 6,
}
func (x MetricDescriptor_ValueType) String() string {
return proto.EnumName(MetricDescriptor_ValueType_name, int32(x))
}
func (MetricDescriptor_ValueType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor0, []int{0, 1}
}
// Defines a metric type and its schema. Once a metric descriptor is created,
// deleting or altering it stops data collection and makes the metric type's
// existing data unusable.
type MetricDescriptor struct {
// The resource name of the metric descriptor. Depending on the
// implementation, the name typically includes: (1) the parent resource name
// that defines the scope of the metric type or of its data; and (2) the
// metric's URL-encoded type, which also appears in the `type` field of this
// descriptor. For example, following is the resource name of a custom
// metric within the GCP project `my-project-id`:
//
// "projects/my-project-id/metricDescriptors/custom.googleapis.com%2Finvoice%2Fpaid%2Famount"
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The metric type, including its DNS name prefix. The type is not
// URL-encoded. All user-defined custom metric types have the DNS name
// `custom.googleapis.com`. Metric types should use a natural hierarchical
// grouping. For example:
//
// "custom.googleapis.com/invoice/paid/amount"
// "appengine.googleapis.com/http/server/response_latencies"
Type string `protobuf:"bytes,8,opt,name=type" json:"type,omitempty"`
// The set of labels that can be used to describe a specific
// instance of this metric type. For example, the
// `appengine.googleapis.com/http/server/response_latencies` metric
// type has a label for the HTTP response code, `response_code`, so
// you can look at latencies for successful responses or just
// for responses that failed.
Labels []*google_api.LabelDescriptor `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty"`
// Whether the metric records instantaneous values, changes to a value, etc.
// Some combinations of `metric_kind` and `value_type` might not be supported.
MetricKind MetricDescriptor_MetricKind `protobuf:"varint,3,opt,name=metric_kind,json=metricKind,enum=google.api.MetricDescriptor_MetricKind" json:"metric_kind,omitempty"`
// Whether the measurement is an integer, a floating-point number, etc.
// Some combinations of `metric_kind` and `value_type` might not be supported.
ValueType MetricDescriptor_ValueType `protobuf:"varint,4,opt,name=value_type,json=valueType,enum=google.api.MetricDescriptor_ValueType" json:"value_type,omitempty"`
// The unit in which the metric value is reported. It is only applicable
// if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The
// supported units are a subset of [The Unified Code for Units of
// Measure](http://unitsofmeasure.org/ucum.html) standard:
//
// **Basic units (UNIT)**
//
// * `bit` bit
// * `By` byte
// * `s` second
// * `min` minute
// * `h` hour
// * `d` day
//
// **Prefixes (PREFIX)**
//
// * `k` kilo (10**3)
// * `M` mega (10**6)
// * `G` giga (10**9)
// * `T` tera (10**12)
// * `P` peta (10**15)
// * `E` exa (10**18)
// * `Z` zetta (10**21)
// * `Y` yotta (10**24)
// * `m` milli (10**-3)
// * `u` micro (10**-6)
// * `n` nano (10**-9)
// * `p` pico (10**-12)
// * `f` femto (10**-15)
// * `a` atto (10**-18)
// * `z` zepto (10**-21)
// * `y` yocto (10**-24)
// * `Ki` kibi (2**10)
// * `Mi` mebi (2**20)
// * `Gi` gibi (2**30)
// * `Ti` tebi (2**40)
//
// **Grammar**
//
// The grammar includes the dimensionless unit `1`, such as `1/s`.
//
// The grammar also includes these connectors:
//
// * `/` division (as an infix operator, e.g. `1/s`).
// * `.` multiplication (as an infix operator, e.g. `GBy.d`)
//
// The grammar for a unit is as follows:
//
// Expression = Component { "." Component } { "/" Component } ;
//
// Component = [ PREFIX ] UNIT [ Annotation ]
// | Annotation
// | "1"
// ;
//
// Annotation = "{" NAME "}" ;
//
// Notes:
//
// * `Annotation` is just a comment if it follows a `UNIT` and is
// equivalent to `1` if it is used alone. For examples,
// `{requests}/s == 1/s`, `By{transmitted}/s == By/s`.
// * `NAME` is a sequence of non-blank printable ASCII characters not
// containing '{' or '}'.
Unit string `protobuf:"bytes,5,opt,name=unit" json:"unit,omitempty"`
// A detailed description of the metric, which can be used in documentation.
Description string `protobuf:"bytes,6,opt,name=description" json:"description,omitempty"`
// A concise name for the metric, which can be displayed in user interfaces.
// Use sentence case without an ending period, for example "Request count".
DisplayName string `protobuf:"bytes,7,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
}
func (m *MetricDescriptor) Reset() { *m = MetricDescriptor{} }
func (m *MetricDescriptor) String() string { return proto.CompactTextString(m) }
func (*MetricDescriptor) ProtoMessage() {}
func (*MetricDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *MetricDescriptor) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *MetricDescriptor) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *MetricDescriptor) GetLabels() []*google_api.LabelDescriptor {
if m != nil {
return m.Labels
}
return nil
}
func (m *MetricDescriptor) GetMetricKind() MetricDescriptor_MetricKind {
if m != nil {
return m.MetricKind
}
return MetricDescriptor_METRIC_KIND_UNSPECIFIED
}
func (m *MetricDescriptor) GetValueType() MetricDescriptor_ValueType {
if m != nil {
return m.ValueType
}
return MetricDescriptor_VALUE_TYPE_UNSPECIFIED
}
func (m *MetricDescriptor) GetUnit() string {
if m != nil {
return m.Unit
}
return ""
}
func (m *MetricDescriptor) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *MetricDescriptor) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
// A specific metric, identified by specifying values for all of the
// labels of a [`MetricDescriptor`][google.api.MetricDescriptor].
type Metric struct {
// An existing metric type, see [google.api.MetricDescriptor][google.api.MetricDescriptor].
// For example, `custom.googleapis.com/invoice/paid/amount`.
Type string `protobuf:"bytes,3,opt,name=type" json:"type,omitempty"`
// The set of label values that uniquely identify this metric. All
// labels listed in the `MetricDescriptor` must be assigned values.
Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}
func (m *Metric) Reset() { *m = Metric{} }
func (m *Metric) String() string { return proto.CompactTextString(m) }
func (*Metric) ProtoMessage() {}
func (*Metric) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *Metric) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *Metric) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func init() {
proto.RegisterType((*MetricDescriptor)(nil), "google.api.MetricDescriptor")
proto.RegisterType((*Metric)(nil), "google.api.Metric")
proto.RegisterEnum("google.api.MetricDescriptor_MetricKind", MetricDescriptor_MetricKind_name, MetricDescriptor_MetricKind_value)
proto.RegisterEnum("google.api.MetricDescriptor_ValueType", MetricDescriptor_ValueType_name, MetricDescriptor_ValueType_value)
}
func init() { proto.RegisterFile("google/api/metric.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 506 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0x4d, 0x6f, 0xda, 0x40,
0x10, 0xad, 0x3f, 0x70, 0xc3, 0x10, 0xa1, 0xd5, 0xaa, 0x4a, 0x2c, 0x22, 0x55, 0x94, 0x43, 0xcb,
0x09, 0xa4, 0xa4, 0x4a, 0xbf, 0x4e, 0x80, 0xb7, 0xd4, 0x8a, 0xb1, 0x91, 0x63, 0x23, 0xa5, 0x17,
0xcb, 0x81, 0x95, 0x65, 0xc5, 0xd8, 0xae, 0x71, 0x22, 0xf9, 0x57, 0xf4, 0x17, 0xf4, 0xd2, 0x5f,
0x5a, 0xed, 0xae, 0x03, 0x16, 0x95, 0x72, 0xe2, 0xed, 0x9b, 0x37, 0x6f, 0x67, 0x96, 0x67, 0x38,
0x8f, 0xb2, 0x2c, 0x4a, 0xe8, 0x38, 0xcc, 0xe3, 0xf1, 0x96, 0x96, 0x45, 0xbc, 0x1e, 0xe5, 0x45,
0x56, 0x66, 0x18, 0x44, 0x61, 0x14, 0xe6, 0x71, 0xef, 0xac, 0x21, 0x4a, 0xc2, 0x7b, 0x9a, 0x08,
0xcd, 0xe0, 0x8f, 0x0a, 0x68, 0xc1, 0x9b, 0x0c, 0xba, 0x5b, 0x17, 0x71, 0x5e, 0x66, 0x05, 0xc6,
0xa0, 0xa6, 0xe1, 0x96, 0xea, 0x52, 0x5f, 0x1a, 0xb6, 0x5d, 0x8e, 0x19, 0x57, 0x56, 0x39, 0xd5,
0x4f, 0x04, 0xc7, 0x30, 0xbe, 0x02, 0x8d, 0x7b, 0xed, 0x74, 0xb9, 0xaf, 0x0c, 0x3b, 0x97, 0x17,
0xa3, 0xc3, 0x8d, 0x23, 0x8b, 0x55, 0x0e, 0xa6, 0x6e, 0x2d, 0xc5, 0x3f, 0xa0, 0x23, 0xa6, 0x0c,
0x1e, 0xe2, 0x74, 0xa3, 0x2b, 0x7d, 0x69, 0xd8, 0xbd, 0xfc, 0xd0, 0xec, 0x3c, 0x9e, 0xa7, 0x26,
0x6e, 0xe2, 0x74, 0xe3, 0xc2, 0x76, 0x8f, 0x31, 0x01, 0x78, 0x0a, 0x93, 0x47, 0x1a, 0xf0, 0xc1,
0x54, 0x6e, 0xf4, 0xfe, 0x45, 0xa3, 0x15, 0x93, 0x7b, 0x55, 0x4e, 0xdd, 0xf6, 0xd3, 0x33, 0x64,
0x9b, 0x3d, 0xa6, 0x71, 0xa9, 0xb7, 0xc4, 0x66, 0x0c, 0xe3, 0x3e, 0x74, 0x36, 0x75, 0x5b, 0x9c,
0xa5, 0xba, 0xc6, 0x4b, 0x4d, 0x0a, 0xbf, 0x83, 0xd3, 0x4d, 0xbc, 0xcb, 0x93, 0xb0, 0x0a, 0xf8,
0x5b, 0xbd, 0xae, 0x25, 0x82, 0xb3, 0xc3, 0x2d, 0x1d, 0x38, 0x00, 0x87, 0xc9, 0xf1, 0x05, 0x9c,
0x2f, 0x88, 0xe7, 0x9a, 0xb3, 0xe0, 0xc6, 0xb4, 0x8d, 0xc0, 0xb7, 0x6f, 0x97, 0x64, 0x66, 0x7e,
0x37, 0x89, 0x81, 0x5e, 0xe1, 0x36, 0xb4, 0xe6, 0x13, 0x7f, 0x4e, 0x90, 0xc4, 0xa0, 0x41, 0x2c,
0x6f, 0x82, 0x64, 0xdc, 0x05, 0x98, 0xf9, 0x0b, 0xdf, 0x9a, 0x78, 0xe6, 0x8a, 0x20, 0x65, 0xf0,
0x0b, 0xda, 0xfb, 0x0d, 0x70, 0x0f, 0xce, 0x56, 0x13, 0xcb, 0x27, 0x81, 0x77, 0xb7, 0x24, 0x47,
0x76, 0x27, 0xa0, 0x4e, 0x1d, 0xc7, 0x12, 0x6e, 0xa6, 0xed, 0x5d, 0x7f, 0x44, 0x32, 0x06, 0xd0,
0x0c, 0xc7, 0x9f, 0x5a, 0x04, 0x29, 0x0c, 0xdf, 0x7a, 0xae, 0x69, 0xcf, 0x91, 0x8a, 0x11, 0x9c,
0x1a, 0x26, 0x3b, 0x4d, 0x7d, 0xcf, 0x74, 0x6c, 0xd4, 0x62, 0x4d, 0x0b, 0xc7, 0x26, 0x77, 0x48,
0x1b, 0xfc, 0x96, 0x40, 0x13, 0x4b, 0xec, 0x13, 0xa0, 0x34, 0x12, 0x70, 0x7d, 0x94, 0x80, 0xb7,
0xff, 0x3f, 0xbf, 0x08, 0xc2, 0x8e, 0xa4, 0x65, 0x51, 0x3d, 0x87, 0xa0, 0xf7, 0x05, 0x3a, 0x0d,
0x1a, 0x23, 0x50, 0x1e, 0x68, 0x55, 0xe7, 0x8d, 0x41, 0xfc, 0x06, 0x5a, 0xfc, 0x1f, 0xd2, 0x65,
0xce, 0x89, 0xc3, 0x57, 0xf9, 0xb3, 0x34, 0x0d, 0xa0, 0xbb, 0xce, 0xb6, 0x8d, 0x7b, 0xa6, 0x1d,
0x71, 0xd1, 0x92, 0x05, 0x7a, 0x29, 0xfd, 0xfc, 0x54, 0x97, 0xa2, 0x2c, 0x09, 0xd3, 0x68, 0x94,
0x15, 0xd1, 0x38, 0xa2, 0x29, 0x8f, 0xfb, 0x58, 0x94, 0xc2, 0x3c, 0xde, 0x35, 0x3e, 0x97, 0x6f,
0xe2, 0xe7, 0xaf, 0xac, 0xce, 0x27, 0x4b, 0xf3, 0x5e, 0xe3, 0xd2, 0xab, 0x7f, 0x01, 0x00, 0x00,
0xff, 0xff, 0x18, 0x04, 0x05, 0x82, 0x58, 0x03, 0x00, 0x00,
}

180
vendor/google.golang.org/genproto/googleapis/api/monitoredres/monitored_resource.pb.go generated vendored Normal file
View File

@ -0,0 +1,180 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/monitored_resource.proto
/*
Package monitoredres is a generated protocol buffer package.
It is generated from these files:
google/api/monitored_resource.proto
It has these top-level messages:
MonitoredResourceDescriptor
MonitoredResource
*/
package monitoredres
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_api "google.golang.org/genproto/googleapis/api/label"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// An object that describes the schema of a [MonitoredResource][google.api.MonitoredResource] object using a
// type name and a set of labels. For example, the monitored resource
// descriptor for Google Compute Engine VM instances has a type of
// `"gce_instance"` and specifies the use of the labels `"instance_id"` and
// `"zone"` to identify particular VM instances.
//
// Different APIs can support different monitored resource types. APIs generally
// provide a `list` method that returns the monitored resource descriptors used
// by the API.
type MonitoredResourceDescriptor struct {
// Optional. The resource name of the monitored resource descriptor:
// `"projects/{project_id}/monitoredResourceDescriptors/{type}"` where
// {type} is the value of the `type` field in this object and
// {project_id} is a project ID that provides API-specific context for
// accessing the type. APIs that do not use project information can use the
// resource name format `"monitoredResourceDescriptors/{type}"`.
Name string `protobuf:"bytes,5,opt,name=name" json:"name,omitempty"`
// Required. The monitored resource type. For example, the type
// `"cloudsql_database"` represents databases in Google Cloud SQL.
// The maximum length of this value is 256 characters.
Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
// Optional. A concise name for the monitored resource type that might be
// displayed in user interfaces. It should be a Title Cased Noun Phrase,
// without any article or other determiners. For example,
// `"Google Cloud SQL Database"`.
DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
// Optional. A detailed description of the monitored resource type that might
// be used in documentation.
Description string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
// Required. A set of labels used to describe instances of this monitored
// resource type. For example, an individual Google Cloud SQL database is
// identified by values for the labels `"database_id"` and `"zone"`.
Labels []*google_api.LabelDescriptor `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty"`
}
func (m *MonitoredResourceDescriptor) Reset() { *m = MonitoredResourceDescriptor{} }
func (m *MonitoredResourceDescriptor) String() string { return proto.CompactTextString(m) }
func (*MonitoredResourceDescriptor) ProtoMessage() {}
func (*MonitoredResourceDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *MonitoredResourceDescriptor) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *MonitoredResourceDescriptor) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *MonitoredResourceDescriptor) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
func (m *MonitoredResourceDescriptor) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *MonitoredResourceDescriptor) GetLabels() []*google_api.LabelDescriptor {
if m != nil {
return m.Labels
}
return nil
}
// An object representing a resource that can be used for monitoring, logging,
// billing, or other purposes. Examples include virtual machine instances,
// databases, and storage devices such as disks. The `type` field identifies a
// [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor] object that describes the resource's
// schema. Information in the `labels` field identifies the actual resource and
// its attributes according to the schema. For example, a particular Compute
// Engine VM instance could be represented by the following object, because the
// [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor] for `"gce_instance"` has labels
// `"instance_id"` and `"zone"`:
//
// { "type": "gce_instance",
// "labels": { "instance_id": "12345678901234",
// "zone": "us-central1-a" }}
type MonitoredResource struct {
// Required. The monitored resource type. This field must match
// the `type` field of a [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor] object. For
// example, the type of a Cloud SQL database is `"cloudsql_database"`.
Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
// Required. Values for all of the labels listed in the associated monitored
// resource descriptor. For example, Cloud SQL databases use the labels
// `"database_id"` and `"zone"`.
Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}
func (m *MonitoredResource) Reset() { *m = MonitoredResource{} }
func (m *MonitoredResource) String() string { return proto.CompactTextString(m) }
func (*MonitoredResource) ProtoMessage() {}
func (*MonitoredResource) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *MonitoredResource) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *MonitoredResource) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func init() {
proto.RegisterType((*MonitoredResourceDescriptor)(nil), "google.api.MonitoredResourceDescriptor")
proto.RegisterType((*MonitoredResource)(nil), "google.api.MonitoredResource")
}
func init() { proto.RegisterFile("google/api/monitored_resource.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 321 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0x4b, 0x4b, 0x3b, 0x31,
0x10, 0x27, 0xdb, 0x07, 0xfc, 0x67, 0xff, 0x88, 0x06, 0x29, 0x4b, 0x7b, 0xa9, 0xf5, 0x52, 0x2f,
0xbb, 0x60, 0x2f, 0x3e, 0x4e, 0xad, 0x8a, 0x08, 0x2a, 0xa5, 0x47, 0x2f, 0x25, 0x6d, 0xc3, 0x12,
0xdc, 0x66, 0x42, 0xb2, 0x15, 0xf6, 0xeb, 0x08, 0x7e, 0x0e, 0xbf, 0x96, 0x47, 0xc9, 0xa3, 0x76,
0xa5, 0xde, 0x26, 0xbf, 0xf9, 0x3d, 0x66, 0x32, 0x70, 0x9a, 0x23, 0xe6, 0x05, 0xcf, 0x98, 0x12,
0xd9, 0x1a, 0xa5, 0x28, 0x51, 0xf3, 0xd5, 0x5c, 0x73, 0x83, 0x1b, 0xbd, 0xe4, 0xa9, 0xd2, 0x58,
0x22, 0x05, 0x4f, 0x4a, 0x99, 0x12, 0xdd, 0x4e, 0x4d, 0x50, 0xb0, 0x05, 0x2f, 0x3c, 0x67, 0xf0,
0x49, 0xa0, 0xf7, 0xb4, 0x35, 0x98, 0x05, 0xfd, 0x2d, 0x37, 0x4b, 0x2d, 0x54, 0x89, 0x9a, 0x52,
0x68, 0x4a, 0xb6, 0xe6, 0x49, 0xab, 0x4f, 0x86, 0xff, 0x66, 0xae, 0xb6, 0x58, 0x59, 0x29, 0x9e,
0x10, 0x8f, 0xd9, 0x9a, 0x9e, 0xc0, 0xff, 0x95, 0x30, 0xaa, 0x60, 0xd5, 0xdc, 0xf1, 0x23, 0xd7,
0x8b, 0x03, 0xf6, 0x6c, 0x65, 0x7d, 0x88, 0x57, 0xc1, 0x58, 0xa0, 0x4c, 0x1a, 0x81, 0xb1, 0x83,
0xe8, 0x08, 0xda, 0x6e, 0x36, 0x93, 0x34, 0xfb, 0x8d, 0x61, 0x7c, 0xde, 0x4b, 0x77, 0x1b, 0xa4,
0x8f, 0xb6, 0xb3, 0x9b, 0x6c, 0x16, 0xa8, 0x83, 0x0f, 0x02, 0x47, 0x7b, 0x1b, 0xfc, 0x39, 0xe3,
0xf8, 0xc7, 0x3e, 0x72, 0xf6, 0x67, 0x75, 0xfb, 0x3d, 0x0b, 0x1f, 0x68, 0xee, 0x64, 0xa9, 0xab,
0x6d, 0x58, 0xf7, 0x12, 0xe2, 0x1a, 0x4c, 0x0f, 0xa1, 0xf1, 0xca, 0xab, 0x10, 0x62, 0x4b, 0x7a,
0x0c, 0xad, 0x37, 0x56, 0x6c, 0xb6, 0x1f, 0xe0, 0x1f, 0x57, 0xd1, 0x05, 0x99, 0x54, 0x70, 0xb0,
0xc4, 0x75, 0x2d, 0x72, 0xd2, 0xd9, 0xcb, 0x9c, 0xda, 0x9b, 0x4c, 0xc9, 0xcb, 0x4d, 0x60, 0xe5,
0x58, 0x30, 0x99, 0xa7, 0xa8, 0xf3, 0x2c, 0xe7, 0xd2, 0x5d, 0x2c, 0xf3, 0x2d, 0xa6, 0x84, 0xf9,
0x7d, 0x7d, 0xcd, 0xcd, 0x75, 0xfd, 0xf1, 0x45, 0xc8, 0x7b, 0xd4, 0xbc, 0x1f, 0x4f, 0x1f, 0x16,
0x6d, 0xa7, 0x1c, 0x7d, 0x07, 0x00, 0x00, 0xff, 0xff, 0xf8, 0xfb, 0xfb, 0x11, 0x36, 0x02, 0x00,
0x00,
}

392
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/auth.pb.go generated vendored Normal file
View File

@ -0,0 +1,392 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/auth.proto
/*
Package serviceconfig is a generated protocol buffer package.
It is generated from these files:
google/api/auth.proto
google/api/backend.proto
google/api/billing.proto
google/api/consumer.proto
google/api/context.proto
google/api/control.proto
google/api/documentation.proto
google/api/endpoint.proto
google/api/log.proto
google/api/logging.proto
google/api/monitoring.proto
google/api/quota.proto
google/api/service.proto
google/api/source_info.proto
google/api/system_parameter.proto
google/api/usage.proto
It has these top-level messages:
Authentication
AuthenticationRule
AuthProvider
OAuthRequirements
AuthRequirement
Backend
BackendRule
Billing
ProjectProperties
Property
Context
ContextRule
Control
Documentation
DocumentationRule
Page
Endpoint
LogDescriptor
Logging
Monitoring
Quota
MetricRule
QuotaLimit
Service
SourceInfo
SystemParameters
SystemParameterRule
SystemParameter
Usage
UsageRule
*/
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// `Authentication` defines the authentication configuration for an API.
//
// Example for an API targeted for external use:
//
// name: calendar.googleapis.com
// authentication:
// providers:
// - id: google_calendar_auth
// jwks_uri: https://www.googleapis.com/oauth2/v1/certs
// issuer: https://securetoken.google.com
// rules:
// - selector: "*"
// requirements:
// provider_id: google_calendar_auth
type Authentication struct {
// A list of authentication rules that apply to individual API methods.
//
// **NOTE:** All service configuration rules follow "last one wins" order.
Rules []*AuthenticationRule `protobuf:"bytes,3,rep,name=rules" json:"rules,omitempty"`
// Defines a set of authentication providers that a service supports.
Providers []*AuthProvider `protobuf:"bytes,4,rep,name=providers" json:"providers,omitempty"`
}
func (m *Authentication) Reset() { *m = Authentication{} }
func (m *Authentication) String() string { return proto.CompactTextString(m) }
func (*Authentication) ProtoMessage() {}
func (*Authentication) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Authentication) GetRules() []*AuthenticationRule {
if m != nil {
return m.Rules
}
return nil
}
func (m *Authentication) GetProviders() []*AuthProvider {
if m != nil {
return m.Providers
}
return nil
}
// Authentication rules for the service.
//
// By default, if a method has any authentication requirements, every request
// must include a valid credential matching one of the requirements.
// It's an error to include more than one kind of credential in a single
// request.
//
// If a method doesn't have any auth requirements, request credentials will be
// ignored.
type AuthenticationRule struct {
// Selects the methods to which this rule applies.
//
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// The requirements for OAuth credentials.
Oauth *OAuthRequirements `protobuf:"bytes,2,opt,name=oauth" json:"oauth,omitempty"`
// Whether to allow requests without a credential. The credential can be
// an OAuth token, Google cookies (first-party auth) or EndUserCreds.
//
// For requests without credentials, if the service control environment is
// specified, each incoming request **must** be associated with a service
// consumer. This can be done by passing an API key that belongs to a consumer
// project.
AllowWithoutCredential bool `protobuf:"varint,5,opt,name=allow_without_credential,json=allowWithoutCredential" json:"allow_without_credential,omitempty"`
// Requirements for additional authentication providers.
Requirements []*AuthRequirement `protobuf:"bytes,7,rep,name=requirements" json:"requirements,omitempty"`
}
func (m *AuthenticationRule) Reset() { *m = AuthenticationRule{} }
func (m *AuthenticationRule) String() string { return proto.CompactTextString(m) }
func (*AuthenticationRule) ProtoMessage() {}
func (*AuthenticationRule) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *AuthenticationRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *AuthenticationRule) GetOauth() *OAuthRequirements {
if m != nil {
return m.Oauth
}
return nil
}
func (m *AuthenticationRule) GetAllowWithoutCredential() bool {
if m != nil {
return m.AllowWithoutCredential
}
return false
}
func (m *AuthenticationRule) GetRequirements() []*AuthRequirement {
if m != nil {
return m.Requirements
}
return nil
}
// Configuration for an anthentication provider, including support for
// [JSON Web Token (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
type AuthProvider struct {
// The unique identifier of the auth provider. It will be referred to by
// `AuthRequirement.provider_id`.
//
// Example: "bookstore_auth".
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
// Identifies the principal that issued the JWT. See
// https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.1
// Usually a URL or an email address.
//
// Example: https://securetoken.google.com
// Example: 1234567-compute@developer.gserviceaccount.com
Issuer string `protobuf:"bytes,2,opt,name=issuer" json:"issuer,omitempty"`
// URL of the provider's public key set to validate signature of the JWT. See
// [OpenID Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata).
// Optional if the key set document:
// - can be retrieved from
// [OpenID Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html
// of the issuer.
// - can be inferred from the email domain of the issuer (e.g. a Google service account).
//
// Example: https://www.googleapis.com/oauth2/v1/certs
JwksUri string `protobuf:"bytes,3,opt,name=jwks_uri,json=jwksUri" json:"jwks_uri,omitempty"`
// The list of JWT
// [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.3).
// that are allowed to access. A JWT containing any of these audiences will
// be accepted. When this setting is absent, only JWTs with audience
// "https://[Service_name][google.api.Service.name]/[API_name][google.protobuf.Api.name]"
// will be accepted. For example, if no audiences are in the setting,
// LibraryService API will only accept JWTs with the following audience
// "https://library-example.googleapis.com/google.example.library.v1.LibraryService".
//
// Example:
//
// audiences: bookstore_android.apps.googleusercontent.com,
// bookstore_web.apps.googleusercontent.com
Audiences string `protobuf:"bytes,4,opt,name=audiences" json:"audiences,omitempty"`
// Redirect URL if JWT token is required but no present or is expired.
// Implement authorizationUrl of securityDefinitions in OpenAPI spec.
AuthorizationUrl string `protobuf:"bytes,5,opt,name=authorization_url,json=authorizationUrl" json:"authorization_url,omitempty"`
}
func (m *AuthProvider) Reset() { *m = AuthProvider{} }
func (m *AuthProvider) String() string { return proto.CompactTextString(m) }
func (*AuthProvider) ProtoMessage() {}
func (*AuthProvider) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *AuthProvider) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *AuthProvider) GetIssuer() string {
if m != nil {
return m.Issuer
}
return ""
}
func (m *AuthProvider) GetJwksUri() string {
if m != nil {
return m.JwksUri
}
return ""
}
func (m *AuthProvider) GetAudiences() string {
if m != nil {
return m.Audiences
}
return ""
}
func (m *AuthProvider) GetAuthorizationUrl() string {
if m != nil {
return m.AuthorizationUrl
}
return ""
}
// OAuth scopes are a way to define data and permissions on data. For example,
// there are scopes defined for "Read-only access to Google Calendar" and
// "Access to Cloud Platform". Users can consent to a scope for an application,
// giving it permission to access that data on their behalf.
//
// OAuth scope specifications should be fairly coarse grained; a user will need
// to see and understand the text description of what your scope means.
//
// In most cases: use one or at most two OAuth scopes for an entire family of
// products. If your product has multiple APIs, you should probably be sharing
// the OAuth scope across all of those APIs.
//
// When you need finer grained OAuth consent screens: talk with your product
// management about how developers will use them in practice.
//
// Please note that even though each of the canonical scopes is enough for a
// request to be accepted and passed to the backend, a request can still fail
// due to the backend requiring additional scopes or permissions.
type OAuthRequirements struct {
// The list of publicly documented OAuth scopes that are allowed access. An
// OAuth token containing any of these scopes will be accepted.
//
// Example:
//
// canonical_scopes: https://www.googleapis.com/auth/calendar,
// https://www.googleapis.com/auth/calendar.read
CanonicalScopes string `protobuf:"bytes,1,opt,name=canonical_scopes,json=canonicalScopes" json:"canonical_scopes,omitempty"`
}
func (m *OAuthRequirements) Reset() { *m = OAuthRequirements{} }
func (m *OAuthRequirements) String() string { return proto.CompactTextString(m) }
func (*OAuthRequirements) ProtoMessage() {}
func (*OAuthRequirements) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *OAuthRequirements) GetCanonicalScopes() string {
if m != nil {
return m.CanonicalScopes
}
return ""
}
// User-defined authentication requirements, including support for
// [JSON Web Token (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
type AuthRequirement struct {
// [id][google.api.AuthProvider.id] from authentication provider.
//
// Example:
//
// provider_id: bookstore_auth
ProviderId string `protobuf:"bytes,1,opt,name=provider_id,json=providerId" json:"provider_id,omitempty"`
// NOTE: This will be deprecated soon, once AuthProvider.audiences is
// implemented and accepted in all the runtime components.
//
// The list of JWT
// [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.3).
// that are allowed to access. A JWT containing any of these audiences will
// be accepted. When this setting is absent, only JWTs with audience
// "https://[Service_name][google.api.Service.name]/[API_name][google.protobuf.Api.name]"
// will be accepted. For example, if no audiences are in the setting,
// LibraryService API will only accept JWTs with the following audience
// "https://library-example.googleapis.com/google.example.library.v1.LibraryService".
//
// Example:
//
// audiences: bookstore_android.apps.googleusercontent.com,
// bookstore_web.apps.googleusercontent.com
Audiences string `protobuf:"bytes,2,opt,name=audiences" json:"audiences,omitempty"`
}
func (m *AuthRequirement) Reset() { *m = AuthRequirement{} }
func (m *AuthRequirement) String() string { return proto.CompactTextString(m) }
func (*AuthRequirement) ProtoMessage() {}
func (*AuthRequirement) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *AuthRequirement) GetProviderId() string {
if m != nil {
return m.ProviderId
}
return ""
}
func (m *AuthRequirement) GetAudiences() string {
if m != nil {
return m.Audiences
}
return ""
}
func init() {
proto.RegisterType((*Authentication)(nil), "google.api.Authentication")
proto.RegisterType((*AuthenticationRule)(nil), "google.api.AuthenticationRule")
proto.RegisterType((*AuthProvider)(nil), "google.api.AuthProvider")
proto.RegisterType((*OAuthRequirements)(nil), "google.api.OAuthRequirements")
proto.RegisterType((*AuthRequirement)(nil), "google.api.AuthRequirement")
}
func init() { proto.RegisterFile("google/api/auth.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 465 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0x5f, 0x6b, 0x13, 0x4f,
0x14, 0x65, 0x93, 0xa6, 0xcd, 0xde, 0x94, 0xb4, 0x1d, 0xf8, 0x95, 0xfd, 0xd5, 0xaa, 0x21, 0x4f,
0x11, 0x61, 0x03, 0xad, 0x88, 0x20, 0x28, 0xad, 0x88, 0xf4, 0xc9, 0x30, 0x52, 0x04, 0x5f, 0x96,
0x71, 0x76, 0xdc, 0x8c, 0x9d, 0xce, 0x5d, 0xe7, 0x4f, 0x03, 0x3e, 0xf8, 0x49, 0x7c, 0xf2, 0x93,
0xf9, 0x51, 0x64, 0x67, 0xb7, 0xc9, 0x6e, 0xfa, 0x78, 0xef, 0x39, 0xe7, 0xde, 0x7b, 0xce, 0x0c,
0xfc, 0x57, 0x20, 0x16, 0x4a, 0xcc, 0x59, 0x29, 0xe7, 0xcc, 0xbb, 0x65, 0x5a, 0x1a, 0x74, 0x48,
0xa0, 0x6e, 0xa7, 0xac, 0x94, 0x27, 0xa7, 0x6d, 0x8a, 0xd6, 0xe8, 0x98, 0x93, 0xa8, 0x6d, 0xcd,
0x9c, 0xfe, 0x82, 0xf1, 0x85, 0x77, 0x4b, 0xa1, 0x9d, 0xe4, 0x01, 0x20, 0x2f, 0x60, 0x60, 0xbc,
0x12, 0x36, 0xe9, 0x4f, 0xfa, 0xb3, 0xd1, 0xd9, 0x93, 0x74, 0x33, 0x2b, 0xed, 0x52, 0xa9, 0x57,
0x82, 0xd6, 0x64, 0xf2, 0x12, 0xe2, 0xd2, 0xe0, 0x9d, 0xcc, 0x85, 0xb1, 0xc9, 0x4e, 0x50, 0x26,
0xdb, 0xca, 0x45, 0x43, 0xa0, 0x1b, 0xea, 0xf4, 0x6f, 0x04, 0xe4, 0xe1, 0x54, 0x72, 0x02, 0x43,
0x2b, 0x94, 0xe0, 0x0e, 0x4d, 0x12, 0x4d, 0xa2, 0x59, 0x4c, 0xd7, 0x35, 0x39, 0x87, 0x01, 0x56,
0x5e, 0x93, 0xde, 0x24, 0x9a, 0x8d, 0xce, 0x1e, 0xb7, 0xd7, 0x7c, 0xac, 0x66, 0x51, 0xf1, 0xc3,
0x4b, 0x23, 0x6e, 0x85, 0x76, 0x96, 0xd6, 0x5c, 0xf2, 0x0a, 0x12, 0xa6, 0x14, 0xae, 0xb2, 0x95,
0x74, 0x4b, 0xf4, 0x2e, 0xe3, 0x46, 0xe4, 0xd5, 0x52, 0xa6, 0x92, 0xc1, 0x24, 0x9a, 0x0d, 0xe9,
0x71, 0xc0, 0x3f, 0xd7, 0xf0, 0xbb, 0x35, 0x4a, 0xde, 0xc2, 0xbe, 0x69, 0x0d, 0x4c, 0xf6, 0x82,
0xb9, 0x47, 0xdb, 0xe6, 0x5a, 0x4b, 0x69, 0x47, 0x30, 0xfd, 0x1d, 0xc1, 0x7e, 0xdb, 0x3e, 0x19,
0x43, 0x4f, 0xe6, 0x8d, 0xad, 0x9e, 0xcc, 0xc9, 0x31, 0xec, 0x4a, 0x6b, 0xbd, 0x30, 0xc1, 0x51,
0x4c, 0x9b, 0x8a, 0xfc, 0x0f, 0xc3, 0xef, 0xab, 0x1b, 0x9b, 0x79, 0x23, 0x93, 0x7e, 0x40, 0xf6,
0xaa, 0xfa, 0xda, 0x48, 0x72, 0x0a, 0x31, 0xf3, 0xb9, 0x14, 0x9a, 0x8b, 0x2a, 0xee, 0x0a, 0xdb,
0x34, 0xc8, 0x73, 0x38, 0xaa, 0x4c, 0xa3, 0x91, 0x3f, 0x43, 0xa4, 0x99, 0x37, 0xb5, 0xcb, 0x98,
0x1e, 0x76, 0x80, 0x6b, 0xa3, 0xa6, 0x6f, 0xe0, 0xe8, 0x41, 0x6a, 0xe4, 0x19, 0x1c, 0x72, 0xa6,
0x51, 0x4b, 0xce, 0x54, 0x66, 0x39, 0x96, 0xc2, 0x36, 0x07, 0x1f, 0xac, 0xfb, 0x9f, 0x42, 0x7b,
0xba, 0x80, 0x83, 0x2d, 0x39, 0x79, 0x0a, 0xa3, 0xfb, 0x17, 0xce, 0xd6, 0x4e, 0xe1, 0xbe, 0x75,
0x95, 0x77, 0xcf, 0xef, 0x6d, 0x9d, 0x7f, 0x79, 0x03, 0x63, 0x8e, 0xb7, 0xad, 0x80, 0x2f, 0xe3,
0x26, 0x3f, 0x87, 0x8b, 0xe8, 0xcb, 0xfb, 0x06, 0x28, 0x50, 0x31, 0x5d, 0xa4, 0x68, 0x8a, 0x79,
0x21, 0x74, 0xf8, 0xce, 0xf3, 0x1a, 0x62, 0xa5, 0xb4, 0xe1, 0xbf, 0x5b, 0x61, 0xee, 0x24, 0x17,
0x1c, 0xf5, 0x37, 0x59, 0xbc, 0xee, 0x54, 0x7f, 0x7a, 0x3b, 0x1f, 0x2e, 0x16, 0x57, 0x5f, 0x77,
0x83, 0xf0, 0xfc, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe5, 0xa3, 0x9d, 0xc6, 0x4a, 0x03, 0x00,
0x00,
}

98
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/backend.pb.go generated vendored Normal file
View File

@ -0,0 +1,98 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/backend.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// `Backend` defines the backend configuration for a service.
type Backend struct {
// A list of API backend rules that apply to individual API methods.
//
// **NOTE:** All service configuration rules follow "last one wins" order.
Rules []*BackendRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *Backend) Reset() { *m = Backend{} }
func (m *Backend) String() string { return proto.CompactTextString(m) }
func (*Backend) ProtoMessage() {}
func (*Backend) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
func (m *Backend) GetRules() []*BackendRule {
if m != nil {
return m.Rules
}
return nil
}
// A backend rule provides configuration for an individual API element.
type BackendRule struct {
// Selects the methods to which this rule applies.
//
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// The address of the API backend.
Address string `protobuf:"bytes,2,opt,name=address" json:"address,omitempty"`
// The number of seconds to wait for a response from a request. The
// default depends on the deployment context.
Deadline float64 `protobuf:"fixed64,3,opt,name=deadline" json:"deadline,omitempty"`
}
func (m *BackendRule) Reset() { *m = BackendRule{} }
func (m *BackendRule) String() string { return proto.CompactTextString(m) }
func (*BackendRule) ProtoMessage() {}
func (*BackendRule) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
func (m *BackendRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *BackendRule) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *BackendRule) GetDeadline() float64 {
if m != nil {
return m.Deadline
}
return 0
}
func init() {
proto.RegisterType((*Backend)(nil), "google.api.Backend")
proto.RegisterType((*BackendRule)(nil), "google.api.BackendRule")
}
func init() { proto.RegisterFile("google/api/backend.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 227 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0x31, 0x4f, 0x03, 0x21,
0x18, 0x86, 0x43, 0xab, 0x56, 0xbf, 0x1a, 0x87, 0x5b, 0x24, 0x4e, 0x97, 0x4e, 0xb7, 0xc8, 0x25,
0xba, 0x98, 0x38, 0x79, 0x89, 0x31, 0x6e, 0x17, 0x46, 0x17, 0x43, 0xe1, 0x93, 0x10, 0x91, 0x8f,
0x40, 0xeb, 0x0f, 0xf2, 0x97, 0x9a, 0xc2, 0x59, 0xdb, 0xf1, 0xe1, 0x79, 0xdf, 0xc0, 0x0b, 0x70,
0x4b, 0x64, 0x3d, 0xf6, 0x2a, 0xba, 0x7e, 0xad, 0xf4, 0x27, 0x06, 0x23, 0x62, 0xa2, 0x0d, 0x35,
0x50, 0x8d, 0x50, 0xd1, 0xad, 0x1e, 0x60, 0x31, 0x54, 0xd9, 0xdc, 0xc2, 0x69, 0xda, 0x7a, 0xcc,
0x9c, 0xb5, 0xf3, 0x6e, 0x79, 0x77, 0x2d, 0xfe, 0x63, 0x62, 0xca, 0xc8, 0xad, 0x47, 0x59, 0x53,
0xab, 0x77, 0x58, 0x1e, 0x9c, 0x36, 0x37, 0x70, 0x9e, 0xd1, 0xa3, 0xde, 0x50, 0xe2, 0xac, 0x65,
0xdd, 0x85, 0xdc, 0x73, 0xc3, 0x61, 0xa1, 0x8c, 0x49, 0x98, 0x33, 0x9f, 0x15, 0xf5, 0x87, 0xbb,
0x96, 0x41, 0x65, 0xbc, 0x0b, 0xc8, 0xe7, 0x2d, 0xeb, 0x98, 0xdc, 0xf3, 0x10, 0xe0, 0x4a, 0xd3,
0xd7, 0xc1, 0x2b, 0x86, 0xcb, 0xe9, 0xc2, 0x71, 0x37, 0x63, 0x64, 0x6f, 0xcf, 0x93, 0xb3, 0xe4,
0x55, 0xb0, 0x82, 0x92, 0xed, 0x2d, 0x86, 0x32, 0xb2, 0xaf, 0x4a, 0x45, 0x97, 0xcb, 0x0f, 0x64,
0x4c, 0xdf, 0x4e, 0xa3, 0xa6, 0xf0, 0xe1, 0xec, 0xe3, 0x11, 0xfd, 0xcc, 0x4e, 0x5e, 0x9e, 0xc6,
0xd7, 0xf5, 0x59, 0x29, 0xde, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x93, 0x9e, 0x00, 0x39,
0x01, 0x00, 0x00,
}

113
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/billing.pb.go generated vendored Normal file
View File

@ -0,0 +1,113 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/billing.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import _ "google.golang.org/genproto/googleapis/api/metric"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Billing related configuration of the service.
//
// The following example shows how to configure monitored resources and metrics
// for billing:
// monitored_resources:
// - type: library.googleapis.com/branch
// labels:
// - key: /city
// description: The city where the library branch is located in.
// - key: /name
// description: The name of the branch.
// metrics:
// - name: library.googleapis.com/book/borrowed_count
// metric_kind: DELTA
// value_type: INT64
// billing:
// consumer_destinations:
// - monitored_resource: library.googleapis.com/branch
// metrics:
// - library.googleapis.com/book/borrowed_count
type Billing struct {
// Billing configurations for sending metrics to the consumer project.
// There can be multiple consumer destinations per service, each one must have
// a different monitored resource type. A metric can be used in at most
// one consumer destination.
ConsumerDestinations []*Billing_BillingDestination `protobuf:"bytes,8,rep,name=consumer_destinations,json=consumerDestinations" json:"consumer_destinations,omitempty"`
}
func (m *Billing) Reset() { *m = Billing{} }
func (m *Billing) String() string { return proto.CompactTextString(m) }
func (*Billing) ProtoMessage() {}
func (*Billing) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *Billing) GetConsumerDestinations() []*Billing_BillingDestination {
if m != nil {
return m.ConsumerDestinations
}
return nil
}
// Configuration of a specific billing destination (Currently only support
// bill against consumer project).
type Billing_BillingDestination struct {
// The monitored resource type. The type must be defined in
// [Service.monitored_resources][google.api.Service.monitored_resources] section.
MonitoredResource string `protobuf:"bytes,1,opt,name=monitored_resource,json=monitoredResource" json:"monitored_resource,omitempty"`
// Names of the metrics to report to this billing destination.
// Each name must be defined in [Service.metrics][google.api.Service.metrics] section.
Metrics []string `protobuf:"bytes,2,rep,name=metrics" json:"metrics,omitempty"`
}
func (m *Billing_BillingDestination) Reset() { *m = Billing_BillingDestination{} }
func (m *Billing_BillingDestination) String() string { return proto.CompactTextString(m) }
func (*Billing_BillingDestination) ProtoMessage() {}
func (*Billing_BillingDestination) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0, 0} }
func (m *Billing_BillingDestination) GetMonitoredResource() string {
if m != nil {
return m.MonitoredResource
}
return ""
}
func (m *Billing_BillingDestination) GetMetrics() []string {
if m != nil {
return m.Metrics
}
return nil
}
func init() {
proto.RegisterType((*Billing)(nil), "google.api.Billing")
proto.RegisterType((*Billing_BillingDestination)(nil), "google.api.Billing.BillingDestination")
}
func init() { proto.RegisterFile("google/api/billing.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 265 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xc1, 0x4a, 0xc4, 0x30,
0x10, 0x86, 0xe9, 0xae, 0xb8, 0x6e, 0x14, 0xc1, 0xa0, 0x58, 0x8a, 0x87, 0xe2, 0x41, 0x7a, 0xb1,
0x05, 0x3d, 0x7a, 0xb2, 0x28, 0xe2, 0xad, 0xf4, 0xa8, 0xc8, 0x92, 0xcd, 0x8e, 0x61, 0xa0, 0x9d,
0x29, 0x49, 0xd6, 0x07, 0xf2, 0x5d, 0x7c, 0x2f, 0xb1, 0x69, 0xdd, 0x8a, 0xa7, 0x30, 0xf9, 0xfe,
0xf9, 0x67, 0xe6, 0x17, 0xb1, 0x61, 0x36, 0x0d, 0x14, 0xaa, 0xc3, 0x62, 0x8d, 0x4d, 0x83, 0x64,
0xf2, 0xce, 0xb2, 0x67, 0x29, 0x02, 0xc9, 0x55, 0x87, 0xc9, 0xc5, 0x44, 0xa5, 0x88, 0xd8, 0x2b,
0x8f, 0x4c, 0x2e, 0x28, 0x93, 0xf3, 0x09, 0x6d, 0xc1, 0x5b, 0xd4, 0x01, 0x5c, 0x7e, 0x45, 0x62,
0x51, 0x06, 0x53, 0xf9, 0x2a, 0xce, 0x34, 0x93, 0xdb, 0xb6, 0x60, 0x57, 0x1b, 0x70, 0x1e, 0x29,
0x78, 0xc4, 0x07, 0xe9, 0x3c, 0x3b, 0xbc, 0xb9, 0xca, 0x77, 0xe3, 0xf2, 0xa1, 0x67, 0x7c, 0x1f,
0x76, 0xf2, 0xfa, 0x74, 0x34, 0x99, 0x7c, 0xba, 0xe4, 0x4d, 0xc8, 0xff, 0x5a, 0x79, 0x2d, 0x64,
0xcb, 0x84, 0x9e, 0x2d, 0x6c, 0x56, 0x16, 0x1c, 0x6f, 0xad, 0x86, 0x38, 0x4a, 0xa3, 0x6c, 0x59,
0x9f, 0xfc, 0x92, 0x7a, 0x00, 0x32, 0x16, 0x8b, 0xb0, 0xbd, 0x8b, 0x67, 0xe9, 0x3c, 0x5b, 0xd6,
0x63, 0x59, 0x92, 0x38, 0xd6, 0xdc, 0x4e, 0x36, 0x2c, 0x8f, 0x86, 0x71, 0xd5, 0xcf, 0x9d, 0x55,
0xf4, 0xf2, 0x38, 0x30, 0xc3, 0x8d, 0x22, 0x93, 0xb3, 0x35, 0x85, 0x01, 0xea, 0x53, 0x28, 0x02,
0x52, 0x1d, 0xba, 0x3e, 0x21, 0x07, 0xf6, 0x03, 0x35, 0x68, 0xa6, 0x77, 0x34, 0x77, 0x7f, 0xaa,
0xcf, 0xd9, 0xde, 0xd3, 0x7d, 0xf5, 0xbc, 0xde, 0xef, 0x1b, 0x6f, 0xbf, 0x03, 0x00, 0x00, 0xff,
0xff, 0xca, 0x8b, 0xb4, 0x63, 0x9d, 0x01, 0x00, 0x00,
}

158
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/consumer.pb.go generated vendored Normal file
View File

@ -0,0 +1,158 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/consumer.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Supported data type of the property values
type Property_PropertyType int32
const (
// The type is unspecified, and will result in an error.
Property_UNSPECIFIED Property_PropertyType = 0
// The type is `int64`.
Property_INT64 Property_PropertyType = 1
// The type is `bool`.
Property_BOOL Property_PropertyType = 2
// The type is `string`.
Property_STRING Property_PropertyType = 3
// The type is 'double'.
Property_DOUBLE Property_PropertyType = 4
)
var Property_PropertyType_name = map[int32]string{
0: "UNSPECIFIED",
1: "INT64",
2: "BOOL",
3: "STRING",
4: "DOUBLE",
}
var Property_PropertyType_value = map[string]int32{
"UNSPECIFIED": 0,
"INT64": 1,
"BOOL": 2,
"STRING": 3,
"DOUBLE": 4,
}
func (x Property_PropertyType) String() string {
return proto.EnumName(Property_PropertyType_name, int32(x))
}
func (Property_PropertyType) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{1, 0} }
// A descriptor for defining project properties for a service. One service may
// have many consumer projects, and the service may want to behave differently
// depending on some properties on the project. For example, a project may be
// associated with a school, or a business, or a government agency, a business
// type property on the project may affect how a service responds to the client.
// This descriptor defines which properties are allowed to be set on a project.
//
// Example:
//
// project_properties:
// properties:
// - name: NO_WATERMARK
// type: BOOL
// description: Allows usage of the API without watermarks.
// - name: EXTENDED_TILE_CACHE_PERIOD
// type: INT64
type ProjectProperties struct {
// List of per consumer project-specific properties.
Properties []*Property `protobuf:"bytes,1,rep,name=properties" json:"properties,omitempty"`
}
func (m *ProjectProperties) Reset() { *m = ProjectProperties{} }
func (m *ProjectProperties) String() string { return proto.CompactTextString(m) }
func (*ProjectProperties) ProtoMessage() {}
func (*ProjectProperties) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
func (m *ProjectProperties) GetProperties() []*Property {
if m != nil {
return m.Properties
}
return nil
}
// Defines project properties.
//
// API services can define properties that can be assigned to consumer projects
// so that backends can perform response customization without having to make
// additional calls or maintain additional storage. For example, Maps API
// defines properties that controls map tile cache period, or whether to embed a
// watermark in a result.
//
// These values can be set via API producer console. Only API providers can
// define and set these properties.
type Property struct {
// The name of the property (a.k.a key).
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The type of this property.
Type Property_PropertyType `protobuf:"varint,2,opt,name=type,enum=google.api.Property_PropertyType" json:"type,omitempty"`
// The description of the property
Description string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
}
func (m *Property) Reset() { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage() {}
func (*Property) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
func (m *Property) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Property) GetType() Property_PropertyType {
if m != nil {
return m.Type
}
return Property_UNSPECIFIED
}
func (m *Property) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*ProjectProperties)(nil), "google.api.ProjectProperties")
proto.RegisterType((*Property)(nil), "google.api.Property")
proto.RegisterEnum("google.api.Property_PropertyType", Property_PropertyType_name, Property_PropertyType_value)
}
func init() { proto.RegisterFile("google/api/consumer.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 299 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x4f, 0x4f, 0xf2, 0x40,
0x10, 0xc6, 0xdf, 0x85, 0xbe, 0x04, 0x06, 0xc5, 0xba, 0xf1, 0x50, 0x6f, 0x95, 0x13, 0xa7, 0x36,
0x41, 0xf4, 0xe2, 0xad, 0x50, 0x4d, 0x13, 0x02, 0x4d, 0x81, 0x8b, 0xb7, 0x5a, 0xc7, 0x75, 0x0d,
0xec, 0x6c, 0xb6, 0xd5, 0x84, 0x0f, 0xe8, 0xf7, 0x32, 0x2c, 0x88, 0x35, 0xf1, 0xf6, 0xcc, 0x3e,
0x7f, 0xb2, 0xf9, 0xc1, 0xa5, 0x20, 0x12, 0x6b, 0x0c, 0x73, 0x2d, 0xc3, 0x82, 0x54, 0xf9, 0xbe,
0x41, 0x13, 0x68, 0x43, 0x15, 0x71, 0xd8, 0x5b, 0x41, 0xae, 0x65, 0x3f, 0x81, 0xf3, 0xd4, 0xd0,
0x1b, 0x16, 0x55, 0x6a, 0x48, 0xa3, 0xa9, 0x24, 0x96, 0x7c, 0x04, 0xa0, 0x8f, 0x97, 0xc7, 0xfc,
0xe6, 0xa0, 0x3b, 0xbc, 0x08, 0x7e, 0x5a, 0xc1, 0x21, 0xbb, 0xcd, 0x6a, 0xb9, 0xfe, 0x27, 0x83,
0xf6, 0xb7, 0xc1, 0x39, 0x38, 0x2a, 0xdf, 0xa0, 0xc7, 0x7c, 0x36, 0xe8, 0x64, 0x56, 0xf3, 0x1b,
0x70, 0xaa, 0xad, 0x46, 0xaf, 0xe1, 0xb3, 0x41, 0x6f, 0x78, 0xf5, 0xd7, 0xe0, 0x51, 0x2c, 0xb7,
0x1a, 0x33, 0x1b, 0xe7, 0x3e, 0x74, 0x9f, 0xb1, 0x2c, 0x8c, 0xd4, 0x95, 0x24, 0xe5, 0x35, 0xed,
0x62, 0xfd, 0xa9, 0x3f, 0x85, 0x93, 0x7a, 0x8f, 0x9f, 0x41, 0x77, 0x35, 0x5b, 0xa4, 0xf1, 0x38,
0xb9, 0x4f, 0xe2, 0x89, 0xfb, 0x8f, 0x77, 0xe0, 0x7f, 0x32, 0x5b, 0xde, 0x8e, 0x5c, 0xc6, 0xdb,
0xe0, 0x44, 0xf3, 0xf9, 0xd4, 0x6d, 0x70, 0x80, 0xd6, 0x62, 0x99, 0x25, 0xb3, 0x07, 0xb7, 0xb9,
0xd3, 0x93, 0xf9, 0x2a, 0x9a, 0xc6, 0xae, 0x13, 0xbd, 0x42, 0xaf, 0xa0, 0x4d, 0xed, 0x77, 0xd1,
0xe9, 0xf8, 0x00, 0x30, 0xdd, 0xf1, 0x4b, 0xd9, 0x63, 0x7c, 0x30, 0x05, 0xad, 0x73, 0x25, 0x02,
0x32, 0x22, 0x14, 0xa8, 0x2c, 0xdd, 0x70, 0x6f, 0xe5, 0x5a, 0x96, 0x96, 0x7d, 0x89, 0xe6, 0x43,
0x16, 0x58, 0x90, 0x7a, 0x91, 0xe2, 0xee, 0xd7, 0xf5, 0xd4, 0xb2, 0x8d, 0xeb, 0xaf, 0x00, 0x00,
0x00, 0xff, 0xff, 0xb7, 0xa4, 0x04, 0x2c, 0xac, 0x01, 0x00, 0x00,
}

114
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/context.pb.go generated vendored Normal file
View File

@ -0,0 +1,114 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/context.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// `Context` defines which contexts an API requests.
//
// Example:
//
// context:
// rules:
// - selector: "*"
// requested:
// - google.rpc.context.ProjectContext
// - google.rpc.context.OriginContext
//
// The above specifies that all methods in the API request
// `google.rpc.context.ProjectContext` and
// `google.rpc.context.OriginContext`.
//
// Available context types are defined in package
// `google.rpc.context`.
type Context struct {
// A list of RPC context rules that apply to individual API methods.
//
// **NOTE:** All service configuration rules follow "last one wins" order.
Rules []*ContextRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *Context) Reset() { *m = Context{} }
func (m *Context) String() string { return proto.CompactTextString(m) }
func (*Context) ProtoMessage() {}
func (*Context) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
func (m *Context) GetRules() []*ContextRule {
if m != nil {
return m.Rules
}
return nil
}
// A context rule provides information about the context for an individual API
// element.
type ContextRule struct {
// Selects the methods to which this rule applies.
//
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// A list of full type names of requested contexts.
Requested []string `protobuf:"bytes,2,rep,name=requested" json:"requested,omitempty"`
// A list of full type names of provided contexts.
Provided []string `protobuf:"bytes,3,rep,name=provided" json:"provided,omitempty"`
}
func (m *ContextRule) Reset() { *m = ContextRule{} }
func (m *ContextRule) String() string { return proto.CompactTextString(m) }
func (*ContextRule) ProtoMessage() {}
func (*ContextRule) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
func (m *ContextRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *ContextRule) GetRequested() []string {
if m != nil {
return m.Requested
}
return nil
}
func (m *ContextRule) GetProvided() []string {
if m != nil {
return m.Provided
}
return nil
}
func init() {
proto.RegisterType((*Context)(nil), "google.api.Context")
proto.RegisterType((*ContextRule)(nil), "google.api.ContextRule")
}
func init() { proto.RegisterFile("google/api/context.proto", fileDescriptor4) }
var fileDescriptor4 = []byte{
// 231 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0x4f, 0x4b, 0xc4, 0x30,
0x14, 0xc4, 0xe9, 0xd6, 0x7f, 0x7d, 0x2b, 0x1e, 0x7a, 0x31, 0x88, 0x87, 0xb2, 0xa7, 0x5e, 0x4c,
0x41, 0x2f, 0x82, 0x27, 0x57, 0x44, 0xbc, 0x95, 0x1e, 0xbd, 0xc5, 0xf4, 0x19, 0x02, 0x31, 0x2f,
0x26, 0xe9, 0xe2, 0xe7, 0xf1, 0x93, 0xca, 0x26, 0x65, 0xff, 0x1c, 0x67, 0x7e, 0x33, 0x24, 0xf3,
0x80, 0x29, 0x22, 0x65, 0xb0, 0x13, 0x4e, 0x77, 0x92, 0x6c, 0xc4, 0xdf, 0xc8, 0x9d, 0xa7, 0x48,
0x35, 0x64, 0xc2, 0x85, 0xd3, 0xab, 0x47, 0x38, 0x7f, 0xc9, 0xb0, 0xbe, 0x83, 0x53, 0x3f, 0x19,
0x0c, 0xac, 0x68, 0xca, 0x76, 0x79, 0x7f, 0xcd, 0xf7, 0x31, 0x3e, 0x67, 0x86, 0xc9, 0xe0, 0x90,
0x53, 0x2b, 0x09, 0xcb, 0x03, 0xb7, 0xbe, 0x81, 0x8b, 0x80, 0x06, 0x65, 0x24, 0xcf, 0x8a, 0xa6,
0x68, 0xab, 0x61, 0xa7, 0xeb, 0x5b, 0xa8, 0x3c, 0xfe, 0x4c, 0x18, 0x22, 0x8e, 0x6c, 0xd1, 0x94,
0x6d, 0x35, 0xec, 0x8d, 0x6d, 0xd3, 0x79, 0xda, 0xe8, 0x11, 0x47, 0x56, 0x26, 0xb8, 0xd3, 0x6b,
0x0b, 0x57, 0x92, 0xbe, 0x0f, 0x7e, 0xb2, 0xbe, 0x9c, 0x1f, 0xed, 0xb7, 0x53, 0xfa, 0xe2, 0xe3,
0x75, 0x66, 0x8a, 0x8c, 0xb0, 0x8a, 0x93, 0x57, 0x9d, 0x42, 0x9b, 0x86, 0x76, 0x19, 0x09, 0xa7,
0x43, 0xba, 0x42, 0x40, 0xbf, 0xd1, 0x12, 0x25, 0xd9, 0x2f, 0xad, 0x9e, 0x8e, 0xd4, 0xdf, 0xe2,
0xe4, 0xed, 0xb9, 0x7f, 0xff, 0x3c, 0x4b, 0xc5, 0x87, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb5,
0x18, 0x98, 0x7a, 0x3d, 0x01, 0x00, 0x00,
}

55
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/control.pb.go generated vendored Normal file
View File

@ -0,0 +1,55 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/control.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Selects and configures the service controller used by the service. The
// service controller handles features like abuse, quota, billing, logging,
// monitoring, etc.
type Control struct {
// The service control environment to use. If empty, no control plane
// feature (like quota and billing) will be enabled.
Environment string `protobuf:"bytes,1,opt,name=environment" json:"environment,omitempty"`
}
func (m *Control) Reset() { *m = Control{} }
func (m *Control) String() string { return proto.CompactTextString(m) }
func (*Control) ProtoMessage() {}
func (*Control) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
func (m *Control) GetEnvironment() string {
if m != nil {
return m.Environment
}
return ""
}
func init() {
proto.RegisterType((*Control)(nil), "google.api.Control")
}
func init() { proto.RegisterFile("google/api/control.proto", fileDescriptor5) }
var fileDescriptor5 = []byte{
// 165 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x48, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xce, 0xcf, 0x2b, 0x29, 0xca, 0xcf, 0xd1, 0x2b,
0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0xc8, 0xe8, 0x25, 0x16, 0x64, 0x2a, 0x69, 0x73, 0xb1,
0x3b, 0x43, 0x24, 0x85, 0x14, 0xb8, 0xb8, 0x53, 0xf3, 0xca, 0x32, 0x8b, 0xf2, 0xf3, 0x72, 0x53,
0xf3, 0x4a, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x90, 0x85, 0x9c, 0xf2, 0xb8, 0xf8, 0x92,
0xf3, 0x73, 0xf5, 0x10, 0xda, 0x9d, 0x78, 0xa0, 0x9a, 0x03, 0x40, 0x06, 0x07, 0x30, 0x46, 0xb9,
0x42, 0xe5, 0xd2, 0xf3, 0x73, 0x12, 0xf3, 0xd2, 0xf5, 0xf2, 0x8b, 0xd2, 0xf5, 0xd3, 0x53, 0xf3,
0xc0, 0xd6, 0xea, 0x43, 0xa4, 0x12, 0x0b, 0x32, 0x8b, 0xc1, 0x6e, 0x2a, 0x4e, 0x2d, 0x2a, 0xcb,
0x4c, 0x4e, 0x4d, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xb7, 0x46, 0xe1, 0x2d, 0x62, 0x62, 0x71, 0x77,
0x0c, 0xf0, 0x4c, 0x62, 0x03, 0x6b, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x44, 0x6e, 0x78,
0xbd, 0xcb, 0x00, 0x00, 0x00,
}

267
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/documentation.pb.go generated vendored Normal file
View File

@ -0,0 +1,267 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/documentation.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// `Documentation` provides the information for describing a service.
//
// Example:
// <pre><code>documentation:
// summary: >
// The Google Calendar API gives access
// to most calendar features.
// pages:
// - name: Overview
// content: &#40;== include google/foo/overview.md ==&#41;
// - name: Tutorial
// content: &#40;== include google/foo/tutorial.md ==&#41;
// subpages;
// - name: Java
// content: &#40;== include google/foo/tutorial_java.md ==&#41;
// rules:
// - selector: google.calendar.Calendar.Get
// description: >
// ...
// - selector: google.calendar.Calendar.Put
// description: >
// ...
// </code></pre>
// Documentation is provided in markdown syntax. In addition to
// standard markdown features, definition lists, tables and fenced
// code blocks are supported. Section headers can be provided and are
// interpreted relative to the section nesting of the context where
// a documentation fragment is embedded.
//
// Documentation from the IDL is merged with documentation defined
// via the config at normalization time, where documentation provided
// by config rules overrides IDL provided.
//
// A number of constructs specific to the API platform are supported
// in documentation text.
//
// In order to reference a proto element, the following
// notation can be used:
// <pre><code>&#91;fully.qualified.proto.name]&#91;]</code></pre>
// To override the display text used for the link, this can be used:
// <pre><code>&#91;display text]&#91;fully.qualified.proto.name]</code></pre>
// Text can be excluded from doc using the following notation:
// <pre><code>&#40;-- internal comment --&#41;</code></pre>
// Comments can be made conditional using a visibility label. The below
// text will be only rendered if the `BETA` label is available:
// <pre><code>&#40;--BETA: comment for BETA users --&#41;</code></pre>
// A few directives are available in documentation. Note that
// directives must appear on a single line to be properly
// identified. The `include` directive includes a markdown file from
// an external source:
// <pre><code>&#40;== include path/to/file ==&#41;</code></pre>
// The `resource_for` directive marks a message to be the resource of
// a collection in REST view. If it is not specified, tools attempt
// to infer the resource from the operations in a collection:
// <pre><code>&#40;== resource_for v1.shelves.books ==&#41;</code></pre>
// The directive `suppress_warning` does not directly affect documentation
// and is documented together with service config validation.
type Documentation struct {
// A short summary of what the service does. Can only be provided by
// plain text.
Summary string `protobuf:"bytes,1,opt,name=summary" json:"summary,omitempty"`
// The top level pages for the documentation set.
Pages []*Page `protobuf:"bytes,5,rep,name=pages" json:"pages,omitempty"`
// A list of documentation rules that apply to individual API elements.
//
// **NOTE:** All service configuration rules follow "last one wins" order.
Rules []*DocumentationRule `protobuf:"bytes,3,rep,name=rules" json:"rules,omitempty"`
// The URL to the root of documentation.
DocumentationRootUrl string `protobuf:"bytes,4,opt,name=documentation_root_url,json=documentationRootUrl" json:"documentation_root_url,omitempty"`
// Declares a single overview page. For example:
// <pre><code>documentation:
// summary: ...
// overview: &#40;== include overview.md ==&#41;
// </code></pre>
// This is a shortcut for the following declaration (using pages style):
// <pre><code>documentation:
// summary: ...
// pages:
// - name: Overview
// content: &#40;== include overview.md ==&#41;
// </code></pre>
// Note: you cannot specify both `overview` field and `pages` field.
Overview string `protobuf:"bytes,2,opt,name=overview" json:"overview,omitempty"`
}
func (m *Documentation) Reset() { *m = Documentation{} }
func (m *Documentation) String() string { return proto.CompactTextString(m) }
func (*Documentation) ProtoMessage() {}
func (*Documentation) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
func (m *Documentation) GetSummary() string {
if m != nil {
return m.Summary
}
return ""
}
func (m *Documentation) GetPages() []*Page {
if m != nil {
return m.Pages
}
return nil
}
func (m *Documentation) GetRules() []*DocumentationRule {
if m != nil {
return m.Rules
}
return nil
}
func (m *Documentation) GetDocumentationRootUrl() string {
if m != nil {
return m.DocumentationRootUrl
}
return ""
}
func (m *Documentation) GetOverview() string {
if m != nil {
return m.Overview
}
return ""
}
// A documentation rule provides information about individual API elements.
type DocumentationRule struct {
// The selector is a comma-separated list of patterns. Each pattern is a
// qualified name of the element which may end in "*", indicating a wildcard.
// Wildcards are only allowed at the end and for a whole component of the
// qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
// specify a default for all applicable elements, the whole pattern "*"
// is used.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// Description of the selected API(s).
Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"`
// Deprecation description of the selected element(s). It can be provided if an
// element is marked as `deprecated`.
DeprecationDescription string `protobuf:"bytes,3,opt,name=deprecation_description,json=deprecationDescription" json:"deprecation_description,omitempty"`
}
func (m *DocumentationRule) Reset() { *m = DocumentationRule{} }
func (m *DocumentationRule) String() string { return proto.CompactTextString(m) }
func (*DocumentationRule) ProtoMessage() {}
func (*DocumentationRule) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
func (m *DocumentationRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *DocumentationRule) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *DocumentationRule) GetDeprecationDescription() string {
if m != nil {
return m.DeprecationDescription
}
return ""
}
// Represents a documentation page. A page can contain subpages to represent
// nested documentation set structure.
type Page struct {
// The name of the page. It will be used as an identity of the page to
// generate URI of the page, text of the link to this page in navigation,
// etc. The full page name (start from the root page name to this page
// concatenated with `.`) can be used as reference to the page in your
// documentation. For example:
// <pre><code>pages:
// - name: Tutorial
// content: &#40;== include tutorial.md ==&#41;
// subpages:
// - name: Java
// content: &#40;== include tutorial_java.md ==&#41;
// </code></pre>
// You can reference `Java` page using Markdown reference link syntax:
// `[Java][Tutorial.Java]`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The Markdown content of the page. You can use <code>&#40;== include {path} ==&#41;</code>
// to include content from a Markdown file.
Content string `protobuf:"bytes,2,opt,name=content" json:"content,omitempty"`
// Subpages of this page. The order of subpages specified here will be
// honored in the generated docset.
Subpages []*Page `protobuf:"bytes,3,rep,name=subpages" json:"subpages,omitempty"`
}
func (m *Page) Reset() { *m = Page{} }
func (m *Page) String() string { return proto.CompactTextString(m) }
func (*Page) ProtoMessage() {}
func (*Page) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
func (m *Page) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Page) GetContent() string {
if m != nil {
return m.Content
}
return ""
}
func (m *Page) GetSubpages() []*Page {
if m != nil {
return m.Subpages
}
return nil
}
func init() {
proto.RegisterType((*Documentation)(nil), "google.api.Documentation")
proto.RegisterType((*DocumentationRule)(nil), "google.api.DocumentationRule")
proto.RegisterType((*Page)(nil), "google.api.Page")
}
func init() { proto.RegisterFile("google/api/documentation.proto", fileDescriptor6) }
var fileDescriptor6 = []byte{
// 356 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xc1, 0x6a, 0xe3, 0x30,
0x14, 0x45, 0x71, 0xec, 0xcc, 0x64, 0x5e, 0x98, 0x61, 0x46, 0x0c, 0x19, 0x33, 0xd0, 0x12, 0xb2,
0x28, 0x59, 0x14, 0x1b, 0x9a, 0x42, 0x17, 0x5d, 0x35, 0xa4, 0x94, 0xee, 0x8c, 0xa1, 0x9b, 0x6e,
0x82, 0xa2, 0xbc, 0x0a, 0x83, 0xad, 0x67, 0x24, 0x39, 0xa5, 0xbf, 0xd0, 0xcf, 0xe8, 0x57, 0xf5,
0x73, 0x8a, 0x65, 0x27, 0xb1, 0x29, 0xdd, 0xf9, 0xfa, 0x1e, 0xe9, 0x3e, 0x5d, 0x09, 0x4e, 0x25,
0x91, 0xcc, 0x31, 0xe6, 0x65, 0x16, 0x6f, 0x49, 0x54, 0x05, 0x2a, 0xcb, 0x6d, 0x46, 0x2a, 0x2a,
0x35, 0x59, 0x62, 0xd0, 0xf8, 0x11, 0x2f, 0xb3, 0xd9, 0xbb, 0x07, 0x3f, 0x57, 0x5d, 0x86, 0x85,
0xf0, 0xdd, 0x54, 0x45, 0xc1, 0xf5, 0x4b, 0xe8, 0x4d, 0xbd, 0xf9, 0x8f, 0x74, 0x2f, 0xd9, 0x19,
0x0c, 0x4b, 0x2e, 0xd1, 0x84, 0xc3, 0xa9, 0x3f, 0x1f, 0x5f, 0xfc, 0x8e, 0x8e, 0xfb, 0x44, 0x09,
0x97, 0x98, 0x36, 0x36, 0x5b, 0xc0, 0x50, 0x57, 0x39, 0x9a, 0xd0, 0x77, 0xdc, 0x49, 0x97, 0xeb,
0x65, 0xa5, 0x55, 0x8e, 0x69, 0xc3, 0xb2, 0x4b, 0x98, 0xf4, 0x66, 0x5d, 0x6b, 0x22, 0xbb, 0xae,
0x74, 0x1e, 0x06, 0x6e, 0x8a, 0xbf, 0x3d, 0x37, 0x25, 0xb2, 0x0f, 0x3a, 0x67, 0xff, 0x61, 0x44,
0x3b, 0xd4, 0xbb, 0x0c, 0x9f, 0xc3, 0x81, 0xe3, 0x0e, 0x7a, 0xf6, 0xea, 0xc1, 0x9f, 0x4f, 0x71,
0xf5, 0x0a, 0x83, 0x39, 0x0a, 0x4b, 0xba, 0x3d, 0xdf, 0x41, 0xb3, 0x29, 0x8c, 0xb7, 0x68, 0x84,
0xce, 0xca, 0x1a, 0x6f, 0x37, 0xec, 0xfe, 0x62, 0x57, 0xf0, 0x6f, 0x8b, 0xa5, 0x46, 0xd1, 0xcc,
0xd8, 0xa5, 0x7d, 0x47, 0x4f, 0x3a, 0xf6, 0xea, 0xe8, 0xce, 0x36, 0x10, 0xd4, 0x15, 0x31, 0x06,
0x81, 0xe2, 0x05, 0xb6, 0xd1, 0xee, 0xbb, 0x6e, 0x5c, 0x90, 0xb2, 0xa8, 0x6c, 0x1b, 0xb9, 0x97,
0xec, 0x1c, 0x46, 0xa6, 0xda, 0x34, 0xa5, 0xfb, 0x5f, 0x94, 0x7e, 0x20, 0x96, 0x16, 0x7e, 0x09,
0x2a, 0x3a, 0xc0, 0x92, 0xf5, 0xce, 0x9f, 0xd4, 0xb7, 0x9f, 0x78, 0x8f, 0xb7, 0x2d, 0x21, 0x29,
0xe7, 0x4a, 0x46, 0xa4, 0x65, 0x2c, 0x51, 0xb9, 0xb7, 0x11, 0x37, 0x16, 0x2f, 0x33, 0xe3, 0x9e,
0x8f, 0xa9, 0xbb, 0x14, 0x28, 0x48, 0x3d, 0x65, 0xf2, 0xba, 0xa7, 0xde, 0x06, 0xc1, 0xdd, 0x4d,
0x72, 0xbf, 0xf9, 0xe6, 0x16, 0x2e, 0x3e, 0x02, 0x00, 0x00, 0xff, 0xff, 0x3e, 0x04, 0x32, 0xbf,
0x76, 0x02, 0x00, 0x00,
}

130
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/endpoint.pb.go generated vendored Normal file
View File

@ -0,0 +1,130 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/endpoint.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// `Endpoint` describes a network endpoint that serves a set of APIs.
// A service may expose any number of endpoints, and all endpoints share the
// same service configuration, such as quota configuration and monitoring
// configuration.
//
// Example service configuration:
//
// name: library-example.googleapis.com
// endpoints:
// # Below entry makes 'google.example.library.v1.Library'
// # API be served from endpoint address library-example.googleapis.com.
// # It also allows HTTP OPTIONS calls to be passed to the backend, for
// # it to decide whether the subsequent cross-origin request is
// # allowed to proceed.
// - name: library-example.googleapis.com
// allow_cors: true
type Endpoint struct {
// The canonical name of this endpoint.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// DEPRECATED: This field is no longer supported. Instead of using aliases,
// please specify multiple [google.api.Endpoint][google.api.Endpoint] for each of the intented
// alias.
//
// Additional names that this endpoint will be hosted on.
Aliases []string `protobuf:"bytes,2,rep,name=aliases" json:"aliases,omitempty"`
// The list of APIs served by this endpoint.
Apis []string `protobuf:"bytes,3,rep,name=apis" json:"apis,omitempty"`
// The list of features enabled on this endpoint.
Features []string `protobuf:"bytes,4,rep,name=features" json:"features,omitempty"`
// The specification of an Internet routable address of API frontend that will
// handle requests to this [API Endpoint](https://cloud.google.com/apis/design/glossary).
// It should be either a valid IPv4 address or a fully-qualified domain name.
// For example, "8.8.8.8" or "myservice.appspot.com".
Target string `protobuf:"bytes,101,opt,name=target" json:"target,omitempty"`
// Allowing
// [CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing), aka
// cross-domain traffic, would allow the backends served from this endpoint to
// receive and respond to HTTP OPTIONS requests. The response will be used by
// the browser to determine whether the subsequent cross-origin request is
// allowed to proceed.
AllowCors bool `protobuf:"varint,5,opt,name=allow_cors,json=allowCors" json:"allow_cors,omitempty"`
}
func (m *Endpoint) Reset() { *m = Endpoint{} }
func (m *Endpoint) String() string { return proto.CompactTextString(m) }
func (*Endpoint) ProtoMessage() {}
func (*Endpoint) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
func (m *Endpoint) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Endpoint) GetAliases() []string {
if m != nil {
return m.Aliases
}
return nil
}
func (m *Endpoint) GetApis() []string {
if m != nil {
return m.Apis
}
return nil
}
func (m *Endpoint) GetFeatures() []string {
if m != nil {
return m.Features
}
return nil
}
func (m *Endpoint) GetTarget() string {
if m != nil {
return m.Target
}
return ""
}
func (m *Endpoint) GetAllowCors() bool {
if m != nil {
return m.AllowCors
}
return false
}
func init() {
proto.RegisterType((*Endpoint)(nil), "google.api.Endpoint")
}
func init() { proto.RegisterFile("google/api/endpoint.proto", fileDescriptor7) }
var fileDescriptor7 = []byte{
// 253 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0x41, 0x4b, 0xc4, 0x30,
0x10, 0x85, 0xe9, 0x6e, 0x5d, 0xdb, 0x01, 0x3d, 0xe4, 0x20, 0x71, 0x51, 0x28, 0x9e, 0x7a, 0x6a,
0x0f, 0x1e, 0x3d, 0xb9, 0xb2, 0x88, 0xb7, 0xd2, 0xa3, 0x17, 0x19, 0xeb, 0x6c, 0x08, 0x64, 0x33,
0x21, 0x89, 0xfa, 0x73, 0x04, 0x7f, 0xa9, 0x34, 0xed, 0xaa, 0x7b, 0x9b, 0xef, 0xbd, 0x37, 0x61,
0x5e, 0xe0, 0x52, 0x31, 0x2b, 0x43, 0x2d, 0x3a, 0xdd, 0x92, 0x7d, 0x73, 0xac, 0x6d, 0x6c, 0x9c,
0xe7, 0xc8, 0x02, 0x26, 0xab, 0x41, 0xa7, 0xd7, 0x57, 0xff, 0x62, 0x68, 0x2d, 0x47, 0x8c, 0x9a,
0x6d, 0x98, 0x92, 0x37, 0x5f, 0x19, 0x14, 0xdb, 0x79, 0x59, 0x08, 0xc8, 0x2d, 0xee, 0x49, 0x66,
0x55, 0x56, 0x97, 0x7d, 0x9a, 0x85, 0x84, 0x53, 0x34, 0x1a, 0x03, 0x05, 0xb9, 0xa8, 0x96, 0x75,
0xd9, 0x1f, 0x70, 0x4c, 0xa3, 0xd3, 0x41, 0x2e, 0x93, 0x9c, 0x66, 0xb1, 0x86, 0x62, 0x47, 0x18,
0xdf, 0x3d, 0x05, 0x99, 0x27, 0xfd, 0x97, 0xc5, 0x05, 0xac, 0x22, 0x7a, 0x45, 0x51, 0x52, 0x7a,
0x7f, 0x26, 0x71, 0x0d, 0x80, 0xc6, 0xf0, 0xe7, 0xcb, 0xc0, 0x3e, 0xc8, 0x93, 0x2a, 0xab, 0x8b,
0xbe, 0x4c, 0xca, 0x03, 0xfb, 0xb0, 0x61, 0x38, 0x1f, 0x78, 0xdf, 0xfc, 0x35, 0xda, 0x9c, 0x1d,
0x0e, 0xee, 0xc6, 0x0a, 0x5d, 0xf6, 0xbc, 0x9d, 0x4d, 0xc5, 0x06, 0xad, 0x6a, 0xd8, 0xab, 0x56,
0x91, 0x4d, 0x05, 0xdb, 0xc9, 0x1a, 0x8f, 0x4b, 0x3f, 0x10, 0xc8, 0x7f, 0xe8, 0x81, 0x06, 0xb6,
0x3b, 0xad, 0xee, 0x8e, 0xe8, 0x7b, 0x91, 0x3f, 0xde, 0x77, 0x4f, 0xaf, 0xab, 0xb4, 0x78, 0xfb,
0x13, 0x00, 0x00, 0xff, 0xff, 0x34, 0x0e, 0xdd, 0x70, 0x60, 0x01, 0x00, 0x00,
}

98
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/log.pb.go generated vendored Normal file
View File

@ -0,0 +1,98 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/log.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_api2 "google.golang.org/genproto/googleapis/api/label"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// A description of a log type. Example in YAML format:
//
// - name: library.googleapis.com/activity_history
// description: The history of borrowing and returning library items.
// display_name: Activity
// labels:
// - key: /customer_id
// description: Identifier of a library customer
type LogDescriptor struct {
// The name of the log. It must be less than 512 characters long and can
// include the following characters: upper- and lower-case alphanumeric
// characters [A-Za-z0-9], and punctuation characters including
// slash, underscore, hyphen, period [/_-.].
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The set of labels that are available to describe a specific log entry.
// Runtime requests that contain labels not specified here are
// considered invalid.
Labels []*google_api2.LabelDescriptor `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty"`
// A human-readable description of this log. This information appears in
// the documentation and can contain details.
Description string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
// The human-readable name for this log. This information appears on
// the user interface and should be concise.
DisplayName string `protobuf:"bytes,4,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
}
func (m *LogDescriptor) Reset() { *m = LogDescriptor{} }
func (m *LogDescriptor) String() string { return proto.CompactTextString(m) }
func (*LogDescriptor) ProtoMessage() {}
func (*LogDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
func (m *LogDescriptor) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *LogDescriptor) GetLabels() []*google_api2.LabelDescriptor {
if m != nil {
return m.Labels
}
return nil
}
func (m *LogDescriptor) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *LogDescriptor) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
func init() {
proto.RegisterType((*LogDescriptor)(nil), "google.api.LogDescriptor")
}
func init() { proto.RegisterFile("google/api/log.proto", fileDescriptor8) }
var fileDescriptor8 = []byte{
// 238 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x8f, 0xc1, 0x4a, 0xc3, 0x40,
0x10, 0x86, 0x49, 0x1b, 0x8a, 0x6e, 0xd5, 0xc3, 0x22, 0x12, 0xf4, 0x12, 0x3d, 0xf5, 0xb4, 0x01,
0x7b, 0xf4, 0x64, 0x51, 0x44, 0x08, 0x12, 0x7a, 0xf4, 0x22, 0xd3, 0x74, 0x1c, 0x46, 0x36, 0x3b,
0xcb, 0x6e, 0x11, 0x7c, 0x18, 0x2f, 0x3e, 0xa9, 0x74, 0x13, 0x68, 0x7a, 0xdb, 0xfd, 0xe6, 0x9b,
0x7f, 0x66, 0xd4, 0x25, 0x89, 0x90, 0xc5, 0x0a, 0x3c, 0x57, 0x56, 0xc8, 0xf8, 0x20, 0x3b, 0xd1,
0xaa, 0xa7, 0x06, 0x3c, 0x5f, 0x5f, 0x8d, 0x0d, 0xd8, 0xa0, 0xed, 0x9d, 0xbb, 0xdf, 0x4c, 0x9d,
0xd7, 0x42, 0x4f, 0x18, 0xdb, 0xc0, 0x7e, 0x27, 0x41, 0x6b, 0x95, 0x3b, 0xe8, 0xb0, 0xc8, 0xca,
0x6c, 0x71, 0xba, 0x4e, 0x6f, 0xbd, 0x54, 0xb3, 0xd4, 0x14, 0x8b, 0x49, 0x39, 0x5d, 0xcc, 0xef,
0x6f, 0xcc, 0x21, 0xda, 0xd4, 0xfb, 0xca, 0x21, 0x60, 0x3d, 0xa8, 0xba, 0x54, 0xf3, 0xed, 0x40,
0x59, 0x5c, 0x31, 0x4d, 0x79, 0x63, 0xa4, 0x6f, 0xd5, 0xd9, 0x96, 0xa3, 0xb7, 0xf0, 0xf3, 0x91,
0x46, 0xe6, 0x83, 0xd2, 0xb3, 0x37, 0xe8, 0x70, 0xf5, 0xa5, 0x2e, 0x5a, 0xe9, 0x46, 0xe3, 0x56,
0x27, 0xb5, 0x50, 0xb3, 0xdf, 0xbd, 0xc9, 0xde, 0x9f, 0x07, 0x4e, 0x62, 0xc1, 0x91, 0x91, 0x40,
0x15, 0xa1, 0x4b, 0x97, 0x55, 0x7d, 0x09, 0x3c, 0xc7, 0x74, 0x74, 0xc4, 0xf0, 0xcd, 0x2d, 0xb6,
0xe2, 0x3e, 0x99, 0x1e, 0x8e, 0x7e, 0x7f, 0x93, 0xfc, 0xe5, 0xb1, 0x79, 0xdd, 0xcc, 0x52, 0xe3,
0xf2, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x25, 0x6c, 0x32, 0xff, 0x4e, 0x01, 0x00, 0x00,
}

135
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/logging.pb.go generated vendored Normal file
View File

@ -0,0 +1,135 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/logging.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Logging configuration of the service.
//
// The following example shows how to configure logs to be sent to the
// producer and consumer projects. In the example, the `activity_history`
// log is sent to both the producer and consumer projects, whereas the
// `purchase_history` log is only sent to the producer project.
//
// monitored_resources:
// - type: library.googleapis.com/branch
// labels:
// - key: /city
// description: The city where the library branch is located in.
// - key: /name
// description: The name of the branch.
// logs:
// - name: activity_history
// labels:
// - key: /customer_id
// - name: purchase_history
// logging:
// producer_destinations:
// - monitored_resource: library.googleapis.com/branch
// logs:
// - activity_history
// - purchase_history
// consumer_destinations:
// - monitored_resource: library.googleapis.com/branch
// logs:
// - activity_history
type Logging struct {
// Logging configurations for sending logs to the producer project.
// There can be multiple producer destinations, each one must have a
// different monitored resource type. A log can be used in at most
// one producer destination.
ProducerDestinations []*Logging_LoggingDestination `protobuf:"bytes,1,rep,name=producer_destinations,json=producerDestinations" json:"producer_destinations,omitempty"`
// Logging configurations for sending logs to the consumer project.
// There can be multiple consumer destinations, each one must have a
// different monitored resource type. A log can be used in at most
// one consumer destination.
ConsumerDestinations []*Logging_LoggingDestination `protobuf:"bytes,2,rep,name=consumer_destinations,json=consumerDestinations" json:"consumer_destinations,omitempty"`
}
func (m *Logging) Reset() { *m = Logging{} }
func (m *Logging) String() string { return proto.CompactTextString(m) }
func (*Logging) ProtoMessage() {}
func (*Logging) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
func (m *Logging) GetProducerDestinations() []*Logging_LoggingDestination {
if m != nil {
return m.ProducerDestinations
}
return nil
}
func (m *Logging) GetConsumerDestinations() []*Logging_LoggingDestination {
if m != nil {
return m.ConsumerDestinations
}
return nil
}
// Configuration of a specific logging destination (the producer project
// or the consumer project).
type Logging_LoggingDestination struct {
// The monitored resource type. The type must be defined in the
// [Service.monitored_resources][google.api.Service.monitored_resources] section.
MonitoredResource string `protobuf:"bytes,3,opt,name=monitored_resource,json=monitoredResource" json:"monitored_resource,omitempty"`
// Names of the logs to be sent to this destination. Each name must
// be defined in the [Service.logs][google.api.Service.logs] section. If the log name is
// not a domain scoped name, it will be automatically prefixed with
// the service name followed by "/".
Logs []string `protobuf:"bytes,1,rep,name=logs" json:"logs,omitempty"`
}
func (m *Logging_LoggingDestination) Reset() { *m = Logging_LoggingDestination{} }
func (m *Logging_LoggingDestination) String() string { return proto.CompactTextString(m) }
func (*Logging_LoggingDestination) ProtoMessage() {}
func (*Logging_LoggingDestination) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0, 0} }
func (m *Logging_LoggingDestination) GetMonitoredResource() string {
if m != nil {
return m.MonitoredResource
}
return ""
}
func (m *Logging_LoggingDestination) GetLogs() []string {
if m != nil {
return m.Logs
}
return nil
}
func init() {
proto.RegisterType((*Logging)(nil), "google.api.Logging")
proto.RegisterType((*Logging_LoggingDestination)(nil), "google.api.Logging.LoggingDestination")
}
func init() { proto.RegisterFile("google/api/logging.proto", fileDescriptor9) }
var fileDescriptor9 = []byte{
// 270 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x90, 0x4f, 0x4b, 0xc4, 0x30,
0x10, 0xc5, 0x69, 0x77, 0x51, 0x36, 0x8a, 0x60, 0x50, 0x28, 0x8b, 0x87, 0xc5, 0x83, 0xec, 0xc5,
0x14, 0xf4, 0xe8, 0xc9, 0x45, 0x11, 0xc1, 0x43, 0xe9, 0x45, 0xd0, 0xc3, 0x12, 0xd3, 0x38, 0x04,
0xda, 0x99, 0x90, 0xa4, 0x7e, 0x1a, 0x4f, 0x7e, 0x52, 0xd9, 0xa6, 0x75, 0xab, 0x9e, 0xf6, 0x94,
0x3f, 0xef, 0xbd, 0x5f, 0x32, 0x8f, 0x65, 0x40, 0x04, 0xb5, 0xce, 0xa5, 0x35, 0x79, 0x4d, 0x00,
0x06, 0x41, 0x58, 0x47, 0x81, 0x38, 0x8b, 0x8a, 0x90, 0xd6, 0xcc, 0xcf, 0x46, 0x2e, 0x89, 0x48,
0x41, 0x06, 0x43, 0xe8, 0xa3, 0xf3, 0xfc, 0x33, 0x65, 0xfb, 0x4f, 0x31, 0xcb, 0x5f, 0xd9, 0xa9,
0x75, 0x54, 0xb5, 0x4a, 0xbb, 0x75, 0xa5, 0x7d, 0x30, 0x18, 0xad, 0x59, 0xb2, 0x98, 0x2c, 0x0f,
0xae, 0x2e, 0xc4, 0x96, 0x2a, 0xfa, 0xcc, 0xb0, 0xde, 0x6d, 0xed, 0xe5, 0xc9, 0x00, 0x19, 0x5d,
0xfa, 0x0d, 0x5c, 0x11, 0xfa, 0xb6, 0xf9, 0x0b, 0x4f, 0x77, 0x83, 0x0f, 0x90, 0x31, 0x7c, 0xfe,
0xcc, 0xf8, 0x7f, 0x2f, 0xbf, 0x64, 0xbc, 0x21, 0x34, 0x81, 0x9c, 0xae, 0xd6, 0x4e, 0x7b, 0x6a,
0x9d, 0xd2, 0xd9, 0x64, 0x91, 0x2c, 0x67, 0xe5, 0xf1, 0x8f, 0x52, 0xf6, 0x02, 0xe7, 0x6c, 0x5a,
0x13, 0xc4, 0x69, 0x67, 0x65, 0xb7, 0x5f, 0x21, 0x3b, 0x52, 0xd4, 0x8c, 0xfe, 0xb6, 0x3a, 0xec,
0x1f, 0x2a, 0x36, 0xf5, 0x15, 0xc9, 0xcb, 0x7d, 0xaf, 0x01, 0xd5, 0x12, 0x41, 0x90, 0x83, 0x1c,
0x34, 0x76, 0xe5, 0xe6, 0x51, 0x92, 0xd6, 0xf8, 0xae, 0x7d, 0xaf, 0xdd, 0x87, 0x51, 0x5a, 0x11,
0xbe, 0x1b, 0xb8, 0xf9, 0x75, 0xfa, 0x4a, 0xa7, 0x0f, 0xb7, 0xc5, 0xe3, 0xdb, 0x5e, 0x17, 0xbc,
0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x73, 0x4f, 0x86, 0x6e, 0xdb, 0x01, 0x00, 0x00,
}

143
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/monitoring.pb.go generated vendored Normal file
View File

@ -0,0 +1,143 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/monitoring.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Monitoring configuration of the service.
//
// The example below shows how to configure monitored resources and metrics
// for monitoring. In the example, a monitored resource and two metrics are
// defined. The `library.googleapis.com/book/returned_count` metric is sent
// to both producer and consumer projects, whereas the
// `library.googleapis.com/book/overdue_count` metric is only sent to the
// consumer project.
//
// monitored_resources:
// - type: library.googleapis.com/branch
// labels:
// - key: /city
// description: The city where the library branch is located in.
// - key: /name
// description: The name of the branch.
// metrics:
// - name: library.googleapis.com/book/returned_count
// metric_kind: DELTA
// value_type: INT64
// labels:
// - key: /customer_id
// - name: library.googleapis.com/book/overdue_count
// metric_kind: GAUGE
// value_type: INT64
// labels:
// - key: /customer_id
// monitoring:
// producer_destinations:
// - monitored_resource: library.googleapis.com/branch
// metrics:
// - library.googleapis.com/book/returned_count
// consumer_destinations:
// - monitored_resource: library.googleapis.com/branch
// metrics:
// - library.googleapis.com/book/returned_count
// - library.googleapis.com/book/overdue_count
type Monitoring struct {
// Monitoring configurations for sending metrics to the producer project.
// There can be multiple producer destinations, each one must have a
// different monitored resource type. A metric can be used in at most
// one producer destination.
ProducerDestinations []*Monitoring_MonitoringDestination `protobuf:"bytes,1,rep,name=producer_destinations,json=producerDestinations" json:"producer_destinations,omitempty"`
// Monitoring configurations for sending metrics to the consumer project.
// There can be multiple consumer destinations, each one must have a
// different monitored resource type. A metric can be used in at most
// one consumer destination.
ConsumerDestinations []*Monitoring_MonitoringDestination `protobuf:"bytes,2,rep,name=consumer_destinations,json=consumerDestinations" json:"consumer_destinations,omitempty"`
}
func (m *Monitoring) Reset() { *m = Monitoring{} }
func (m *Monitoring) String() string { return proto.CompactTextString(m) }
func (*Monitoring) ProtoMessage() {}
func (*Monitoring) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{0} }
func (m *Monitoring) GetProducerDestinations() []*Monitoring_MonitoringDestination {
if m != nil {
return m.ProducerDestinations
}
return nil
}
func (m *Monitoring) GetConsumerDestinations() []*Monitoring_MonitoringDestination {
if m != nil {
return m.ConsumerDestinations
}
return nil
}
// Configuration of a specific monitoring destination (the producer project
// or the consumer project).
type Monitoring_MonitoringDestination struct {
// The monitored resource type. The type must be defined in
// [Service.monitored_resources][google.api.Service.monitored_resources] section.
MonitoredResource string `protobuf:"bytes,1,opt,name=monitored_resource,json=monitoredResource" json:"monitored_resource,omitempty"`
// Names of the metrics to report to this monitoring destination.
// Each name must be defined in [Service.metrics][google.api.Service.metrics] section.
Metrics []string `protobuf:"bytes,2,rep,name=metrics" json:"metrics,omitempty"`
}
func (m *Monitoring_MonitoringDestination) Reset() { *m = Monitoring_MonitoringDestination{} }
func (m *Monitoring_MonitoringDestination) String() string { return proto.CompactTextString(m) }
func (*Monitoring_MonitoringDestination) ProtoMessage() {}
func (*Monitoring_MonitoringDestination) Descriptor() ([]byte, []int) {
return fileDescriptor10, []int{0, 0}
}
func (m *Monitoring_MonitoringDestination) GetMonitoredResource() string {
if m != nil {
return m.MonitoredResource
}
return ""
}
func (m *Monitoring_MonitoringDestination) GetMetrics() []string {
if m != nil {
return m.Metrics
}
return nil
}
func init() {
proto.RegisterType((*Monitoring)(nil), "google.api.Monitoring")
proto.RegisterType((*Monitoring_MonitoringDestination)(nil), "google.api.Monitoring.MonitoringDestination")
}
func init() { proto.RegisterFile("google/api/monitoring.proto", fileDescriptor10) }
var fileDescriptor10 = []byte{
// 271 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x51, 0xcd, 0x4a, 0xc4, 0x30,
0x10, 0xa6, 0x55, 0x94, 0x8d, 0xa0, 0x58, 0x5c, 0x28, 0xab, 0x87, 0xc5, 0xd3, 0x1e, 0xb4, 0x05,
0x3d, 0x7a, 0x72, 0x51, 0xc4, 0x83, 0x50, 0x7a, 0xf4, 0xb2, 0xc6, 0x74, 0x0c, 0x03, 0xdb, 0x99,
0x9a, 0xa4, 0x3e, 0x90, 0xcf, 0xe0, 0x03, 0xca, 0x36, 0xed, 0x36, 0x8a, 0x27, 0x6f, 0x99, 0x7c,
0x7f, 0xc3, 0x37, 0xe2, 0x54, 0x33, 0xeb, 0x35, 0xe4, 0xb2, 0xc1, 0xbc, 0x66, 0x42, 0xc7, 0x06,
0x49, 0x67, 0x8d, 0x61, 0xc7, 0x89, 0xf0, 0x60, 0x26, 0x1b, 0x9c, 0x9d, 0x05, 0x44, 0x49, 0xc4,
0x4e, 0x3a, 0x64, 0xb2, 0x9e, 0x79, 0xfe, 0x15, 0x0b, 0xf1, 0xb4, 0x95, 0x27, 0x52, 0x4c, 0x1b,
0xc3, 0x55, 0xab, 0xc0, 0xac, 0x2a, 0xb0, 0x0e, 0xc9, 0xb3, 0xd3, 0x68, 0xbe, 0xb3, 0x38, 0xb8,
0xba, 0xc8, 0x46, 0xe3, 0x6c, 0x94, 0x05, 0xcf, 0xbb, 0x51, 0x54, 0x9e, 0x0c, 0x56, 0xc1, 0xa7,
0xdd, 0x44, 0x28, 0x26, 0xdb, 0xd6, 0xbf, 0x23, 0xe2, 0xff, 0x44, 0x0c, 0x56, 0x61, 0xc4, 0xec,
0x45, 0x4c, 0xff, 0xa4, 0x27, 0x97, 0x22, 0xe9, 0xbb, 0x82, 0x6a, 0x65, 0xc0, 0x72, 0x6b, 0x14,
0xa4, 0xd1, 0x3c, 0x5a, 0x4c, 0xca, 0xe3, 0x2d, 0x52, 0xf6, 0x40, 0x92, 0x8a, 0xfd, 0x1a, 0x9c,
0x41, 0xe5, 0x97, 0x9b, 0x94, 0xc3, 0xb8, 0x7c, 0x17, 0x87, 0x8a, 0xeb, 0x60, 0xd5, 0xe5, 0xd1,
0x98, 0x58, 0x6c, 0x9a, 0x2d, 0xa2, 0xe7, 0xfb, 0x1e, 0xd6, 0xbc, 0x96, 0xa4, 0x33, 0x36, 0x3a,
0xd7, 0x40, 0x5d, 0xef, 0xb9, 0x87, 0x64, 0x83, 0xb6, 0x3b, 0x8c, 0x05, 0xf3, 0x81, 0x0a, 0x14,
0xd3, 0x1b, 0xea, 0x9b, 0x1f, 0xd3, 0x67, 0xbc, 0xfb, 0x70, 0x5b, 0x3c, 0xbe, 0xee, 0x75, 0xc2,
0xeb, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x51, 0x35, 0xf3, 0xe2, 0xf9, 0x01, 0x00, 0x00,
}

391
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/quota.pb.go generated vendored Normal file
View File

@ -0,0 +1,391 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/quota.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Quota configuration helps to achieve fairness and budgeting in service
// usage.
//
// The quota configuration works this way:
// - The service configuration defines a set of metrics.
// - For API calls, the quota.metric_rules maps methods to metrics with
// corresponding costs.
// - The quota.limits defines limits on the metrics, which will be used for
// quota checks at runtime.
//
// An example quota configuration in yaml format:
//
// quota:
// limits:
//
// - name: apiWriteQpsPerProject
// metric: library.googleapis.com/write_calls
// unit: "1/min/{project}" # rate limit for consumer projects
// values:
// STANDARD: 10000
//
// # The metric rules bind all methods to the read_calls metric,
// # except for the UpdateBook and DeleteBook methods. These two methods
// # are mapped to the write_calls metric, with the UpdateBook method
// # consuming at twice rate as the DeleteBook method.
// metric_rules:
// - selector: "*"
// metric_costs:
// library.googleapis.com/read_calls: 1
// - selector: google.example.library.v1.LibraryService.UpdateBook
// metric_costs:
// library.googleapis.com/write_calls: 2
// - selector: google.example.library.v1.LibraryService.DeleteBook
// metric_costs:
// library.googleapis.com/write_calls: 1
//
// Corresponding Metric definition:
//
// metrics:
// - name: library.googleapis.com/read_calls
// display_name: Read requests
// metric_kind: DELTA
// value_type: INT64
//
// - name: library.googleapis.com/write_calls
// display_name: Write requests
// metric_kind: DELTA
// value_type: INT64
//
type Quota struct {
// List of `QuotaLimit` definitions for the service.
//
// Used by metric-based quotas only.
Limits []*QuotaLimit `protobuf:"bytes,3,rep,name=limits" json:"limits,omitempty"`
// List of `MetricRule` definitions, each one mapping a selected method to one
// or more metrics.
//
// Used by metric-based quotas only.
MetricRules []*MetricRule `protobuf:"bytes,4,rep,name=metric_rules,json=metricRules" json:"metric_rules,omitempty"`
}
func (m *Quota) Reset() { *m = Quota{} }
func (m *Quota) String() string { return proto.CompactTextString(m) }
func (*Quota) ProtoMessage() {}
func (*Quota) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{0} }
func (m *Quota) GetLimits() []*QuotaLimit {
if m != nil {
return m.Limits
}
return nil
}
func (m *Quota) GetMetricRules() []*MetricRule {
if m != nil {
return m.MetricRules
}
return nil
}
// Bind API methods to metrics. Binding a method to a metric causes that
// metric's configured quota, billing, and monitoring behaviors to apply to the
// method call.
//
// Used by metric-based quotas only.
type MetricRule struct {
// Selects the methods to which this rule applies.
//
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// Metrics to update when the selected methods are called, and the associated
// cost applied to each metric.
//
// The key of the map is the metric name, and the values are the amount
// increased for the metric against which the quota limits are defined.
// The value must not be negative.
MetricCosts map[string]int64 `protobuf:"bytes,2,rep,name=metric_costs,json=metricCosts" json:"metric_costs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
}
func (m *MetricRule) Reset() { *m = MetricRule{} }
func (m *MetricRule) String() string { return proto.CompactTextString(m) }
func (*MetricRule) ProtoMessage() {}
func (*MetricRule) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
func (m *MetricRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *MetricRule) GetMetricCosts() map[string]int64 {
if m != nil {
return m.MetricCosts
}
return nil
}
// `QuotaLimit` defines a specific limit that applies over a specified duration
// for a limit type. There can be at most one limit for a duration and limit
// type combination defined within a `QuotaGroup`.
type QuotaLimit struct {
// Name of the quota limit. The name is used to refer to the limit when
// overriding the default limit on per-consumer basis.
//
// For group-based quota limits, the name must be unique within the quota
// group. If a name is not provided, it will be generated from the limit_by
// and duration fields.
//
// For metric-based quota limits, the name must be provided, and it must be
// unique within the service. The name can only include alphanumeric
// characters as well as '-'.
//
// The maximum length of the limit name is 64 characters.
//
// The name of a limit is used as a unique identifier for this limit.
// Therefore, once a limit has been put into use, its name should be
// immutable. You can use the display_name field to provide a user-friendly
// name for the limit. The display name can be evolved over time without
// affecting the identity of the limit.
Name string `protobuf:"bytes,6,opt,name=name" json:"name,omitempty"`
// Optional. User-visible, extended description for this quota limit.
// Should be used only when more context is needed to understand this limit
// than provided by the limit's display name (see: `display_name`).
Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"`
// Default number of tokens that can be consumed during the specified
// duration. This is the number of tokens assigned when a client
// application developer activates the service for his/her project.
//
// Specifying a value of 0 will block all requests. This can be used if you
// are provisioning quota to selected consumers and blocking others.
// Similarly, a value of -1 will indicate an unlimited quota. No other
// negative values are allowed.
//
// Used by group-based quotas only.
DefaultLimit int64 `protobuf:"varint,3,opt,name=default_limit,json=defaultLimit" json:"default_limit,omitempty"`
// Maximum number of tokens that can be consumed during the specified
// duration. Client application developers can override the default limit up
// to this maximum. If specified, this value cannot be set to a value less
// than the default limit. If not specified, it is set to the default limit.
//
// To allow clients to apply overrides with no upper bound, set this to -1,
// indicating unlimited maximum quota.
//
// Used by group-based quotas only.
MaxLimit int64 `protobuf:"varint,4,opt,name=max_limit,json=maxLimit" json:"max_limit,omitempty"`
// Free tier value displayed in the Developers Console for this limit.
// The free tier is the number of tokens that will be subtracted from the
// billed amount when billing is enabled.
// This field can only be set on a limit with duration "1d", in a billable
// group; it is invalid on any other limit. If this field is not set, it
// defaults to 0, indicating that there is no free tier for this service.
//
// Used by group-based quotas only.
FreeTier int64 `protobuf:"varint,7,opt,name=free_tier,json=freeTier" json:"free_tier,omitempty"`
// Duration of this limit in textual notation. Example: "100s", "24h", "1d".
// For duration longer than a day, only multiple of days is supported. We
// support only "100s" and "1d" for now. Additional support will be added in
// the future. "0" indicates indefinite duration.
//
// Used by group-based quotas only.
Duration string `protobuf:"bytes,5,opt,name=duration" json:"duration,omitempty"`
// The name of the metric this quota limit applies to. The quota limits with
// the same metric will be checked together during runtime. The metric must be
// defined within the service config.
//
// Used by metric-based quotas only.
Metric string `protobuf:"bytes,8,opt,name=metric" json:"metric,omitempty"`
// Specify the unit of the quota limit. It uses the same syntax as
// [Metric.unit][]. The supported unit kinds are determined by the quota
// backend system.
//
// The [Google Service Control](https://cloud.google.com/service-control)
// supports the following unit components:
// * One of the time intevals:
// * "/min" for quota every minute.
// * "/d" for quota every 24 hours, starting 00:00 US Pacific Time.
// * Otherwise the quota won't be reset by time, such as storage limit.
// * One and only one of the granted containers:
// * "/{organization}" quota for an organization.
// * "/{project}" quota for a project.
// * "/{folder}" quota for a folder.
// * "/{resource}" quota for a universal resource.
// * Zero or more quota segmentation dimension. Not all combos are valid.
// * "/{region}" quota for every region. Not to be used with time intervals.
// * Otherwise the resources granted on the target is not segmented.
// * "/{zone}" quota for every zone. Not to be used with time intervals.
// * Otherwise the resources granted on the target is not segmented.
// * "/{resource}" quota for a resource associated with a project or org.
//
// Here are some examples:
// * "1/min/{project}" for quota per minute per project.
// * "1/min/{user}" for quota per minute per user.
// * "1/min/{organization}" for quota per minute per organization.
//
// Note: the order of unit components is insignificant.
// The "1" at the beginning is required to follow the metric unit syntax.
//
// Used by metric-based quotas only.
Unit string `protobuf:"bytes,9,opt,name=unit" json:"unit,omitempty"`
// Tiered limit values. Also allows for regional or zone overrides for these
// values if "/{region}" or "/{zone}" is specified in the unit field.
//
// Currently supported tiers from low to high:
// VERY_LOW, LOW, STANDARD, HIGH, VERY_HIGH
//
// To apply different limit values for users according to their tiers, specify
// the values for the tiers you want to differentiate. For example:
// {LOW:100, STANDARD:500, HIGH:1000, VERY_HIGH:5000}
//
// The limit value for each tier is optional except for the tier STANDARD.
// The limit value for an unspecified tier falls to the value of its next
// tier towards tier STANDARD. For the above example, the limit value for tier
// STANDARD is 500.
//
// To apply the same limit value for all users, just specify limit value for
// tier STANDARD. For example: {STANDARD:500}.
//
// To apply a regional overide for a tier, add a map entry with key
// "<TIER>/<region>", where <region> is a region name. Similarly, for a zone
// override, add a map entry with key "<TIER>/{zone}".
// Further, a wildcard can be used at the end of a zone name in order to
// specify zone level overrides. For example:
// LOW: 10, STANDARD: 50, HIGH: 100,
// LOW/us-central1: 20, STANDARD/us-central1: 60, HIGH/us-central1: 200,
// LOW/us-central1-*: 10, STANDARD/us-central1-*: 20, HIGH/us-central1-*: 80
//
// The regional overrides tier set for each region must be the same as
// the tier set for default limit values. Same rule applies for zone overrides
// tier as well.
//
// Used by metric-based quotas only.
Values map[string]int64 `protobuf:"bytes,10,rep,name=values" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
// User-visible display name for this limit.
// Optional. If not set, the UI will provide a default display name based on
// the quota configuration. This field can be used to override the default
// display name generated from the configuration.
DisplayName string `protobuf:"bytes,12,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
}
func (m *QuotaLimit) Reset() { *m = QuotaLimit{} }
func (m *QuotaLimit) String() string { return proto.CompactTextString(m) }
func (*QuotaLimit) ProtoMessage() {}
func (*QuotaLimit) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{2} }
func (m *QuotaLimit) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *QuotaLimit) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *QuotaLimit) GetDefaultLimit() int64 {
if m != nil {
return m.DefaultLimit
}
return 0
}
func (m *QuotaLimit) GetMaxLimit() int64 {
if m != nil {
return m.MaxLimit
}
return 0
}
func (m *QuotaLimit) GetFreeTier() int64 {
if m != nil {
return m.FreeTier
}
return 0
}
func (m *QuotaLimit) GetDuration() string {
if m != nil {
return m.Duration
}
return ""
}
func (m *QuotaLimit) GetMetric() string {
if m != nil {
return m.Metric
}
return ""
}
func (m *QuotaLimit) GetUnit() string {
if m != nil {
return m.Unit
}
return ""
}
func (m *QuotaLimit) GetValues() map[string]int64 {
if m != nil {
return m.Values
}
return nil
}
func (m *QuotaLimit) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
func init() {
proto.RegisterType((*Quota)(nil), "google.api.Quota")
proto.RegisterType((*MetricRule)(nil), "google.api.MetricRule")
proto.RegisterType((*QuotaLimit)(nil), "google.api.QuotaLimit")
}
func init() { proto.RegisterFile("google/api/quota.proto", fileDescriptor11) }
var fileDescriptor11 = []byte{
// 466 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xc1, 0x8e, 0xd3, 0x30,
0x10, 0x55, 0x9a, 0xb6, 0xb4, 0xd3, 0x82, 0x56, 0x16, 0xaa, 0xac, 0xc2, 0xa1, 0x94, 0x03, 0x3d,
0xa5, 0x12, 0x5c, 0xd8, 0x45, 0x42, 0x62, 0xd1, 0x0a, 0x81, 0x00, 0x95, 0x08, 0x71, 0xe0, 0x52,
0x99, 0x74, 0x1a, 0x59, 0x38, 0x71, 0xb0, 0x9d, 0xd5, 0xf6, 0xcc, 0x9f, 0xf0, 0x0d, 0x7c, 0x20,
0xf2, 0xd8, 0xdb, 0x16, 0xd8, 0xcb, 0xde, 0x66, 0xe6, 0xbd, 0xe7, 0x17, 0x3f, 0x4f, 0x60, 0x52,
0x6a, 0x5d, 0x2a, 0x5c, 0x8a, 0x46, 0x2e, 0x7f, 0xb4, 0xda, 0x89, 0xac, 0x31, 0xda, 0x69, 0x06,
0x61, 0x9e, 0x89, 0x46, 0x4e, 0x1f, 0x1e, 0x71, 0x44, 0x5d, 0x6b, 0x27, 0x9c, 0xd4, 0xb5, 0x0d,
0xcc, 0xb9, 0x81, 0xde, 0x27, 0x2f, 0x64, 0x19, 0xf4, 0x95, 0xac, 0xa4, 0xb3, 0x3c, 0x9d, 0xa5,
0x8b, 0xd1, 0xd3, 0x49, 0x76, 0x38, 0x23, 0x23, 0xca, 0x7b, 0x0f, 0xe7, 0x91, 0xc5, 0x4e, 0x61,
0x5c, 0xa1, 0x33, 0xb2, 0x58, 0x9b, 0x56, 0xa1, 0xe5, 0xdd, 0xff, 0x55, 0x1f, 0x08, 0xcf, 0x5b,
0x85, 0xf9, 0xa8, 0xda, 0xd7, 0x76, 0xfe, 0x3b, 0x01, 0x38, 0x60, 0x6c, 0x0a, 0x03, 0x8b, 0x0a,
0x0b, 0xa7, 0x0d, 0x4f, 0x66, 0xc9, 0x62, 0x98, 0xef, 0x7b, 0xf6, 0x6e, 0xef, 0x52, 0x68, 0xeb,
0x2c, 0xef, 0x90, 0xcb, 0x93, 0x9b, 0x5d, 0x62, 0xf9, 0xda, 0x33, 0x2f, 0x6a, 0x67, 0x76, 0xd7,
0xb6, 0x34, 0x99, 0xbe, 0x84, 0x93, 0x7f, 0x09, 0xec, 0x04, 0xd2, 0xef, 0xb8, 0x8b, 0xb6, 0xbe,
0x64, 0xf7, 0xa1, 0x77, 0x29, 0x54, 0x8b, 0xbc, 0x33, 0x4b, 0x16, 0x69, 0x1e, 0x9a, 0xb3, 0xce,
0xf3, 0x64, 0xfe, 0x33, 0x05, 0x38, 0x04, 0xc1, 0x18, 0x74, 0x6b, 0x51, 0x21, 0xef, 0x93, 0x96,
0x6a, 0x36, 0x83, 0xd1, 0x06, 0x6d, 0x61, 0x64, 0xe3, 0x33, 0xa6, 0x23, 0x86, 0xf9, 0xf1, 0x88,
0x3d, 0x86, 0xbb, 0x1b, 0xdc, 0x8a, 0x56, 0xb9, 0x35, 0x05, 0xc9, 0x53, 0xb2, 0x19, 0xc7, 0x61,
0x38, 0xfa, 0x01, 0x0c, 0x2b, 0x71, 0x15, 0x09, 0x5d, 0x22, 0x0c, 0x2a, 0x71, 0xb5, 0x07, 0xb7,
0x06, 0x71, 0xed, 0x24, 0x1a, 0x7e, 0x27, 0x80, 0x7e, 0xf0, 0x59, 0xa2, 0xf1, 0x59, 0x6e, 0x5a,
0x43, 0x2f, 0xcc, 0x7b, 0x21, 0xcb, 0xeb, 0x9e, 0x4d, 0xa0, 0x1f, 0xe2, 0xe0, 0x03, 0x42, 0x62,
0xe7, 0x2f, 0xd2, 0xd6, 0xd2, 0xf1, 0x61, 0xb8, 0x88, 0xaf, 0xd9, 0x19, 0xf4, 0xe9, 0xe2, 0x96,
0x03, 0x25, 0x3e, 0xbf, 0x79, 0x1b, 0xb2, 0x2f, 0x44, 0x0a, 0x61, 0x47, 0x05, 0x7b, 0x04, 0xe3,
0x8d, 0xb4, 0x8d, 0x12, 0xbb, 0x35, 0x05, 0x34, 0x8e, 0x29, 0x84, 0xd9, 0x47, 0x51, 0xe1, 0xf4,
0x14, 0x46, 0x47, 0xca, 0xdb, 0xbc, 0xc2, 0xb9, 0x82, 0x7b, 0x85, 0xae, 0x8e, 0x3e, 0xe7, 0x3c,
0x3c, 0xca, 0xca, 0xaf, 0xf3, 0x2a, 0xf9, 0x7a, 0x11, 0x91, 0x52, 0x2b, 0x51, 0x97, 0x99, 0x36,
0xe5, 0xb2, 0xc4, 0x9a, 0x96, 0x7d, 0x19, 0x20, 0xd1, 0x48, 0x4b, 0x7f, 0x83, 0x45, 0x73, 0x29,
0x0b, 0x2c, 0x74, 0xbd, 0x95, 0xe5, 0x8b, 0xbf, 0xba, 0x5f, 0x9d, 0xee, 0x9b, 0x57, 0xab, 0xb7,
0xdf, 0xfa, 0x24, 0x7c, 0xf6, 0x27, 0x00, 0x00, 0xff, 0xff, 0x90, 0x7e, 0xf5, 0xab, 0x69, 0x03,
0x00, 0x00,
}

376
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/service.pb.go generated vendored Normal file
View File

@ -0,0 +1,376 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/service.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_api5 "google.golang.org/genproto/googleapis/api"
import google_api "google.golang.org/genproto/googleapis/api/annotations"
import _ "google.golang.org/genproto/googleapis/api/label"
import google_api3 "google.golang.org/genproto/googleapis/api/metric"
import google_api6 "google.golang.org/genproto/googleapis/api/monitoredres"
import _ "github.com/golang/protobuf/ptypes/any"
import google_protobuf4 "google.golang.org/genproto/protobuf/api"
import google_protobuf3 "google.golang.org/genproto/protobuf/ptype"
import google_protobuf5 "github.com/golang/protobuf/ptypes/wrappers"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// `Service` is the root object of Google service configuration schema. It
// describes basic information about a service, such as the name and the
// title, and delegates other aspects to sub-sections. Each sub-section is
// either a proto message or a repeated proto message that configures a
// specific aspect, such as auth. See each proto message definition for details.
//
// Example:
//
// type: google.api.Service
// config_version: 3
// name: calendar.googleapis.com
// title: Google Calendar API
// apis:
// - name: google.calendar.v3.Calendar
// authentication:
// providers:
// - id: google_calendar_auth
// jwks_uri: https://www.googleapis.com/oauth2/v1/certs
// issuer: https://securetoken.google.com
// rules:
// - selector: "*"
// requirements:
// provider_id: google_calendar_auth
type Service struct {
// The semantic version of the service configuration. The config version
// affects the interpretation of the service configuration. For example,
// certain features are enabled by default for certain config versions.
// The latest config version is `3`.
ConfigVersion *google_protobuf5.UInt32Value `protobuf:"bytes,20,opt,name=config_version,json=configVersion" json:"config_version,omitempty"`
// The DNS address at which this service is available,
// e.g. `calendar.googleapis.com`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// A unique ID for a specific instance of this message, typically assigned
// by the client for tracking purpose. If empty, the server may choose to
// generate one instead.
Id string `protobuf:"bytes,33,opt,name=id" json:"id,omitempty"`
// The product title for this service.
Title string `protobuf:"bytes,2,opt,name=title" json:"title,omitempty"`
// The Google project that owns this service.
ProducerProjectId string `protobuf:"bytes,22,opt,name=producer_project_id,json=producerProjectId" json:"producer_project_id,omitempty"`
// A list of API interfaces exported by this service. Only the `name` field
// of the [google.protobuf.Api][google.protobuf.Api] needs to be provided by the configuration
// author, as the remaining fields will be derived from the IDL during the
// normalization process. It is an error to specify an API interface here
// which cannot be resolved against the associated IDL files.
Apis []*google_protobuf4.Api `protobuf:"bytes,3,rep,name=apis" json:"apis,omitempty"`
// A list of all proto message types included in this API service.
// Types referenced directly or indirectly by the `apis` are
// automatically included. Messages which are not referenced but
// shall be included, such as types used by the `google.protobuf.Any` type,
// should be listed here by name. Example:
//
// types:
// - name: google.protobuf.Int32
Types []*google_protobuf3.Type `protobuf:"bytes,4,rep,name=types" json:"types,omitempty"`
// A list of all enum types included in this API service. Enums
// referenced directly or indirectly by the `apis` are automatically
// included. Enums which are not referenced but shall be included
// should be listed here by name. Example:
//
// enums:
// - name: google.someapi.v1.SomeEnum
Enums []*google_protobuf3.Enum `protobuf:"bytes,5,rep,name=enums" json:"enums,omitempty"`
// Additional API documentation.
Documentation *Documentation `protobuf:"bytes,6,opt,name=documentation" json:"documentation,omitempty"`
// API backend configuration.
Backend *Backend `protobuf:"bytes,8,opt,name=backend" json:"backend,omitempty"`
// HTTP configuration.
Http *google_api.Http `protobuf:"bytes,9,opt,name=http" json:"http,omitempty"`
// Quota configuration.
Quota *Quota `protobuf:"bytes,10,opt,name=quota" json:"quota,omitempty"`
// Auth configuration.
Authentication *Authentication `protobuf:"bytes,11,opt,name=authentication" json:"authentication,omitempty"`
// Context configuration.
Context *Context `protobuf:"bytes,12,opt,name=context" json:"context,omitempty"`
// Configuration controlling usage of this service.
Usage *Usage `protobuf:"bytes,15,opt,name=usage" json:"usage,omitempty"`
// Configuration for network endpoints. If this is empty, then an endpoint
// with the same name as the service is automatically generated to service all
// defined APIs.
Endpoints []*Endpoint `protobuf:"bytes,18,rep,name=endpoints" json:"endpoints,omitempty"`
// Configuration for the service control plane.
Control *Control `protobuf:"bytes,21,opt,name=control" json:"control,omitempty"`
// Defines the logs used by this service.
Logs []*LogDescriptor `protobuf:"bytes,23,rep,name=logs" json:"logs,omitempty"`
// Defines the metrics used by this service.
Metrics []*google_api3.MetricDescriptor `protobuf:"bytes,24,rep,name=metrics" json:"metrics,omitempty"`
// Defines the monitored resources used by this service. This is required
// by the [Service.monitoring][google.api.Service.monitoring] and [Service.logging][google.api.Service.logging] configurations.
MonitoredResources []*google_api6.MonitoredResourceDescriptor `protobuf:"bytes,25,rep,name=monitored_resources,json=monitoredResources" json:"monitored_resources,omitempty"`
// Billing configuration.
Billing *Billing `protobuf:"bytes,26,opt,name=billing" json:"billing,omitempty"`
// Logging configuration.
Logging *Logging `protobuf:"bytes,27,opt,name=logging" json:"logging,omitempty"`
// Monitoring configuration.
Monitoring *Monitoring `protobuf:"bytes,28,opt,name=monitoring" json:"monitoring,omitempty"`
// System parameter configuration.
SystemParameters *SystemParameters `protobuf:"bytes,29,opt,name=system_parameters,json=systemParameters" json:"system_parameters,omitempty"`
// Output only. The source information for this configuration if available.
SourceInfo *SourceInfo `protobuf:"bytes,37,opt,name=source_info,json=sourceInfo" json:"source_info,omitempty"`
// Experimental configuration.
Experimental *google_api5.Experimental `protobuf:"bytes,101,opt,name=experimental" json:"experimental,omitempty"`
}
func (m *Service) Reset() { *m = Service{} }
func (m *Service) String() string { return proto.CompactTextString(m) }
func (*Service) ProtoMessage() {}
func (*Service) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{0} }
func (m *Service) GetConfigVersion() *google_protobuf5.UInt32Value {
if m != nil {
return m.ConfigVersion
}
return nil
}
func (m *Service) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Service) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Service) GetTitle() string {
if m != nil {
return m.Title
}
return ""
}
func (m *Service) GetProducerProjectId() string {
if m != nil {
return m.ProducerProjectId
}
return ""
}
func (m *Service) GetApis() []*google_protobuf4.Api {
if m != nil {
return m.Apis
}
return nil
}
func (m *Service) GetTypes() []*google_protobuf3.Type {
if m != nil {
return m.Types
}
return nil
}
func (m *Service) GetEnums() []*google_protobuf3.Enum {
if m != nil {
return m.Enums
}
return nil
}
func (m *Service) GetDocumentation() *Documentation {
if m != nil {
return m.Documentation
}
return nil
}
func (m *Service) GetBackend() *Backend {
if m != nil {
return m.Backend
}
return nil
}
func (m *Service) GetHttp() *google_api.Http {
if m != nil {
return m.Http
}
return nil
}
func (m *Service) GetQuota() *Quota {
if m != nil {
return m.Quota
}
return nil
}
func (m *Service) GetAuthentication() *Authentication {
if m != nil {
return m.Authentication
}
return nil
}
func (m *Service) GetContext() *Context {
if m != nil {
return m.Context
}
return nil
}
func (m *Service) GetUsage() *Usage {
if m != nil {
return m.Usage
}
return nil
}
func (m *Service) GetEndpoints() []*Endpoint {
if m != nil {
return m.Endpoints
}
return nil
}
func (m *Service) GetControl() *Control {
if m != nil {
return m.Control
}
return nil
}
func (m *Service) GetLogs() []*LogDescriptor {
if m != nil {
return m.Logs
}
return nil
}
func (m *Service) GetMetrics() []*google_api3.MetricDescriptor {
if m != nil {
return m.Metrics
}
return nil
}
func (m *Service) GetMonitoredResources() []*google_api6.MonitoredResourceDescriptor {
if m != nil {
return m.MonitoredResources
}
return nil
}
func (m *Service) GetBilling() *Billing {
if m != nil {
return m.Billing
}
return nil
}
func (m *Service) GetLogging() *Logging {
if m != nil {
return m.Logging
}
return nil
}
func (m *Service) GetMonitoring() *Monitoring {
if m != nil {
return m.Monitoring
}
return nil
}
func (m *Service) GetSystemParameters() *SystemParameters {
if m != nil {
return m.SystemParameters
}
return nil
}
func (m *Service) GetSourceInfo() *SourceInfo {
if m != nil {
return m.SourceInfo
}
return nil
}
func (m *Service) GetExperimental() *google_api5.Experimental {
if m != nil {
return m.Experimental
}
return nil
}
func init() {
proto.RegisterType((*Service)(nil), "google.api.Service")
}
func init() { proto.RegisterFile("google/api/service.proto", fileDescriptor12) }
var fileDescriptor12 = []byte{
// 825 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x96, 0xdf, 0x6e, 0xdb, 0x36,
0x14, 0x87, 0x61, 0xd7, 0x6e, 0x16, 0x3a, 0xcd, 0x1a, 0xc6, 0x49, 0x19, 0xd7, 0x1b, 0xd2, 0xfd,
0x41, 0x8d, 0x0d, 0x95, 0x01, 0x17, 0xe8, 0x2e, 0x36, 0x60, 0x88, 0xdb, 0x60, 0x33, 0xd0, 0x01,
0x1e, 0xb3, 0x16, 0xc3, 0x6e, 0x0c, 0x5a, 0xa2, 0x55, 0x6e, 0x12, 0xc9, 0x91, 0x54, 0x17, 0x3f,
0xc7, 0xde, 0x60, 0x4f, 0x3a, 0x88, 0xa4, 0x62, 0xca, 0x52, 0xee, 0x22, 0x7e, 0xdf, 0x39, 0x38,
0x14, 0xa9, 0x9f, 0x03, 0x50, 0x2a, 0x44, 0x9a, 0xd1, 0x29, 0x91, 0x6c, 0xaa, 0xa9, 0xfa, 0xc8,
0x62, 0x1a, 0x49, 0x25, 0x8c, 0x80, 0xc0, 0x91, 0x88, 0x48, 0x36, 0x1a, 0x07, 0x16, 0xe1, 0x5c,
0x18, 0x62, 0x98, 0xe0, 0xda, 0x99, 0xa3, 0xb3, 0x90, 0x16, 0xe6, 0x83, 0x5f, 0x0e, 0x5b, 0xaf,
0x49, 0xfc, 0x17, 0xe5, 0x49, 0x1b, 0x61, 0x59, 0xc6, 0x78, 0xda, 0x42, 0x62, 0xc1, 0x0d, 0xbd,
0x35, 0xf7, 0x10, 0x25, 0x32, 0x4f, 0x3e, 0x0f, 0x48, 0x22, 0xe2, 0x22, 0xa7, 0xdc, 0xcd, 0xe7,
0xf9, 0x45, 0xc0, 0x29, 0x4f, 0xa4, 0x60, 0xbc, 0x6a, 0xfa, 0x4d, 0x88, 0x6e, 0x25, 0x55, 0xcc,
0x16, 0x67, 0xb5, 0x87, 0x96, 0x5d, 0x7e, 0x30, 0x46, 0xfa, 0xe5, 0xf3, 0x60, 0x39, 0x23, 0x6b,
0x5a, 0xe9, 0xc3, 0x70, 0x5d, 0xb4, 0xed, 0x2f, 0x13, 0x69, 0xba, 0xdb, 0xf9, 0x93, 0x80, 0xe4,
0xd4, 0x28, 0x16, 0x7b, 0xf0, 0x65, 0x08, 0x04, 0x67, 0x46, 0x28, 0x9a, 0xac, 0x14, 0xd5, 0xa2,
0x50, 0xd5, 0x61, 0x8d, 0x9e, 0x36, 0xa5, 0x5d, 0xeb, 0x70, 0xc4, 0xbf, 0x0b, 0x61, 0x88, 0x5f,
0x0f, 0x4f, 0xd5, 0x75, 0x5b, 0x31, 0xbe, 0x11, 0x9e, 0x3e, 0x0b, 0xe9, 0x56, 0x1b, 0x9a, 0xaf,
0x24, 0x51, 0x24, 0xa7, 0x86, 0xaa, 0x96, 0xc6, 0x85, 0x26, 0x29, 0xdd, 0x7b, 0xe3, 0xf6, 0x69,
0x5d, 0x6c, 0xa6, 0x84, 0x6f, 0xef, 0x45, 0x92, 0x79, 0x34, 0xda, 0x47, 0x66, 0x2b, 0xe9, 0xde,
0x19, 0xdf, 0xb1, 0x7f, 0x14, 0x91, 0x92, 0x2a, 0x7f, 0x05, 0xbf, 0xf8, 0x17, 0x80, 0x83, 0x1b,
0x77, 0x7d, 0xe1, 0x6b, 0x70, 0x1c, 0x0b, 0xbe, 0x61, 0xe9, 0xea, 0x23, 0x55, 0x9a, 0x09, 0x8e,
0x86, 0x97, 0x9d, 0xc9, 0x60, 0x36, 0x8e, 0xfc, 0x8d, 0xae, 0x9a, 0x44, 0xef, 0x16, 0xdc, 0xbc,
0x9c, 0xbd, 0x27, 0x59, 0x41, 0xf1, 0x23, 0x57, 0xf3, 0xde, 0x95, 0x40, 0x08, 0x7a, 0x9c, 0xe4,
0x14, 0x75, 0x2e, 0x3b, 0x93, 0x43, 0x6c, 0xff, 0x86, 0xc7, 0xa0, 0xcb, 0x12, 0xf4, 0xcc, 0xae,
0x74, 0x59, 0x02, 0x87, 0xa0, 0x6f, 0x98, 0xc9, 0x28, 0xea, 0xda, 0x25, 0xf7, 0x00, 0x23, 0x70,
0x2a, 0x95, 0x48, 0x8a, 0x98, 0xaa, 0x95, 0x54, 0xe2, 0x4f, 0x1a, 0x9b, 0x15, 0x4b, 0xd0, 0xb9,
0x75, 0x4e, 0x2a, 0xb4, 0x74, 0x64, 0x91, 0xc0, 0x09, 0xe8, 0x11, 0xc9, 0x34, 0x7a, 0x70, 0xf9,
0x60, 0x32, 0x98, 0x0d, 0x1b, 0x43, 0x5e, 0x49, 0x86, 0xad, 0x01, 0xbf, 0x05, 0xfd, 0xf2, 0x95,
0x68, 0xd4, 0xb3, 0xea, 0x59, 0x43, 0xfd, 0x6d, 0x2b, 0x29, 0x76, 0x4e, 0x29, 0x53, 0x5e, 0xe4,
0x1a, 0xf5, 0xef, 0x91, 0xaf, 0x79, 0x91, 0x63, 0xe7, 0xc0, 0x1f, 0xc1, 0xa3, 0xda, 0x97, 0x83,
0x1e, 0xda, 0x37, 0x76, 0x11, 0xed, 0x32, 0x20, 0x7a, 0x13, 0x0a, 0xb8, 0xee, 0xc3, 0x17, 0xe0,
0xc0, 0x7f, 0xe2, 0xe8, 0x13, 0x5b, 0x7a, 0x1a, 0x96, 0xce, 0x1d, 0xc2, 0x95, 0x03, 0xbf, 0x02,
0xbd, 0xf2, 0x13, 0x42, 0x87, 0xd6, 0x7d, 0x1c, 0xba, 0x3f, 0x1b, 0x23, 0xb1, 0xa5, 0xf0, 0x39,
0xe8, 0xdb, 0xeb, 0x8a, 0x80, 0xd5, 0x4e, 0x42, 0xed, 0xd7, 0x12, 0x60, 0xc7, 0xe1, 0x1c, 0x1c,
0x97, 0xb9, 0x43, 0xb9, 0x61, 0xb1, 0x9b, 0x7f, 0x60, 0x2b, 0x46, 0x61, 0xc5, 0x55, 0xcd, 0xc0,
0x7b, 0x15, 0xe5, 0x0e, 0x7c, 0xe0, 0xa0, 0xa3, 0xe6, 0x0e, 0x5e, 0x3b, 0x84, 0x2b, 0xa7, 0x9c,
0xcd, 0xde, 0x78, 0xf4, 0x69, 0x73, 0xb6, 0x77, 0x25, 0xc0, 0x8e, 0xc3, 0x19, 0x38, 0xac, 0x42,
0x47, 0x23, 0x58, 0x3f, 0xe3, 0x52, 0xbe, 0xf6, 0x10, 0xef, 0xb4, 0x6a, 0x16, 0x25, 0x32, 0x74,
0xd6, 0x3e, 0x8b, 0x12, 0x19, 0xae, 0x1c, 0xf8, 0x02, 0xf4, 0x32, 0x91, 0x6a, 0xf4, 0xc4, 0x76,
0xaf, 0x1d, 0xda, 0x5b, 0x91, 0xbe, 0xa1, 0x3a, 0x56, 0x4c, 0x1a, 0xa1, 0xb0, 0xd5, 0xe0, 0x2b,
0x70, 0xe0, 0x02, 0x46, 0x23, 0x64, 0x2b, 0xc6, 0x61, 0xc5, 0x2f, 0x16, 0x05, 0x45, 0x95, 0x0c,
0x7f, 0x07, 0xa7, 0xcd, 0xfc, 0xd1, 0xe8, 0xc2, 0xf6, 0x78, 0x5e, 0xeb, 0x51, 0x69, 0xd8, 0x5b,
0x41, 0x3b, 0x98, 0xef, 0x43, 0xbb, 0x5f, 0xff, 0x33, 0x80, 0x46, 0x2d, 0xb7, 0xc7, 0x21, 0x5c,
0x39, 0xa5, 0xee, 0xb3, 0x13, 0x3d, 0x6d, 0xea, 0x6f, 0x1d, 0xc2, 0x95, 0x03, 0x5f, 0x01, 0xb0,
0x8b, 0x44, 0x34, 0xb6, 0x15, 0xe7, 0x2d, 0xe3, 0x96, 0x45, 0x81, 0x09, 0x17, 0xe0, 0x64, 0x3f,
0xf7, 0x34, 0xfa, 0xac, 0x1e, 0x25, 0x65, 0xf9, 0x8d, 0x95, 0x96, 0x77, 0x0e, 0x7e, 0xac, 0xf7,
0x56, 0xe0, 0x77, 0x60, 0x10, 0x04, 0x2c, 0xfa, 0xba, 0x39, 0xc3, 0x8d, 0xc5, 0x0b, 0xbe, 0x11,
0x18, 0xe8, 0xbb, 0xbf, 0xe1, 0x0f, 0xe0, 0x28, 0xfc, 0x29, 0x42, 0xd4, 0x56, 0xa2, 0xda, 0x05,
0x0a, 0x38, 0xae, 0xd9, 0x73, 0x5e, 0x26, 0x61, 0x1e, 0xc8, 0xf3, 0x23, 0x1f, 0x92, 0xcb, 0x32,
0x05, 0x96, 0x9d, 0x3f, 0xae, 0x3d, 0x4b, 0x45, 0x46, 0x78, 0x1a, 0x09, 0x95, 0x4e, 0x53, 0xca,
0x6d, 0x46, 0x4c, 0x1d, 0x2a, 0x93, 0x27, 0xfc, 0xef, 0xc0, 0xc5, 0xe4, 0xf7, 0xb5, 0xa7, 0xff,
0xba, 0xbd, 0x9f, 0xae, 0x96, 0x8b, 0xf5, 0x43, 0x5b, 0xf8, 0xf2, 0xff, 0x00, 0x00, 0x00, 0xff,
0xff, 0xfe, 0x6c, 0x4b, 0xf7, 0x55, 0x08, 0x00, 0x00,
}

55
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/source_info.pb.go generated vendored Normal file
View File

@ -0,0 +1,55 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/source_info.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Source information used to create a Service Config
type SourceInfo struct {
// All files used during config generation.
SourceFiles []*google_protobuf1.Any `protobuf:"bytes,1,rep,name=source_files,json=sourceFiles" json:"source_files,omitempty"`
}
func (m *SourceInfo) Reset() { *m = SourceInfo{} }
func (m *SourceInfo) String() string { return proto.CompactTextString(m) }
func (*SourceInfo) ProtoMessage() {}
func (*SourceInfo) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
func (m *SourceInfo) GetSourceFiles() []*google_protobuf1.Any {
if m != nil {
return m.SourceFiles
}
return nil
}
func init() {
proto.RegisterType((*SourceInfo)(nil), "google.api.SourceInfo")
}
func init() { proto.RegisterFile("google/api/source_info.proto", fileDescriptor13) }
var fileDescriptor13 = []byte{
// 198 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x2f, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0x8d, 0xcf, 0xcc,
0x4b, 0xcb, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0xc8, 0xea, 0x25, 0x16, 0x64,
0x4a, 0x49, 0x42, 0x55, 0x82, 0x65, 0x92, 0x4a, 0xd3, 0xf4, 0x13, 0xf3, 0x2a, 0x21, 0xca, 0x94,
0x5c, 0xb9, 0xb8, 0x82, 0xc1, 0x7a, 0x3d, 0xf3, 0xd2, 0xf2, 0x85, 0xcc, 0xb9, 0x78, 0xa0, 0x26,
0xa5, 0x65, 0xe6, 0xa4, 0x16, 0x4b, 0x30, 0x2a, 0x30, 0x6b, 0x70, 0x1b, 0x89, 0xe8, 0x41, 0xcd,
0x82, 0xe9, 0xd7, 0x73, 0xcc, 0xab, 0x0c, 0xe2, 0x86, 0xa8, 0x74, 0x03, 0x29, 0x74, 0x2a, 0xe4,
0xe2, 0x4b, 0xce, 0xcf, 0xd5, 0x43, 0xd8, 0xe9, 0xc4, 0x8f, 0x30, 0x36, 0x00, 0xa4, 0x2d, 0x80,
0x31, 0xca, 0x15, 0x2a, 0x9d, 0x9e, 0x9f, 0x93, 0x98, 0x97, 0xae, 0x97, 0x5f, 0x94, 0xae, 0x9f,
0x9e, 0x9a, 0x07, 0x36, 0x54, 0x1f, 0x22, 0x95, 0x58, 0x90, 0x59, 0x0c, 0xf1, 0x4f, 0x6a, 0x51,
0x59, 0x66, 0x72, 0x6a, 0x72, 0x7e, 0x5e, 0x5a, 0x66, 0xba, 0x35, 0x0a, 0x6f, 0x11, 0x13, 0x8b,
0xbb, 0x63, 0x80, 0x67, 0x12, 0x1b, 0x58, 0xa3, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x78,
0x5d, 0xab, 0x07, 0x01, 0x00, 0x00,
}

169
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/system_parameter.pb.go generated vendored Normal file
View File

@ -0,0 +1,169 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/system_parameter.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// ### System parameter configuration
//
// A system parameter is a special kind of parameter defined by the API
// system, not by an individual API. It is typically mapped to an HTTP header
// and/or a URL query parameter. This configuration specifies which methods
// change the names of the system parameters.
type SystemParameters struct {
// Define system parameters.
//
// The parameters defined here will override the default parameters
// implemented by the system. If this field is missing from the service
// config, default system parameters will be used. Default system parameters
// and names is implementation-dependent.
//
// Example: define api key for all methods
//
// system_parameters
// rules:
// - selector: "*"
// parameters:
// - name: api_key
// url_query_parameter: api_key
//
//
// Example: define 2 api key names for a specific method.
//
// system_parameters
// rules:
// - selector: "/ListShelves"
// parameters:
// - name: api_key
// http_header: Api-Key1
// - name: api_key
// http_header: Api-Key2
//
// **NOTE:** All service configuration rules follow "last one wins" order.
Rules []*SystemParameterRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *SystemParameters) Reset() { *m = SystemParameters{} }
func (m *SystemParameters) String() string { return proto.CompactTextString(m) }
func (*SystemParameters) ProtoMessage() {}
func (*SystemParameters) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
func (m *SystemParameters) GetRules() []*SystemParameterRule {
if m != nil {
return m.Rules
}
return nil
}
// Define a system parameter rule mapping system parameter definitions to
// methods.
type SystemParameterRule struct {
// Selects the methods to which this rule applies. Use '*' to indicate all
// methods in all APIs.
//
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// Define parameters. Multiple names may be defined for a parameter.
// For a given method call, only one of them should be used. If multiple
// names are used the behavior is implementation-dependent.
// If none of the specified names are present the behavior is
// parameter-dependent.
Parameters []*SystemParameter `protobuf:"bytes,2,rep,name=parameters" json:"parameters,omitempty"`
}
func (m *SystemParameterRule) Reset() { *m = SystemParameterRule{} }
func (m *SystemParameterRule) String() string { return proto.CompactTextString(m) }
func (*SystemParameterRule) ProtoMessage() {}
func (*SystemParameterRule) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
func (m *SystemParameterRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *SystemParameterRule) GetParameters() []*SystemParameter {
if m != nil {
return m.Parameters
}
return nil
}
// Define a parameter's name and location. The parameter may be passed as either
// an HTTP header or a URL query parameter, and if both are passed the behavior
// is implementation-dependent.
type SystemParameter struct {
// Define the name of the parameter, such as "api_key" . It is case sensitive.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Define the HTTP header name to use for the parameter. It is case
// insensitive.
HttpHeader string `protobuf:"bytes,2,opt,name=http_header,json=httpHeader" json:"http_header,omitempty"`
// Define the URL query parameter name to use for the parameter. It is case
// sensitive.
UrlQueryParameter string `protobuf:"bytes,3,opt,name=url_query_parameter,json=urlQueryParameter" json:"url_query_parameter,omitempty"`
}
func (m *SystemParameter) Reset() { *m = SystemParameter{} }
func (m *SystemParameter) String() string { return proto.CompactTextString(m) }
func (*SystemParameter) ProtoMessage() {}
func (*SystemParameter) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
func (m *SystemParameter) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *SystemParameter) GetHttpHeader() string {
if m != nil {
return m.HttpHeader
}
return ""
}
func (m *SystemParameter) GetUrlQueryParameter() string {
if m != nil {
return m.UrlQueryParameter
}
return ""
}
func init() {
proto.RegisterType((*SystemParameters)(nil), "google.api.SystemParameters")
proto.RegisterType((*SystemParameterRule)(nil), "google.api.SystemParameterRule")
proto.RegisterType((*SystemParameter)(nil), "google.api.SystemParameter")
}
func init() { proto.RegisterFile("google/api/system_parameter.proto", fileDescriptor14) }
var fileDescriptor14 = []byte{
// 286 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xbf, 0x4e, 0xc3, 0x30,
0x10, 0x87, 0x95, 0xb6, 0x20, 0xb8, 0x4a, 0xfc, 0x71, 0x19, 0x22, 0x18, 0x5a, 0x3a, 0x75, 0x72,
0x24, 0x10, 0x53, 0x27, 0x2a, 0x21, 0xe8, 0x16, 0xca, 0xc6, 0x12, 0x99, 0x70, 0xb8, 0x91, 0x9c,
0xd8, 0x9c, 0x9d, 0x48, 0x7d, 0x1d, 0x9e, 0x14, 0xc5, 0x29, 0x69, 0x89, 0x10, 0x9b, 0xef, 0xbe,
0xcf, 0xfa, 0x9d, 0xee, 0xe0, 0x5a, 0x6a, 0x2d, 0x15, 0x46, 0xc2, 0x64, 0x91, 0xdd, 0x58, 0x87,
0x79, 0x62, 0x04, 0x89, 0x1c, 0x1d, 0x12, 0x37, 0xa4, 0x9d, 0x66, 0xd0, 0x28, 0x5c, 0x98, 0x6c,
0xba, 0x84, 0xb3, 0x17, 0x6f, 0xc5, 0x3f, 0x92, 0x65, 0x77, 0x70, 0x40, 0xa5, 0x42, 0x1b, 0x06,
0x93, 0xfe, 0x6c, 0x78, 0x33, 0xe6, 0x3b, 0x9f, 0x77, 0xe4, 0x55, 0xa9, 0x70, 0xd5, 0xd8, 0xd3,
0x02, 0x46, 0x7f, 0x50, 0x76, 0x09, 0x47, 0x16, 0x15, 0xa6, 0x4e, 0x53, 0x18, 0x4c, 0x82, 0xd9,
0xf1, 0xaa, 0xad, 0xd9, 0x1c, 0xa0, 0x1d, 0xce, 0x86, 0x3d, 0x1f, 0x77, 0xf5, 0x5f, 0xdc, 0x9e,
0x3e, 0xad, 0xe0, 0xb4, 0x83, 0x19, 0x83, 0x41, 0x21, 0x72, 0xdc, 0xe6, 0xf8, 0x37, 0x1b, 0xc3,
0x70, 0xed, 0x9c, 0x49, 0xd6, 0x28, 0xde, 0x91, 0xc2, 0x9e, 0x47, 0x50, 0xb7, 0x9e, 0x7c, 0x87,
0x71, 0x18, 0x95, 0xa4, 0x92, 0xcf, 0x12, 0x69, 0xb3, 0xdb, 0x55, 0xd8, 0xf7, 0xe2, 0x79, 0x49,
0xea, 0xb9, 0x26, 0x6d, 0xc8, 0xa2, 0x82, 0x93, 0x54, 0xe7, 0x7b, 0x53, 0x2e, 0x2e, 0x3a, 0x73,
0xc4, 0xf5, 0x9a, 0xe3, 0xe0, 0xf5, 0x61, 0xeb, 0x48, 0xad, 0x44, 0x21, 0xb9, 0x26, 0x19, 0x49,
0x2c, 0xfc, 0x11, 0xa2, 0x06, 0x09, 0x93, 0xd9, 0xe6, 0x54, 0x48, 0x55, 0x96, 0x62, 0xaa, 0x8b,
0x8f, 0x4c, 0xce, 0x7f, 0x55, 0x5f, 0xbd, 0xc1, 0xe3, 0x7d, 0xbc, 0x7c, 0x3b, 0xf4, 0x1f, 0x6f,
0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x5e, 0xdf, 0x2e, 0x09, 0xe2, 0x01, 0x00, 0x00,
}

157
vendor/google.golang.org/genproto/googleapis/api/serviceconfig/usage.pb.go generated vendored Normal file
View File

@ -0,0 +1,157 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/usage.proto
package serviceconfig
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Configuration controlling usage of a service.
type Usage struct {
// Requirements that must be satisfied before a consumer project can use the
// service. Each requirement is of the form <service.name>/<requirement-id>;
// for example 'serviceusage.googleapis.com/billing-enabled'.
Requirements []string `protobuf:"bytes,1,rep,name=requirements" json:"requirements,omitempty"`
// A list of usage rules that apply to individual API methods.
//
// **NOTE:** All service configuration rules follow "last one wins" order.
Rules []*UsageRule `protobuf:"bytes,6,rep,name=rules" json:"rules,omitempty"`
// The full resource name of a channel used for sending notifications to the
// service producer.
//
// Google Service Management currently only supports
// [Google Cloud Pub/Sub](https://cloud.google.com/pubsub) as a notification
// channel. To use Google Cloud Pub/Sub as the channel, this must be the name
// of a Cloud Pub/Sub topic that uses the Cloud Pub/Sub topic name format
// documented in https://cloud.google.com/pubsub/docs/overview.
ProducerNotificationChannel string `protobuf:"bytes,7,opt,name=producer_notification_channel,json=producerNotificationChannel" json:"producer_notification_channel,omitempty"`
}
func (m *Usage) Reset() { *m = Usage{} }
func (m *Usage) String() string { return proto.CompactTextString(m) }
func (*Usage) ProtoMessage() {}
func (*Usage) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0} }
func (m *Usage) GetRequirements() []string {
if m != nil {
return m.Requirements
}
return nil
}
func (m *Usage) GetRules() []*UsageRule {
if m != nil {
return m.Rules
}
return nil
}
func (m *Usage) GetProducerNotificationChannel() string {
if m != nil {
return m.ProducerNotificationChannel
}
return ""
}
// Usage configuration rules for the service.
//
// NOTE: Under development.
//
//
// Use this rule to configure unregistered calls for the service. Unregistered
// calls are calls that do not contain consumer project identity.
// (Example: calls that do not contain an API key).
// By default, API methods do not allow unregistered calls, and each method call
// must be identified by a consumer project identity. Use this rule to
// allow/disallow unregistered calls.
//
// Example of an API that wants to allow unregistered calls for entire service.
//
// usage:
// rules:
// - selector: "*"
// allow_unregistered_calls: true
//
// Example of a method that wants to allow unregistered calls.
//
// usage:
// rules:
// - selector: "google.example.library.v1.LibraryService.CreateBook"
// allow_unregistered_calls: true
type UsageRule struct {
// Selects the methods to which this rule applies. Use '*' to indicate all
// methods in all APIs.
//
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
Selector string `protobuf:"bytes,1,opt,name=selector" json:"selector,omitempty"`
// True, if the method allows unregistered calls; false otherwise.
AllowUnregisteredCalls bool `protobuf:"varint,2,opt,name=allow_unregistered_calls,json=allowUnregisteredCalls" json:"allow_unregistered_calls,omitempty"`
// True, if the method should skip service control. If so, no control plane
// feature (like quota and billing) will be enabled.
SkipServiceControl bool `protobuf:"varint,3,opt,name=skip_service_control,json=skipServiceControl" json:"skip_service_control,omitempty"`
}
func (m *UsageRule) Reset() { *m = UsageRule{} }
func (m *UsageRule) String() string { return proto.CompactTextString(m) }
func (*UsageRule) ProtoMessage() {}
func (*UsageRule) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{1} }
func (m *UsageRule) GetSelector() string {
if m != nil {
return m.Selector
}
return ""
}
func (m *UsageRule) GetAllowUnregisteredCalls() bool {
if m != nil {
return m.AllowUnregisteredCalls
}
return false
}
func (m *UsageRule) GetSkipServiceControl() bool {
if m != nil {
return m.SkipServiceControl
}
return false
}
func init() {
proto.RegisterType((*Usage)(nil), "google.api.Usage")
proto.RegisterType((*UsageRule)(nil), "google.api.UsageRule")
}
func init() { proto.RegisterFile("google/api/usage.proto", fileDescriptor15) }
var fileDescriptor15 = []byte{
// 331 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x91, 0xc1, 0x4b, 0xfb, 0x30,
0x14, 0xc7, 0xe9, 0xf6, 0xdb, 0x7e, 0x5b, 0x14, 0x0f, 0x41, 0x47, 0x99, 0x0a, 0x65, 0xa7, 0x82,
0xd0, 0x8a, 0x5e, 0x04, 0x4f, 0x6e, 0x88, 0x78, 0x91, 0x51, 0xd9, 0xc5, 0x4b, 0x89, 0xd9, 0x5b,
0x0c, 0x66, 0x79, 0x35, 0x49, 0xf5, 0x0f, 0xf1, 0xea, 0xc9, 0xbf, 0x54, 0x9a, 0xcc, 0xd9, 0x1d,
0xdf, 0xfb, 0x7c, 0xbe, 0xef, 0xb5, 0x2f, 0x64, 0x24, 0x10, 0x85, 0x82, 0x9c, 0x55, 0x32, 0xaf,
0x2d, 0x13, 0x90, 0x55, 0x06, 0x1d, 0x52, 0x12, 0xfa, 0x19, 0xab, 0xe4, 0xf8, 0xa4, 0xe5, 0x30,
0xad, 0xd1, 0x31, 0x27, 0x51, 0xdb, 0x60, 0x4e, 0xbe, 0x22, 0xd2, 0x5b, 0x34, 0x49, 0x3a, 0x21,
0xfb, 0x06, 0xde, 0x6a, 0x69, 0x60, 0x0d, 0xda, 0xd9, 0x38, 0x4a, 0xba, 0xe9, 0xb0, 0xd8, 0xe9,
0xd1, 0x33, 0xd2, 0x33, 0xb5, 0x02, 0x1b, 0xf7, 0x93, 0x6e, 0xba, 0x77, 0x71, 0x94, 0xfd, 0xed,
0xc9, 0xfc, 0x94, 0xa2, 0x56, 0x50, 0x04, 0x87, 0x4e, 0xc9, 0x69, 0x65, 0x70, 0x59, 0x73, 0x30,
0xa5, 0x46, 0x27, 0x57, 0x92, 0xfb, 0xd5, 0x25, 0x7f, 0x61, 0x5a, 0x83, 0x8a, 0xff, 0x27, 0x51,
0x3a, 0x2c, 0x8e, 0x7f, 0xa5, 0x87, 0x96, 0x33, 0x0b, 0xca, 0xe4, 0x33, 0x22, 0xc3, 0xed, 0x60,
0x3a, 0x26, 0x03, 0x0b, 0x0a, 0xb8, 0x43, 0x13, 0x47, 0x3e, 0xbc, 0xad, 0xe9, 0x15, 0x89, 0x99,
0x52, 0xf8, 0x51, 0xd6, 0xda, 0x80, 0x90, 0xd6, 0x81, 0x81, 0x65, 0xc9, 0x99, 0x52, 0x36, 0xee,
0x24, 0x51, 0x3a, 0x28, 0x46, 0x9e, 0x2f, 0x5a, 0x78, 0xd6, 0x50, 0x7a, 0x4e, 0x0e, 0xed, 0xab,
0xac, 0x4a, 0x0b, 0xe6, 0x5d, 0x72, 0x28, 0x39, 0x6a, 0x67, 0x50, 0xc5, 0x5d, 0x9f, 0xa2, 0x0d,
0x7b, 0x0c, 0x68, 0x16, 0xc8, 0x54, 0x91, 0x03, 0x8e, 0xeb, 0xd6, 0xcf, 0x4f, 0x89, 0xff, 0xc8,
0x79, 0x73, 0xd2, 0x79, 0xf4, 0x74, 0xbb, 0x21, 0x02, 0x15, 0xd3, 0x22, 0x43, 0x23, 0x72, 0x01,
0xda, 0x1f, 0x3c, 0x0f, 0x88, 0x55, 0xd2, 0xfa, 0x17, 0xd9, 0x2c, 0xe5, 0xa8, 0x57, 0x52, 0x5c,
0xef, 0x54, 0xdf, 0x9d, 0x7f, 0x77, 0x37, 0xf3, 0xfb, 0xe7, 0xbe, 0x0f, 0x5e, 0xfe, 0x04, 0x00,
0x00, 0xff, 0xff, 0x9c, 0x4b, 0x8c, 0x57, 0xed, 0x01, 0x00, 0x00,
}

207
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/check_error.pb.go generated vendored Normal file
View File

@ -0,0 +1,207 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicecontrol/v1/check_error.proto
/*
Package servicecontrol is a generated protocol buffer package.
It is generated from these files:
google/api/servicecontrol/v1/check_error.proto
google/api/servicecontrol/v1/distribution.proto
google/api/servicecontrol/v1/log_entry.proto
google/api/servicecontrol/v1/metric_value.proto
google/api/servicecontrol/v1/operation.proto
google/api/servicecontrol/v1/quota_controller.proto
google/api/servicecontrol/v1/service_controller.proto
It has these top-level messages:
CheckError
Distribution
LogEntry
MetricValue
MetricValueSet
Operation
AllocateQuotaRequest
QuotaOperation
AllocateQuotaResponse
QuotaError
CheckRequest
CheckResponse
ReportRequest
ReportResponse
*/
package servicecontrol
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Error codes for Check responses.
type CheckError_Code int32
const (
// This is never used in `CheckResponse`.
CheckError_ERROR_CODE_UNSPECIFIED CheckError_Code = 0
// The consumer's project id was not found.
// Same as [google.rpc.Code.NOT_FOUND][].
CheckError_NOT_FOUND CheckError_Code = 5
// The consumer doesn't have access to the specified resource.
// Same as [google.rpc.Code.PERMISSION_DENIED][].
CheckError_PERMISSION_DENIED CheckError_Code = 7
// Quota check failed. Same as [google.rpc.Code.RESOURCE_EXHAUSTED][].
CheckError_RESOURCE_EXHAUSTED CheckError_Code = 8
// The consumer hasn't activated the service.
CheckError_SERVICE_NOT_ACTIVATED CheckError_Code = 104
// The consumer cannot access the service because billing is disabled.
CheckError_BILLING_DISABLED CheckError_Code = 107
// The consumer's project has been marked as deleted (soft deletion).
CheckError_PROJECT_DELETED CheckError_Code = 108
// The consumer's project number or id does not represent a valid project.
CheckError_PROJECT_INVALID CheckError_Code = 114
// The IP address of the consumer is invalid for the specific consumer
// project.
CheckError_IP_ADDRESS_BLOCKED CheckError_Code = 109
// The referer address of the consumer request is invalid for the specific
// consumer project.
CheckError_REFERER_BLOCKED CheckError_Code = 110
// The client application of the consumer request is invalid for the
// specific consumer project.
CheckError_CLIENT_APP_BLOCKED CheckError_Code = 111
// The consumer's API key is invalid.
CheckError_API_KEY_INVALID CheckError_Code = 105
// The consumer's API Key has expired.
CheckError_API_KEY_EXPIRED CheckError_Code = 112
// The consumer's API Key was not found in config record.
CheckError_API_KEY_NOT_FOUND CheckError_Code = 113
// The backend server for looking up project id/number is unavailable.
CheckError_NAMESPACE_LOOKUP_UNAVAILABLE CheckError_Code = 300
// The backend server for checking service status is unavailable.
CheckError_SERVICE_STATUS_UNAVAILABLE CheckError_Code = 301
// The backend server for checking billing status is unavailable.
CheckError_BILLING_STATUS_UNAVAILABLE CheckError_Code = 302
)
var CheckError_Code_name = map[int32]string{
0: "ERROR_CODE_UNSPECIFIED",
5: "NOT_FOUND",
7: "PERMISSION_DENIED",
8: "RESOURCE_EXHAUSTED",
104: "SERVICE_NOT_ACTIVATED",
107: "BILLING_DISABLED",
108: "PROJECT_DELETED",
114: "PROJECT_INVALID",
109: "IP_ADDRESS_BLOCKED",
110: "REFERER_BLOCKED",
111: "CLIENT_APP_BLOCKED",
105: "API_KEY_INVALID",
112: "API_KEY_EXPIRED",
113: "API_KEY_NOT_FOUND",
300: "NAMESPACE_LOOKUP_UNAVAILABLE",
301: "SERVICE_STATUS_UNAVAILABLE",
302: "BILLING_STATUS_UNAVAILABLE",
}
var CheckError_Code_value = map[string]int32{
"ERROR_CODE_UNSPECIFIED": 0,
"NOT_FOUND": 5,
"PERMISSION_DENIED": 7,
"RESOURCE_EXHAUSTED": 8,
"SERVICE_NOT_ACTIVATED": 104,
"BILLING_DISABLED": 107,
"PROJECT_DELETED": 108,
"PROJECT_INVALID": 114,
"IP_ADDRESS_BLOCKED": 109,
"REFERER_BLOCKED": 110,
"CLIENT_APP_BLOCKED": 111,
"API_KEY_INVALID": 105,
"API_KEY_EXPIRED": 112,
"API_KEY_NOT_FOUND": 113,
"NAMESPACE_LOOKUP_UNAVAILABLE": 300,
"SERVICE_STATUS_UNAVAILABLE": 301,
"BILLING_STATUS_UNAVAILABLE": 302,
}
func (x CheckError_Code) String() string {
return proto.EnumName(CheckError_Code_name, int32(x))
}
func (CheckError_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }
// Defines the errors to be returned in
// [google.api.servicecontrol.v1.CheckResponse.check_errors][google.api.servicecontrol.v1.CheckResponse.check_errors].
type CheckError struct {
// The error code.
Code CheckError_Code `protobuf:"varint,1,opt,name=code,enum=google.api.servicecontrol.v1.CheckError_Code" json:"code,omitempty"`
// Free-form text providing details on the error cause of the error.
Detail string `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"`
}
func (m *CheckError) Reset() { *m = CheckError{} }
func (m *CheckError) String() string { return proto.CompactTextString(m) }
func (*CheckError) ProtoMessage() {}
func (*CheckError) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *CheckError) GetCode() CheckError_Code {
if m != nil {
return m.Code
}
return CheckError_ERROR_CODE_UNSPECIFIED
}
func (m *CheckError) GetDetail() string {
if m != nil {
return m.Detail
}
return ""
}
func init() {
proto.RegisterType((*CheckError)(nil), "google.api.servicecontrol.v1.CheckError")
proto.RegisterEnum("google.api.servicecontrol.v1.CheckError_Code", CheckError_Code_name, CheckError_Code_value)
}
func init() { proto.RegisterFile("google/api/servicecontrol/v1/check_error.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 484 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xdd, 0x6e, 0xd3, 0x3e,
0x18, 0xc6, 0xff, 0xe9, 0xbf, 0x0c, 0x66, 0x09, 0x16, 0x0c, 0xab, 0x46, 0x55, 0x89, 0xb2, 0xa3,
0x9d, 0x90, 0x68, 0x70, 0xc8, 0x91, 0x6b, 0xbf, 0x05, 0xaf, 0x59, 0x62, 0xd9, 0x49, 0x35, 0x38,
0xb1, 0x42, 0x1a, 0x65, 0xd1, 0xba, 0xb8, 0xa4, 0x51, 0xaf, 0x80, 0x0b, 0xe0, 0x2a, 0x38, 0x02,
0xae, 0x8f, 0x43, 0xe4, 0x76, 0xfd, 0x92, 0xa6, 0x1d, 0xfa, 0x79, 0x7f, 0xcf, 0x63, 0xbd, 0x1f,
0xc8, 0x2b, 0x8c, 0x29, 0xa6, 0xb9, 0x9f, 0xce, 0x4a, 0x7f, 0x9e, 0xd7, 0x8b, 0x32, 0xcb, 0x33,
0x53, 0x35, 0xb5, 0x99, 0xfa, 0x8b, 0x73, 0x3f, 0xbb, 0xce, 0xb3, 0x1b, 0x9d, 0xd7, 0xb5, 0xa9,
0xbd, 0x59, 0x6d, 0x1a, 0x83, 0x7b, 0x2b, 0xde, 0x4b, 0x67, 0xa5, 0xb7, 0xcf, 0x7b, 0x8b, 0xf3,
0x6e, 0x6f, 0x27, 0x2d, 0xad, 0x2a, 0xd3, 0xa4, 0x4d, 0x69, 0xaa, 0xf9, 0xca, 0x7b, 0xfa, 0xa3,
0x8d, 0x10, 0xb5, 0x89, 0x60, 0x03, 0x31, 0x41, 0xed, 0xcc, 0x4c, 0xf2, 0x13, 0xa7, 0xef, 0x9c,
0x3d, 0x7b, 0xf7, 0xd6, 0x7b, 0x28, 0xd9, 0xdb, 0xfa, 0x3c, 0x6a, 0x26, 0xb9, 0x5c, 0x5a, 0x71,
0x07, 0x1d, 0x4c, 0xf2, 0x26, 0x2d, 0xa7, 0x27, 0xad, 0xbe, 0x73, 0x76, 0x28, 0xef, 0x5e, 0xa7,
0x3f, 0xff, 0x47, 0x6d, 0x8b, 0xe1, 0x2e, 0xea, 0x80, 0x94, 0x91, 0xd4, 0x34, 0x62, 0xa0, 0x93,
0x50, 0x09, 0xa0, 0x7c, 0xc8, 0x81, 0xb9, 0xff, 0xe1, 0xa7, 0xe8, 0x30, 0x8c, 0x62, 0x3d, 0x8c,
0x92, 0x90, 0xb9, 0x8f, 0xf0, 0x31, 0x7a, 0x2e, 0x40, 0x5e, 0x72, 0xa5, 0x78, 0x14, 0x6a, 0x06,
0xa1, 0xa5, 0x1e, 0xe3, 0x0e, 0xc2, 0x12, 0x54, 0x94, 0x48, 0x0a, 0x1a, 0xae, 0x3e, 0x91, 0x44,
0xc5, 0xc0, 0xdc, 0x27, 0xf8, 0x15, 0x3a, 0x56, 0x20, 0xc7, 0x9c, 0x82, 0xb6, 0x29, 0x84, 0xc6,
0x7c, 0x4c, 0x6c, 0xe9, 0x1a, 0xbf, 0x44, 0xee, 0x80, 0x07, 0x01, 0x0f, 0x3f, 0x6a, 0xc6, 0x15,
0x19, 0x04, 0xc0, 0xdc, 0x1b, 0xfc, 0x02, 0x1d, 0x09, 0x19, 0x5d, 0x00, 0x8d, 0x35, 0x83, 0x00,
0x2c, 0x3a, 0xdd, 0x15, 0x79, 0x38, 0x26, 0x01, 0x67, 0x6e, 0x6d, 0xbf, 0xe4, 0x42, 0x13, 0xc6,
0x24, 0x28, 0xa5, 0x07, 0x41, 0x44, 0x47, 0xc0, 0xdc, 0x5b, 0x0b, 0x4b, 0x18, 0x82, 0x04, 0xb9,
0x11, 0x2b, 0x0b, 0xd3, 0x80, 0x43, 0x18, 0x6b, 0x22, 0xc4, 0x46, 0x37, 0x16, 0x26, 0x82, 0xeb,
0x11, 0x7c, 0xde, 0x24, 0x97, 0xbb, 0x22, 0x5c, 0x09, 0x2e, 0x81, 0xb9, 0x33, 0xdb, 0xf8, 0x5a,
0xdc, 0xce, 0xe3, 0x1b, 0x7e, 0x83, 0x7a, 0x21, 0xb9, 0x04, 0x25, 0x08, 0x05, 0x1d, 0x44, 0xd1,
0x28, 0x11, 0x3a, 0x09, 0xc9, 0x98, 0xf0, 0xc0, 0xb6, 0xe4, 0xfe, 0x6a, 0xe1, 0xd7, 0xa8, 0xbb,
0x9e, 0x81, 0x8a, 0x49, 0x9c, 0xa8, 0x3d, 0xe0, 0xf7, 0x12, 0x58, 0x4f, 0xe2, 0x1e, 0xe0, 0x4f,
0x6b, 0xf0, 0xdd, 0x41, 0xfd, 0xcc, 0xdc, 0x3e, 0xb8, 0xfb, 0xc1, 0xd1, 0x76, 0xf9, 0xc2, 0x1e,
0x92, 0x70, 0xbe, 0x5c, 0xdc, 0x19, 0x0a, 0x33, 0x4d, 0xab, 0xc2, 0x33, 0x75, 0xe1, 0x17, 0x79,
0xb5, 0x3c, 0x33, 0x7f, 0x55, 0x4a, 0x67, 0xe5, 0xfc, 0xfe, 0xab, 0xfe, 0xb0, 0xaf, 0xfc, 0x75,
0x9c, 0xaf, 0x07, 0x4b, 0xe7, 0xfb, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7d, 0x65, 0x26, 0xbf,
0x0e, 0x03, 0x00, 0x00,
}

430
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/distribution.pb.go generated vendored Normal file
View File

@ -0,0 +1,430 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicecontrol/v1/distribution.proto
package servicecontrol
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Distribution represents a frequency distribution of double-valued sample
// points. It contains the size of the population of sample points plus
// additional optional information:
//
// - the arithmetic mean of the samples
// - the minimum and maximum of the samples
// - the sum-squared-deviation of the samples, used to compute variance
// - a histogram of the values of the sample points
type Distribution struct {
// The total number of samples in the distribution. Must be >= 0.
Count int64 `protobuf:"varint,1,opt,name=count" json:"count,omitempty"`
// The arithmetic mean of the samples in the distribution. If `count` is
// zero then this field must be zero.
Mean float64 `protobuf:"fixed64,2,opt,name=mean" json:"mean,omitempty"`
// The minimum of the population of values. Ignored if `count` is zero.
Minimum float64 `protobuf:"fixed64,3,opt,name=minimum" json:"minimum,omitempty"`
// The maximum of the population of values. Ignored if `count` is zero.
Maximum float64 `protobuf:"fixed64,4,opt,name=maximum" json:"maximum,omitempty"`
// The sum of squared deviations from the mean:
// Sum[i=1..count]((x_i - mean)^2)
// where each x_i is a sample values. If `count` is zero then this field
// must be zero, otherwise validation of the request fails.
SumOfSquaredDeviation float64 `protobuf:"fixed64,5,opt,name=sum_of_squared_deviation,json=sumOfSquaredDeviation" json:"sum_of_squared_deviation,omitempty"`
// The number of samples in each histogram bucket. `bucket_counts` are
// optional. If present, they must sum to the `count` value.
//
// The buckets are defined below in `bucket_option`. There are N buckets.
// `bucket_counts[0]` is the number of samples in the underflow bucket.
// `bucket_counts[1]` to `bucket_counts[N-1]` are the numbers of samples
// in each of the finite buckets. And `bucket_counts[N] is the number
// of samples in the overflow bucket. See the comments of `bucket_option`
// below for more details.
//
// Any suffix of trailing zeros may be omitted.
BucketCounts []int64 `protobuf:"varint,6,rep,packed,name=bucket_counts,json=bucketCounts" json:"bucket_counts,omitempty"`
// Defines the buckets in the histogram. `bucket_option` and `bucket_counts`
// must be both set, or both unset.
//
// Buckets are numbered in the range of [0, N], with a total of N+1 buckets.
// There must be at least two buckets (a single-bucket histogram gives
// no information that isn't already provided by `count`).
//
// The first bucket is the underflow bucket which has a lower bound
// of -inf. The last bucket is the overflow bucket which has an
// upper bound of +inf. All other buckets (if any) are called "finite"
// buckets because they have finite lower and upper bounds. As described
// below, there are three ways to define the finite buckets.
//
// (1) Buckets with constant width.
// (2) Buckets with exponentially growing widths.
// (3) Buckets with arbitrary user-provided widths.
//
// In all cases, the buckets cover the entire real number line (-inf,
// +inf). Bucket upper bounds are exclusive and lower bounds are
// inclusive. The upper bound of the underflow bucket is equal to the
// lower bound of the smallest finite bucket; the lower bound of the
// overflow bucket is equal to the upper bound of the largest finite
// bucket.
//
// Types that are valid to be assigned to BucketOption:
// *Distribution_LinearBuckets_
// *Distribution_ExponentialBuckets_
// *Distribution_ExplicitBuckets_
BucketOption isDistribution_BucketOption `protobuf_oneof:"bucket_option"`
}
func (m *Distribution) Reset() { *m = Distribution{} }
func (m *Distribution) String() string { return proto.CompactTextString(m) }
func (*Distribution) ProtoMessage() {}
func (*Distribution) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
type isDistribution_BucketOption interface {
isDistribution_BucketOption()
}
type Distribution_LinearBuckets_ struct {
LinearBuckets *Distribution_LinearBuckets `protobuf:"bytes,7,opt,name=linear_buckets,json=linearBuckets,oneof"`
}
type Distribution_ExponentialBuckets_ struct {
ExponentialBuckets *Distribution_ExponentialBuckets `protobuf:"bytes,8,opt,name=exponential_buckets,json=exponentialBuckets,oneof"`
}
type Distribution_ExplicitBuckets_ struct {
ExplicitBuckets *Distribution_ExplicitBuckets `protobuf:"bytes,9,opt,name=explicit_buckets,json=explicitBuckets,oneof"`
}
func (*Distribution_LinearBuckets_) isDistribution_BucketOption() {}
func (*Distribution_ExponentialBuckets_) isDistribution_BucketOption() {}
func (*Distribution_ExplicitBuckets_) isDistribution_BucketOption() {}
func (m *Distribution) GetBucketOption() isDistribution_BucketOption {
if m != nil {
return m.BucketOption
}
return nil
}
func (m *Distribution) GetCount() int64 {
if m != nil {
return m.Count
}
return 0
}
func (m *Distribution) GetMean() float64 {
if m != nil {
return m.Mean
}
return 0
}
func (m *Distribution) GetMinimum() float64 {
if m != nil {
return m.Minimum
}
return 0
}
func (m *Distribution) GetMaximum() float64 {
if m != nil {
return m.Maximum
}
return 0
}
func (m *Distribution) GetSumOfSquaredDeviation() float64 {
if m != nil {
return m.SumOfSquaredDeviation
}
return 0
}
func (m *Distribution) GetBucketCounts() []int64 {
if m != nil {
return m.BucketCounts
}
return nil
}
func (m *Distribution) GetLinearBuckets() *Distribution_LinearBuckets {
if x, ok := m.GetBucketOption().(*Distribution_LinearBuckets_); ok {
return x.LinearBuckets
}
return nil
}
func (m *Distribution) GetExponentialBuckets() *Distribution_ExponentialBuckets {
if x, ok := m.GetBucketOption().(*Distribution_ExponentialBuckets_); ok {
return x.ExponentialBuckets
}
return nil
}
func (m *Distribution) GetExplicitBuckets() *Distribution_ExplicitBuckets {
if x, ok := m.GetBucketOption().(*Distribution_ExplicitBuckets_); ok {
return x.ExplicitBuckets
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Distribution) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Distribution_OneofMarshaler, _Distribution_OneofUnmarshaler, _Distribution_OneofSizer, []interface{}{
(*Distribution_LinearBuckets_)(nil),
(*Distribution_ExponentialBuckets_)(nil),
(*Distribution_ExplicitBuckets_)(nil),
}
}
func _Distribution_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Distribution)
// bucket_option
switch x := m.BucketOption.(type) {
case *Distribution_LinearBuckets_:
b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.LinearBuckets); err != nil {
return err
}
case *Distribution_ExponentialBuckets_:
b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ExponentialBuckets); err != nil {
return err
}
case *Distribution_ExplicitBuckets_:
b.EncodeVarint(9<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ExplicitBuckets); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Distribution.BucketOption has unexpected type %T", x)
}
return nil
}
func _Distribution_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Distribution)
switch tag {
case 7: // bucket_option.linear_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_LinearBuckets)
err := b.DecodeMessage(msg)
m.BucketOption = &Distribution_LinearBuckets_{msg}
return true, err
case 8: // bucket_option.exponential_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_ExponentialBuckets)
err := b.DecodeMessage(msg)
m.BucketOption = &Distribution_ExponentialBuckets_{msg}
return true, err
case 9: // bucket_option.explicit_buckets
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution_ExplicitBuckets)
err := b.DecodeMessage(msg)
m.BucketOption = &Distribution_ExplicitBuckets_{msg}
return true, err
default:
return false, nil
}
}
func _Distribution_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Distribution)
// bucket_option
switch x := m.BucketOption.(type) {
case *Distribution_LinearBuckets_:
s := proto.Size(x.LinearBuckets)
n += proto.SizeVarint(7<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *Distribution_ExponentialBuckets_:
s := proto.Size(x.ExponentialBuckets)
n += proto.SizeVarint(8<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *Distribution_ExplicitBuckets_:
s := proto.Size(x.ExplicitBuckets)
n += proto.SizeVarint(9<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Describing buckets with constant width.
type Distribution_LinearBuckets struct {
// The number of finite buckets. With the underflow and overflow buckets,
// the total number of buckets is `num_finite_buckets` + 2.
// See comments on `bucket_options` for details.
NumFiniteBuckets int32 `protobuf:"varint,1,opt,name=num_finite_buckets,json=numFiniteBuckets" json:"num_finite_buckets,omitempty"`
// The i'th linear bucket covers the interval
// [offset + (i-1) * width, offset + i * width)
// where i ranges from 1 to num_finite_buckets, inclusive.
// Must be strictly positive.
Width float64 `protobuf:"fixed64,2,opt,name=width" json:"width,omitempty"`
// The i'th linear bucket covers the interval
// [offset + (i-1) * width, offset + i * width)
// where i ranges from 1 to num_finite_buckets, inclusive.
Offset float64 `protobuf:"fixed64,3,opt,name=offset" json:"offset,omitempty"`
}
func (m *Distribution_LinearBuckets) Reset() { *m = Distribution_LinearBuckets{} }
func (m *Distribution_LinearBuckets) String() string { return proto.CompactTextString(m) }
func (*Distribution_LinearBuckets) ProtoMessage() {}
func (*Distribution_LinearBuckets) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0, 0} }
func (m *Distribution_LinearBuckets) GetNumFiniteBuckets() int32 {
if m != nil {
return m.NumFiniteBuckets
}
return 0
}
func (m *Distribution_LinearBuckets) GetWidth() float64 {
if m != nil {
return m.Width
}
return 0
}
func (m *Distribution_LinearBuckets) GetOffset() float64 {
if m != nil {
return m.Offset
}
return 0
}
// Describing buckets with exponentially growing width.
type Distribution_ExponentialBuckets struct {
// The number of finite buckets. With the underflow and overflow buckets,
// the total number of buckets is `num_finite_buckets` + 2.
// See comments on `bucket_options` for details.
NumFiniteBuckets int32 `protobuf:"varint,1,opt,name=num_finite_buckets,json=numFiniteBuckets" json:"num_finite_buckets,omitempty"`
// The i'th exponential bucket covers the interval
// [scale * growth_factor^(i-1), scale * growth_factor^i)
// where i ranges from 1 to num_finite_buckets inclusive.
// Must be larger than 1.0.
GrowthFactor float64 `protobuf:"fixed64,2,opt,name=growth_factor,json=growthFactor" json:"growth_factor,omitempty"`
// The i'th exponential bucket covers the interval
// [scale * growth_factor^(i-1), scale * growth_factor^i)
// where i ranges from 1 to num_finite_buckets inclusive.
// Must be > 0.
Scale float64 `protobuf:"fixed64,3,opt,name=scale" json:"scale,omitempty"`
}
func (m *Distribution_ExponentialBuckets) Reset() { *m = Distribution_ExponentialBuckets{} }
func (m *Distribution_ExponentialBuckets) String() string { return proto.CompactTextString(m) }
func (*Distribution_ExponentialBuckets) ProtoMessage() {}
func (*Distribution_ExponentialBuckets) Descriptor() ([]byte, []int) {
return fileDescriptor1, []int{0, 1}
}
func (m *Distribution_ExponentialBuckets) GetNumFiniteBuckets() int32 {
if m != nil {
return m.NumFiniteBuckets
}
return 0
}
func (m *Distribution_ExponentialBuckets) GetGrowthFactor() float64 {
if m != nil {
return m.GrowthFactor
}
return 0
}
func (m *Distribution_ExponentialBuckets) GetScale() float64 {
if m != nil {
return m.Scale
}
return 0
}
// Describing buckets with arbitrary user-provided width.
type Distribution_ExplicitBuckets struct {
// 'bound' is a list of strictly increasing boundaries between
// buckets. Note that a list of length N-1 defines N buckets because
// of fenceposting. See comments on `bucket_options` for details.
//
// The i'th finite bucket covers the interval
// [bound[i-1], bound[i])
// where i ranges from 1 to bound_size() - 1. Note that there are no
// finite buckets at all if 'bound' only contains a single element; in
// that special case the single bound defines the boundary between the
// underflow and overflow buckets.
//
// bucket number lower bound upper bound
// i == 0 (underflow) -inf bound[i]
// 0 < i < bound_size() bound[i-1] bound[i]
// i == bound_size() (overflow) bound[i-1] +inf
Bounds []float64 `protobuf:"fixed64,1,rep,packed,name=bounds" json:"bounds,omitempty"`
}
func (m *Distribution_ExplicitBuckets) Reset() { *m = Distribution_ExplicitBuckets{} }
func (m *Distribution_ExplicitBuckets) String() string { return proto.CompactTextString(m) }
func (*Distribution_ExplicitBuckets) ProtoMessage() {}
func (*Distribution_ExplicitBuckets) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0, 2} }
func (m *Distribution_ExplicitBuckets) GetBounds() []float64 {
if m != nil {
return m.Bounds
}
return nil
}
func init() {
proto.RegisterType((*Distribution)(nil), "google.api.servicecontrol.v1.Distribution")
proto.RegisterType((*Distribution_LinearBuckets)(nil), "google.api.servicecontrol.v1.Distribution.LinearBuckets")
proto.RegisterType((*Distribution_ExponentialBuckets)(nil), "google.api.servicecontrol.v1.Distribution.ExponentialBuckets")
proto.RegisterType((*Distribution_ExplicitBuckets)(nil), "google.api.servicecontrol.v1.Distribution.ExplicitBuckets")
}
func init() { proto.RegisterFile("google/api/servicecontrol/v1/distribution.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 486 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x4d, 0x6f, 0xd3, 0x40,
0x10, 0x86, 0x31, 0x6e, 0x52, 0x18, 0x12, 0x52, 0x96, 0x82, 0xac, 0x88, 0x83, 0x45, 0x2f, 0x41,
0x42, 0xb6, 0x0a, 0x07, 0x10, 0x88, 0x4b, 0x28, 0x15, 0x42, 0x48, 0x54, 0xe6, 0xc6, 0xc5, 0xda,
0xd8, 0x6b, 0x77, 0x55, 0x7b, 0xc7, 0xec, 0x47, 0x9a, 0x0b, 0x57, 0x7e, 0x0f, 0x3f, 0x8f, 0x23,
0xf2, 0xae, 0xf3, 0x45, 0xab, 0x48, 0xb9, 0xf9, 0x7d, 0xc7, 0x33, 0xcf, 0xec, 0x68, 0x06, 0xe2,
0x12, 0xb1, 0xac, 0x58, 0x4c, 0x1b, 0x1e, 0x2b, 0x26, 0xe7, 0x3c, 0x63, 0x19, 0x0a, 0x2d, 0xb1,
0x8a, 0xe7, 0xa7, 0x71, 0xce, 0x95, 0x96, 0x7c, 0x66, 0x34, 0x47, 0x11, 0x35, 0x12, 0x35, 0x92,
0x67, 0x2e, 0x21, 0xa2, 0x0d, 0x8f, 0xb6, 0x13, 0xa2, 0xf9, 0xe9, 0xf3, 0x3f, 0x7d, 0x18, 0x9c,
0x6d, 0x24, 0x91, 0x63, 0xe8, 0x65, 0x68, 0x84, 0x0e, 0xbc, 0xd0, 0x9b, 0xf8, 0x89, 0x13, 0x84,
0xc0, 0x41, 0xcd, 0xa8, 0x08, 0xee, 0x86, 0xde, 0xc4, 0x4b, 0xec, 0x37, 0x09, 0xe0, 0xb0, 0xe6,
0x82, 0xd7, 0xa6, 0x0e, 0x7c, 0x6b, 0x2f, 0xa5, 0x8d, 0xd0, 0x85, 0x8d, 0x1c, 0x74, 0x11, 0x27,
0xc9, 0x1b, 0x08, 0x94, 0xa9, 0x53, 0x2c, 0x52, 0xf5, 0xd3, 0x50, 0xc9, 0xf2, 0x34, 0x67, 0x73,
0x4e, 0x5b, 0x72, 0xd0, 0xb3, 0xbf, 0x3e, 0x51, 0xa6, 0xfe, 0x56, 0x7c, 0x77, 0xd1, 0xb3, 0x65,
0x90, 0x9c, 0xc0, 0x70, 0x66, 0xb2, 0x2b, 0xa6, 0x53, 0xdb, 0x90, 0x0a, 0xfa, 0xa1, 0x3f, 0xf1,
0x93, 0x81, 0x33, 0x3f, 0x5a, 0x8f, 0x50, 0x78, 0x58, 0x71, 0xc1, 0xa8, 0x4c, 0x9d, 0xad, 0x82,
0xc3, 0xd0, 0x9b, 0x3c, 0x78, 0xf5, 0x36, 0xda, 0x35, 0x83, 0x68, 0xf3, 0xfd, 0xd1, 0x57, 0x5b,
0x60, 0xea, 0xf2, 0x3f, 0xdf, 0x49, 0x86, 0xd5, 0xa6, 0x41, 0x1a, 0x78, 0xcc, 0x16, 0x0d, 0x0a,
0x26, 0x34, 0xa7, 0xd5, 0x8a, 0x73, 0xcf, 0x72, 0x3e, 0xec, 0xc1, 0xf9, 0xb4, 0xae, 0xb2, 0x86,
0x11, 0x76, 0xc3, 0x25, 0x25, 0x1c, 0xb1, 0x45, 0x53, 0xf1, 0x8c, 0xeb, 0x15, 0xee, 0xbe, 0xc5,
0xbd, 0xdb, 0x0f, 0x67, 0x4b, 0xac, 0x59, 0x23, 0xb6, 0x6d, 0x8d, 0xaf, 0x60, 0xb8, 0xf5, 0x78,
0xf2, 0x12, 0x88, 0x30, 0x75, 0x5a, 0x70, 0xc1, 0x35, 0x5b, 0xb1, 0xdb, 0xbd, 0xe8, 0x25, 0x47,
0xc2, 0xd4, 0xe7, 0x36, 0xb0, 0xfc, 0xfb, 0x18, 0x7a, 0xd7, 0x3c, 0xd7, 0x97, 0xdd, 0x8e, 0x38,
0x41, 0x9e, 0x42, 0x1f, 0x8b, 0x42, 0x31, 0xdd, 0xed, 0x48, 0xa7, 0xc6, 0xbf, 0x80, 0xdc, 0x9c,
0xc0, 0x9e, 0xc4, 0x13, 0x18, 0x96, 0x12, 0xaf, 0xf5, 0x65, 0x5a, 0xd0, 0x4c, 0xa3, 0xec, 0xc8,
0x03, 0x67, 0x9e, 0x5b, 0xaf, 0x6d, 0x4b, 0x65, 0xb4, 0x62, 0x1d, 0xdf, 0x89, 0xf1, 0x0b, 0x18,
0xfd, 0x37, 0x91, 0xb6, 0xd3, 0x19, 0x1a, 0x91, 0xb7, 0x3c, 0xbf, 0xed, 0xd4, 0xa9, 0xe9, 0x68,
0xb5, 0x79, 0xd8, 0xb4, 0xa3, 0x9c, 0xfe, 0xf6, 0x20, 0xcc, 0xb0, 0xde, 0x39, 0xfc, 0xe9, 0xa3,
0xcd, 0xe9, 0x5f, 0xb4, 0x87, 0x78, 0xe1, 0xfd, 0xf8, 0xd2, 0xa5, 0x94, 0x58, 0x51, 0x51, 0x46,
0x28, 0xcb, 0xb8, 0x64, 0xc2, 0x9e, 0x69, 0x77, 0xd6, 0xb4, 0xe1, 0xea, 0xf6, 0xd3, 0x7e, 0xbf,
0xed, 0xfc, 0xf5, 0xbc, 0x59, 0xdf, 0x66, 0xbe, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0x14, 0x52,
0xaf, 0xef, 0x13, 0x04, 0x00, 0x00,
}

258
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/log_entry.pb.go generated vendored Normal file
View File

@ -0,0 +1,258 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicecontrol/v1/log_entry.proto
package servicecontrol
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_logging_type "google.golang.org/genproto/googleapis/logging/type"
import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
import google_protobuf2 "github.com/golang/protobuf/ptypes/struct"
import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// An individual log entry.
type LogEntry struct {
// Required. The log to which this log entry belongs. Examples: `"syslog"`,
// `"book_log"`.
Name string `protobuf:"bytes,10,opt,name=name" json:"name,omitempty"`
// The time the event described by the log entry occurred. If
// omitted, defaults to operation start time.
Timestamp *google_protobuf3.Timestamp `protobuf:"bytes,11,opt,name=timestamp" json:"timestamp,omitempty"`
// The severity of the log entry. The default value is
// `LogSeverity.DEFAULT`.
Severity google_logging_type.LogSeverity `protobuf:"varint,12,opt,name=severity,enum=google.logging.type.LogSeverity" json:"severity,omitempty"`
// A unique ID for the log entry used for deduplication. If omitted,
// the implementation will generate one based on operation_id.
InsertId string `protobuf:"bytes,4,opt,name=insert_id,json=insertId" json:"insert_id,omitempty"`
// A set of user-defined (key, value) data that provides additional
// information about the log entry.
Labels map[string]string `protobuf:"bytes,13,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// The log entry payload, which can be one of multiple types.
//
// Types that are valid to be assigned to Payload:
// *LogEntry_ProtoPayload
// *LogEntry_TextPayload
// *LogEntry_StructPayload
Payload isLogEntry_Payload `protobuf_oneof:"payload"`
}
func (m *LogEntry) Reset() { *m = LogEntry{} }
func (m *LogEntry) String() string { return proto.CompactTextString(m) }
func (*LogEntry) ProtoMessage() {}
func (*LogEntry) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
type isLogEntry_Payload interface {
isLogEntry_Payload()
}
type LogEntry_ProtoPayload struct {
ProtoPayload *google_protobuf1.Any `protobuf:"bytes,2,opt,name=proto_payload,json=protoPayload,oneof"`
}
type LogEntry_TextPayload struct {
TextPayload string `protobuf:"bytes,3,opt,name=text_payload,json=textPayload,oneof"`
}
type LogEntry_StructPayload struct {
StructPayload *google_protobuf2.Struct `protobuf:"bytes,6,opt,name=struct_payload,json=structPayload,oneof"`
}
func (*LogEntry_ProtoPayload) isLogEntry_Payload() {}
func (*LogEntry_TextPayload) isLogEntry_Payload() {}
func (*LogEntry_StructPayload) isLogEntry_Payload() {}
func (m *LogEntry) GetPayload() isLogEntry_Payload {
if m != nil {
return m.Payload
}
return nil
}
func (m *LogEntry) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *LogEntry) GetTimestamp() *google_protobuf3.Timestamp {
if m != nil {
return m.Timestamp
}
return nil
}
func (m *LogEntry) GetSeverity() google_logging_type.LogSeverity {
if m != nil {
return m.Severity
}
return google_logging_type.LogSeverity_DEFAULT
}
func (m *LogEntry) GetInsertId() string {
if m != nil {
return m.InsertId
}
return ""
}
func (m *LogEntry) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *LogEntry) GetProtoPayload() *google_protobuf1.Any {
if x, ok := m.GetPayload().(*LogEntry_ProtoPayload); ok {
return x.ProtoPayload
}
return nil
}
func (m *LogEntry) GetTextPayload() string {
if x, ok := m.GetPayload().(*LogEntry_TextPayload); ok {
return x.TextPayload
}
return ""
}
func (m *LogEntry) GetStructPayload() *google_protobuf2.Struct {
if x, ok := m.GetPayload().(*LogEntry_StructPayload); ok {
return x.StructPayload
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*LogEntry) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _LogEntry_OneofMarshaler, _LogEntry_OneofUnmarshaler, _LogEntry_OneofSizer, []interface{}{
(*LogEntry_ProtoPayload)(nil),
(*LogEntry_TextPayload)(nil),
(*LogEntry_StructPayload)(nil),
}
}
func _LogEntry_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*LogEntry)
// payload
switch x := m.Payload.(type) {
case *LogEntry_ProtoPayload:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ProtoPayload); err != nil {
return err
}
case *LogEntry_TextPayload:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.TextPayload)
case *LogEntry_StructPayload:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.StructPayload); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("LogEntry.Payload has unexpected type %T", x)
}
return nil
}
func _LogEntry_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*LogEntry)
switch tag {
case 2: // payload.proto_payload
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf1.Any)
err := b.DecodeMessage(msg)
m.Payload = &LogEntry_ProtoPayload{msg}
return true, err
case 3: // payload.text_payload
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Payload = &LogEntry_TextPayload{x}
return true, err
case 6: // payload.struct_payload
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf2.Struct)
err := b.DecodeMessage(msg)
m.Payload = &LogEntry_StructPayload{msg}
return true, err
default:
return false, nil
}
}
func _LogEntry_OneofSizer(msg proto.Message) (n int) {
m := msg.(*LogEntry)
// payload
switch x := m.Payload.(type) {
case *LogEntry_ProtoPayload:
s := proto.Size(x.ProtoPayload)
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *LogEntry_TextPayload:
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.TextPayload)))
n += len(x.TextPayload)
case *LogEntry_StructPayload:
s := proto.Size(x.StructPayload)
n += proto.SizeVarint(6<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
func init() {
proto.RegisterType((*LogEntry)(nil), "google.api.servicecontrol.v1.LogEntry")
}
func init() { proto.RegisterFile("google/api/servicecontrol/v1/log_entry.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 454 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x4f, 0x8f, 0xd3, 0x30,
0x10, 0xc5, 0x9b, 0xed, 0x52, 0x1a, 0xa7, 0x5d, 0x21, 0x6b, 0x25, 0x42, 0xa8, 0x44, 0x04, 0x12,
0xea, 0x01, 0x39, 0xda, 0x72, 0x59, 0x58, 0x0e, 0x50, 0x09, 0xa9, 0xac, 0x7a, 0x58, 0x65, 0x39,
0x71, 0xa9, 0xdc, 0xd6, 0x58, 0x16, 0xae, 0x27, 0x4a, 0xdc, 0x88, 0x9c, 0xf8, 0xbc, 0x7c, 0x0b,
0x94, 0xb1, 0x53, 0xf6, 0x9f, 0xf6, 0xe6, 0xf1, 0xfb, 0xbd, 0x99, 0x79, 0x8e, 0x42, 0xde, 0x49,
0x00, 0xa9, 0x45, 0xc6, 0x0b, 0x95, 0x55, 0xa2, 0xac, 0xd5, 0x46, 0x6c, 0xc0, 0xd8, 0x12, 0x74,
0x56, 0x9f, 0x65, 0x1a, 0xe4, 0x4a, 0x18, 0x5b, 0x36, 0xac, 0x28, 0xc1, 0x02, 0x9d, 0x38, 0x9a,
0xf1, 0x42, 0xb1, 0xdb, 0x34, 0xab, 0xcf, 0x92, 0xc9, 0x8d, 0x5e, 0xdc, 0x18, 0xb0, 0xdc, 0x2a,
0x30, 0x95, 0xf3, 0x26, 0x6f, 0xbd, 0xaa, 0x41, 0x4a, 0x65, 0x64, 0x66, 0x9b, 0x02, 0x8b, 0x55,
0x25, 0x6a, 0x51, 0x2a, 0xeb, 0x67, 0x24, 0x2f, 0x3c, 0x87, 0xd5, 0x7a, 0xff, 0x33, 0xe3, 0xa6,
0x93, 0x26, 0x77, 0xa5, 0xca, 0x96, 0xfb, 0x8d, 0xf5, 0xea, 0xab, 0xbb, 0xaa, 0x55, 0x3b, 0x51,
0x59, 0xbe, 0x2b, 0x1c, 0xf0, 0xfa, 0x6f, 0x9f, 0x0c, 0x97, 0x20, 0xbf, 0xb6, 0x81, 0x28, 0x25,
0xc7, 0x86, 0xef, 0x44, 0x4c, 0xd2, 0x60, 0x1a, 0xe6, 0x78, 0xa6, 0xe7, 0x24, 0x3c, 0x78, 0xe2,
0x28, 0x0d, 0xa6, 0xd1, 0x2c, 0x61, 0x3e, 0x72, 0xd7, 0x95, 0x7d, 0xef, 0x88, 0xfc, 0x3f, 0x4c,
0x3f, 0x91, 0x61, 0x17, 0x23, 0x1e, 0xa5, 0xc1, 0xf4, 0x64, 0x96, 0x76, 0x46, 0x9f, 0x97, 0xb5,
0x79, 0xd9, 0x12, 0xe4, 0xb5, 0xe7, 0xf2, 0x83, 0x83, 0xbe, 0x24, 0xa1, 0x32, 0x95, 0x28, 0xed,
0x4a, 0x6d, 0xe3, 0x63, 0x5c, 0x68, 0xe8, 0x2e, 0xbe, 0x6d, 0xe9, 0x25, 0x19, 0x68, 0xbe, 0x16,
0xba, 0x8a, 0xc7, 0x69, 0x7f, 0x1a, 0xcd, 0x66, 0xec, 0xb1, 0x8f, 0xc0, 0xba, 0x80, 0x6c, 0x89,
0x26, 0x3c, 0xe7, 0xbe, 0x03, 0xbd, 0x20, 0x63, 0xcc, 0xb1, 0x2a, 0x78, 0xa3, 0x81, 0x6f, 0xe3,
0x23, 0x0c, 0x79, 0x7a, 0x2f, 0xe4, 0x17, 0xd3, 0x2c, 0x7a, 0xf9, 0x08, 0xeb, 0x2b, 0xc7, 0xd2,
0x37, 0x64, 0x64, 0xc5, 0x6f, 0x7b, 0xf0, 0xf6, 0xdb, 0x45, 0x17, 0xbd, 0x3c, 0x6a, 0x6f, 0x3b,
0xe8, 0x33, 0x39, 0x71, 0x1f, 0xe5, 0x80, 0x0d, 0x70, 0xc4, 0xf3, 0x7b, 0x23, 0xae, 0x11, 0x5b,
0xf4, 0xf2, 0xb1, 0x33, 0xf8, 0x0e, 0xc9, 0x07, 0x12, 0xdd, 0x58, 0x9d, 0x3e, 0x23, 0xfd, 0x5f,
0xa2, 0x89, 0x03, 0x7c, 0x95, 0xf6, 0x48, 0x4f, 0xc9, 0x93, 0x9a, 0xeb, 0xbd, 0xc0, 0xe5, 0xc3,
0xdc, 0x15, 0x1f, 0x8f, 0xce, 0x83, 0x79, 0x48, 0x9e, 0xfa, 0xa9, 0xf3, 0x3f, 0x24, 0xdd, 0xc0,
0xee, 0xd1, 0xa7, 0x9a, 0x8f, 0xbb, 0xb7, 0xba, 0xc2, 0x98, 0xc1, 0x8f, 0x4b, 0x8f, 0x4b, 0xd0,
0xdc, 0x48, 0x06, 0xa5, 0xcc, 0xa4, 0x30, 0xb8, 0x71, 0xe6, 0x24, 0x5e, 0xa8, 0xea, 0xe1, 0x7f,
0xe5, 0xe2, 0xf6, 0xcd, 0x7a, 0x80, 0xb6, 0xf7, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x67, 0x50,
0x6e, 0x13, 0x61, 0x03, 0x00, 0x00,
}

324
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/metric_value.pb.go generated vendored Normal file
View File

@ -0,0 +1,324 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicecontrol/v1/metric_value.proto
package servicecontrol
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp"
import _ "google.golang.org/genproto/googleapis/type/money"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Represents a single metric value.
type MetricValue struct {
// The labels describing the metric value.
// See comments on [google.api.servicecontrol.v1.Operation.labels][google.api.servicecontrol.v1.Operation.labels] for
// the overriding relationship.
Labels map[string]string `protobuf:"bytes,1,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// The start of the time period over which this metric value's measurement
// applies. The time period has different semantics for different metric
// types (cumulative, delta, and gauge). See the metric definition
// documentation in the service configuration for details.
StartTime *google_protobuf3.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
// The end of the time period over which this metric value's measurement
// applies.
EndTime *google_protobuf3.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
// The value. The type of value used in the request must
// agree with the metric definition in the service configuration, otherwise
// the MetricValue is rejected.
//
// Types that are valid to be assigned to Value:
// *MetricValue_BoolValue
// *MetricValue_Int64Value
// *MetricValue_DoubleValue
// *MetricValue_StringValue
// *MetricValue_DistributionValue
Value isMetricValue_Value `protobuf_oneof:"value"`
}
func (m *MetricValue) Reset() { *m = MetricValue{} }
func (m *MetricValue) String() string { return proto.CompactTextString(m) }
func (*MetricValue) ProtoMessage() {}
func (*MetricValue) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
type isMetricValue_Value interface {
isMetricValue_Value()
}
type MetricValue_BoolValue struct {
BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,oneof"`
}
type MetricValue_Int64Value struct {
Int64Value int64 `protobuf:"varint,5,opt,name=int64_value,json=int64Value,oneof"`
}
type MetricValue_DoubleValue struct {
DoubleValue float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue,oneof"`
}
type MetricValue_StringValue struct {
StringValue string `protobuf:"bytes,7,opt,name=string_value,json=stringValue,oneof"`
}
type MetricValue_DistributionValue struct {
DistributionValue *Distribution `protobuf:"bytes,8,opt,name=distribution_value,json=distributionValue,oneof"`
}
func (*MetricValue_BoolValue) isMetricValue_Value() {}
func (*MetricValue_Int64Value) isMetricValue_Value() {}
func (*MetricValue_DoubleValue) isMetricValue_Value() {}
func (*MetricValue_StringValue) isMetricValue_Value() {}
func (*MetricValue_DistributionValue) isMetricValue_Value() {}
func (m *MetricValue) GetValue() isMetricValue_Value {
if m != nil {
return m.Value
}
return nil
}
func (m *MetricValue) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *MetricValue) GetStartTime() *google_protobuf3.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
func (m *MetricValue) GetEndTime() *google_protobuf3.Timestamp {
if m != nil {
return m.EndTime
}
return nil
}
func (m *MetricValue) GetBoolValue() bool {
if x, ok := m.GetValue().(*MetricValue_BoolValue); ok {
return x.BoolValue
}
return false
}
func (m *MetricValue) GetInt64Value() int64 {
if x, ok := m.GetValue().(*MetricValue_Int64Value); ok {
return x.Int64Value
}
return 0
}
func (m *MetricValue) GetDoubleValue() float64 {
if x, ok := m.GetValue().(*MetricValue_DoubleValue); ok {
return x.DoubleValue
}
return 0
}
func (m *MetricValue) GetStringValue() string {
if x, ok := m.GetValue().(*MetricValue_StringValue); ok {
return x.StringValue
}
return ""
}
func (m *MetricValue) GetDistributionValue() *Distribution {
if x, ok := m.GetValue().(*MetricValue_DistributionValue); ok {
return x.DistributionValue
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*MetricValue) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _MetricValue_OneofMarshaler, _MetricValue_OneofUnmarshaler, _MetricValue_OneofSizer, []interface{}{
(*MetricValue_BoolValue)(nil),
(*MetricValue_Int64Value)(nil),
(*MetricValue_DoubleValue)(nil),
(*MetricValue_StringValue)(nil),
(*MetricValue_DistributionValue)(nil),
}
}
func _MetricValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*MetricValue)
// value
switch x := m.Value.(type) {
case *MetricValue_BoolValue:
t := uint64(0)
if x.BoolValue {
t = 1
}
b.EncodeVarint(4<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *MetricValue_Int64Value:
b.EncodeVarint(5<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Int64Value))
case *MetricValue_DoubleValue:
b.EncodeVarint(6<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.DoubleValue))
case *MetricValue_StringValue:
b.EncodeVarint(7<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StringValue)
case *MetricValue_DistributionValue:
b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.DistributionValue); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("MetricValue.Value has unexpected type %T", x)
}
return nil
}
func _MetricValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*MetricValue)
switch tag {
case 4: // value.bool_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &MetricValue_BoolValue{x != 0}
return true, err
case 5: // value.int64_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Value = &MetricValue_Int64Value{int64(x)}
return true, err
case 6: // value.double_value
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Value = &MetricValue_DoubleValue{math.Float64frombits(x)}
return true, err
case 7: // value.string_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Value = &MetricValue_StringValue{x}
return true, err
case 8: // value.distribution_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Distribution)
err := b.DecodeMessage(msg)
m.Value = &MetricValue_DistributionValue{msg}
return true, err
default:
return false, nil
}
}
func _MetricValue_OneofSizer(msg proto.Message) (n int) {
m := msg.(*MetricValue)
// value
switch x := m.Value.(type) {
case *MetricValue_BoolValue:
n += proto.SizeVarint(4<<3 | proto.WireVarint)
n += 1
case *MetricValue_Int64Value:
n += proto.SizeVarint(5<<3 | proto.WireVarint)
n += proto.SizeVarint(uint64(x.Int64Value))
case *MetricValue_DoubleValue:
n += proto.SizeVarint(6<<3 | proto.WireFixed64)
n += 8
case *MetricValue_StringValue:
n += proto.SizeVarint(7<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.StringValue)))
n += len(x.StringValue)
case *MetricValue_DistributionValue:
s := proto.Size(x.DistributionValue)
n += proto.SizeVarint(8<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Represents a set of metric values in the same metric.
// Each metric value in the set should have a unique combination of start time,
// end time, and label values.
type MetricValueSet struct {
// The metric name defined in the service configuration.
MetricName string `protobuf:"bytes,1,opt,name=metric_name,json=metricName" json:"metric_name,omitempty"`
// The values in this metric.
MetricValues []*MetricValue `protobuf:"bytes,2,rep,name=metric_values,json=metricValues" json:"metric_values,omitempty"`
}
func (m *MetricValueSet) Reset() { *m = MetricValueSet{} }
func (m *MetricValueSet) String() string { return proto.CompactTextString(m) }
func (*MetricValueSet) ProtoMessage() {}
func (*MetricValueSet) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
func (m *MetricValueSet) GetMetricName() string {
if m != nil {
return m.MetricName
}
return ""
}
func (m *MetricValueSet) GetMetricValues() []*MetricValue {
if m != nil {
return m.MetricValues
}
return nil
}
func init() {
proto.RegisterType((*MetricValue)(nil), "google.api.servicecontrol.v1.MetricValue")
proto.RegisterType((*MetricValueSet)(nil), "google.api.servicecontrol.v1.MetricValueSet")
}
func init() { proto.RegisterFile("google/api/servicecontrol/v1/metric_value.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 482 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0x8b, 0xd3, 0x40,
0x14, 0xc7, 0x3b, 0x8d, 0xdb, 0x1f, 0x2f, 0xab, 0x68, 0x14, 0x0c, 0x65, 0xa1, 0x71, 0xbd, 0x44,
0x0f, 0x13, 0x76, 0x75, 0xc5, 0xd5, 0x5b, 0x51, 0x28, 0xe2, 0x2e, 0x4b, 0x14, 0x0f, 0x7a, 0x58,
0x26, 0xed, 0x33, 0x0c, 0x26, 0x33, 0x21, 0x33, 0x2d, 0xf4, 0xe8, 0xcd, 0x3f, 0xd9, 0x8b, 0x20,
0xf3, 0xa3, 0x9a, 0x82, 0xd4, 0xbd, 0xe5, 0x7d, 0xf3, 0xfd, 0xbc, 0x7c, 0x27, 0xef, 0x0d, 0x64,
0xa5, 0x94, 0x65, 0x85, 0x19, 0x6b, 0x78, 0xa6, 0xb0, 0x5d, 0xf3, 0x05, 0x2e, 0xa4, 0xd0, 0xad,
0xac, 0xb2, 0xf5, 0x49, 0x56, 0xa3, 0x6e, 0xf9, 0xe2, 0x7a, 0xcd, 0xaa, 0x15, 0xd2, 0xa6, 0x95,
0x5a, 0x46, 0x47, 0x0e, 0xa0, 0xac, 0xe1, 0x74, 0x17, 0xa0, 0xeb, 0x93, 0xc9, 0x51, 0xa7, 0x1d,
0x13, 0x42, 0x6a, 0xa6, 0xb9, 0x14, 0xca, 0xb1, 0x93, 0xfd, 0x1f, 0x5b, 0x72, 0xa5, 0x5b, 0x5e,
0xac, 0x0c, 0xe1, 0x81, 0xa9, 0x07, 0x6c, 0x55, 0xac, 0xbe, 0x66, 0x9a, 0xd7, 0xa8, 0x34, 0xab,
0x1b, 0x6f, 0x78, 0xe8, 0x0d, 0x7a, 0xd3, 0x60, 0x56, 0x4b, 0x81, 0x1b, 0xf7, 0xe2, 0xf8, 0x57,
0x00, 0xe1, 0x85, 0x4d, 0xff, 0xc9, 0x84, 0x8f, 0x2e, 0x60, 0x50, 0xb1, 0x02, 0x2b, 0x15, 0x93,
0x24, 0x48, 0xc3, 0xd3, 0x33, 0xba, 0xef, 0x1c, 0xb4, 0x83, 0xd2, 0xf7, 0x96, 0x7b, 0x2b, 0x74,
0xbb, 0xc9, 0x7d, 0x93, 0xe8, 0x1c, 0x40, 0x69, 0xd6, 0xea, 0x6b, 0x13, 0x28, 0xee, 0x27, 0x24,
0x0d, 0x4f, 0x27, 0xdb, 0x96, 0xdb, 0xb4, 0xf4, 0xe3, 0x36, 0x6d, 0x3e, 0xb6, 0x6e, 0x53, 0x47,
0x67, 0x30, 0x42, 0xb1, 0x74, 0x60, 0xf0, 0x5f, 0x70, 0x88, 0x62, 0x69, 0xb1, 0x29, 0x40, 0x21,
0x65, 0xe5, 0x66, 0x11, 0xdf, 0x4a, 0x48, 0x3a, 0x9a, 0xf7, 0xf2, 0xb1, 0xd1, 0xdc, 0x09, 0x1f,
0x41, 0xc8, 0x85, 0x7e, 0xf1, 0xdc, 0x3b, 0x0e, 0x12, 0x92, 0x06, 0xf3, 0x5e, 0x0e, 0x56, 0x74,
0x96, 0xc7, 0x70, 0xb8, 0x94, 0xab, 0xa2, 0x42, 0xef, 0x19, 0x24, 0x24, 0x25, 0xf3, 0x5e, 0x1e,
0x3a, 0xf5, 0x8f, 0xc9, 0xcc, 0x41, 0x94, 0xde, 0x34, 0x4c, 0x48, 0x3a, 0x36, 0x26, 0xa7, 0x3a,
0xd3, 0x17, 0x88, 0xba, 0xe3, 0xf2, 0xd6, 0x91, 0x3d, 0xce, 0xd3, 0xfd, 0xbf, 0xf6, 0x4d, 0x87,
0x9b, 0xf7, 0xf2, 0x7b, 0xdd, 0x3e, 0xb6, 0xf9, 0xe4, 0x1c, 0xc2, 0xce, 0x3f, 0x8f, 0xee, 0x42,
0xf0, 0x0d, 0x37, 0x31, 0x31, 0x39, 0x72, 0xf3, 0x18, 0x3d, 0x80, 0x03, 0xf7, 0xc1, 0xbe, 0xd5,
0x5c, 0xf1, 0xaa, 0xff, 0x92, 0xcc, 0x86, 0xfe, 0xcd, 0xf1, 0x77, 0x02, 0x77, 0x3a, 0x43, 0xfc,
0x80, 0x3a, 0x9a, 0x42, 0xe8, 0xf7, 0x59, 0xb0, 0x1a, 0x7d, 0x3f, 0x70, 0xd2, 0x25, 0xab, 0x31,
0xba, 0x84, 0xdb, 0xdd, 0x85, 0x57, 0x71, 0xdf, 0xae, 0xca, 0x93, 0x1b, 0xaf, 0x4a, 0x7e, 0x58,
0xff, 0x2d, 0xd4, 0xec, 0x07, 0x81, 0x64, 0x21, 0xeb, 0xbd, 0xf8, 0xec, 0xfe, 0x6e, 0xca, 0x2b,
0xb3, 0x02, 0x57, 0xe4, 0xf3, 0x3b, 0x0f, 0x95, 0xb2, 0x62, 0xa2, 0xa4, 0xb2, 0x2d, 0xb3, 0x12,
0x85, 0x5d, 0x10, 0x7f, 0x8b, 0x58, 0xc3, 0xd5, 0xbf, 0x6f, 0xd2, 0xeb, 0x5d, 0xe5, 0x27, 0x21,
0xc5, 0xc0, 0x92, 0xcf, 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0xdb, 0x00, 0x1a, 0xde, 0xef, 0x03,
0x00, 0x00,
}

215
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/operation.pb.go generated vendored Normal file
View File

@ -0,0 +1,215 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicecontrol/v1/operation.proto
package servicecontrol
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Defines the importance of the data contained in the operation.
type Operation_Importance int32
const (
// The API implementation may cache and aggregate the data.
// The data may be lost when rare and unexpected system failures occur.
Operation_LOW Operation_Importance = 0
// The API implementation doesn't cache and aggregate the data.
// If the method returns successfully, it's guaranteed that the data has
// been persisted in durable storage.
Operation_HIGH Operation_Importance = 1
)
var Operation_Importance_name = map[int32]string{
0: "LOW",
1: "HIGH",
}
var Operation_Importance_value = map[string]int32{
"LOW": 0,
"HIGH": 1,
}
func (x Operation_Importance) String() string {
return proto.EnumName(Operation_Importance_name, int32(x))
}
func (Operation_Importance) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 0} }
// Represents information regarding an operation.
type Operation struct {
// Identity of the operation. This must be unique within the scope of the
// service that generated the operation. If the service calls
// Check() and Report() on the same operation, the two calls should carry
// the same id.
//
// UUID version 4 is recommended, though not required.
// In scenarios where an operation is computed from existing information
// and an idempotent id is desirable for deduplication purpose, UUID version 5
// is recommended. See RFC 4122 for details.
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId" json:"operation_id,omitempty"`
// Fully qualified name of the operation. Reserved for future use.
OperationName string `protobuf:"bytes,2,opt,name=operation_name,json=operationName" json:"operation_name,omitempty"`
// Identity of the consumer who is using the service.
// This field should be filled in for the operations initiated by a
// consumer, but not for service-initiated operations that are
// not related to a specific consumer.
//
// This can be in one of the following formats:
// project:<project_id>,
// project_number:<project_number>,
// api_key:<api_key>.
ConsumerId string `protobuf:"bytes,3,opt,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
// Required. Start time of the operation.
StartTime *google_protobuf3.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
// End time of the operation.
// Required when the operation is used in [ServiceController.Report][google.api.servicecontrol.v1.ServiceController.Report],
// but optional when the operation is used in [ServiceController.Check][google.api.servicecontrol.v1.ServiceController.Check].
EndTime *google_protobuf3.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
// Labels describing the operation. Only the following labels are allowed:
//
// - Labels describing monitored resources as defined in
// the service configuration.
// - Default labels of metric values. When specified, labels defined in the
// metric value override these default.
// - The following labels defined by Google Cloud Platform:
// - `cloud.googleapis.com/location` describing the location where the
// operation happened,
// - `servicecontrol.googleapis.com/user_agent` describing the user agent
// of the API request,
// - `servicecontrol.googleapis.com/service_agent` describing the service
// used to handle the API request (e.g. ESP),
// - `servicecontrol.googleapis.com/platform` describing the platform
// where the API is served (e.g. GAE, GCE, GKE).
Labels map[string]string `protobuf:"bytes,6,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Represents information about this operation. Each MetricValueSet
// corresponds to a metric defined in the service configuration.
// The data type used in the MetricValueSet must agree with
// the data type specified in the metric definition.
//
// Within a single operation, it is not allowed to have more than one
// MetricValue instances that have the same metric names and identical
// label value combinations. If a request has such duplicated MetricValue
// instances, the entire request is rejected with
// an invalid argument error.
MetricValueSets []*MetricValueSet `protobuf:"bytes,7,rep,name=metric_value_sets,json=metricValueSets" json:"metric_value_sets,omitempty"`
// Represents information to be logged.
LogEntries []*LogEntry `protobuf:"bytes,8,rep,name=log_entries,json=logEntries" json:"log_entries,omitempty"`
// DO NOT USE. This is an experimental field.
Importance Operation_Importance `protobuf:"varint,11,opt,name=importance,enum=google.api.servicecontrol.v1.Operation_Importance" json:"importance,omitempty"`
}
func (m *Operation) Reset() { *m = Operation{} }
func (m *Operation) String() string { return proto.CompactTextString(m) }
func (*Operation) ProtoMessage() {}
func (*Operation) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
func (m *Operation) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *Operation) GetOperationName() string {
if m != nil {
return m.OperationName
}
return ""
}
func (m *Operation) GetConsumerId() string {
if m != nil {
return m.ConsumerId
}
return ""
}
func (m *Operation) GetStartTime() *google_protobuf3.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
func (m *Operation) GetEndTime() *google_protobuf3.Timestamp {
if m != nil {
return m.EndTime
}
return nil
}
func (m *Operation) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Operation) GetMetricValueSets() []*MetricValueSet {
if m != nil {
return m.MetricValueSets
}
return nil
}
func (m *Operation) GetLogEntries() []*LogEntry {
if m != nil {
return m.LogEntries
}
return nil
}
func (m *Operation) GetImportance() Operation_Importance {
if m != nil {
return m.Importance
}
return Operation_LOW
}
func init() {
proto.RegisterType((*Operation)(nil), "google.api.servicecontrol.v1.Operation")
proto.RegisterEnum("google.api.servicecontrol.v1.Operation_Importance", Operation_Importance_name, Operation_Importance_value)
}
func init() { proto.RegisterFile("google/api/servicecontrol/v1/operation.proto", fileDescriptor4) }
var fileDescriptor4 = []byte{
// 483 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0x6b, 0x13, 0x41,
0x14, 0xc7, 0x9d, 0xa6, 0xf9, 0xf5, 0x56, 0x63, 0x1c, 0x3c, 0x2c, 0xa1, 0x90, 0x58, 0x50, 0x72,
0x28, 0xb3, 0x34, 0x45, 0xb0, 0x7a, 0x2b, 0x48, 0x1b, 0x8d, 0xb6, 0xac, 0xa2, 0xe2, 0x25, 0x4c,
0x36, 0xcf, 0x65, 0x70, 0x77, 0x66, 0x99, 0x99, 0x04, 0x7a, 0xf6, 0xe2, 0x9f, 0xec, 0x51, 0x76,
0xf6, 0x47, 0x13, 0x90, 0xb5, 0xb7, 0x7d, 0x8f, 0xef, 0xe7, 0xbb, 0xdf, 0x79, 0x6f, 0x06, 0x4e,
0x62, 0xa5, 0xe2, 0x04, 0x03, 0x9e, 0x89, 0xc0, 0xa0, 0xde, 0x8a, 0x08, 0x23, 0x25, 0xad, 0x56,
0x49, 0xb0, 0x3d, 0x0d, 0x54, 0x86, 0x9a, 0x5b, 0xa1, 0x24, 0xcb, 0xb4, 0xb2, 0x8a, 0x1e, 0x15,
0x6a, 0xc6, 0x33, 0xc1, 0xf6, 0xd5, 0x6c, 0x7b, 0x3a, 0x3a, 0xda, 0xf1, 0xe2, 0x52, 0x2a, 0xeb,
0x50, 0x53, 0xb0, 0xa3, 0xe6, 0x3f, 0x25, 0x2a, 0x5e, 0xa2, 0xb4, 0xfa, 0xb6, 0x54, 0x07, 0x8d,
0xea, 0x14, 0xad, 0x16, 0xd1, 0x72, 0xcb, 0x93, 0x0d, 0x96, 0xc0, 0xb8, 0x04, 0x5c, 0xb5, 0xda,
0xfc, 0x08, 0xac, 0x48, 0xd1, 0x58, 0x9e, 0x66, 0x85, 0xe0, 0xf8, 0x77, 0x1b, 0xfa, 0xd7, 0xd5,
0x79, 0xe8, 0x33, 0x78, 0x58, 0x1f, 0x6e, 0x29, 0xd6, 0x3e, 0x99, 0x90, 0x69, 0x3f, 0xf4, 0xea,
0xde, 0x7c, 0x4d, 0x9f, 0xc3, 0xe0, 0x4e, 0x22, 0x79, 0x8a, 0xfe, 0x81, 0x13, 0x3d, 0xaa, 0xbb,
0x1f, 0x79, 0x8a, 0x74, 0x0c, 0x5e, 0xa4, 0xa4, 0xd9, 0xa4, 0xa8, 0x73, 0xa3, 0x96, 0xd3, 0x40,
0xd5, 0x9a, 0xaf, 0xe9, 0x39, 0x80, 0xb1, 0x5c, 0xdb, 0x65, 0x9e, 0xc8, 0x3f, 0x9c, 0x90, 0xa9,
0x37, 0x1b, 0xb1, 0x72, 0x92, 0x55, 0x5c, 0xf6, 0xb9, 0x8a, 0x1b, 0xf6, 0x9d, 0x3a, 0xaf, 0xe9,
0x4b, 0xe8, 0xa1, 0x5c, 0x17, 0x60, 0xfb, 0xbf, 0x60, 0x17, 0xe5, 0xda, 0x61, 0xef, 0xa1, 0x93,
0xf0, 0x15, 0x26, 0xc6, 0xef, 0x4c, 0x5a, 0x53, 0x6f, 0x76, 0xc6, 0x9a, 0xf6, 0xc6, 0xea, 0xa9,
0xb0, 0x85, 0xa3, 0xde, 0xe6, 0x7b, 0x08, 0x4b, 0x0b, 0xfa, 0x0d, 0x9e, 0xec, 0x8e, 0x7b, 0x69,
0xd0, 0x1a, 0xbf, 0xeb, 0x7c, 0x4f, 0x9a, 0x7d, 0x3f, 0x38, 0xec, 0x4b, 0x4e, 0x7d, 0x42, 0x1b,
0x3e, 0x4e, 0xf7, 0x6a, 0x43, 0x2f, 0xc1, 0xab, 0xd6, 0x2e, 0xd0, 0xf8, 0x3d, 0xe7, 0xf9, 0xa2,
0xd9, 0x73, 0xa1, 0xe2, 0x22, 0x1e, 0x24, 0xc5, 0x97, 0x40, 0x43, 0x43, 0x00, 0x91, 0x66, 0x4a,
0x5b, 0x2e, 0x23, 0xf4, 0xbd, 0x09, 0x99, 0x0e, 0x66, 0xb3, 0xfb, 0x9e, 0x79, 0x5e, 0x93, 0xe1,
0x8e, 0xcb, 0xe8, 0x1c, 0xbc, 0x9d, 0x69, 0xd0, 0x21, 0xb4, 0x7e, 0xe2, 0x6d, 0x79, 0x4d, 0xf2,
0x4f, 0xfa, 0x14, 0xda, 0x6e, 0x20, 0xe5, 0xad, 0x28, 0x8a, 0xd7, 0x07, 0xaf, 0xc8, 0xf1, 0x18,
0xe0, 0xce, 0x94, 0x76, 0xa1, 0xb5, 0xb8, 0xfe, 0x3a, 0x7c, 0x40, 0x7b, 0x70, 0x78, 0x35, 0xbf,
0xbc, 0x1a, 0x92, 0x8b, 0x5f, 0x04, 0x26, 0x91, 0x4a, 0x1b, 0x13, 0x5e, 0x0c, 0xea, 0x88, 0x37,
0xf9, 0xaa, 0x6f, 0xc8, 0xf7, 0x77, 0xa5, 0x3e, 0x56, 0x09, 0x97, 0x31, 0x53, 0x3a, 0x0e, 0x62,
0x94, 0xee, 0x22, 0x94, 0xcf, 0x85, 0x67, 0xc2, 0xfc, 0xfb, 0xc9, 0xbc, 0xd9, 0xef, 0xfc, 0x21,
0x64, 0xd5, 0x71, 0xe4, 0xd9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8d, 0x9c, 0xc2, 0x5d, 0x03,
0x04, 0x00, 0x00,
}

489
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/quota_controller.pb.go generated vendored Normal file
View File

@ -0,0 +1,489 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicecontrol/v1/quota_controller.proto
package servicecontrol
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Supported quota modes.
type QuotaOperation_QuotaMode int32
const (
// Guard against implicit default. Must not be used.
QuotaOperation_UNSPECIFIED QuotaOperation_QuotaMode = 0
// For AllocateQuota request, allocates quota for the amount specified in
// the service configuration or specified using the quota metrics. If the
// amount is higher than the available quota, allocation error will be
// returned and no quota will be allocated.
QuotaOperation_NORMAL QuotaOperation_QuotaMode = 1
// The operation allocates quota for the amount specified in the service
// configuration or specified using the quota metrics. If the amount is
// higher than the available quota, request does not fail but all available
// quota will be allocated.
QuotaOperation_BEST_EFFORT QuotaOperation_QuotaMode = 2
// For AllocateQuota request, only checks if there is enough quota
// available and does not change the available quota. No lock is placed on
// the available quota either.
QuotaOperation_CHECK_ONLY QuotaOperation_QuotaMode = 3
)
var QuotaOperation_QuotaMode_name = map[int32]string{
0: "UNSPECIFIED",
1: "NORMAL",
2: "BEST_EFFORT",
3: "CHECK_ONLY",
}
var QuotaOperation_QuotaMode_value = map[string]int32{
"UNSPECIFIED": 0,
"NORMAL": 1,
"BEST_EFFORT": 2,
"CHECK_ONLY": 3,
}
func (x QuotaOperation_QuotaMode) String() string {
return proto.EnumName(QuotaOperation_QuotaMode_name, int32(x))
}
func (QuotaOperation_QuotaMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{1, 0} }
// Error codes related to project config validations are deprecated since the
// quota controller methods do not perform these validations. Instead services
// have to call the Check method, without quota_properties field, to perform
// these validations before calling the quota controller methods. These
// methods check only for project deletion to be wipe out compliant.
type QuotaError_Code int32
const (
// This is never used.
QuotaError_UNSPECIFIED QuotaError_Code = 0
// Quota allocation failed.
// Same as [google.rpc.Code.RESOURCE_EXHAUSTED][].
QuotaError_RESOURCE_EXHAUSTED QuotaError_Code = 8
// Consumer cannot access the service because the service requires active
// billing.
QuotaError_BILLING_NOT_ACTIVE QuotaError_Code = 107
// Consumer's project has been marked as deleted (soft deletion).
QuotaError_PROJECT_DELETED QuotaError_Code = 108
// Specified API key is invalid.
QuotaError_API_KEY_INVALID QuotaError_Code = 105
// Specified API Key has expired.
QuotaError_API_KEY_EXPIRED QuotaError_Code = 112
)
var QuotaError_Code_name = map[int32]string{
0: "UNSPECIFIED",
8: "RESOURCE_EXHAUSTED",
107: "BILLING_NOT_ACTIVE",
108: "PROJECT_DELETED",
105: "API_KEY_INVALID",
112: "API_KEY_EXPIRED",
}
var QuotaError_Code_value = map[string]int32{
"UNSPECIFIED": 0,
"RESOURCE_EXHAUSTED": 8,
"BILLING_NOT_ACTIVE": 107,
"PROJECT_DELETED": 108,
"API_KEY_INVALID": 105,
"API_KEY_EXPIRED": 112,
}
func (x QuotaError_Code) String() string {
return proto.EnumName(QuotaError_Code_name, int32(x))
}
func (QuotaError_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{3, 0} }
// Request message for the AllocateQuota method.
type AllocateQuotaRequest struct {
// Name of the service as specified in the service configuration. For example,
// `"pubsub.googleapis.com"`.
//
// See [google.api.Service][google.api.Service] for the definition of a service name.
ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName" json:"service_name,omitempty"`
// Operation that describes the quota allocation.
AllocateOperation *QuotaOperation `protobuf:"bytes,2,opt,name=allocate_operation,json=allocateOperation" json:"allocate_operation,omitempty"`
// Specifies which version of service configuration should be used to process
// the request. If unspecified or no matching version can be found, the latest
// one will be used.
ServiceConfigId string `protobuf:"bytes,4,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"`
}
func (m *AllocateQuotaRequest) Reset() { *m = AllocateQuotaRequest{} }
func (m *AllocateQuotaRequest) String() string { return proto.CompactTextString(m) }
func (*AllocateQuotaRequest) ProtoMessage() {}
func (*AllocateQuotaRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
func (m *AllocateQuotaRequest) GetServiceName() string {
if m != nil {
return m.ServiceName
}
return ""
}
func (m *AllocateQuotaRequest) GetAllocateOperation() *QuotaOperation {
if m != nil {
return m.AllocateOperation
}
return nil
}
func (m *AllocateQuotaRequest) GetServiceConfigId() string {
if m != nil {
return m.ServiceConfigId
}
return ""
}
// Represents information regarding a quota operation.
type QuotaOperation struct {
// Identity of the operation. This is expected to be unique within the scope
// of the service that generated the operation, and guarantees idempotency in
// case of retries.
//
// UUID version 4 is recommended, though not required. In scenarios where an
// operation is computed from existing information and an idempotent id is
// desirable for deduplication purpose, UUID version 5 is recommended. See
// RFC 4122 for details.
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId" json:"operation_id,omitempty"`
// Fully qualified name of the API method for which this quota operation is
// requested. This name is used for matching quota rules or metric rules and
// billing status rules defined in service configuration. This field is not
// required if the quota operation is performed on non-API resources.
//
// Example of an RPC method name:
// google.example.library.v1.LibraryService.CreateShelf
MethodName string `protobuf:"bytes,2,opt,name=method_name,json=methodName" json:"method_name,omitempty"`
// Identity of the consumer for whom this quota operation is being performed.
//
// This can be in one of the following formats:
// project:<project_id>,
// project_number:<project_number>,
// api_key:<api_key>.
ConsumerId string `protobuf:"bytes,3,opt,name=consumer_id,json=consumerId" json:"consumer_id,omitempty"`
// Labels describing the operation.
Labels map[string]string `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Represents information about this operation. Each MetricValueSet
// corresponds to a metric defined in the service configuration.
// The data type used in the MetricValueSet must agree with
// the data type specified in the metric definition.
//
// Within a single operation, it is not allowed to have more than one
// MetricValue instances that have the same metric names and identical
// label value combinations. If a request has such duplicated MetricValue
// instances, the entire request is rejected with
// an invalid argument error.
QuotaMetrics []*MetricValueSet `protobuf:"bytes,5,rep,name=quota_metrics,json=quotaMetrics" json:"quota_metrics,omitempty"`
// Quota mode for this operation.
QuotaMode QuotaOperation_QuotaMode `protobuf:"varint,6,opt,name=quota_mode,json=quotaMode,enum=google.api.servicecontrol.v1.QuotaOperation_QuotaMode" json:"quota_mode,omitempty"`
}
func (m *QuotaOperation) Reset() { *m = QuotaOperation{} }
func (m *QuotaOperation) String() string { return proto.CompactTextString(m) }
func (*QuotaOperation) ProtoMessage() {}
func (*QuotaOperation) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
func (m *QuotaOperation) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *QuotaOperation) GetMethodName() string {
if m != nil {
return m.MethodName
}
return ""
}
func (m *QuotaOperation) GetConsumerId() string {
if m != nil {
return m.ConsumerId
}
return ""
}
func (m *QuotaOperation) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *QuotaOperation) GetQuotaMetrics() []*MetricValueSet {
if m != nil {
return m.QuotaMetrics
}
return nil
}
func (m *QuotaOperation) GetQuotaMode() QuotaOperation_QuotaMode {
if m != nil {
return m.QuotaMode
}
return QuotaOperation_UNSPECIFIED
}
// Response message for the AllocateQuota method.
type AllocateQuotaResponse struct {
// The same operation_id value used in the AllocateQuotaRequest. Used for
// logging and diagnostics purposes.
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId" json:"operation_id,omitempty"`
// Indicates the decision of the allocate.
AllocateErrors []*QuotaError `protobuf:"bytes,2,rep,name=allocate_errors,json=allocateErrors" json:"allocate_errors,omitempty"`
// Quota metrics to indicate the result of allocation. Depending on the
// request, one or more of the following metrics will be included:
//
// 1. Per quota group or per quota metric incremental usage will be specified
// using the following delta metric :
// "serviceruntime.googleapis.com/api/consumer/quota_used_count"
//
// 2. The quota limit reached condition will be specified using the following
// boolean metric :
// "serviceruntime.googleapis.com/quota/exceeded"
QuotaMetrics []*MetricValueSet `protobuf:"bytes,3,rep,name=quota_metrics,json=quotaMetrics" json:"quota_metrics,omitempty"`
// ID of the actual config used to process the request.
ServiceConfigId string `protobuf:"bytes,4,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"`
}
func (m *AllocateQuotaResponse) Reset() { *m = AllocateQuotaResponse{} }
func (m *AllocateQuotaResponse) String() string { return proto.CompactTextString(m) }
func (*AllocateQuotaResponse) ProtoMessage() {}
func (*AllocateQuotaResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
func (m *AllocateQuotaResponse) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *AllocateQuotaResponse) GetAllocateErrors() []*QuotaError {
if m != nil {
return m.AllocateErrors
}
return nil
}
func (m *AllocateQuotaResponse) GetQuotaMetrics() []*MetricValueSet {
if m != nil {
return m.QuotaMetrics
}
return nil
}
func (m *AllocateQuotaResponse) GetServiceConfigId() string {
if m != nil {
return m.ServiceConfigId
}
return ""
}
// Represents error information for [QuotaOperation][google.api.servicecontrol.v1.QuotaOperation].
type QuotaError struct {
// Error code.
Code QuotaError_Code `protobuf:"varint,1,opt,name=code,enum=google.api.servicecontrol.v1.QuotaError_Code" json:"code,omitempty"`
// Subject to whom this error applies. See the specific enum for more details
// on this field. For example, "clientip:<ip address of client>" or
// "project:<Google developer project id>".
Subject string `protobuf:"bytes,2,opt,name=subject" json:"subject,omitempty"`
// Free-form text that provides details on the cause of the error.
Description string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
}
func (m *QuotaError) Reset() { *m = QuotaError{} }
func (m *QuotaError) String() string { return proto.CompactTextString(m) }
func (*QuotaError) ProtoMessage() {}
func (*QuotaError) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
func (m *QuotaError) GetCode() QuotaError_Code {
if m != nil {
return m.Code
}
return QuotaError_UNSPECIFIED
}
func (m *QuotaError) GetSubject() string {
if m != nil {
return m.Subject
}
return ""
}
func (m *QuotaError) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*AllocateQuotaRequest)(nil), "google.api.servicecontrol.v1.AllocateQuotaRequest")
proto.RegisterType((*QuotaOperation)(nil), "google.api.servicecontrol.v1.QuotaOperation")
proto.RegisterType((*AllocateQuotaResponse)(nil), "google.api.servicecontrol.v1.AllocateQuotaResponse")
proto.RegisterType((*QuotaError)(nil), "google.api.servicecontrol.v1.QuotaError")
proto.RegisterEnum("google.api.servicecontrol.v1.QuotaOperation_QuotaMode", QuotaOperation_QuotaMode_name, QuotaOperation_QuotaMode_value)
proto.RegisterEnum("google.api.servicecontrol.v1.QuotaError_Code", QuotaError_Code_name, QuotaError_Code_value)
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for QuotaController service
type QuotaControllerClient interface {
// Attempts to allocate quota for the specified consumer. It should be called
// before the operation is executed.
//
// This method requires the `servicemanagement.services.quota`
// permission on the specified service. For more information, see
// [Cloud IAM](https://cloud.google.com/iam).
//
// **NOTE:** The client **must** fail-open on server errors `INTERNAL`,
// `UNKNOWN`, `DEADLINE_EXCEEDED`, and `UNAVAILABLE`. To ensure system
// reliability, the server may inject these errors to prohibit any hard
// dependency on the quota functionality.
AllocateQuota(ctx context.Context, in *AllocateQuotaRequest, opts ...grpc.CallOption) (*AllocateQuotaResponse, error)
}
type quotaControllerClient struct {
cc *grpc.ClientConn
}
func NewQuotaControllerClient(cc *grpc.ClientConn) QuotaControllerClient {
return &quotaControllerClient{cc}
}
func (c *quotaControllerClient) AllocateQuota(ctx context.Context, in *AllocateQuotaRequest, opts ...grpc.CallOption) (*AllocateQuotaResponse, error) {
out := new(AllocateQuotaResponse)
err := grpc.Invoke(ctx, "/google.api.servicecontrol.v1.QuotaController/AllocateQuota", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for QuotaController service
type QuotaControllerServer interface {
// Attempts to allocate quota for the specified consumer. It should be called
// before the operation is executed.
//
// This method requires the `servicemanagement.services.quota`
// permission on the specified service. For more information, see
// [Cloud IAM](https://cloud.google.com/iam).
//
// **NOTE:** The client **must** fail-open on server errors `INTERNAL`,
// `UNKNOWN`, `DEADLINE_EXCEEDED`, and `UNAVAILABLE`. To ensure system
// reliability, the server may inject these errors to prohibit any hard
// dependency on the quota functionality.
AllocateQuota(context.Context, *AllocateQuotaRequest) (*AllocateQuotaResponse, error)
}
func RegisterQuotaControllerServer(s *grpc.Server, srv QuotaControllerServer) {
s.RegisterService(&_QuotaController_serviceDesc, srv)
}
func _QuotaController_AllocateQuota_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AllocateQuotaRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QuotaControllerServer).AllocateQuota(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.api.servicecontrol.v1.QuotaController/AllocateQuota",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QuotaControllerServer).AllocateQuota(ctx, req.(*AllocateQuotaRequest))
}
return interceptor(ctx, in, info, handler)
}
var _QuotaController_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.api.servicecontrol.v1.QuotaController",
HandlerType: (*QuotaControllerServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "AllocateQuota",
Handler: _QuotaController_AllocateQuota_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/api/servicecontrol/v1/quota_controller.proto",
}
func init() {
proto.RegisterFile("google/api/servicecontrol/v1/quota_controller.proto", fileDescriptor5)
}
var fileDescriptor5 = []byte{
// 775 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xc1, 0x6e, 0xea, 0x46,
0x14, 0xed, 0x18, 0x42, 0x9b, 0xeb, 0x04, 0x9c, 0x69, 0x5a, 0x59, 0x28, 0x52, 0x28, 0x2b, 0x1a,
0xb5, 0x46, 0x21, 0x55, 0x95, 0xa6, 0x2b, 0x30, 0x93, 0xc6, 0x09, 0x01, 0x62, 0x20, 0x4a, 0xda,
0x85, 0xe5, 0xd8, 0x53, 0xea, 0xc6, 0x78, 0x1c, 0xdb, 0x20, 0x45, 0x55, 0x37, 0x5d, 0x54, 0xaa,
0xd4, 0x5d, 0xfb, 0x1d, 0xfd, 0x88, 0xfc, 0x42, 0x7f, 0xe1, 0xfd, 0xc3, 0x7b, 0xcb, 0x27, 0x8f,
0x0d, 0x0f, 0x22, 0xc4, 0x0b, 0x7a, 0x3b, 0xcf, 0xf1, 0x9c, 0x33, 0xf7, 0xde, 0x73, 0xe7, 0x0e,
0x1c, 0x0d, 0x19, 0x1b, 0xba, 0xb4, 0x6a, 0xfa, 0x4e, 0x35, 0xa4, 0xc1, 0xc4, 0xb1, 0xa8, 0xc5,
0xbc, 0x28, 0x60, 0x6e, 0x75, 0x72, 0x58, 0x7d, 0x18, 0xb3, 0xc8, 0x34, 0x52, 0xc0, 0xa5, 0x81,
0xe2, 0x07, 0x2c, 0x62, 0x78, 0x2f, 0x21, 0x29, 0xa6, 0xef, 0x28, 0x8b, 0x24, 0x65, 0x72, 0x58,
0xdc, 0x9b, 0x93, 0x34, 0x3d, 0x8f, 0x45, 0x66, 0xe4, 0x30, 0x2f, 0x4c, 0xb8, 0xc5, 0xea, 0xca,
0x03, 0x47, 0x34, 0x0a, 0x1c, 0xcb, 0x98, 0x98, 0xee, 0x98, 0x26, 0x84, 0xf2, 0x13, 0x82, 0xdd,
0xba, 0xeb, 0x32, 0xcb, 0x8c, 0xe8, 0x55, 0x1c, 0x8f, 0x4e, 0x1f, 0xc6, 0x34, 0x8c, 0xf0, 0x17,
0xb0, 0x95, 0x0a, 0x18, 0x9e, 0x39, 0xa2, 0x32, 0x2a, 0xa1, 0xca, 0xa6, 0x2e, 0xa6, 0x58, 0xdb,
0x1c, 0x51, 0xfc, 0x13, 0x60, 0x33, 0xa5, 0x1a, 0xcc, 0xa7, 0x01, 0x8f, 0x44, 0x16, 0x4a, 0xa8,
0x22, 0xd6, 0xbe, 0x52, 0x56, 0x65, 0xa1, 0xf0, 0xa3, 0x3a, 0x53, 0x8e, 0xbe, 0x33, 0xd5, 0x99,
0x41, 0xf8, 0x00, 0x76, 0xa6, 0xe7, 0x5b, 0xcc, 0xfb, 0xd9, 0x19, 0x1a, 0x8e, 0x2d, 0x67, 0x79,
0x10, 0x85, 0xf4, 0x87, 0xca, 0x71, 0xcd, 0x2e, 0xbf, 0xce, 0x40, 0x7e, 0x51, 0x31, 0x0e, 0x7f,
0x16, 0x52, 0xcc, 0x4c, 0xc3, 0x9f, 0x61, 0x9a, 0x8d, 0xf7, 0x41, 0x1c, 0xd1, 0xe8, 0x17, 0x66,
0x27, 0x09, 0x0a, 0x7c, 0x07, 0x24, 0x10, 0xcf, 0x6f, 0x1f, 0x44, 0x8b, 0x79, 0xe1, 0x78, 0x44,
0x83, 0x58, 0x22, 0x93, 0x6c, 0x98, 0x42, 0x9a, 0x8d, 0xbb, 0x90, 0x73, 0xcd, 0x3b, 0xea, 0x86,
0x72, 0xb6, 0x94, 0xa9, 0x88, 0xb5, 0xe3, 0x75, 0x92, 0x56, 0x5a, 0x9c, 0x4a, 0xbc, 0x28, 0x78,
0xd4, 0x53, 0x1d, 0x7c, 0x05, 0xdb, 0x49, 0x57, 0x24, 0x56, 0x85, 0xf2, 0x06, 0x17, 0x7e, 0x4f,
0x35, 0x2f, 0xf9, 0xe6, 0xeb, 0xd8, 0xd6, 0x1e, 0x8d, 0xf4, 0x2d, 0x2e, 0x91, 0x80, 0x21, 0x1e,
0x00, 0xa4, 0x92, 0xcc, 0xa6, 0x72, 0xae, 0x84, 0x2a, 0xf9, 0xda, 0xb7, 0x6b, 0x05, 0xca, 0x97,
0x97, 0xcc, 0xa6, 0xfa, 0xe6, 0xc3, 0xf4, 0xb3, 0xf8, 0x1d, 0x88, 0x73, 0x09, 0x60, 0x09, 0x32,
0xf7, 0xf4, 0x31, 0x2d, 0x73, 0xfc, 0x89, 0x77, 0x61, 0x83, 0x37, 0x5a, 0x5a, 0xd8, 0x64, 0x71,
0x22, 0x1c, 0xa3, 0xb2, 0x06, 0x9b, 0x33, 0x49, 0x5c, 0x00, 0x71, 0xd0, 0xee, 0x75, 0x89, 0xaa,
0x9d, 0x6a, 0xa4, 0x29, 0x7d, 0x84, 0x01, 0x72, 0xed, 0x8e, 0x7e, 0x59, 0x6f, 0x49, 0x28, 0xfe,
0xd9, 0x20, 0xbd, 0xbe, 0x41, 0x4e, 0x4f, 0x3b, 0x7a, 0x5f, 0x12, 0x70, 0x1e, 0x40, 0x3d, 0x23,
0xea, 0x85, 0xd1, 0x69, 0xb7, 0x6e, 0xa5, 0x4c, 0xf9, 0x6f, 0x01, 0x3e, 0x7b, 0xd6, 0xbe, 0xa1,
0xcf, 0xbc, 0x90, 0xbe, 0xa4, 0x01, 0xae, 0xa0, 0x30, 0xeb, 0x5f, 0x1a, 0x04, 0x2c, 0x08, 0x65,
0x81, 0x97, 0xbb, 0xf2, 0x82, 0xf2, 0x90, 0x98, 0xa0, 0xe7, 0xa7, 0x02, 0x7c, 0xb9, 0xc4, 0xbf,
0xcc, 0x07, 0xfb, 0xb7, 0xce, 0x45, 0xf8, 0x57, 0x00, 0x78, 0x17, 0x1d, 0xae, 0x43, 0xd6, 0x8a,
0x4d, 0x47, 0xdc, 0xf4, 0xaf, 0x5f, 0x9a, 0x95, 0xa2, 0xc6, 0x5e, 0x73, 0x2a, 0x96, 0xe1, 0xe3,
0x70, 0x7c, 0xf7, 0x2b, 0xb5, 0xa2, 0xd4, 0xc7, 0xe9, 0x12, 0x97, 0x40, 0xb4, 0x69, 0x68, 0x05,
0x8e, 0xcf, 0xaf, 0x7d, 0x72, 0x3b, 0xe6, 0xa1, 0xf2, 0x9f, 0x08, 0xb2, 0xea, 0x52, 0x8f, 0x3f,
0x07, 0xac, 0x93, 0x5e, 0x67, 0xa0, 0xab, 0xc4, 0x20, 0x37, 0x67, 0xf5, 0x41, 0xaf, 0x4f, 0x9a,
0xd2, 0x27, 0x31, 0xde, 0xd0, 0x5a, 0x2d, 0xad, 0xfd, 0x83, 0xd1, 0xee, 0xf4, 0x8d, 0xba, 0xda,
0xd7, 0xae, 0x89, 0x74, 0x8f, 0x3f, 0x85, 0x42, 0x57, 0xef, 0x9c, 0x13, 0xb5, 0x6f, 0x34, 0x49,
0x8b, 0xc4, 0x9b, 0xdd, 0x18, 0xac, 0x77, 0x35, 0xe3, 0x82, 0xdc, 0x1a, 0x5a, 0xfb, 0xba, 0xde,
0xd2, 0x9a, 0x92, 0x33, 0x0f, 0x92, 0x9b, 0xae, 0xa6, 0x93, 0xa6, 0xe4, 0xd7, 0x9e, 0x10, 0x14,
0x78, 0x7a, 0xea, 0x6c, 0xd6, 0xe2, 0xff, 0x10, 0x6c, 0x2f, 0x74, 0x0e, 0xae, 0xad, 0xae, 0xcf,
0xb2, 0x29, 0x59, 0x3c, 0x5a, 0x8b, 0x93, 0xb4, 0x66, 0xf9, 0x9b, 0x3f, 0xfe, 0x7f, 0xf5, 0x8f,
0xa0, 0x94, 0xbf, 0x8c, 0x67, 0x72, 0x4a, 0x0a, 0xab, 0xbf, 0xcd, 0x8f, 0xdb, 0xdf, 0x4f, 0xcc,
0x79, 0xea, 0x09, 0x3a, 0x68, 0xfc, 0x85, 0xa0, 0x64, 0xb1, 0xd1, 0xca, 0x03, 0x1b, 0xbb, 0xcf,
0xd2, 0xec, 0xc6, 0x43, 0xbe, 0x8b, 0x7e, 0x3c, 0x4f, 0x59, 0x43, 0xe6, 0x9a, 0xde, 0x50, 0x61,
0xc1, 0xb0, 0x3a, 0xa4, 0x1e, 0x7f, 0x02, 0xd2, 0x27, 0xc3, 0xf4, 0x9d, 0x70, 0xf9, 0xb3, 0xf1,
0xfd, 0x22, 0xf2, 0x06, 0xa1, 0xbb, 0x1c, 0x67, 0x1e, 0xbd, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xbb,
0x98, 0x03, 0x4f, 0xe0, 0x06, 0x00, 0x00,
}

488
vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/service_controller.pb.go generated vendored Normal file
View File

@ -0,0 +1,488 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicecontrol/v1/service_controller.proto
package servicecontrol
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_rpc "google.golang.org/genproto/googleapis/rpc/status"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Request message for the Check method.
type CheckRequest struct {
// The service name as specified in its service configuration. For example,
// `"pubsub.googleapis.com"`.
//
// See
// [google.api.Service](https://cloud.google.com/service-management/reference/rpc/google.api#google.api.Service)
// for the definition of a service name.
ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName" json:"service_name,omitempty"`
// The operation to be checked.
Operation *Operation `protobuf:"bytes,2,opt,name=operation" json:"operation,omitempty"`
// Specifies which version of service configuration should be used to process
// the request.
//
// If unspecified or no matching version can be found, the
// latest one will be used.
ServiceConfigId string `protobuf:"bytes,4,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"`
}
func (m *CheckRequest) Reset() { *m = CheckRequest{} }
func (m *CheckRequest) String() string { return proto.CompactTextString(m) }
func (*CheckRequest) ProtoMessage() {}
func (*CheckRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
func (m *CheckRequest) GetServiceName() string {
if m != nil {
return m.ServiceName
}
return ""
}
func (m *CheckRequest) GetOperation() *Operation {
if m != nil {
return m.Operation
}
return nil
}
func (m *CheckRequest) GetServiceConfigId() string {
if m != nil {
return m.ServiceConfigId
}
return ""
}
// Response message for the Check method.
type CheckResponse struct {
// The same operation_id value used in the [CheckRequest][google.api.servicecontrol.v1.CheckRequest].
// Used for logging and diagnostics purposes.
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId" json:"operation_id,omitempty"`
// Indicate the decision of the check.
//
// If no check errors are present, the service should process the operation.
// Otherwise the service should use the list of errors to determine the
// appropriate action.
CheckErrors []*CheckError `protobuf:"bytes,2,rep,name=check_errors,json=checkErrors" json:"check_errors,omitempty"`
// The actual config id used to process the request.
ServiceConfigId string `protobuf:"bytes,5,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"`
// Feedback data returned from the server during processing a Check request.
CheckInfo *CheckResponse_CheckInfo `protobuf:"bytes,6,opt,name=check_info,json=checkInfo" json:"check_info,omitempty"`
}
func (m *CheckResponse) Reset() { *m = CheckResponse{} }
func (m *CheckResponse) String() string { return proto.CompactTextString(m) }
func (*CheckResponse) ProtoMessage() {}
func (*CheckResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
func (m *CheckResponse) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *CheckResponse) GetCheckErrors() []*CheckError {
if m != nil {
return m.CheckErrors
}
return nil
}
func (m *CheckResponse) GetServiceConfigId() string {
if m != nil {
return m.ServiceConfigId
}
return ""
}
func (m *CheckResponse) GetCheckInfo() *CheckResponse_CheckInfo {
if m != nil {
return m.CheckInfo
}
return nil
}
type CheckResponse_CheckInfo struct {
// Consumer info of this check.
ConsumerInfo *CheckResponse_ConsumerInfo `protobuf:"bytes,2,opt,name=consumer_info,json=consumerInfo" json:"consumer_info,omitempty"`
}
func (m *CheckResponse_CheckInfo) Reset() { *m = CheckResponse_CheckInfo{} }
func (m *CheckResponse_CheckInfo) String() string { return proto.CompactTextString(m) }
func (*CheckResponse_CheckInfo) ProtoMessage() {}
func (*CheckResponse_CheckInfo) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1, 0} }
func (m *CheckResponse_CheckInfo) GetConsumerInfo() *CheckResponse_ConsumerInfo {
if m != nil {
return m.ConsumerInfo
}
return nil
}
// `ConsumerInfo` provides information about the consumer project.
type CheckResponse_ConsumerInfo struct {
// The Google cloud project number, e.g. 1234567890. A value of 0 indicates
// no project number is found.
ProjectNumber int64 `protobuf:"varint,1,opt,name=project_number,json=projectNumber" json:"project_number,omitempty"`
}
func (m *CheckResponse_ConsumerInfo) Reset() { *m = CheckResponse_ConsumerInfo{} }
func (m *CheckResponse_ConsumerInfo) String() string { return proto.CompactTextString(m) }
func (*CheckResponse_ConsumerInfo) ProtoMessage() {}
func (*CheckResponse_ConsumerInfo) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1, 1} }
func (m *CheckResponse_ConsumerInfo) GetProjectNumber() int64 {
if m != nil {
return m.ProjectNumber
}
return 0
}
// Request message for the Report method.
type ReportRequest struct {
// The service name as specified in its service configuration. For example,
// `"pubsub.googleapis.com"`.
//
// See
// [google.api.Service](https://cloud.google.com/service-management/reference/rpc/google.api#google.api.Service)
// for the definition of a service name.
ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName" json:"service_name,omitempty"`
// Operations to be reported.
//
// Typically the service should report one operation per request.
// Putting multiple operations into a single request is allowed, but should
// be used only when multiple operations are natually available at the time
// of the report.
//
// If multiple operations are in a single request, the total request size
// should be no larger than 1MB. See [ReportResponse.report_errors][google.api.servicecontrol.v1.ReportResponse.report_errors] for
// partial failure behavior.
Operations []*Operation `protobuf:"bytes,2,rep,name=operations" json:"operations,omitempty"`
// Specifies which version of service config should be used to process the
// request.
//
// If unspecified or no matching version can be found, the
// latest one will be used.
ServiceConfigId string `protobuf:"bytes,3,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"`
}
func (m *ReportRequest) Reset() { *m = ReportRequest{} }
func (m *ReportRequest) String() string { return proto.CompactTextString(m) }
func (*ReportRequest) ProtoMessage() {}
func (*ReportRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
func (m *ReportRequest) GetServiceName() string {
if m != nil {
return m.ServiceName
}
return ""
}
func (m *ReportRequest) GetOperations() []*Operation {
if m != nil {
return m.Operations
}
return nil
}
func (m *ReportRequest) GetServiceConfigId() string {
if m != nil {
return m.ServiceConfigId
}
return ""
}
// Response message for the Report method.
type ReportResponse struct {
// Partial failures, one for each `Operation` in the request that failed
// processing. There are three possible combinations of the RPC status:
//
// 1. The combination of a successful RPC status and an empty `report_errors`
// list indicates a complete success where all `Operations` in the
// request are processed successfully.
// 2. The combination of a successful RPC status and a non-empty
// `report_errors` list indicates a partial success where some
// `Operations` in the request succeeded. Each
// `Operation` that failed processing has a corresponding item
// in this list.
// 3. A failed RPC status indicates a general non-deterministic failure.
// When this happens, it's impossible to know which of the
// 'Operations' in the request succeeded or failed.
ReportErrors []*ReportResponse_ReportError `protobuf:"bytes,1,rep,name=report_errors,json=reportErrors" json:"report_errors,omitempty"`
// The actual config id used to process the request.
ServiceConfigId string `protobuf:"bytes,2,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"`
}
func (m *ReportResponse) Reset() { *m = ReportResponse{} }
func (m *ReportResponse) String() string { return proto.CompactTextString(m) }
func (*ReportResponse) ProtoMessage() {}
func (*ReportResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
func (m *ReportResponse) GetReportErrors() []*ReportResponse_ReportError {
if m != nil {
return m.ReportErrors
}
return nil
}
func (m *ReportResponse) GetServiceConfigId() string {
if m != nil {
return m.ServiceConfigId
}
return ""
}
// Represents the processing error of one [Operation][google.api.servicecontrol.v1.Operation] in the request.
type ReportResponse_ReportError struct {
// The [Operation.operation_id][google.api.servicecontrol.v1.Operation.operation_id] value from the request.
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId" json:"operation_id,omitempty"`
// Details of the error when processing the [Operation][google.api.servicecontrol.v1.Operation].
Status *google_rpc.Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}
func (m *ReportResponse_ReportError) Reset() { *m = ReportResponse_ReportError{} }
func (m *ReportResponse_ReportError) String() string { return proto.CompactTextString(m) }
func (*ReportResponse_ReportError) ProtoMessage() {}
func (*ReportResponse_ReportError) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3, 0} }
func (m *ReportResponse_ReportError) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *ReportResponse_ReportError) GetStatus() *google_rpc.Status {
if m != nil {
return m.Status
}
return nil
}
func init() {
proto.RegisterType((*CheckRequest)(nil), "google.api.servicecontrol.v1.CheckRequest")
proto.RegisterType((*CheckResponse)(nil), "google.api.servicecontrol.v1.CheckResponse")
proto.RegisterType((*CheckResponse_CheckInfo)(nil), "google.api.servicecontrol.v1.CheckResponse.CheckInfo")
proto.RegisterType((*CheckResponse_ConsumerInfo)(nil), "google.api.servicecontrol.v1.CheckResponse.ConsumerInfo")
proto.RegisterType((*ReportRequest)(nil), "google.api.servicecontrol.v1.ReportRequest")
proto.RegisterType((*ReportResponse)(nil), "google.api.servicecontrol.v1.ReportResponse")
proto.RegisterType((*ReportResponse_ReportError)(nil), "google.api.servicecontrol.v1.ReportResponse.ReportError")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for ServiceController service
type ServiceControllerClient interface {
// Checks an operation with Google Service Control to decide whether
// the given operation should proceed. It should be called before the
// operation is executed.
//
// If feasible, the client should cache the check results and reuse them for
// 60 seconds. In case of server errors, the client can rely on the cached
// results for longer time.
//
// NOTE: the [CheckRequest][google.api.servicecontrol.v1.CheckRequest] has the size limit of 64KB.
//
// This method requires the `servicemanagement.services.check` permission
// on the specified service. For more information, see
// [Google Cloud IAM](https://cloud.google.com/iam).
Check(ctx context.Context, in *CheckRequest, opts ...grpc.CallOption) (*CheckResponse, error)
// Reports operation results to Google Service Control, such as logs and
// metrics. It should be called after an operation is completed.
//
// If feasible, the client should aggregate reporting data for up to 5
// seconds to reduce API traffic. Limiting aggregation to 5 seconds is to
// reduce data loss during client crashes. Clients should carefully choose
// the aggregation time window to avoid data loss risk more than 0.01%
// for business and compliance reasons.
//
// NOTE: the [ReportRequest][google.api.servicecontrol.v1.ReportRequest] has the size limit of 1MB.
//
// This method requires the `servicemanagement.services.report` permission
// on the specified service. For more information, see
// [Google Cloud IAM](https://cloud.google.com/iam).
Report(ctx context.Context, in *ReportRequest, opts ...grpc.CallOption) (*ReportResponse, error)
}
type serviceControllerClient struct {
cc *grpc.ClientConn
}
func NewServiceControllerClient(cc *grpc.ClientConn) ServiceControllerClient {
return &serviceControllerClient{cc}
}
func (c *serviceControllerClient) Check(ctx context.Context, in *CheckRequest, opts ...grpc.CallOption) (*CheckResponse, error) {
out := new(CheckResponse)
err := grpc.Invoke(ctx, "/google.api.servicecontrol.v1.ServiceController/Check", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *serviceControllerClient) Report(ctx context.Context, in *ReportRequest, opts ...grpc.CallOption) (*ReportResponse, error) {
out := new(ReportResponse)
err := grpc.Invoke(ctx, "/google.api.servicecontrol.v1.ServiceController/Report", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for ServiceController service
type ServiceControllerServer interface {
// Checks an operation with Google Service Control to decide whether
// the given operation should proceed. It should be called before the
// operation is executed.
//
// If feasible, the client should cache the check results and reuse them for
// 60 seconds. In case of server errors, the client can rely on the cached
// results for longer time.
//
// NOTE: the [CheckRequest][google.api.servicecontrol.v1.CheckRequest] has the size limit of 64KB.
//
// This method requires the `servicemanagement.services.check` permission
// on the specified service. For more information, see
// [Google Cloud IAM](https://cloud.google.com/iam).
Check(context.Context, *CheckRequest) (*CheckResponse, error)
// Reports operation results to Google Service Control, such as logs and
// metrics. It should be called after an operation is completed.
//
// If feasible, the client should aggregate reporting data for up to 5
// seconds to reduce API traffic. Limiting aggregation to 5 seconds is to
// reduce data loss during client crashes. Clients should carefully choose
// the aggregation time window to avoid data loss risk more than 0.01%
// for business and compliance reasons.
//
// NOTE: the [ReportRequest][google.api.servicecontrol.v1.ReportRequest] has the size limit of 1MB.
//
// This method requires the `servicemanagement.services.report` permission
// on the specified service. For more information, see
// [Google Cloud IAM](https://cloud.google.com/iam).
Report(context.Context, *ReportRequest) (*ReportResponse, error)
}
func RegisterServiceControllerServer(s *grpc.Server, srv ServiceControllerServer) {
s.RegisterService(&_ServiceController_serviceDesc, srv)
}
func _ServiceController_Check_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CheckRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ServiceControllerServer).Check(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.api.servicecontrol.v1.ServiceController/Check",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ServiceControllerServer).Check(ctx, req.(*CheckRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ServiceController_Report_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReportRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ServiceControllerServer).Report(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.api.servicecontrol.v1.ServiceController/Report",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ServiceControllerServer).Report(ctx, req.(*ReportRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ServiceController_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.api.servicecontrol.v1.ServiceController",
HandlerType: (*ServiceControllerServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Check",
Handler: _ServiceController_Check_Handler,
},
{
MethodName: "Report",
Handler: _ServiceController_Report_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/api/servicecontrol/v1/service_controller.proto",
}
func init() {
proto.RegisterFile("google/api/servicecontrol/v1/service_controller.proto", fileDescriptor6)
}
var fileDescriptor6 = []byte{
// 619 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xc1, 0x6e, 0xd3, 0x4c,
0x10, 0xd6, 0x3a, 0x6d, 0xa4, 0x4c, 0x9c, 0xfe, 0xea, 0x1e, 0x7e, 0x22, 0xab, 0x87, 0xd4, 0x12,
0x34, 0x4a, 0x8b, 0xad, 0x16, 0x55, 0x42, 0xe1, 0x44, 0xa3, 0xaa, 0x0a, 0x48, 0xa5, 0x72, 0x38,
0x21, 0xaa, 0xc8, 0xdd, 0x6c, 0x8c, 0x4b, 0xb2, 0x6b, 0xd6, 0x4e, 0x2e, 0x88, 0x0b, 0x0f, 0xc0,
0xa1, 0xbc, 0x01, 0xaa, 0xc4, 0x33, 0xf0, 0x1c, 0xbc, 0x02, 0x0f, 0x01, 0x37, 0x94, 0xdd, 0xb5,
0xeb, 0x08, 0x63, 0x92, 0x9b, 0xf7, 0xdb, 0x99, 0xf9, 0xbe, 0x9d, 0xf9, 0x3c, 0x70, 0x1c, 0x70,
0x1e, 0x4c, 0xa8, 0xeb, 0x47, 0xa1, 0x1b, 0x53, 0x31, 0x0f, 0x09, 0x25, 0x9c, 0x25, 0x82, 0x4f,
0xdc, 0xf9, 0x61, 0x8a, 0x0c, 0x35, 0x34, 0xa1, 0xc2, 0x89, 0x04, 0x4f, 0x38, 0xde, 0x51, 0x69,
0x8e, 0x1f, 0x85, 0xce, 0x72, 0x9a, 0x33, 0x3f, 0xb4, 0x76, 0x72, 0x45, 0x7d, 0xc6, 0x78, 0xe2,
0x27, 0x21, 0x67, 0xb1, 0xca, 0xb5, 0x9c, 0x52, 0x4a, 0xf2, 0x86, 0x92, 0xb7, 0x43, 0x2a, 0x04,
0xd7, 0x5c, 0xd6, 0x41, 0x69, 0x3c, 0x8f, 0xa8, 0x90, 0xe5, 0x75, 0xf4, 0x3d, 0x1d, 0x2d, 0x22,
0xe2, 0xc6, 0x89, 0x9f, 0xcc, 0x34, 0xad, 0x7d, 0x8b, 0xc0, 0xec, 0x2d, 0x8a, 0x7b, 0xf4, 0xdd,
0x8c, 0xc6, 0x09, 0xde, 0x05, 0x33, 0x7d, 0x1f, 0xf3, 0xa7, 0xb4, 0x89, 0x5a, 0xa8, 0x5d, 0xf3,
0xea, 0x1a, 0x3b, 0xf7, 0xa7, 0x14, 0x9f, 0x42, 0x2d, 0xab, 0xdf, 0x34, 0x5a, 0xa8, 0x5d, 0x3f,
0xda, 0x73, 0xca, 0x9e, 0xee, 0xbc, 0x48, 0xc3, 0xbd, 0xbb, 0x4c, 0xdc, 0x81, 0xed, 0x5c, 0x27,
0xc7, 0x61, 0x30, 0x0c, 0x47, 0xcd, 0x0d, 0x49, 0xf7, 0x9f, 0xbe, 0xe8, 0x49, 0xbc, 0x3f, 0xb2,
0x6f, 0x2b, 0xd0, 0xd0, 0x32, 0xe3, 0x88, 0xb3, 0x98, 0x2e, 0x74, 0x66, 0xa5, 0x16, 0x89, 0x5a,
0x67, 0x86, 0xf5, 0x47, 0xf8, 0x39, 0x98, 0xb9, 0xbe, 0xc5, 0x4d, 0xa3, 0x55, 0x69, 0xd7, 0x8f,
0xda, 0xe5, 0x52, 0x25, 0xcb, 0xe9, 0x22, 0xc1, 0xab, 0x93, 0xec, 0x3b, 0x2e, 0x56, 0xbb, 0x59,
0xa8, 0x16, 0xbf, 0x04, 0x50, 0xc4, 0x21, 0x1b, 0xf3, 0x66, 0x55, 0x76, 0xe8, 0x78, 0x05, 0xda,
0xf4, 0x71, 0xea, 0xd4, 0x67, 0x63, 0xee, 0xd5, 0x48, 0xfa, 0x69, 0x5d, 0x43, 0x2d, 0xc3, 0xf1,
0x25, 0x34, 0x08, 0x67, 0xf1, 0x6c, 0x4a, 0x85, 0x62, 0x51, 0x73, 0x78, 0xbc, 0x16, 0x8b, 0x2e,
0x20, 0x89, 0x4c, 0x92, 0x3b, 0x59, 0xc7, 0x60, 0xe6, 0x6f, 0xf1, 0x7d, 0xd8, 0x8a, 0x04, 0xbf,
0xa6, 0x24, 0x19, 0xb2, 0xd9, 0xf4, 0x8a, 0x0a, 0xd9, 0xef, 0x8a, 0xd7, 0xd0, 0xe8, 0xb9, 0x04,
0xed, 0xaf, 0x08, 0x1a, 0x1e, 0x8d, 0xb8, 0x48, 0xd6, 0xb0, 0xd3, 0x19, 0x40, 0x36, 0xb5, 0x74,
0x48, 0x2b, 0xfb, 0x29, 0x97, 0x5a, 0x3c, 0xa2, 0x4a, 0xb1, 0xa1, 0x7e, 0x21, 0xd8, 0x4a, 0x95,
0x6a, 0x47, 0x5d, 0x42, 0x43, 0x48, 0x24, 0xf5, 0x0b, 0x92, 0x52, 0xfe, 0xd1, 0xd2, 0xe5, 0x22,
0xfa, 0xa8, 0xfc, 0x63, 0x8a, 0xbb, 0xc3, 0x5f, 0xd4, 0x19, 0x85, 0xea, 0xac, 0xd7, 0x50, 0xcf,
0x15, 0x5a, 0xc5, 0xeb, 0x1d, 0xa8, 0xaa, 0xff, 0x5a, 0x1b, 0x01, 0xa7, 0xaa, 0x45, 0x44, 0x9c,
0x81, 0xbc, 0xf1, 0x74, 0xc4, 0xd1, 0x37, 0x03, 0xb6, 0x07, 0x19, 0xa3, 0x5e, 0x61, 0xf8, 0x13,
0x82, 0x4d, 0xe9, 0x0f, 0xdc, 0x59, 0xc9, 0x44, 0x72, 0xbe, 0xd6, 0xfe, 0x1a, 0x86, 0xb3, 0x0f,
0x3e, 0x7e, 0xff, 0xf1, 0xd9, 0x78, 0x60, 0xef, 0xe6, 0xb6, 0x68, 0xec, 0xbe, 0xcf, 0x1b, 0xe4,
0x43, 0x57, 0x1a, 0xbe, 0x8b, 0x3a, 0xf8, 0x06, 0x41, 0x55, 0x75, 0x01, 0xef, 0xaf, 0x36, 0x03,
0x25, 0xe9, 0x60, 0x9d, 0x81, 0xd9, 0x0f, 0xa5, 0xa6, 0x3d, 0xdb, 0x2e, 0xd3, 0xa4, 0x06, 0xd9,
0x45, 0x9d, 0x93, 0x1b, 0x04, 0x2d, 0xc2, 0xa7, 0xa5, 0x14, 0x27, 0xff, 0xff, 0xd1, 0xdd, 0x8b,
0xc5, 0xb2, 0xbd, 0x40, 0xaf, 0x9e, 0xe9, 0xbc, 0x80, 0x4f, 0x7c, 0x16, 0x38, 0x5c, 0x04, 0x6e,
0x40, 0x99, 0x5c, 0xc5, 0xae, 0xba, 0xf2, 0xa3, 0x30, 0x2e, 0x5e, 0xea, 0x4f, 0x96, 0x91, 0x9f,
0x08, 0x7d, 0x31, 0x36, 0xce, 0x9e, 0x0e, 0x7a, 0x57, 0x55, 0x59, 0xe0, 0xd1, 0xef, 0x00, 0x00,
0x00, 0xff, 0xff, 0x5e, 0x28, 0x7b, 0xe6, 0xb7, 0x06, 0x00, 0x00,
}

802
vendor/google.golang.org/genproto/googleapis/api/servicemanagement/v1/resources.pb.go generated vendored Normal file
View File

@ -0,0 +1,802 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/api/servicemanagement/v1/resources.proto
/*
Package servicemanagement is a generated protocol buffer package.
It is generated from these files:
google/api/servicemanagement/v1/resources.proto
google/api/servicemanagement/v1/servicemanager.proto
It has these top-level messages:
ManagedService
OperationMetadata
Diagnostic
ConfigSource
ConfigFile
ConfigRef
ChangeReport
Rollout
ListServicesRequest
ListServicesResponse
GetServiceRequest
CreateServiceRequest
DeleteServiceRequest
UndeleteServiceRequest
UndeleteServiceResponse
GetServiceConfigRequest
ListServiceConfigsRequest
ListServiceConfigsResponse
CreateServiceConfigRequest
SubmitConfigSourceRequest
SubmitConfigSourceResponse
CreateServiceRolloutRequest
ListServiceRolloutsRequest
ListServiceRolloutsResponse
GetServiceRolloutRequest
EnableServiceRequest
DisableServiceRequest
GenerateConfigReportRequest
GenerateConfigReportResponse
*/
package servicemanagement
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_api2 "google.golang.org/genproto/googleapis/api/configchange"
import _ "google.golang.org/genproto/googleapis/api/serviceconfig"
import _ "google.golang.org/genproto/googleapis/longrunning"
import _ "github.com/golang/protobuf/ptypes/any"
import _ "google.golang.org/genproto/protobuf/field_mask"
import _ "github.com/golang/protobuf/ptypes/struct"
import google_protobuf9 "github.com/golang/protobuf/ptypes/timestamp"
import _ "google.golang.org/genproto/googleapis/rpc/status"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Code describes the status of one operation step.
type OperationMetadata_Status int32
const (
// Unspecifed code.
OperationMetadata_STATUS_UNSPECIFIED OperationMetadata_Status = 0
// The step has completed without errors.
OperationMetadata_DONE OperationMetadata_Status = 1
// The step has not started yet.
OperationMetadata_NOT_STARTED OperationMetadata_Status = 2
// The step is in progress.
OperationMetadata_IN_PROGRESS OperationMetadata_Status = 3
// The step has completed with errors.
OperationMetadata_FAILED OperationMetadata_Status = 4
// The step has completed with cancellation.
OperationMetadata_CANCELLED OperationMetadata_Status = 5
)
var OperationMetadata_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "DONE",
2: "NOT_STARTED",
3: "IN_PROGRESS",
4: "FAILED",
5: "CANCELLED",
}
var OperationMetadata_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"DONE": 1,
"NOT_STARTED": 2,
"IN_PROGRESS": 3,
"FAILED": 4,
"CANCELLED": 5,
}
func (x OperationMetadata_Status) String() string {
return proto.EnumName(OperationMetadata_Status_name, int32(x))
}
func (OperationMetadata_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
// The kind of diagnostic information possible.
type Diagnostic_Kind int32
const (
// Warnings and errors
Diagnostic_WARNING Diagnostic_Kind = 0
// Only errors
Diagnostic_ERROR Diagnostic_Kind = 1
)
var Diagnostic_Kind_name = map[int32]string{
0: "WARNING",
1: "ERROR",
}
var Diagnostic_Kind_value = map[string]int32{
"WARNING": 0,
"ERROR": 1,
}
func (x Diagnostic_Kind) String() string {
return proto.EnumName(Diagnostic_Kind_name, int32(x))
}
func (Diagnostic_Kind) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
type ConfigFile_FileType int32
const (
// Unknown file type.
ConfigFile_FILE_TYPE_UNSPECIFIED ConfigFile_FileType = 0
// YAML-specification of service.
ConfigFile_SERVICE_CONFIG_YAML ConfigFile_FileType = 1
// OpenAPI specification, serialized in JSON.
ConfigFile_OPEN_API_JSON ConfigFile_FileType = 2
// OpenAPI specification, serialized in YAML.
ConfigFile_OPEN_API_YAML ConfigFile_FileType = 3
// FileDescriptorSet, generated by protoc.
//
// To generate, use protoc with imports and source info included.
// For an example test.proto file, the following command would put the value
// in a new file named out.pb.
//
// $protoc --include_imports --include_source_info test.proto -o out.pb
ConfigFile_FILE_DESCRIPTOR_SET_PROTO ConfigFile_FileType = 4
)
var ConfigFile_FileType_name = map[int32]string{
0: "FILE_TYPE_UNSPECIFIED",
1: "SERVICE_CONFIG_YAML",
2: "OPEN_API_JSON",
3: "OPEN_API_YAML",
4: "FILE_DESCRIPTOR_SET_PROTO",
}
var ConfigFile_FileType_value = map[string]int32{
"FILE_TYPE_UNSPECIFIED": 0,
"SERVICE_CONFIG_YAML": 1,
"OPEN_API_JSON": 2,
"OPEN_API_YAML": 3,
"FILE_DESCRIPTOR_SET_PROTO": 4,
}
func (x ConfigFile_FileType) String() string {
return proto.EnumName(ConfigFile_FileType_name, int32(x))
}
func (ConfigFile_FileType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4, 0} }
// Status of a Rollout.
type Rollout_RolloutStatus int32
const (
// No status specified.
Rollout_ROLLOUT_STATUS_UNSPECIFIED Rollout_RolloutStatus = 0
// The Rollout is in progress.
Rollout_IN_PROGRESS Rollout_RolloutStatus = 1
// The Rollout has completed successfully.
Rollout_SUCCESS Rollout_RolloutStatus = 2
// The Rollout has been cancelled. This can happen if you have overlapping
// Rollout pushes, and the previous ones will be cancelled.
Rollout_CANCELLED Rollout_RolloutStatus = 3
// The Rollout has failed. It is typically caused by configuration errors.
Rollout_FAILED Rollout_RolloutStatus = 4
// The Rollout has not started yet and is pending for execution.
Rollout_PENDING Rollout_RolloutStatus = 5
)
var Rollout_RolloutStatus_name = map[int32]string{
0: "ROLLOUT_STATUS_UNSPECIFIED",
1: "IN_PROGRESS",
2: "SUCCESS",
3: "CANCELLED",
4: "FAILED",
5: "PENDING",
}
var Rollout_RolloutStatus_value = map[string]int32{
"ROLLOUT_STATUS_UNSPECIFIED": 0,
"IN_PROGRESS": 1,
"SUCCESS": 2,
"CANCELLED": 3,
"FAILED": 4,
"PENDING": 5,
}
func (x Rollout_RolloutStatus) String() string {
return proto.EnumName(Rollout_RolloutStatus_name, int32(x))
}
func (Rollout_RolloutStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7, 0} }
// The full representation of a Service that is managed by
// Google Service Management.
type ManagedService struct {
// The name of the service. See the [overview](/service-management/overview)
// for naming requirements.
ServiceName string `protobuf:"bytes,2,opt,name=service_name,json=serviceName" json:"service_name,omitempty"`
// ID of the project that produces and owns this service.
ProducerProjectId string `protobuf:"bytes,3,opt,name=producer_project_id,json=producerProjectId" json:"producer_project_id,omitempty"`
}
func (m *ManagedService) Reset() { *m = ManagedService{} }
func (m *ManagedService) String() string { return proto.CompactTextString(m) }
func (*ManagedService) ProtoMessage() {}
func (*ManagedService) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *ManagedService) GetServiceName() string {
if m != nil {
return m.ServiceName
}
return ""
}
func (m *ManagedService) GetProducerProjectId() string {
if m != nil {
return m.ProducerProjectId
}
return ""
}
// The metadata associated with a long running operation resource.
type OperationMetadata struct {
// The full name of the resources that this operation is directly
// associated with.
ResourceNames []string `protobuf:"bytes,1,rep,name=resource_names,json=resourceNames" json:"resource_names,omitempty"`
// Detailed status information for each step. The order is undetermined.
Steps []*OperationMetadata_Step `protobuf:"bytes,2,rep,name=steps" json:"steps,omitempty"`
// Percentage of completion of this operation, ranging from 0 to 100.
ProgressPercentage int32 `protobuf:"varint,3,opt,name=progress_percentage,json=progressPercentage" json:"progress_percentage,omitempty"`
// The start time of the operation.
StartTime *google_protobuf9.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
}
func (m *OperationMetadata) Reset() { *m = OperationMetadata{} }
func (m *OperationMetadata) String() string { return proto.CompactTextString(m) }
func (*OperationMetadata) ProtoMessage() {}
func (*OperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *OperationMetadata) GetResourceNames() []string {
if m != nil {
return m.ResourceNames
}
return nil
}
func (m *OperationMetadata) GetSteps() []*OperationMetadata_Step {
if m != nil {
return m.Steps
}
return nil
}
func (m *OperationMetadata) GetProgressPercentage() int32 {
if m != nil {
return m.ProgressPercentage
}
return 0
}
func (m *OperationMetadata) GetStartTime() *google_protobuf9.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
// Represents the status of one operation step.
type OperationMetadata_Step struct {
// The short description of the step.
Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"`
// The status code.
Status OperationMetadata_Status `protobuf:"varint,4,opt,name=status,enum=google.api.servicemanagement.v1.OperationMetadata_Status" json:"status,omitempty"`
}
func (m *OperationMetadata_Step) Reset() { *m = OperationMetadata_Step{} }
func (m *OperationMetadata_Step) String() string { return proto.CompactTextString(m) }
func (*OperationMetadata_Step) ProtoMessage() {}
func (*OperationMetadata_Step) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
func (m *OperationMetadata_Step) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *OperationMetadata_Step) GetStatus() OperationMetadata_Status {
if m != nil {
return m.Status
}
return OperationMetadata_STATUS_UNSPECIFIED
}
// Represents a diagnostic message (error or warning)
type Diagnostic struct {
// File name and line number of the error or warning.
Location string `protobuf:"bytes,1,opt,name=location" json:"location,omitempty"`
// The kind of diagnostic information provided.
Kind Diagnostic_Kind `protobuf:"varint,2,opt,name=kind,enum=google.api.servicemanagement.v1.Diagnostic_Kind" json:"kind,omitempty"`
// Message describing the error or warning.
Message string `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
}
func (m *Diagnostic) Reset() { *m = Diagnostic{} }
func (m *Diagnostic) String() string { return proto.CompactTextString(m) }
func (*Diagnostic) ProtoMessage() {}
func (*Diagnostic) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *Diagnostic) GetLocation() string {
if m != nil {
return m.Location
}
return ""
}
func (m *Diagnostic) GetKind() Diagnostic_Kind {
if m != nil {
return m.Kind
}
return Diagnostic_WARNING
}
func (m *Diagnostic) GetMessage() string {
if m != nil {
return m.Message
}
return ""
}
// Represents a source file which is used to generate the service configuration
// defined by `google.api.Service`.
type ConfigSource struct {
// A unique ID for a specific instance of this message, typically assigned
// by the client for tracking purpose. If empty, the server may choose to
// generate one instead.
Id string `protobuf:"bytes,5,opt,name=id" json:"id,omitempty"`
// Set of source configuration files that are used to generate a service
// configuration (`google.api.Service`).
Files []*ConfigFile `protobuf:"bytes,2,rep,name=files" json:"files,omitempty"`
}
func (m *ConfigSource) Reset() { *m = ConfigSource{} }
func (m *ConfigSource) String() string { return proto.CompactTextString(m) }
func (*ConfigSource) ProtoMessage() {}
func (*ConfigSource) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *ConfigSource) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ConfigSource) GetFiles() []*ConfigFile {
if m != nil {
return m.Files
}
return nil
}
// Generic specification of a source configuration file
type ConfigFile struct {
// The file name of the configuration file (full or relative path).
FilePath string `protobuf:"bytes,1,opt,name=file_path,json=filePath" json:"file_path,omitempty"`
// The bytes that constitute the file.
FileContents []byte `protobuf:"bytes,3,opt,name=file_contents,json=fileContents,proto3" json:"file_contents,omitempty"`
// The type of configuration file this represents.
FileType ConfigFile_FileType `protobuf:"varint,4,opt,name=file_type,json=fileType,enum=google.api.servicemanagement.v1.ConfigFile_FileType" json:"file_type,omitempty"`
}
func (m *ConfigFile) Reset() { *m = ConfigFile{} }
func (m *ConfigFile) String() string { return proto.CompactTextString(m) }
func (*ConfigFile) ProtoMessage() {}
func (*ConfigFile) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *ConfigFile) GetFilePath() string {
if m != nil {
return m.FilePath
}
return ""
}
func (m *ConfigFile) GetFileContents() []byte {
if m != nil {
return m.FileContents
}
return nil
}
func (m *ConfigFile) GetFileType() ConfigFile_FileType {
if m != nil {
return m.FileType
}
return ConfigFile_FILE_TYPE_UNSPECIFIED
}
// Represents a service configuration with its name and id.
type ConfigRef struct {
// Resource name of a service config. It must have the following
// format: "services/{service name}/configs/{config id}".
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *ConfigRef) Reset() { *m = ConfigRef{} }
func (m *ConfigRef) String() string { return proto.CompactTextString(m) }
func (*ConfigRef) ProtoMessage() {}
func (*ConfigRef) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *ConfigRef) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Change report associated with a particular service configuration.
//
// It contains a list of ConfigChanges based on the comparison between
// two service configurations.
type ChangeReport struct {
// List of changes between two service configurations.
// The changes will be alphabetically sorted based on the identifier
// of each change.
// A ConfigChange identifier is a dot separated path to the configuration.
// Example: visibility.rules[selector='LibraryService.CreateBook'].restriction
ConfigChanges []*google_api2.ConfigChange `protobuf:"bytes,1,rep,name=config_changes,json=configChanges" json:"config_changes,omitempty"`
}
func (m *ChangeReport) Reset() { *m = ChangeReport{} }
func (m *ChangeReport) String() string { return proto.CompactTextString(m) }
func (*ChangeReport) ProtoMessage() {}
func (*ChangeReport) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
func (m *ChangeReport) GetConfigChanges() []*google_api2.ConfigChange {
if m != nil {
return m.ConfigChanges
}
return nil
}
// A rollout resource that defines how service configuration versions are pushed
// to control plane systems. Typically, you create a new version of the
// service config, and then create a Rollout to push the service config.
type Rollout struct {
// Optional unique identifier of this Rollout. Only lower case letters, digits
// and '-' are allowed.
//
// If not specified by client, the server will generate one. The generated id
// will have the form of <date><revision number>, where "date" is the create
// date in ISO 8601 format. "revision number" is a monotonically increasing
// positive number that is reset every day for each service.
// An example of the generated rollout_id is '2016-02-16r1'
RolloutId string `protobuf:"bytes,1,opt,name=rollout_id,json=rolloutId" json:"rollout_id,omitempty"`
// Creation time of the rollout. Readonly.
CreateTime *google_protobuf9.Timestamp `protobuf:"bytes,2,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
// The user who created the Rollout. Readonly.
CreatedBy string `protobuf:"bytes,3,opt,name=created_by,json=createdBy" json:"created_by,omitempty"`
// The status of this rollout. Readonly. In case of a failed rollout,
// the system will automatically rollback to the current Rollout
// version. Readonly.
Status Rollout_RolloutStatus `protobuf:"varint,4,opt,name=status,enum=google.api.servicemanagement.v1.Rollout_RolloutStatus" json:"status,omitempty"`
// Strategy that defines which versions of service configurations should be
// pushed
// and how they should be used at runtime.
//
// Types that are valid to be assigned to Strategy:
// *Rollout_TrafficPercentStrategy_
// *Rollout_DeleteServiceStrategy_
Strategy isRollout_Strategy `protobuf_oneof:"strategy"`
// The name of the service associated with this Rollout.
ServiceName string `protobuf:"bytes,8,opt,name=service_name,json=serviceName" json:"service_name,omitempty"`
}
func (m *Rollout) Reset() { *m = Rollout{} }
func (m *Rollout) String() string { return proto.CompactTextString(m) }
func (*Rollout) ProtoMessage() {}
func (*Rollout) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
type isRollout_Strategy interface {
isRollout_Strategy()
}
type Rollout_TrafficPercentStrategy_ struct {
TrafficPercentStrategy *Rollout_TrafficPercentStrategy `protobuf:"bytes,5,opt,name=traffic_percent_strategy,json=trafficPercentStrategy,oneof"`
}
type Rollout_DeleteServiceStrategy_ struct {
DeleteServiceStrategy *Rollout_DeleteServiceStrategy `protobuf:"bytes,200,opt,name=delete_service_strategy,json=deleteServiceStrategy,oneof"`
}
func (*Rollout_TrafficPercentStrategy_) isRollout_Strategy() {}
func (*Rollout_DeleteServiceStrategy_) isRollout_Strategy() {}
func (m *Rollout) GetStrategy() isRollout_Strategy {
if m != nil {
return m.Strategy
}
return nil
}
func (m *Rollout) GetRolloutId() string {
if m != nil {
return m.RolloutId
}
return ""
}
func (m *Rollout) GetCreateTime() *google_protobuf9.Timestamp {
if m != nil {
return m.CreateTime
}
return nil
}
func (m *Rollout) GetCreatedBy() string {
if m != nil {
return m.CreatedBy
}
return ""
}
func (m *Rollout) GetStatus() Rollout_RolloutStatus {
if m != nil {
return m.Status
}
return Rollout_ROLLOUT_STATUS_UNSPECIFIED
}
func (m *Rollout) GetTrafficPercentStrategy() *Rollout_TrafficPercentStrategy {
if x, ok := m.GetStrategy().(*Rollout_TrafficPercentStrategy_); ok {
return x.TrafficPercentStrategy
}
return nil
}
func (m *Rollout) GetDeleteServiceStrategy() *Rollout_DeleteServiceStrategy {
if x, ok := m.GetStrategy().(*Rollout_DeleteServiceStrategy_); ok {
return x.DeleteServiceStrategy
}
return nil
}
func (m *Rollout) GetServiceName() string {
if m != nil {
return m.ServiceName
}
return ""
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Rollout) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Rollout_OneofMarshaler, _Rollout_OneofUnmarshaler, _Rollout_OneofSizer, []interface{}{
(*Rollout_TrafficPercentStrategy_)(nil),
(*Rollout_DeleteServiceStrategy_)(nil),
}
}
func _Rollout_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Rollout)
// strategy
switch x := m.Strategy.(type) {
case *Rollout_TrafficPercentStrategy_:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.TrafficPercentStrategy); err != nil {
return err
}
case *Rollout_DeleteServiceStrategy_:
b.EncodeVarint(200<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.DeleteServiceStrategy); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Rollout.Strategy has unexpected type %T", x)
}
return nil
}
func _Rollout_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Rollout)
switch tag {
case 5: // strategy.traffic_percent_strategy
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Rollout_TrafficPercentStrategy)
err := b.DecodeMessage(msg)
m.Strategy = &Rollout_TrafficPercentStrategy_{msg}
return true, err
case 200: // strategy.delete_service_strategy
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Rollout_DeleteServiceStrategy)
err := b.DecodeMessage(msg)
m.Strategy = &Rollout_DeleteServiceStrategy_{msg}
return true, err
default:
return false, nil
}
}
func _Rollout_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Rollout)
// strategy
switch x := m.Strategy.(type) {
case *Rollout_TrafficPercentStrategy_:
s := proto.Size(x.TrafficPercentStrategy)
n += proto.SizeVarint(5<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *Rollout_DeleteServiceStrategy_:
s := proto.Size(x.DeleteServiceStrategy)
n += proto.SizeVarint(200<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Strategy that specifies how Google Service Control should select
// different
// versions of service configurations based on traffic percentage.
//
// One example of how to gradually rollout a new service configuration using
// this
// strategy:
// Day 1
//
// Rollout {
// id: "example.googleapis.com/rollout_20160206"
// traffic_percent_strategy {
// percentages: {
// "example.googleapis.com/20160201": 70.00
// "example.googleapis.com/20160206": 30.00
// }
// }
// }
//
// Day 2
//
// Rollout {
// id: "example.googleapis.com/rollout_20160207"
// traffic_percent_strategy: {
// percentages: {
// "example.googleapis.com/20160206": 100.00
// }
// }
// }
type Rollout_TrafficPercentStrategy struct {
// Maps service configuration IDs to their corresponding traffic percentage.
// Key is the service configuration ID, Value is the traffic percentage
// which must be greater than 0.0 and the sum must equal to 100.0.
Percentages map[string]float64 `protobuf:"bytes,1,rep,name=percentages" json:"percentages,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
}
func (m *Rollout_TrafficPercentStrategy) Reset() { *m = Rollout_TrafficPercentStrategy{} }
func (m *Rollout_TrafficPercentStrategy) String() string { return proto.CompactTextString(m) }
func (*Rollout_TrafficPercentStrategy) ProtoMessage() {}
func (*Rollout_TrafficPercentStrategy) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{7, 0}
}
func (m *Rollout_TrafficPercentStrategy) GetPercentages() map[string]float64 {
if m != nil {
return m.Percentages
}
return nil
}
// Strategy used to delete a service. This strategy is a placeholder only
// used by the system generated rollout to delete a service.
type Rollout_DeleteServiceStrategy struct {
}
func (m *Rollout_DeleteServiceStrategy) Reset() { *m = Rollout_DeleteServiceStrategy{} }
func (m *Rollout_DeleteServiceStrategy) String() string { return proto.CompactTextString(m) }
func (*Rollout_DeleteServiceStrategy) ProtoMessage() {}
func (*Rollout_DeleteServiceStrategy) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{7, 1}
}
func init() {
proto.RegisterType((*ManagedService)(nil), "google.api.servicemanagement.v1.ManagedService")
proto.RegisterType((*OperationMetadata)(nil), "google.api.servicemanagement.v1.OperationMetadata")
proto.RegisterType((*OperationMetadata_Step)(nil), "google.api.servicemanagement.v1.OperationMetadata.Step")
proto.RegisterType((*Diagnostic)(nil), "google.api.servicemanagement.v1.Diagnostic")
proto.RegisterType((*ConfigSource)(nil), "google.api.servicemanagement.v1.ConfigSource")
proto.RegisterType((*ConfigFile)(nil), "google.api.servicemanagement.v1.ConfigFile")
proto.RegisterType((*ConfigRef)(nil), "google.api.servicemanagement.v1.ConfigRef")
proto.RegisterType((*ChangeReport)(nil), "google.api.servicemanagement.v1.ChangeReport")
proto.RegisterType((*Rollout)(nil), "google.api.servicemanagement.v1.Rollout")
proto.RegisterType((*Rollout_TrafficPercentStrategy)(nil), "google.api.servicemanagement.v1.Rollout.TrafficPercentStrategy")
proto.RegisterType((*Rollout_DeleteServiceStrategy)(nil), "google.api.servicemanagement.v1.Rollout.DeleteServiceStrategy")
proto.RegisterEnum("google.api.servicemanagement.v1.OperationMetadata_Status", OperationMetadata_Status_name, OperationMetadata_Status_value)
proto.RegisterEnum("google.api.servicemanagement.v1.Diagnostic_Kind", Diagnostic_Kind_name, Diagnostic_Kind_value)
proto.RegisterEnum("google.api.servicemanagement.v1.ConfigFile_FileType", ConfigFile_FileType_name, ConfigFile_FileType_value)
proto.RegisterEnum("google.api.servicemanagement.v1.Rollout_RolloutStatus", Rollout_RolloutStatus_name, Rollout_RolloutStatus_value)
}
func init() { proto.RegisterFile("google/api/servicemanagement/v1/resources.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1166 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xef, 0x8e, 0xdb, 0x44,
0x10, 0xaf, 0xf3, 0xe7, 0xee, 0x32, 0xb9, 0x0b, 0xee, 0x96, 0xf6, 0xd2, 0xd0, 0x3f, 0xc1, 0x15,
0xd2, 0x49, 0x48, 0x0e, 0x0d, 0x08, 0x28, 0x95, 0x5a, 0xe5, 0x12, 0xdf, 0x61, 0xc8, 0xd9, 0xee,
0xda, 0x07, 0x2a, 0x5f, 0xac, 0xad, 0xbd, 0x71, 0x4d, 0x13, 0xdb, 0xb2, 0x37, 0x27, 0x45, 0xfd,
0xc8, 0x0b, 0xf0, 0x0c, 0x7c, 0x81, 0x47, 0xe1, 0x03, 0x4f, 0x00, 0x2f, 0x83, 0xbc, 0x5e, 0xdf,
0xe5, 0xcf, 0xa1, 0x14, 0xf8, 0x92, 0xec, 0xfc, 0x66, 0xf6, 0x37, 0xb3, 0xb3, 0x33, 0xb3, 0x86,
0x5e, 0x10, 0xc7, 0xc1, 0x94, 0xf6, 0x48, 0x12, 0xf6, 0x32, 0x9a, 0x5e, 0x84, 0x1e, 0x9d, 0x91,
0x88, 0x04, 0x74, 0x46, 0x23, 0xd6, 0xbb, 0x78, 0xdc, 0x4b, 0x69, 0x16, 0xcf, 0x53, 0x8f, 0x66,
0x6a, 0x92, 0xc6, 0x2c, 0x46, 0x0f, 0x8b, 0x0d, 0x2a, 0x49, 0x42, 0x75, 0x63, 0x83, 0x7a, 0xf1,
0xb8, 0x73, 0x6f, 0x89, 0x91, 0x44, 0x51, 0xcc, 0x08, 0x0b, 0xe3, 0x48, 0x6c, 0xef, 0x3c, 0x58,
0xd2, 0x7a, 0x71, 0x34, 0x09, 0x03, 0xd7, 0x7b, 0x4d, 0xa2, 0x80, 0x0a, 0x7d, 0x7b, 0x33, 0x1e,
0xa1, 0x79, 0x24, 0x34, 0xd3, 0x38, 0x0a, 0xd2, 0x79, 0x14, 0x85, 0x51, 0xd0, 0x8b, 0x13, 0x9a,
0xae, 0xd0, 0xdf, 0x15, 0x46, 0x5c, 0x7a, 0x35, 0x9f, 0xf4, 0x48, 0xb4, 0x10, 0xaa, 0xee, 0xba,
0x6a, 0x12, 0xd2, 0xa9, 0xef, 0xce, 0x48, 0xf6, 0x46, 0x58, 0xdc, 0x5b, 0xb7, 0xc8, 0x58, 0x3a,
0xf7, 0x98, 0xd0, 0x3e, 0x5c, 0xd7, 0xb2, 0x70, 0x46, 0x33, 0x46, 0x66, 0x89, 0x30, 0x38, 0x14,
0x06, 0x69, 0xe2, 0xf5, 0x32, 0x46, 0xd8, 0x5c, 0x04, 0xa5, 0x78, 0xd0, 0x3a, 0xe3, 0x29, 0xf2,
0xed, 0xe2, 0x44, 0xe8, 0x43, 0xd8, 0x17, 0x87, 0x73, 0x23, 0x32, 0xa3, 0xed, 0x4a, 0x57, 0x3a,
0x6a, 0xe0, 0xa6, 0xc0, 0x0c, 0x32, 0xa3, 0x48, 0x85, 0x5b, 0x49, 0x1a, 0xfb, 0x73, 0x8f, 0xa6,
0x6e, 0x92, 0xc6, 0x3f, 0x52, 0x8f, 0xb9, 0xa1, 0xdf, 0xae, 0x72, 0xcb, 0x9b, 0xa5, 0xca, 0x2a,
0x34, 0xba, 0xaf, 0xfc, 0x55, 0x85, 0x9b, 0x66, 0x99, 0x8e, 0x33, 0xca, 0x88, 0x4f, 0x18, 0x41,
0x1f, 0x41, 0xab, 0xbc, 0x40, 0xee, 0x29, 0x6b, 0x4b, 0xdd, 0xea, 0x51, 0x03, 0x1f, 0x94, 0x68,
0xee, 0x2b, 0x43, 0x67, 0x50, 0xcf, 0x18, 0x4d, 0xb2, 0x76, 0xa5, 0x5b, 0x3d, 0x6a, 0xf6, 0xbf,
0x50, 0xb7, 0x5c, 0xb2, 0xba, 0xe1, 0x49, 0xb5, 0x19, 0x4d, 0x70, 0xc1, 0x82, 0x7a, 0x3c, 0xf6,
0x20, 0xa5, 0x59, 0xe6, 0x26, 0x34, 0xf5, 0x68, 0xc4, 0x48, 0x40, 0x79, 0xec, 0x75, 0x8c, 0x4a,
0x95, 0x75, 0xa9, 0x41, 0x4f, 0x00, 0x32, 0x46, 0x52, 0xe6, 0xe6, 0x39, 0x6d, 0xd7, 0xba, 0xd2,
0x51, 0xb3, 0xdf, 0x29, 0x83, 0x28, 0x13, 0xae, 0x3a, 0x65, 0xc2, 0x71, 0x83, 0x5b, 0xe7, 0x72,
0xe7, 0x2d, 0xd4, 0x72, 0xd7, 0xa8, 0x0b, 0x4d, 0x9f, 0x66, 0x5e, 0x1a, 0x26, 0x79, 0x58, 0x65,
0x46, 0x97, 0x20, 0xf4, 0x02, 0x76, 0x8a, 0x6b, 0xe1, 0x0e, 0x5a, 0xfd, 0x27, 0xff, 0xe9, 0x94,
0x39, 0x01, 0x16, 0x44, 0x4a, 0x00, 0x3b, 0x05, 0x82, 0xee, 0x00, 0xb2, 0x9d, 0x81, 0x73, 0x6e,
0xbb, 0xe7, 0x86, 0x6d, 0x69, 0x43, 0xfd, 0x44, 0xd7, 0x46, 0xf2, 0x0d, 0xb4, 0x07, 0xb5, 0x91,
0x69, 0x68, 0xb2, 0x84, 0xde, 0x83, 0xa6, 0x61, 0x3a, 0xae, 0xed, 0x0c, 0xb0, 0xa3, 0x8d, 0xe4,
0x4a, 0x0e, 0xe8, 0x86, 0x6b, 0x61, 0xf3, 0x14, 0x6b, 0xb6, 0x2d, 0x57, 0x11, 0xc0, 0xce, 0xc9,
0x40, 0x1f, 0x6b, 0x23, 0xb9, 0x86, 0x0e, 0xa0, 0x31, 0x1c, 0x18, 0x43, 0x6d, 0x9c, 0x8b, 0x75,
0xe5, 0x37, 0x09, 0x60, 0x14, 0x92, 0x20, 0x8a, 0x33, 0x16, 0x7a, 0xa8, 0x03, 0x7b, 0xd3, 0xd8,
0xe3, 0xa1, 0xb5, 0x25, 0x7e, 0xd2, 0x4b, 0x19, 0x8d, 0xa0, 0xf6, 0x26, 0x8c, 0x7c, 0x9e, 0x81,
0x56, 0xff, 0x93, 0xad, 0x87, 0xbc, 0xa2, 0x55, 0xbf, 0x0d, 0x23, 0x1f, 0xf3, 0xdd, 0xa8, 0x0d,
0xbb, 0x33, 0x9a, 0x65, 0xe5, 0xb5, 0x35, 0x70, 0x29, 0x2a, 0x0f, 0xa0, 0x96, 0xdb, 0xa1, 0x26,
0xec, 0x7e, 0x3f, 0xc0, 0x86, 0x6e, 0x9c, 0xca, 0x37, 0x50, 0x03, 0xea, 0x1a, 0xc6, 0x26, 0x96,
0x25, 0x85, 0xc0, 0xfe, 0x90, 0x37, 0xb6, 0xcd, 0x0b, 0x0c, 0xb5, 0xa0, 0x12, 0xfa, 0xed, 0x3a,
0x27, 0xa9, 0x84, 0x3e, 0x1a, 0x40, 0x7d, 0x12, 0x4e, 0x69, 0x59, 0x6b, 0x1f, 0x6f, 0x0d, 0xb0,
0x60, 0x3b, 0x09, 0xa7, 0x14, 0x17, 0x3b, 0x95, 0x5f, 0x2b, 0x00, 0x57, 0x28, 0xfa, 0x00, 0x1a,
0x39, 0xee, 0x26, 0x84, 0xbd, 0x2e, 0xd3, 0x91, 0x03, 0x16, 0x61, 0xaf, 0xd1, 0x23, 0x38, 0xe0,
0x4a, 0x2f, 0x8e, 0x18, 0x8d, 0x58, 0xc6, 0x8f, 0xb3, 0x8f, 0xf7, 0x73, 0x70, 0x28, 0x30, 0xf4,
0x42, 0x30, 0xb0, 0x45, 0x42, 0x45, 0x75, 0x7c, 0xf6, 0x2f, 0xe2, 0x52, 0xf3, 0x1f, 0x67, 0x91,
0xd0, 0xc2, 0x6f, 0xbe, 0x52, 0x7e, 0x92, 0x60, 0xaf, 0x84, 0xd1, 0x5d, 0xb8, 0x7d, 0xa2, 0x8f,
0x35, 0xd7, 0x79, 0x69, 0x69, 0x6b, 0x05, 0x72, 0x08, 0xb7, 0x6c, 0x0d, 0x7f, 0xa7, 0x0f, 0x35,
0x77, 0x68, 0x1a, 0x27, 0xfa, 0xa9, 0xfb, 0x72, 0x70, 0x36, 0x96, 0x25, 0x74, 0x13, 0x0e, 0x4c,
0x4b, 0x33, 0xdc, 0x81, 0xa5, 0xbb, 0xdf, 0xd8, 0xa6, 0x21, 0x57, 0x56, 0x20, 0x6e, 0x55, 0x45,
0xf7, 0xe1, 0x2e, 0x67, 0x1e, 0x69, 0xf6, 0x10, 0xeb, 0x96, 0x63, 0x62, 0xd7, 0xd6, 0x9c, 0xbc,
0xaa, 0x1c, 0x53, 0xae, 0x29, 0x0f, 0xa1, 0x51, 0x84, 0x89, 0xe9, 0x04, 0x21, 0xa8, 0xf1, 0x69,
0x53, 0xa4, 0x88, 0xaf, 0x15, 0x13, 0xf6, 0x87, 0x7c, 0xfe, 0x62, 0x9a, 0xc4, 0x29, 0x43, 0xcf,
0xa1, 0xb5, 0x32, 0x96, 0x8b, 0x81, 0xd1, 0xec, 0xb7, 0x97, 0xd3, 0x51, 0x50, 0x8a, 0x7d, 0x07,
0xde, 0x92, 0x94, 0x29, 0x7f, 0xee, 0xc0, 0x2e, 0x8e, 0xa7, 0xd3, 0x78, 0xce, 0xd0, 0x7d, 0x80,
0xb4, 0x58, 0xe6, 0xa3, 0xab, 0x70, 0xdb, 0x10, 0x88, 0xee, 0xa3, 0xa7, 0xd0, 0xf4, 0x52, 0x4a,
0x18, 0x2d, 0xda, 0xbe, 0xb2, 0xb5, 0xed, 0xa1, 0x30, 0xcf, 0x81, 0x9c, 0xbb, 0x90, 0x7c, 0xf7,
0xd5, 0x42, 0xd4, 0x68, 0x43, 0x20, 0xc7, 0x0b, 0x64, 0xac, 0x35, 0xfb, 0xe7, 0x5b, 0xaf, 0x53,
0x04, 0x5d, 0xfe, 0xaf, 0x76, 0x3a, 0x7a, 0x0b, 0x6d, 0x96, 0x92, 0xc9, 0x24, 0xf4, 0xca, 0x89,
0xe6, 0x66, 0x2c, 0x25, 0x8c, 0x06, 0x0b, 0x5e, 0xdb, 0xcd, 0xfe, 0xf3, 0x77, 0xf6, 0xe0, 0x14,
0x44, 0x62, 0xfe, 0xd9, 0x82, 0xe6, 0xeb, 0x1b, 0xf8, 0x0e, 0xbb, 0x56, 0x83, 0x16, 0x70, 0xe8,
0xd3, 0x29, 0x65, 0xd4, 0x2d, 0x5f, 0x8d, 0x4b, 0xdf, 0xbf, 0x4b, 0xdc, 0xf9, 0xb3, 0x77, 0x76,
0x3e, 0xe2, 0x44, 0xe2, 0x21, 0x5a, 0xf2, 0x7d, 0xdb, 0xbf, 0x4e, 0xb1, 0xf1, 0x52, 0xed, 0x6d,
0xbc, 0x54, 0x9d, 0x3f, 0x24, 0xb8, 0x73, 0xfd, 0x91, 0x50, 0x0a, 0xcd, 0xab, 0xf9, 0x5f, 0x96,
0x92, 0xf5, 0x3f, 0x13, 0xa5, 0x5e, 0x3d, 0x1c, 0x99, 0x16, 0xb1, 0x74, 0x81, 0x97, 0x9d, 0x74,
0x9e, 0x81, 0xbc, 0x6e, 0x80, 0x64, 0xa8, 0xbe, 0xa1, 0x0b, 0x51, 0x81, 0xf9, 0x12, 0xbd, 0x0f,
0xf5, 0x0b, 0x32, 0x9d, 0x17, 0x55, 0x27, 0xe1, 0x42, 0xf8, 0xaa, 0xf2, 0xa5, 0xd4, 0x39, 0x84,
0xdb, 0xd7, 0xe6, 0x48, 0x99, 0xc3, 0xc1, 0x4a, 0x6d, 0xa0, 0x07, 0xd0, 0xc1, 0xe6, 0x78, 0x6c,
0x9e, 0xf3, 0xa9, 0xbe, 0x39, 0xfb, 0xd7, 0x06, 0xbc, 0x94, 0x8f, 0x4c, 0xfb, 0x7c, 0x38, 0xcc,
0x85, 0xca, 0xea, 0x84, 0x5f, 0x1d, 0xfe, 0x4d, 0xd8, 0xb5, 0x34, 0x63, 0x94, 0x8f, 0xd6, 0xfa,
0x31, 0xc0, 0x5e, 0x79, 0xdb, 0xc7, 0x3f, 0x4b, 0xf0, 0xc8, 0x8b, 0x67, 0xdb, 0x12, 0x78, 0xdc,
0xc2, 0xe5, 0x57, 0x9b, 0x95, 0x77, 0x91, 0x25, 0xfd, 0x60, 0x89, 0x2d, 0x41, 0x3c, 0x25, 0x51,
0xa0, 0xc6, 0x69, 0xd0, 0x0b, 0x68, 0xc4, 0x7b, 0x4c, 0x7c, 0x02, 0x92, 0x24, 0xcc, 0xfe, 0xf1,
0x33, 0xf0, 0xe9, 0x06, 0xf8, 0x4b, 0xa5, 0x76, 0x3a, 0xb0, 0xcf, 0x5e, 0xed, 0x70, 0x8e, 0x4f,
0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x2d, 0x64, 0x4d, 0x1e, 0x49, 0x0a, 0x00, 0x00,
}

1514
vendor/google.golang.org/genproto/googleapis/api/servicemanagement/v1/servicemanager.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

83
vendor/google.golang.org/genproto/googleapis/appengine/legacy/audit_data.pb.go generated vendored Normal file
View File

@ -0,0 +1,83 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/legacy/audit_data.proto
/*
Package legacy is a generated protocol buffer package.
It is generated from these files:
google/appengine/legacy/audit_data.proto
It has these top-level messages:
AuditData
*/
package legacy
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Admin Console legacy audit log.
type AuditData struct {
// Text description of the admin event.
// This is the "Event" column in Admin Console's Admin Logs.
EventMessage string `protobuf:"bytes,1,opt,name=event_message,json=eventMessage" json:"event_message,omitempty"`
// Arbitrary event data.
// This is the "Result" column in Admin Console's Admin Logs.
EventData map[string]string `protobuf:"bytes,2,rep,name=event_data,json=eventData" json:"event_data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}
func (m *AuditData) Reset() { *m = AuditData{} }
func (m *AuditData) String() string { return proto.CompactTextString(m) }
func (*AuditData) ProtoMessage() {}
func (*AuditData) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *AuditData) GetEventMessage() string {
if m != nil {
return m.EventMessage
}
return ""
}
func (m *AuditData) GetEventData() map[string]string {
if m != nil {
return m.EventData
}
return nil
}
func init() {
proto.RegisterType((*AuditData)(nil), "google.appengine.legacy.AuditData")
}
func init() { proto.RegisterFile("google/appengine/legacy/audit_data.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 247 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x4f, 0x4b, 0x03, 0x31,
0x10, 0xc5, 0xc9, 0x16, 0x85, 0x1d, 0xb5, 0x48, 0x10, 0x5c, 0xf4, 0x52, 0xf4, 0xb2, 0xa7, 0x04,
0xf5, 0x22, 0xfe, 0x39, 0x58, 0xec, 0x51, 0x58, 0x7a, 0xf4, 0x52, 0xc6, 0x76, 0x18, 0x16, 0xb7,
0x49, 0xd8, 0x4d, 0x0b, 0xfb, 0xed, 0xfc, 0x68, 0x92, 0xa4, 0x2e, 0x48, 0xe9, 0x29, 0x33, 0x6f,
0x7e, 0x99, 0x79, 0x3c, 0x28, 0xd9, 0x5a, 0x6e, 0x48, 0xa3, 0x73, 0x64, 0xb8, 0x36, 0xa4, 0x1b,
0x62, 0x5c, 0xf6, 0x1a, 0x37, 0xab, 0xda, 0x2f, 0x56, 0xe8, 0x51, 0xb9, 0xd6, 0x7a, 0x2b, 0x2f,
0x13, 0xa9, 0x06, 0x52, 0x25, 0xf2, 0xe6, 0x47, 0x40, 0xfe, 0x16, 0xe8, 0x77, 0xf4, 0x28, 0x6f,
0xe1, 0x8c, 0xb6, 0x64, 0xfc, 0x62, 0x4d, 0x5d, 0x87, 0x4c, 0x85, 0x98, 0x88, 0x32, 0x9f, 0x9f,
0x46, 0xf1, 0x23, 0x69, 0xb2, 0x02, 0x48, 0x50, 0xd8, 0x5f, 0x64, 0x93, 0x51, 0x79, 0x72, 0x7f,
0xa7, 0x0e, 0x1c, 0x50, 0xc3, 0x72, 0x35, 0x0b, 0x9f, 0x42, 0x35, 0x33, 0xbe, 0xed, 0xe7, 0x39,
0xfd, 0xf5, 0x57, 0x2f, 0x30, 0xfe, 0x3f, 0x94, 0xe7, 0x30, 0xfa, 0xa6, 0x7e, 0x77, 0x3e, 0x94,
0xf2, 0x02, 0x8e, 0xb6, 0xd8, 0x6c, 0xa8, 0xc8, 0xa2, 0x96, 0x9a, 0xa7, 0xec, 0x51, 0x4c, 0x0d,
0x5c, 0x2f, 0xed, 0xfa, 0x90, 0x81, 0xe9, 0x78, 0x70, 0x50, 0x85, 0x28, 0x2a, 0xf1, 0xf9, 0xba,
0x43, 0xd9, 0x36, 0x68, 0x58, 0xd9, 0x96, 0x35, 0x93, 0x89, 0x41, 0xe9, 0x34, 0x42, 0x57, 0x77,
0x7b, 0xa9, 0x3e, 0xa7, 0xe7, 0xeb, 0x38, 0x92, 0x0f, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4e,
0x5d, 0x14, 0xaa, 0x7e, 0x01, 0x00, 0x00,
}

538
vendor/google.golang.org/genproto/googleapis/appengine/logging/v1/request_log.pb.go generated vendored Normal file
View File

@ -0,0 +1,538 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/logging/v1/request_log.proto
/*
Package logging is a generated protocol buffer package.
It is generated from these files:
google/appengine/logging/v1/request_log.proto
It has these top-level messages:
LogLine
SourceLocation
SourceReference
RequestLog
*/
package logging
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_logging_type "google.golang.org/genproto/googleapis/logging/type"
import google_protobuf1 "github.com/golang/protobuf/ptypes/duration"
import google_protobuf2 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Application log line emitted while processing a request.
type LogLine struct {
// Approximate time when this log entry was made.
Time *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=time" json:"time,omitempty"`
// Severity of this log entry.
Severity google_logging_type.LogSeverity `protobuf:"varint,2,opt,name=severity,enum=google.logging.type.LogSeverity" json:"severity,omitempty"`
// App-provided log message.
LogMessage string `protobuf:"bytes,3,opt,name=log_message,json=logMessage" json:"log_message,omitempty"`
// Where in the source code this log message was written.
SourceLocation *SourceLocation `protobuf:"bytes,4,opt,name=source_location,json=sourceLocation" json:"source_location,omitempty"`
}
func (m *LogLine) Reset() { *m = LogLine{} }
func (m *LogLine) String() string { return proto.CompactTextString(m) }
func (*LogLine) ProtoMessage() {}
func (*LogLine) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *LogLine) GetTime() *google_protobuf2.Timestamp {
if m != nil {
return m.Time
}
return nil
}
func (m *LogLine) GetSeverity() google_logging_type.LogSeverity {
if m != nil {
return m.Severity
}
return google_logging_type.LogSeverity_DEFAULT
}
func (m *LogLine) GetLogMessage() string {
if m != nil {
return m.LogMessage
}
return ""
}
func (m *LogLine) GetSourceLocation() *SourceLocation {
if m != nil {
return m.SourceLocation
}
return nil
}
// Specifies a location in a source code file.
type SourceLocation struct {
// Source file name. Depending on the runtime environment, this might be a
// simple name or a fully-qualified name.
File string `protobuf:"bytes,1,opt,name=file" json:"file,omitempty"`
// Line within the source file.
Line int64 `protobuf:"varint,2,opt,name=line" json:"line,omitempty"`
// Human-readable name of the function or method being invoked, with optional
// context such as the class or package name. This information is used in
// contexts such as the logs viewer, where a file and line number are less
// meaningful. The format can vary by language. For example:
// `qual.if.ied.Class.method` (Java), `dir/package.func` (Go), `function`
// (Python).
FunctionName string `protobuf:"bytes,3,opt,name=function_name,json=functionName" json:"function_name,omitempty"`
}
func (m *SourceLocation) Reset() { *m = SourceLocation{} }
func (m *SourceLocation) String() string { return proto.CompactTextString(m) }
func (*SourceLocation) ProtoMessage() {}
func (*SourceLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *SourceLocation) GetFile() string {
if m != nil {
return m.File
}
return ""
}
func (m *SourceLocation) GetLine() int64 {
if m != nil {
return m.Line
}
return 0
}
func (m *SourceLocation) GetFunctionName() string {
if m != nil {
return m.FunctionName
}
return ""
}
// A reference to a particular snapshot of the source tree used to build and
// deploy an application.
type SourceReference struct {
// Optional. A URI string identifying the repository.
// Example: "https://github.com/GoogleCloudPlatform/kubernetes.git"
Repository string `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
// The canonical and persistent identifier of the deployed revision.
// Example (git): "0035781c50ec7aa23385dc841529ce8a4b70db1b"
RevisionId string `protobuf:"bytes,2,opt,name=revision_id,json=revisionId" json:"revision_id,omitempty"`
}
func (m *SourceReference) Reset() { *m = SourceReference{} }
func (m *SourceReference) String() string { return proto.CompactTextString(m) }
func (*SourceReference) ProtoMessage() {}
func (*SourceReference) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *SourceReference) GetRepository() string {
if m != nil {
return m.Repository
}
return ""
}
func (m *SourceReference) GetRevisionId() string {
if m != nil {
return m.RevisionId
}
return ""
}
// Complete log information about a single HTTP request to an App Engine
// application.
type RequestLog struct {
// Application that handled this request.
AppId string `protobuf:"bytes,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
// Module of the application that handled this request.
ModuleId string `protobuf:"bytes,37,opt,name=module_id,json=moduleId" json:"module_id,omitempty"`
// Version of the application that handled this request.
VersionId string `protobuf:"bytes,2,opt,name=version_id,json=versionId" json:"version_id,omitempty"`
// Globally unique identifier for a request, which is based on the request
// start time. Request IDs for requests which started later will compare
// greater as strings than those for requests which started earlier.
RequestId string `protobuf:"bytes,3,opt,name=request_id,json=requestId" json:"request_id,omitempty"`
// Origin IP address.
Ip string `protobuf:"bytes,4,opt,name=ip" json:"ip,omitempty"`
// Time when the request started.
StartTime *google_protobuf2.Timestamp `protobuf:"bytes,6,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
// Time when the request finished.
EndTime *google_protobuf2.Timestamp `protobuf:"bytes,7,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
// Latency of the request.
Latency *google_protobuf1.Duration `protobuf:"bytes,8,opt,name=latency" json:"latency,omitempty"`
// Number of CPU megacycles used to process request.
MegaCycles int64 `protobuf:"varint,9,opt,name=mega_cycles,json=megaCycles" json:"mega_cycles,omitempty"`
// Request method. Example: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`, `"DELETE"`.
Method string `protobuf:"bytes,10,opt,name=method" json:"method,omitempty"`
// Contains the path and query portion of the URL that was requested. For
// example, if the URL was "http://example.com/app?name=val", the resource
// would be "/app?name=val". The fragment identifier, which is identified by
// the `#` character, is not included.
Resource string `protobuf:"bytes,11,opt,name=resource" json:"resource,omitempty"`
// HTTP version of request. Example: `"HTTP/1.1"`.
HttpVersion string `protobuf:"bytes,12,opt,name=http_version,json=httpVersion" json:"http_version,omitempty"`
// HTTP response status code. Example: 200, 404.
Status int32 `protobuf:"varint,13,opt,name=status" json:"status,omitempty"`
// Size in bytes sent back to client by request.
ResponseSize int64 `protobuf:"varint,14,opt,name=response_size,json=responseSize" json:"response_size,omitempty"`
// Referrer URL of request.
Referrer string `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"`
// User agent that made the request.
UserAgent string `protobuf:"bytes,16,opt,name=user_agent,json=userAgent" json:"user_agent,omitempty"`
// The logged-in user who made the request.
//
// Most likely, this is the part of the user's email before the `@` sign. The
// field value is the same for different requests from the same user, but
// different users can have similar names. This information is also
// available to the application via the App Engine Users API.
//
// This field will be populated starting with App Engine 1.9.21.
Nickname string `protobuf:"bytes,40,opt,name=nickname" json:"nickname,omitempty"`
// File or class that handled the request.
UrlMapEntry string `protobuf:"bytes,17,opt,name=url_map_entry,json=urlMapEntry" json:"url_map_entry,omitempty"`
// Internet host and port number of the resource being requested.
Host string `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"`
// An indication of the relative cost of serving this request.
Cost float64 `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"`
// Queue name of the request, in the case of an offline request.
TaskQueueName string `protobuf:"bytes,22,opt,name=task_queue_name,json=taskQueueName" json:"task_queue_name,omitempty"`
// Task name of the request, in the case of an offline request.
TaskName string `protobuf:"bytes,23,opt,name=task_name,json=taskName" json:"task_name,omitempty"`
// Whether this was a loading request for the instance.
WasLoadingRequest bool `protobuf:"varint,24,opt,name=was_loading_request,json=wasLoadingRequest" json:"was_loading_request,omitempty"`
// Time this request spent in the pending request queue.
PendingTime *google_protobuf1.Duration `protobuf:"bytes,25,opt,name=pending_time,json=pendingTime" json:"pending_time,omitempty"`
// If the instance processing this request belongs to a manually scaled
// module, then this is the 0-based index of the instance. Otherwise, this
// value is -1.
InstanceIndex int32 `protobuf:"varint,26,opt,name=instance_index,json=instanceIndex" json:"instance_index,omitempty"`
// Whether this request is finished or active.
Finished bool `protobuf:"varint,27,opt,name=finished" json:"finished,omitempty"`
// Whether this is the first `RequestLog` entry for this request. If an
// active request has several `RequestLog` entries written to Stackdriver
// Logging, then this field will be set for one of them.
First bool `protobuf:"varint,42,opt,name=first" json:"first,omitempty"`
// An identifier for the instance that handled the request.
InstanceId string `protobuf:"bytes,28,opt,name=instance_id,json=instanceId" json:"instance_id,omitempty"`
// A list of log lines emitted by the application while serving this request.
Line []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"`
// App Engine release version.
AppEngineRelease string `protobuf:"bytes,38,opt,name=app_engine_release,json=appEngineRelease" json:"app_engine_release,omitempty"`
// Stackdriver Trace identifier for this request.
TraceId string `protobuf:"bytes,39,opt,name=trace_id,json=traceId" json:"trace_id,omitempty"`
// Source code for the application that handled this request. There can be
// more than one source reference per deployed application if source code is
// distributed among multiple repositories.
SourceReference []*SourceReference `protobuf:"bytes,41,rep,name=source_reference,json=sourceReference" json:"source_reference,omitempty"`
}
func (m *RequestLog) Reset() { *m = RequestLog{} }
func (m *RequestLog) String() string { return proto.CompactTextString(m) }
func (*RequestLog) ProtoMessage() {}
func (*RequestLog) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *RequestLog) GetAppId() string {
if m != nil {
return m.AppId
}
return ""
}
func (m *RequestLog) GetModuleId() string {
if m != nil {
return m.ModuleId
}
return ""
}
func (m *RequestLog) GetVersionId() string {
if m != nil {
return m.VersionId
}
return ""
}
func (m *RequestLog) GetRequestId() string {
if m != nil {
return m.RequestId
}
return ""
}
func (m *RequestLog) GetIp() string {
if m != nil {
return m.Ip
}
return ""
}
func (m *RequestLog) GetStartTime() *google_protobuf2.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
func (m *RequestLog) GetEndTime() *google_protobuf2.Timestamp {
if m != nil {
return m.EndTime
}
return nil
}
func (m *RequestLog) GetLatency() *google_protobuf1.Duration {
if m != nil {
return m.Latency
}
return nil
}
func (m *RequestLog) GetMegaCycles() int64 {
if m != nil {
return m.MegaCycles
}
return 0
}
func (m *RequestLog) GetMethod() string {
if m != nil {
return m.Method
}
return ""
}
func (m *RequestLog) GetResource() string {
if m != nil {
return m.Resource
}
return ""
}
func (m *RequestLog) GetHttpVersion() string {
if m != nil {
return m.HttpVersion
}
return ""
}
func (m *RequestLog) GetStatus() int32 {
if m != nil {
return m.Status
}
return 0
}
func (m *RequestLog) GetResponseSize() int64 {
if m != nil {
return m.ResponseSize
}
return 0
}
func (m *RequestLog) GetReferrer() string {
if m != nil {
return m.Referrer
}
return ""
}
func (m *RequestLog) GetUserAgent() string {
if m != nil {
return m.UserAgent
}
return ""
}
func (m *RequestLog) GetNickname() string {
if m != nil {
return m.Nickname
}
return ""
}
func (m *RequestLog) GetUrlMapEntry() string {
if m != nil {
return m.UrlMapEntry
}
return ""
}
func (m *RequestLog) GetHost() string {
if m != nil {
return m.Host
}
return ""
}
func (m *RequestLog) GetCost() float64 {
if m != nil {
return m.Cost
}
return 0
}
func (m *RequestLog) GetTaskQueueName() string {
if m != nil {
return m.TaskQueueName
}
return ""
}
func (m *RequestLog) GetTaskName() string {
if m != nil {
return m.TaskName
}
return ""
}
func (m *RequestLog) GetWasLoadingRequest() bool {
if m != nil {
return m.WasLoadingRequest
}
return false
}
func (m *RequestLog) GetPendingTime() *google_protobuf1.Duration {
if m != nil {
return m.PendingTime
}
return nil
}
func (m *RequestLog) GetInstanceIndex() int32 {
if m != nil {
return m.InstanceIndex
}
return 0
}
func (m *RequestLog) GetFinished() bool {
if m != nil {
return m.Finished
}
return false
}
func (m *RequestLog) GetFirst() bool {
if m != nil {
return m.First
}
return false
}
func (m *RequestLog) GetInstanceId() string {
if m != nil {
return m.InstanceId
}
return ""
}
func (m *RequestLog) GetLine() []*LogLine {
if m != nil {
return m.Line
}
return nil
}
func (m *RequestLog) GetAppEngineRelease() string {
if m != nil {
return m.AppEngineRelease
}
return ""
}
func (m *RequestLog) GetTraceId() string {
if m != nil {
return m.TraceId
}
return ""
}
func (m *RequestLog) GetSourceReference() []*SourceReference {
if m != nil {
return m.SourceReference
}
return nil
}
func init() {
proto.RegisterType((*LogLine)(nil), "google.appengine.logging.v1.LogLine")
proto.RegisterType((*SourceLocation)(nil), "google.appengine.logging.v1.SourceLocation")
proto.RegisterType((*SourceReference)(nil), "google.appengine.logging.v1.SourceReference")
proto.RegisterType((*RequestLog)(nil), "google.appengine.logging.v1.RequestLog")
}
func init() { proto.RegisterFile("google/appengine/logging/v1/request_log.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 921 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0x7f, 0x6f, 0x1c, 0x35,
0x10, 0xd5, 0xe6, 0xe7, 0x9d, 0x2f, 0xb9, 0xa4, 0xa6, 0x2d, 0x4e, 0x42, 0x9b, 0x23, 0xd0, 0x70,
0x40, 0xd9, 0x53, 0x53, 0x21, 0x81, 0xe8, 0x3f, 0x04, 0xfa, 0xc7, 0x49, 0x57, 0x54, 0x36, 0x15,
0x48, 0x48, 0x68, 0xe5, 0xee, 0xce, 0x6d, 0xac, 0xee, 0xda, 0xae, 0xed, 0xbd, 0xf6, 0xfa, 0x41,
0xf8, 0x98, 0x7c, 0x06, 0xe4, 0xb1, 0xf7, 0x4a, 0x00, 0x25, 0xfc, 0xb7, 0xf3, 0xe6, 0xbd, 0xf1,
0xd8, 0x7e, 0x9e, 0x25, 0x5f, 0x55, 0x4a, 0x55, 0x35, 0x4c, 0xb8, 0xd6, 0x20, 0x2b, 0x21, 0x61,
0x52, 0xab, 0xaa, 0x12, 0xb2, 0x9a, 0x2c, 0x1e, 0x4d, 0x0c, 0xbc, 0x6e, 0xc1, 0xba, 0xbc, 0x56,
0x55, 0xaa, 0x8d, 0x72, 0x8a, 0x1e, 0x05, 0x7a, 0xba, 0xa2, 0xa7, 0x91, 0x9e, 0x2e, 0x1e, 0x1d,
0x9e, 0xc6, 0x5a, 0x5d, 0x05, 0xb7, 0xd4, 0x18, 0xe4, 0x16, 0x16, 0x60, 0x84, 0x5b, 0x86, 0x22,
0x87, 0xf7, 0x23, 0x0f, 0xa3, 0x97, 0xed, 0x7c, 0x52, 0xb6, 0x86, 0x3b, 0xa1, 0x64, 0xcc, 0x1f,
0xff, 0x33, 0xef, 0x44, 0x03, 0xd6, 0xf1, 0x46, 0x07, 0xc2, 0xc9, 0x9f, 0x09, 0xd9, 0x9e, 0xa9,
0x6a, 0x26, 0x24, 0xd0, 0x94, 0x6c, 0xf8, 0x34, 0x4b, 0x46, 0xc9, 0x78, 0x70, 0x76, 0x98, 0xc6,
0x06, 0x3b, 0x6d, 0xfa, 0xa2, 0xd3, 0x66, 0xc8, 0xa3, 0x4f, 0x48, 0xaf, 0x6b, 0x87, 0xad, 0x8d,
0x92, 0xf1, 0xf0, 0x6c, 0xd4, 0x69, 0xba, 0xad, 0xf8, 0xbe, 0xd3, 0x99, 0xaa, 0x2e, 0x22, 0x2f,
0x5b, 0x29, 0xe8, 0x31, 0x19, 0xf8, 0x0d, 0x35, 0x60, 0x2d, 0xaf, 0x80, 0xad, 0x8f, 0x92, 0x71,
0x3f, 0x23, 0xb5, 0xaa, 0x9e, 0x05, 0x84, 0xbe, 0x20, 0x7b, 0x56, 0xb5, 0xa6, 0x80, 0xbc, 0x56,
0x05, 0x6e, 0x8a, 0x6d, 0x60, 0x67, 0x5f, 0xa6, 0xd7, 0x1c, 0x5d, 0x7a, 0x81, 0x9a, 0x59, 0x94,
0x64, 0x43, 0x7b, 0x25, 0x3e, 0xf9, 0x9d, 0x0c, 0xaf, 0x32, 0x28, 0x25, 0x1b, 0x73, 0x51, 0x87,
0x6d, 0xf7, 0x33, 0xfc, 0xf6, 0x58, 0x2d, 0x24, 0xe0, 0xb6, 0xd6, 0x33, 0xfc, 0xa6, 0x9f, 0x90,
0xdd, 0x79, 0x2b, 0x0b, 0xaf, 0xc9, 0x25, 0x6f, 0xba, 0x96, 0x77, 0x3a, 0xf0, 0x27, 0xde, 0xc0,
0x49, 0x46, 0xf6, 0x42, 0xf9, 0x0c, 0xe6, 0x60, 0x40, 0x16, 0x40, 0xef, 0x13, 0x62, 0x40, 0x2b,
0x2b, 0x9c, 0x32, 0xcb, 0xb8, 0xca, 0xdf, 0x10, 0x7f, 0x10, 0x06, 0x16, 0xc2, 0xfa, 0xba, 0xa2,
0xc4, 0x25, 0x91, 0x10, 0xa0, 0x69, 0x79, 0xf2, 0x47, 0x9f, 0x90, 0x2c, 0xf8, 0x67, 0xa6, 0x2a,
0x7a, 0x87, 0x6c, 0x71, 0xad, 0x3d, 0x35, 0xd4, 0xda, 0xe4, 0x5a, 0x4f, 0x4b, 0x7a, 0x44, 0xfa,
0x8d, 0x2a, 0xdb, 0x1a, 0x7c, 0xe6, 0x01, 0x66, 0x7a, 0x01, 0x98, 0x96, 0xf4, 0x1e, 0x21, 0x0b,
0x30, 0x57, 0x97, 0xe8, 0x47, 0x24, 0xa4, 0x3b, 0x83, 0x8a, 0x32, 0xee, 0xab, 0x1f, 0x91, 0x69,
0x49, 0x87, 0x64, 0x4d, 0x68, 0x3c, 0xfc, 0x7e, 0xb6, 0x26, 0x34, 0xfd, 0x96, 0x10, 0xeb, 0xb8,
0x71, 0x39, 0xda, 0x65, 0xeb, 0x46, 0xbb, 0xf4, 0x91, 0xed, 0x63, 0xfa, 0x35, 0xe9, 0x81, 0x2c,
0x83, 0x70, 0xfb, 0x46, 0xe1, 0x36, 0xc8, 0x12, 0x65, 0x8f, 0xc9, 0x76, 0xcd, 0x1d, 0xc8, 0x62,
0xc9, 0x7a, 0xa8, 0x3a, 0xf8, 0x97, 0xea, 0xc7, 0xe8, 0xfc, 0xac, 0x63, 0xfa, 0x83, 0x6d, 0xa0,
0xe2, 0x79, 0xb1, 0x2c, 0x6a, 0xb0, 0xac, 0x8f, 0x77, 0x49, 0x3c, 0xf4, 0x03, 0x22, 0xf4, 0x2e,
0xd9, 0x6a, 0xc0, 0x5d, 0xaa, 0x92, 0x11, 0xdc, 0x5b, 0x8c, 0xe8, 0x21, 0xe9, 0x19, 0x08, 0xbe,
0x61, 0x83, 0x70, 0x92, 0x5d, 0x4c, 0x3f, 0x26, 0x3b, 0x97, 0xce, 0xe9, 0x3c, 0x1e, 0x1e, 0xdb,
0xc1, 0xfc, 0xc0, 0x63, 0xbf, 0x04, 0xc8, 0x97, 0xb5, 0x8e, 0xbb, 0xd6, 0xb2, 0xdd, 0x51, 0x32,
0xde, 0xcc, 0x62, 0xe4, 0x0d, 0x64, 0xc0, 0x6a, 0x25, 0x2d, 0xe4, 0x56, 0xbc, 0x03, 0x36, 0xc4,
0x8e, 0x76, 0x3a, 0xf0, 0x42, 0xbc, 0x83, 0xb0, 0xf6, 0x1c, 0x8c, 0x01, 0xc3, 0xf6, 0xba, 0xb5,
0x43, 0xec, 0xaf, 0xa9, 0xb5, 0x60, 0x72, 0x5e, 0x81, 0x74, 0x6c, 0x3f, 0x5c, 0x93, 0x47, 0xbe,
0xf7, 0x80, 0x97, 0x4a, 0x51, 0xbc, 0x42, 0x6f, 0x8e, 0x83, 0xb4, 0x8b, 0xe9, 0x09, 0xd9, 0x6d,
0x4d, 0x9d, 0x37, 0x5c, 0xe7, 0x20, 0x9d, 0x59, 0xb2, 0x5b, 0xa1, 0xef, 0xd6, 0xd4, 0xcf, 0xb8,
0x7e, 0xea, 0x21, 0x6f, 0xfa, 0x4b, 0x65, 0x1d, 0xbb, 0x1d, 0x1e, 0x82, 0xff, 0xf6, 0x58, 0xe1,
0xb1, 0x3b, 0xa3, 0x64, 0x9c, 0x64, 0xf8, 0x4d, 0x4f, 0xc9, 0x9e, 0xe3, 0xf6, 0x55, 0xfe, 0xba,
0x85, 0x16, 0xc2, 0x53, 0xb8, 0x8b, 0x92, 0x5d, 0x0f, 0xff, 0xec, 0x51, 0xff, 0x16, 0xbc, 0x23,
0x91, 0x87, 0x8c, 0x0f, 0x43, 0x43, 0x1e, 0xc0, 0x64, 0x4a, 0x3e, 0x78, 0xc3, 0x6d, 0x5e, 0x2b,
0x5e, 0x0a, 0x59, 0xe5, 0xd1, 0x6c, 0x8c, 0x8d, 0x92, 0x71, 0x2f, 0xbb, 0xf5, 0x86, 0xdb, 0x59,
0xc8, 0x44, 0xe3, 0xd3, 0x27, 0x64, 0x47, 0x83, 0x44, 0x2e, 0x9a, 0xe7, 0xe0, 0x26, 0x1b, 0x0c,
0x22, 0x1d, 0xfd, 0xf3, 0x80, 0x0c, 0x85, 0xb4, 0x8e, 0xcb, 0x02, 0x72, 0x21, 0x4b, 0x78, 0xcb,
0x0e, 0xf1, 0x6a, 0x76, 0x3b, 0x74, 0xea, 0x41, 0x7f, 0x82, 0x73, 0x21, 0x85, 0xbd, 0x84, 0x92,
0x1d, 0x61, 0x27, 0xab, 0x98, 0xde, 0x26, 0x9b, 0x73, 0x61, 0xac, 0x63, 0x5f, 0x60, 0x22, 0x04,
0xde, 0x63, 0xef, 0x0b, 0x97, 0xec, 0xa3, 0xf0, 0x78, 0x57, 0x55, 0x4b, 0xfa, 0x4d, 0x9c, 0x24,
0xf7, 0x46, 0xeb, 0xe3, 0xc1, 0xd9, 0xa7, 0xd7, 0x8e, 0xae, 0x38, 0x88, 0xe3, 0xbc, 0x79, 0x48,
0xa8, 0x7f, 0xe7, 0x81, 0x96, 0x1b, 0xa8, 0x81, 0x5b, 0x60, 0xa7, 0xb8, 0xc2, 0x3e, 0xd7, 0xfa,
0x29, 0x26, 0xb2, 0x80, 0xd3, 0x03, 0xd2, 0x73, 0x86, 0x87, 0x2e, 0x3e, 0x43, 0xce, 0x36, 0xc6,
0xd3, 0x92, 0xfe, 0x4a, 0xf6, 0xe3, 0x20, 0x35, 0xdd, 0x50, 0x62, 0x9f, 0x63, 0x3b, 0x0f, 0xff,
0xc7, 0x24, 0x5d, 0x0d, 0xb2, 0x2c, 0x8e, 0xe3, 0x15, 0x70, 0xfe, 0x96, 0x1c, 0x17, 0xaa, 0xb9,
0xae, 0xc6, 0xf9, 0xde, 0xfb, 0xc1, 0xf5, 0xdc, 0x5f, 0xd1, 0xf3, 0xe4, 0xb7, 0xf3, 0xc8, 0xaf,
0x54, 0xcd, 0x65, 0x95, 0x2a, 0x53, 0x4d, 0x2a, 0x90, 0x78, 0x81, 0x93, 0x90, 0xe2, 0x5a, 0xd8,
0xff, 0xfc, 0x8d, 0x7e, 0x17, 0x3f, 0x5f, 0x6e, 0x21, 0xfd, 0xf1, 0x5f, 0x01, 0x00, 0x00, 0xff,
0xff, 0x05, 0xf7, 0x68, 0xa8, 0x74, 0x07, 0x00, 0x00,
}

900
vendor/google.golang.org/genproto/googleapis/appengine/v1/app_yaml.pb.go generated vendored Normal file
View File

@ -0,0 +1,900 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/app_yaml.proto
/*
Package appengine is a generated protocol buffer package.
It is generated from these files:
google/appengine/v1/app_yaml.proto
google/appengine/v1/appengine.proto
google/appengine/v1/application.proto
google/appengine/v1/audit_data.proto
google/appengine/v1/deploy.proto
google/appengine/v1/instance.proto
google/appengine/v1/location.proto
google/appengine/v1/operation.proto
google/appengine/v1/service.proto
google/appengine/v1/version.proto
It has these top-level messages:
ApiConfigHandler
ErrorHandler
UrlMap
StaticFilesHandler
ScriptHandler
ApiEndpointHandler
HealthCheck
Library
GetApplicationRequest
RepairApplicationRequest
ListServicesRequest
ListServicesResponse
GetServiceRequest
UpdateServiceRequest
DeleteServiceRequest
ListVersionsRequest
ListVersionsResponse
GetVersionRequest
CreateVersionRequest
UpdateVersionRequest
DeleteVersionRequest
ListInstancesRequest
ListInstancesResponse
GetInstanceRequest
DeleteInstanceRequest
DebugInstanceRequest
Application
UrlDispatchRule
AuditData
UpdateServiceMethod
CreateVersionMethod
Deployment
FileInfo
ContainerInfo
ZipInfo
Instance
LocationMetadata
OperationMetadataV1
Service
TrafficSplit
Version
AutomaticScaling
BasicScaling
ManualScaling
CpuUtilization
RequestUtilization
DiskUtilization
NetworkUtilization
Network
Resources
*/
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf1 "github.com/golang/protobuf/ptypes/duration"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Actions to take when the user is not logged in.
type AuthFailAction int32
const (
// Not specified. `AUTH_FAIL_ACTION_REDIRECT` is assumed.
AuthFailAction_AUTH_FAIL_ACTION_UNSPECIFIED AuthFailAction = 0
// Redirects user to "accounts.google.com". The user is redirected back to the
// application URL after signing in or creating an account.
AuthFailAction_AUTH_FAIL_ACTION_REDIRECT AuthFailAction = 1
// Rejects request with a `401` HTTP status code and an error
// message.
AuthFailAction_AUTH_FAIL_ACTION_UNAUTHORIZED AuthFailAction = 2
)
var AuthFailAction_name = map[int32]string{
0: "AUTH_FAIL_ACTION_UNSPECIFIED",
1: "AUTH_FAIL_ACTION_REDIRECT",
2: "AUTH_FAIL_ACTION_UNAUTHORIZED",
}
var AuthFailAction_value = map[string]int32{
"AUTH_FAIL_ACTION_UNSPECIFIED": 0,
"AUTH_FAIL_ACTION_REDIRECT": 1,
"AUTH_FAIL_ACTION_UNAUTHORIZED": 2,
}
func (x AuthFailAction) String() string {
return proto.EnumName(AuthFailAction_name, int32(x))
}
func (AuthFailAction) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
// Methods to restrict access to a URL based on login status.
type LoginRequirement int32
const (
// Not specified. `LOGIN_OPTIONAL` is assumed.
LoginRequirement_LOGIN_UNSPECIFIED LoginRequirement = 0
// Does not require that the user is signed in.
LoginRequirement_LOGIN_OPTIONAL LoginRequirement = 1
// If the user is not signed in, the `auth_fail_action` is taken.
// In addition, if the user is not an administrator for the
// application, they are given an error message regardless of
// `auth_fail_action`. If the user is an administrator, the handler
// proceeds.
LoginRequirement_LOGIN_ADMIN LoginRequirement = 2
// If the user has signed in, the handler proceeds normally. Otherwise, the
// auth_fail_action is taken.
LoginRequirement_LOGIN_REQUIRED LoginRequirement = 3
)
var LoginRequirement_name = map[int32]string{
0: "LOGIN_UNSPECIFIED",
1: "LOGIN_OPTIONAL",
2: "LOGIN_ADMIN",
3: "LOGIN_REQUIRED",
}
var LoginRequirement_value = map[string]int32{
"LOGIN_UNSPECIFIED": 0,
"LOGIN_OPTIONAL": 1,
"LOGIN_ADMIN": 2,
"LOGIN_REQUIRED": 3,
}
func (x LoginRequirement) String() string {
return proto.EnumName(LoginRequirement_name, int32(x))
}
func (LoginRequirement) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
// Methods to enforce security (HTTPS) on a URL.
type SecurityLevel int32
const (
// Not specified.
SecurityLevel_SECURE_UNSPECIFIED SecurityLevel = 0
// Both HTTP and HTTPS requests with URLs that match the handler succeed
// without redirects. The application can examine the request to determine
// which protocol was used, and respond accordingly.
SecurityLevel_SECURE_DEFAULT SecurityLevel = 0
// Requests for a URL that match this handler that use HTTPS are automatically
// redirected to the HTTP equivalent URL.
SecurityLevel_SECURE_NEVER SecurityLevel = 1
// Both HTTP and HTTPS requests with URLs that match the handler succeed
// without redirects. The application can examine the request to determine
// which protocol was used and respond accordingly.
SecurityLevel_SECURE_OPTIONAL SecurityLevel = 2
// Requests for a URL that match this handler that do not use HTTPS are
// automatically redirected to the HTTPS URL with the same path. Query
// parameters are reserved for the redirect.
SecurityLevel_SECURE_ALWAYS SecurityLevel = 3
)
var SecurityLevel_name = map[int32]string{
0: "SECURE_UNSPECIFIED",
// Duplicate value: 0: "SECURE_DEFAULT",
1: "SECURE_NEVER",
2: "SECURE_OPTIONAL",
3: "SECURE_ALWAYS",
}
var SecurityLevel_value = map[string]int32{
"SECURE_UNSPECIFIED": 0,
"SECURE_DEFAULT": 0,
"SECURE_NEVER": 1,
"SECURE_OPTIONAL": 2,
"SECURE_ALWAYS": 3,
}
func (x SecurityLevel) String() string {
return proto.EnumName(SecurityLevel_name, int32(x))
}
func (SecurityLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
// Error codes.
type ErrorHandler_ErrorCode int32
const (
// Not specified. ERROR_CODE_DEFAULT is assumed.
ErrorHandler_ERROR_CODE_UNSPECIFIED ErrorHandler_ErrorCode = 0
// All other error types.
ErrorHandler_ERROR_CODE_DEFAULT ErrorHandler_ErrorCode = 0
// Application has exceeded a resource quota.
ErrorHandler_ERROR_CODE_OVER_QUOTA ErrorHandler_ErrorCode = 1
// Client blocked by the application's Denial of Service protection
// configuration.
ErrorHandler_ERROR_CODE_DOS_API_DENIAL ErrorHandler_ErrorCode = 2
// Deadline reached before the application responds.
ErrorHandler_ERROR_CODE_TIMEOUT ErrorHandler_ErrorCode = 3
)
var ErrorHandler_ErrorCode_name = map[int32]string{
0: "ERROR_CODE_UNSPECIFIED",
// Duplicate value: 0: "ERROR_CODE_DEFAULT",
1: "ERROR_CODE_OVER_QUOTA",
2: "ERROR_CODE_DOS_API_DENIAL",
3: "ERROR_CODE_TIMEOUT",
}
var ErrorHandler_ErrorCode_value = map[string]int32{
"ERROR_CODE_UNSPECIFIED": 0,
"ERROR_CODE_DEFAULT": 0,
"ERROR_CODE_OVER_QUOTA": 1,
"ERROR_CODE_DOS_API_DENIAL": 2,
"ERROR_CODE_TIMEOUT": 3,
}
func (x ErrorHandler_ErrorCode) String() string {
return proto.EnumName(ErrorHandler_ErrorCode_name, int32(x))
}
func (ErrorHandler_ErrorCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
// Redirect codes.
type UrlMap_RedirectHttpResponseCode int32
const (
// Not specified. `302` is assumed.
UrlMap_REDIRECT_HTTP_RESPONSE_CODE_UNSPECIFIED UrlMap_RedirectHttpResponseCode = 0
// `301 Moved Permanently` code.
UrlMap_REDIRECT_HTTP_RESPONSE_CODE_301 UrlMap_RedirectHttpResponseCode = 1
// `302 Moved Temporarily` code.
UrlMap_REDIRECT_HTTP_RESPONSE_CODE_302 UrlMap_RedirectHttpResponseCode = 2
// `303 See Other` code.
UrlMap_REDIRECT_HTTP_RESPONSE_CODE_303 UrlMap_RedirectHttpResponseCode = 3
// `307 Temporary Redirect` code.
UrlMap_REDIRECT_HTTP_RESPONSE_CODE_307 UrlMap_RedirectHttpResponseCode = 4
)
var UrlMap_RedirectHttpResponseCode_name = map[int32]string{
0: "REDIRECT_HTTP_RESPONSE_CODE_UNSPECIFIED",
1: "REDIRECT_HTTP_RESPONSE_CODE_301",
2: "REDIRECT_HTTP_RESPONSE_CODE_302",
3: "REDIRECT_HTTP_RESPONSE_CODE_303",
4: "REDIRECT_HTTP_RESPONSE_CODE_307",
}
var UrlMap_RedirectHttpResponseCode_value = map[string]int32{
"REDIRECT_HTTP_RESPONSE_CODE_UNSPECIFIED": 0,
"REDIRECT_HTTP_RESPONSE_CODE_301": 1,
"REDIRECT_HTTP_RESPONSE_CODE_302": 2,
"REDIRECT_HTTP_RESPONSE_CODE_303": 3,
"REDIRECT_HTTP_RESPONSE_CODE_307": 4,
}
func (x UrlMap_RedirectHttpResponseCode) String() string {
return proto.EnumName(UrlMap_RedirectHttpResponseCode_name, int32(x))
}
func (UrlMap_RedirectHttpResponseCode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor0, []int{2, 0}
}
// [Google Cloud Endpoints](https://cloud.google.com/appengine/docs/python/endpoints/)
// configuration for API handlers.
type ApiConfigHandler struct {
// Action to take when users access resources that require
// authentication. Defaults to `redirect`.
AuthFailAction AuthFailAction `protobuf:"varint,1,opt,name=auth_fail_action,json=authFailAction,enum=google.appengine.v1.AuthFailAction" json:"auth_fail_action,omitempty"`
// Level of login required to access this resource. Defaults to
// `optional`.
Login LoginRequirement `protobuf:"varint,2,opt,name=login,enum=google.appengine.v1.LoginRequirement" json:"login,omitempty"`
// Path to the script from the application root directory.
Script string `protobuf:"bytes,3,opt,name=script" json:"script,omitempty"`
// Security (HTTPS) enforcement for this URL.
SecurityLevel SecurityLevel `protobuf:"varint,4,opt,name=security_level,json=securityLevel,enum=google.appengine.v1.SecurityLevel" json:"security_level,omitempty"`
// URL to serve the endpoint at.
Url string `protobuf:"bytes,5,opt,name=url" json:"url,omitempty"`
}
func (m *ApiConfigHandler) Reset() { *m = ApiConfigHandler{} }
func (m *ApiConfigHandler) String() string { return proto.CompactTextString(m) }
func (*ApiConfigHandler) ProtoMessage() {}
func (*ApiConfigHandler) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *ApiConfigHandler) GetAuthFailAction() AuthFailAction {
if m != nil {
return m.AuthFailAction
}
return AuthFailAction_AUTH_FAIL_ACTION_UNSPECIFIED
}
func (m *ApiConfigHandler) GetLogin() LoginRequirement {
if m != nil {
return m.Login
}
return LoginRequirement_LOGIN_UNSPECIFIED
}
func (m *ApiConfigHandler) GetScript() string {
if m != nil {
return m.Script
}
return ""
}
func (m *ApiConfigHandler) GetSecurityLevel() SecurityLevel {
if m != nil {
return m.SecurityLevel
}
return SecurityLevel_SECURE_UNSPECIFIED
}
func (m *ApiConfigHandler) GetUrl() string {
if m != nil {
return m.Url
}
return ""
}
// Custom static error page to be served when an error occurs.
type ErrorHandler struct {
// Error condition this handler applies to.
ErrorCode ErrorHandler_ErrorCode `protobuf:"varint,1,opt,name=error_code,json=errorCode,enum=google.appengine.v1.ErrorHandler_ErrorCode" json:"error_code,omitempty"`
// Static file content to be served for this error.
StaticFile string `protobuf:"bytes,2,opt,name=static_file,json=staticFile" json:"static_file,omitempty"`
// MIME type of file. Defaults to `text/html`.
MimeType string `protobuf:"bytes,3,opt,name=mime_type,json=mimeType" json:"mime_type,omitempty"`
}
func (m *ErrorHandler) Reset() { *m = ErrorHandler{} }
func (m *ErrorHandler) String() string { return proto.CompactTextString(m) }
func (*ErrorHandler) ProtoMessage() {}
func (*ErrorHandler) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *ErrorHandler) GetErrorCode() ErrorHandler_ErrorCode {
if m != nil {
return m.ErrorCode
}
return ErrorHandler_ERROR_CODE_UNSPECIFIED
}
func (m *ErrorHandler) GetStaticFile() string {
if m != nil {
return m.StaticFile
}
return ""
}
func (m *ErrorHandler) GetMimeType() string {
if m != nil {
return m.MimeType
}
return ""
}
// URL pattern and description of how the URL should be handled. App Engine can
// handle URLs by executing application code or by serving static files
// uploaded with the version, such as images, CSS, or JavaScript.
type UrlMap struct {
// URL prefix. Uses regular expression syntax, which means regexp
// special characters must be escaped, but should not contain groupings.
// All URLs that begin with this prefix are handled by this handler, using the
// portion of the URL after the prefix as part of the file path.
UrlRegex string `protobuf:"bytes,1,opt,name=url_regex,json=urlRegex" json:"url_regex,omitempty"`
// Type of handler for this URL pattern.
//
// Types that are valid to be assigned to HandlerType:
// *UrlMap_StaticFiles
// *UrlMap_Script
// *UrlMap_ApiEndpoint
HandlerType isUrlMap_HandlerType `protobuf_oneof:"handler_type"`
// Security (HTTPS) enforcement for this URL.
SecurityLevel SecurityLevel `protobuf:"varint,5,opt,name=security_level,json=securityLevel,enum=google.appengine.v1.SecurityLevel" json:"security_level,omitempty"`
// Level of login required to access this resource.
Login LoginRequirement `protobuf:"varint,6,opt,name=login,enum=google.appengine.v1.LoginRequirement" json:"login,omitempty"`
// Action to take when users access resources that require
// authentication. Defaults to `redirect`.
AuthFailAction AuthFailAction `protobuf:"varint,7,opt,name=auth_fail_action,json=authFailAction,enum=google.appengine.v1.AuthFailAction" json:"auth_fail_action,omitempty"`
// `30x` code to use when performing redirects for the `secure` field.
// Defaults to `302`.
RedirectHttpResponseCode UrlMap_RedirectHttpResponseCode `protobuf:"varint,8,opt,name=redirect_http_response_code,json=redirectHttpResponseCode,enum=google.appengine.v1.UrlMap_RedirectHttpResponseCode" json:"redirect_http_response_code,omitempty"`
}
func (m *UrlMap) Reset() { *m = UrlMap{} }
func (m *UrlMap) String() string { return proto.CompactTextString(m) }
func (*UrlMap) ProtoMessage() {}
func (*UrlMap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
type isUrlMap_HandlerType interface {
isUrlMap_HandlerType()
}
type UrlMap_StaticFiles struct {
StaticFiles *StaticFilesHandler `protobuf:"bytes,2,opt,name=static_files,json=staticFiles,oneof"`
}
type UrlMap_Script struct {
Script *ScriptHandler `protobuf:"bytes,3,opt,name=script,oneof"`
}
type UrlMap_ApiEndpoint struct {
ApiEndpoint *ApiEndpointHandler `protobuf:"bytes,4,opt,name=api_endpoint,json=apiEndpoint,oneof"`
}
func (*UrlMap_StaticFiles) isUrlMap_HandlerType() {}
func (*UrlMap_Script) isUrlMap_HandlerType() {}
func (*UrlMap_ApiEndpoint) isUrlMap_HandlerType() {}
func (m *UrlMap) GetHandlerType() isUrlMap_HandlerType {
if m != nil {
return m.HandlerType
}
return nil
}
func (m *UrlMap) GetUrlRegex() string {
if m != nil {
return m.UrlRegex
}
return ""
}
func (m *UrlMap) GetStaticFiles() *StaticFilesHandler {
if x, ok := m.GetHandlerType().(*UrlMap_StaticFiles); ok {
return x.StaticFiles
}
return nil
}
func (m *UrlMap) GetScript() *ScriptHandler {
if x, ok := m.GetHandlerType().(*UrlMap_Script); ok {
return x.Script
}
return nil
}
func (m *UrlMap) GetApiEndpoint() *ApiEndpointHandler {
if x, ok := m.GetHandlerType().(*UrlMap_ApiEndpoint); ok {
return x.ApiEndpoint
}
return nil
}
func (m *UrlMap) GetSecurityLevel() SecurityLevel {
if m != nil {
return m.SecurityLevel
}
return SecurityLevel_SECURE_UNSPECIFIED
}
func (m *UrlMap) GetLogin() LoginRequirement {
if m != nil {
return m.Login
}
return LoginRequirement_LOGIN_UNSPECIFIED
}
func (m *UrlMap) GetAuthFailAction() AuthFailAction {
if m != nil {
return m.AuthFailAction
}
return AuthFailAction_AUTH_FAIL_ACTION_UNSPECIFIED
}
func (m *UrlMap) GetRedirectHttpResponseCode() UrlMap_RedirectHttpResponseCode {
if m != nil {
return m.RedirectHttpResponseCode
}
return UrlMap_REDIRECT_HTTP_RESPONSE_CODE_UNSPECIFIED
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*UrlMap) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _UrlMap_OneofMarshaler, _UrlMap_OneofUnmarshaler, _UrlMap_OneofSizer, []interface{}{
(*UrlMap_StaticFiles)(nil),
(*UrlMap_Script)(nil),
(*UrlMap_ApiEndpoint)(nil),
}
}
func _UrlMap_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*UrlMap)
// handler_type
switch x := m.HandlerType.(type) {
case *UrlMap_StaticFiles:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.StaticFiles); err != nil {
return err
}
case *UrlMap_Script:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Script); err != nil {
return err
}
case *UrlMap_ApiEndpoint:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ApiEndpoint); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("UrlMap.HandlerType has unexpected type %T", x)
}
return nil
}
func _UrlMap_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*UrlMap)
switch tag {
case 2: // handler_type.static_files
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(StaticFilesHandler)
err := b.DecodeMessage(msg)
m.HandlerType = &UrlMap_StaticFiles{msg}
return true, err
case 3: // handler_type.script
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ScriptHandler)
err := b.DecodeMessage(msg)
m.HandlerType = &UrlMap_Script{msg}
return true, err
case 4: // handler_type.api_endpoint
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ApiEndpointHandler)
err := b.DecodeMessage(msg)
m.HandlerType = &UrlMap_ApiEndpoint{msg}
return true, err
default:
return false, nil
}
}
func _UrlMap_OneofSizer(msg proto.Message) (n int) {
m := msg.(*UrlMap)
// handler_type
switch x := m.HandlerType.(type) {
case *UrlMap_StaticFiles:
s := proto.Size(x.StaticFiles)
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *UrlMap_Script:
s := proto.Size(x.Script)
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *UrlMap_ApiEndpoint:
s := proto.Size(x.ApiEndpoint)
n += proto.SizeVarint(4<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Files served directly to the user for a given URL, such as images, CSS
// stylesheets, or JavaScript source files. Static file handlers describe which
// files in the application directory are static files, and which URLs serve
// them.
type StaticFilesHandler struct {
// Path to the static files matched by the URL pattern, from the
// application root directory. The path can refer to text matched in groupings
// in the URL pattern.
Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
// Regular expression that matches the file paths for all files that should be
// referenced by this handler.
UploadPathRegex string `protobuf:"bytes,2,opt,name=upload_path_regex,json=uploadPathRegex" json:"upload_path_regex,omitempty"`
// HTTP headers to use for all responses from these URLs.
HttpHeaders map[string]string `protobuf:"bytes,3,rep,name=http_headers,json=httpHeaders" json:"http_headers,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// MIME type used to serve all files served by this handler.
//
// Defaults to file-specific MIME types, which are derived from each file's
// filename extension.
MimeType string `protobuf:"bytes,4,opt,name=mime_type,json=mimeType" json:"mime_type,omitempty"`
// Time a static file served by this handler should be cached
// by web proxies and browsers.
Expiration *google_protobuf1.Duration `protobuf:"bytes,5,opt,name=expiration" json:"expiration,omitempty"`
// Whether this handler should match the request if the file
// referenced by the handler does not exist.
RequireMatchingFile bool `protobuf:"varint,6,opt,name=require_matching_file,json=requireMatchingFile" json:"require_matching_file,omitempty"`
// Whether files should also be uploaded as code data. By default, files
// declared in static file handlers are uploaded as static
// data and are only served to end users; they cannot be read by the
// application. If enabled, uploads are charged against both your code and
// static data storage resource quotas.
ApplicationReadable bool `protobuf:"varint,7,opt,name=application_readable,json=applicationReadable" json:"application_readable,omitempty"`
}
func (m *StaticFilesHandler) Reset() { *m = StaticFilesHandler{} }
func (m *StaticFilesHandler) String() string { return proto.CompactTextString(m) }
func (*StaticFilesHandler) ProtoMessage() {}
func (*StaticFilesHandler) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *StaticFilesHandler) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *StaticFilesHandler) GetUploadPathRegex() string {
if m != nil {
return m.UploadPathRegex
}
return ""
}
func (m *StaticFilesHandler) GetHttpHeaders() map[string]string {
if m != nil {
return m.HttpHeaders
}
return nil
}
func (m *StaticFilesHandler) GetMimeType() string {
if m != nil {
return m.MimeType
}
return ""
}
func (m *StaticFilesHandler) GetExpiration() *google_protobuf1.Duration {
if m != nil {
return m.Expiration
}
return nil
}
func (m *StaticFilesHandler) GetRequireMatchingFile() bool {
if m != nil {
return m.RequireMatchingFile
}
return false
}
func (m *StaticFilesHandler) GetApplicationReadable() bool {
if m != nil {
return m.ApplicationReadable
}
return false
}
// Executes a script to handle the request that matches the URL pattern.
type ScriptHandler struct {
// Path to the script from the application root directory.
ScriptPath string `protobuf:"bytes,1,opt,name=script_path,json=scriptPath" json:"script_path,omitempty"`
}
func (m *ScriptHandler) Reset() { *m = ScriptHandler{} }
func (m *ScriptHandler) String() string { return proto.CompactTextString(m) }
func (*ScriptHandler) ProtoMessage() {}
func (*ScriptHandler) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *ScriptHandler) GetScriptPath() string {
if m != nil {
return m.ScriptPath
}
return ""
}
// Uses Google Cloud Endpoints to handle requests.
type ApiEndpointHandler struct {
// Path to the script from the application root directory.
ScriptPath string `protobuf:"bytes,1,opt,name=script_path,json=scriptPath" json:"script_path,omitempty"`
}
func (m *ApiEndpointHandler) Reset() { *m = ApiEndpointHandler{} }
func (m *ApiEndpointHandler) String() string { return proto.CompactTextString(m) }
func (*ApiEndpointHandler) ProtoMessage() {}
func (*ApiEndpointHandler) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *ApiEndpointHandler) GetScriptPath() string {
if m != nil {
return m.ScriptPath
}
return ""
}
// Health checking configuration for VM instances. Unhealthy instances
// are killed and replaced with new instances. Only applicable for
// instances in App Engine flexible environment.
type HealthCheck struct {
// Whether to explicitly disable health checks for this instance.
DisableHealthCheck bool `protobuf:"varint,1,opt,name=disable_health_check,json=disableHealthCheck" json:"disable_health_check,omitempty"`
// Host header to send when performing an HTTP health check.
// Example: "myapp.appspot.com"
Host string `protobuf:"bytes,2,opt,name=host" json:"host,omitempty"`
// Number of consecutive successful health checks required before receiving
// traffic.
HealthyThreshold uint32 `protobuf:"varint,3,opt,name=healthy_threshold,json=healthyThreshold" json:"healthy_threshold,omitempty"`
// Number of consecutive failed health checks required before removing
// traffic.
UnhealthyThreshold uint32 `protobuf:"varint,4,opt,name=unhealthy_threshold,json=unhealthyThreshold" json:"unhealthy_threshold,omitempty"`
// Number of consecutive failed health checks required before an instance is
// restarted.
RestartThreshold uint32 `protobuf:"varint,5,opt,name=restart_threshold,json=restartThreshold" json:"restart_threshold,omitempty"`
// Interval between health checks.
CheckInterval *google_protobuf1.Duration `protobuf:"bytes,6,opt,name=check_interval,json=checkInterval" json:"check_interval,omitempty"`
// Time before the health check is considered failed.
Timeout *google_protobuf1.Duration `protobuf:"bytes,7,opt,name=timeout" json:"timeout,omitempty"`
}
func (m *HealthCheck) Reset() { *m = HealthCheck{} }
func (m *HealthCheck) String() string { return proto.CompactTextString(m) }
func (*HealthCheck) ProtoMessage() {}
func (*HealthCheck) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
func (m *HealthCheck) GetDisableHealthCheck() bool {
if m != nil {
return m.DisableHealthCheck
}
return false
}
func (m *HealthCheck) GetHost() string {
if m != nil {
return m.Host
}
return ""
}
func (m *HealthCheck) GetHealthyThreshold() uint32 {
if m != nil {
return m.HealthyThreshold
}
return 0
}
func (m *HealthCheck) GetUnhealthyThreshold() uint32 {
if m != nil {
return m.UnhealthyThreshold
}
return 0
}
func (m *HealthCheck) GetRestartThreshold() uint32 {
if m != nil {
return m.RestartThreshold
}
return 0
}
func (m *HealthCheck) GetCheckInterval() *google_protobuf1.Duration {
if m != nil {
return m.CheckInterval
}
return nil
}
func (m *HealthCheck) GetTimeout() *google_protobuf1.Duration {
if m != nil {
return m.Timeout
}
return nil
}
// Third-party Python runtime library that is required by the application.
type Library struct {
// Name of the library. Example: "django".
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Version of the library to select, or "latest".
Version string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
}
func (m *Library) Reset() { *m = Library{} }
func (m *Library) String() string { return proto.CompactTextString(m) }
func (*Library) ProtoMessage() {}
func (*Library) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (m *Library) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Library) GetVersion() string {
if m != nil {
return m.Version
}
return ""
}
func init() {
proto.RegisterType((*ApiConfigHandler)(nil), "google.appengine.v1.ApiConfigHandler")
proto.RegisterType((*ErrorHandler)(nil), "google.appengine.v1.ErrorHandler")
proto.RegisterType((*UrlMap)(nil), "google.appengine.v1.UrlMap")
proto.RegisterType((*StaticFilesHandler)(nil), "google.appengine.v1.StaticFilesHandler")
proto.RegisterType((*ScriptHandler)(nil), "google.appengine.v1.ScriptHandler")
proto.RegisterType((*ApiEndpointHandler)(nil), "google.appengine.v1.ApiEndpointHandler")
proto.RegisterType((*HealthCheck)(nil), "google.appengine.v1.HealthCheck")
proto.RegisterType((*Library)(nil), "google.appengine.v1.Library")
proto.RegisterEnum("google.appengine.v1.AuthFailAction", AuthFailAction_name, AuthFailAction_value)
proto.RegisterEnum("google.appengine.v1.LoginRequirement", LoginRequirement_name, LoginRequirement_value)
proto.RegisterEnum("google.appengine.v1.SecurityLevel", SecurityLevel_name, SecurityLevel_value)
proto.RegisterEnum("google.appengine.v1.ErrorHandler_ErrorCode", ErrorHandler_ErrorCode_name, ErrorHandler_ErrorCode_value)
proto.RegisterEnum("google.appengine.v1.UrlMap_RedirectHttpResponseCode", UrlMap_RedirectHttpResponseCode_name, UrlMap_RedirectHttpResponseCode_value)
}
func init() { proto.RegisterFile("google/appengine/v1/app_yaml.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1232 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdd, 0x6e, 0x13, 0x47,
0x14, 0xc6, 0x76, 0x7e, 0x8f, 0x1d, 0xb3, 0x99, 0x00, 0x75, 0x02, 0x94, 0xd4, 0xa8, 0x02, 0x25,
0x92, 0x4d, 0x92, 0x56, 0xd0, 0x82, 0xaa, 0x2e, 0xf6, 0xa6, 0xde, 0xca, 0x89, 0xcd, 0xd8, 0xa6,
0x82, 0x5e, 0x8c, 0x26, 0xf6, 0xc4, 0x3b, 0x62, 0xbd, 0xbb, 0x9d, 0x1d, 0x47, 0xf8, 0x39, 0xaa,
0xbe, 0x07, 0xb7, 0x7d, 0x90, 0x5e, 0xf5, 0x65, 0xaa, 0x99, 0x1d, 0xff, 0x25, 0x0e, 0xa9, 0xb8,
0x9b, 0x73, 0xce, 0xf7, 0x9d, 0x9d, 0xf3, 0x3b, 0x0b, 0xc5, 0x7e, 0x18, 0xf6, 0x7d, 0x56, 0xa6,
0x51, 0xc4, 0x82, 0x3e, 0x0f, 0x58, 0xf9, 0xe2, 0x40, 0x09, 0x64, 0x44, 0x07, 0x7e, 0x29, 0x12,
0xa1, 0x0c, 0xd1, 0x56, 0x82, 0x29, 0x4d, 0x30, 0xa5, 0x8b, 0x83, 0x9d, 0x07, 0x13, 0x22, 0x2f,
0xd3, 0x20, 0x08, 0x25, 0x95, 0x3c, 0x0c, 0xe2, 0x84, 0xb2, 0xf3, 0xb5, 0xb1, 0x6a, 0xe9, 0x6c,
0x78, 0x5e, 0xee, 0x0d, 0x85, 0x06, 0x24, 0xf6, 0xe2, 0x9f, 0x69, 0xb0, 0xec, 0x88, 0x57, 0xc2,
0xe0, 0x9c, 0xf7, 0x6b, 0x34, 0xe8, 0xf9, 0x4c, 0xa0, 0x13, 0xb0, 0xe8, 0x50, 0x7a, 0xe4, 0x9c,
0x72, 0x9f, 0xd0, 0xae, 0x82, 0x17, 0x52, 0xbb, 0xa9, 0xa7, 0xf9, 0xc3, 0xc7, 0xa5, 0x05, 0x57,
0x28, 0xd9, 0x43, 0xe9, 0x1d, 0x53, 0xee, 0xdb, 0x1a, 0x8a, 0xf3, 0x74, 0x4e, 0x46, 0x2f, 0x61,
0xd9, 0x0f, 0xfb, 0x3c, 0x28, 0xa4, 0xb5, 0x8f, 0x6f, 0x17, 0xfa, 0xa8, 0x2b, 0x04, 0x66, 0x7f,
0x0c, 0xb9, 0x60, 0x03, 0x16, 0x48, 0x9c, 0x70, 0xd0, 0x3d, 0x58, 0x89, 0xbb, 0x82, 0x47, 0xb2,
0x90, 0xd9, 0x4d, 0x3d, 0x5d, 0xc7, 0x46, 0x42, 0x2e, 0xe4, 0x63, 0xd6, 0x1d, 0x0a, 0x2e, 0x47,
0xc4, 0x67, 0x17, 0xcc, 0x2f, 0x2c, 0x69, 0xef, 0xc5, 0x85, 0xde, 0x5b, 0x06, 0x5a, 0x57, 0x48,
0xbc, 0x11, 0xcf, 0x8a, 0xc8, 0x82, 0xcc, 0x50, 0xf8, 0x85, 0x65, 0xed, 0x5f, 0x1d, 0x8b, 0x9f,
0xd2, 0x90, 0x73, 0x84, 0x08, 0xc5, 0x38, 0x23, 0xbf, 0x02, 0x30, 0x25, 0x93, 0x6e, 0xd8, 0x63,
0x26, 0x17, 0xfb, 0x0b, 0xbf, 0x34, 0x4b, 0x4b, 0x84, 0x4a, 0xd8, 0x63, 0x78, 0x9d, 0x8d, 0x8f,
0xe8, 0x11, 0x64, 0x63, 0x55, 0xa4, 0x2e, 0x39, 0xe7, 0x3e, 0xd3, 0x49, 0x59, 0xc7, 0x90, 0xa8,
0x8e, 0xb9, 0xcf, 0xd0, 0x7d, 0x58, 0x1f, 0xf0, 0x01, 0x23, 0x72, 0x14, 0x31, 0x13, 0xf5, 0x9a,
0x52, 0xb4, 0x47, 0x11, 0x2b, 0xfe, 0x95, 0x82, 0xf5, 0x89, 0x5b, 0xb4, 0x03, 0xf7, 0x1c, 0x8c,
0x1b, 0x98, 0x54, 0x1a, 0x55, 0x87, 0x74, 0x4e, 0x5b, 0x4d, 0xa7, 0xe2, 0x1e, 0xbb, 0x4e, 0xd5,
0xba, 0x85, 0xee, 0x01, 0x9a, 0xb1, 0x55, 0x9d, 0x63, 0xbb, 0x53, 0x6f, 0x5b, 0xb7, 0xd0, 0x36,
0xdc, 0x9d, 0xd1, 0x37, 0xde, 0x3a, 0x98, 0xbc, 0xe9, 0x34, 0xda, 0xb6, 0x95, 0x42, 0x0f, 0x61,
0x7b, 0x96, 0xd2, 0x68, 0x11, 0xbb, 0xe9, 0x92, 0xaa, 0x73, 0xea, 0xda, 0x75, 0x2b, 0x7d, 0xc9,
0x63, 0xdb, 0x3d, 0x71, 0x1a, 0x9d, 0xb6, 0x95, 0xd9, 0x49, 0x5b, 0xa9, 0xe2, 0xdf, 0x2b, 0xb0,
0xd2, 0x11, 0xfe, 0x09, 0x8d, 0xd4, 0xfd, 0x87, 0xc2, 0x27, 0x82, 0xf5, 0xd9, 0x47, 0x9d, 0xab,
0x75, 0xbc, 0x36, 0x14, 0x3e, 0x56, 0x32, 0xaa, 0x43, 0x6e, 0x26, 0xfa, 0x58, 0x87, 0x9f, 0x3d,
0x7c, 0xb2, 0xb8, 0x6a, 0x93, 0x9c, 0xc4, 0x26, 0xa3, 0xb5, 0x5b, 0x38, 0x3b, 0xcd, 0x54, 0x8c,
0x5e, 0xcd, 0x75, 0x47, 0xf6, 0xba, 0xea, 0x6b, 0xc8, 0xd4, 0xc5, 0xb8, 0x87, 0xea, 0x90, 0xa3,
0x11, 0x27, 0x2c, 0xe8, 0x45, 0x21, 0x0f, 0xa4, 0xee, 0xa0, 0xeb, 0xee, 0x62, 0x47, 0xdc, 0x31,
0xb8, 0x99, 0xbb, 0xd0, 0xa9, 0x76, 0x41, 0x47, 0x2e, 0x7f, 0x69, 0x47, 0x4e, 0x26, 0x66, 0xe5,
0x0b, 0x26, 0x66, 0xd1, 0xf4, 0xae, 0x7e, 0xf9, 0xf4, 0xc6, 0x70, 0x5f, 0xb0, 0x1e, 0x17, 0xac,
0x2b, 0x89, 0x27, 0x65, 0x44, 0x04, 0x8b, 0xa3, 0x30, 0x88, 0x59, 0x32, 0x0b, 0x6b, 0xda, 0xf3,
0x77, 0x0b, 0x3d, 0x27, 0xfd, 0x50, 0xc2, 0x86, 0x5e, 0x93, 0x32, 0xc2, 0x86, 0xac, 0x87, 0xa2,
0x20, 0xae, 0xb1, 0x14, 0xff, 0x4d, 0x41, 0xe1, 0x3a, 0x1a, 0xda, 0x87, 0x27, 0xd8, 0xa9, 0xba,
0xd8, 0xa9, 0xb4, 0x49, 0xad, 0xdd, 0x6e, 0x12, 0xec, 0xb4, 0x9a, 0x8d, 0xd3, 0x96, 0xb3, 0x68,
0x0a, 0x1e, 0xc3, 0xa3, 0xcf, 0x81, 0x8f, 0x9e, 0x1d, 0x58, 0xa9, 0x9b, 0x41, 0x87, 0x56, 0xfa,
0x66, 0xd0, 0x91, 0x95, 0xb9, 0x19, 0xf4, 0xdc, 0x5a, 0x7a, 0x9d, 0x87, 0x9c, 0x97, 0xf4, 0x90,
0x9e, 0xf1, 0xe2, 0xa7, 0x0c, 0xa0, 0xab, 0xbd, 0x8e, 0x10, 0x2c, 0x45, 0x54, 0x7a, 0x66, 0x84,
0xf4, 0x19, 0xed, 0xc1, 0xe6, 0x30, 0xf2, 0x43, 0xda, 0x23, 0x4a, 0x34, 0x33, 0x96, 0xac, 0x90,
0xdb, 0x89, 0xa1, 0x49, 0xa5, 0x97, 0x8c, 0xda, 0xef, 0x90, 0xd3, 0x05, 0xf3, 0x18, 0xed, 0x31,
0x11, 0x17, 0x32, 0xbb, 0x99, 0xa7, 0xd9, 0xc3, 0x17, 0xff, 0x73, 0xd4, 0x4a, 0x2a, 0xef, 0xb5,
0x84, 0xea, 0x04, 0x52, 0x8c, 0x70, 0xd6, 0x9b, 0x6a, 0xe6, 0x97, 0xd4, 0xd2, 0xfc, 0x92, 0x42,
0x3f, 0x00, 0xb0, 0x8f, 0x11, 0x4f, 0x5e, 0x1a, 0x3d, 0x06, 0xd9, 0xc3, 0xed, 0xf1, 0x77, 0xc7,
0x4f, 0x51, 0xa9, 0x6a, 0x9e, 0x22, 0x3c, 0x03, 0x46, 0x87, 0x70, 0x57, 0x24, 0x3d, 0x4d, 0x06,
0x54, 0x76, 0x3d, 0x1e, 0xf4, 0x93, 0x3d, 0xa9, 0x46, 0x61, 0x0d, 0x6f, 0x19, 0xe3, 0x89, 0xb1,
0xe9, 0x85, 0x79, 0x00, 0x77, 0x68, 0x14, 0xf9, 0xbc, 0xab, 0x5d, 0x10, 0xc1, 0x68, 0x8f, 0x9e,
0xf9, 0x4c, 0x77, 0xfd, 0x1a, 0xde, 0x9a, 0xb1, 0x61, 0x63, 0xda, 0xf9, 0x09, 0xac, 0xcb, 0xf1,
0xa9, 0x77, 0xe0, 0x03, 0x1b, 0x99, 0x74, 0xab, 0x23, 0xba, 0x03, 0xcb, 0x17, 0xd4, 0x1f, 0x8e,
0x97, 0x74, 0x22, 0xfc, 0x98, 0x7e, 0x91, 0x2a, 0x3e, 0x83, 0x8d, 0xb9, 0xad, 0xa2, 0xb7, 0xba,
0x56, 0x90, 0x99, 0x9a, 0x41, 0xa2, 0x52, 0x25, 0x29, 0x7e, 0x0f, 0xe8, 0xea, 0x0e, 0xb9, 0x99,
0xf6, 0x4f, 0x1a, 0xb2, 0x35, 0x46, 0x7d, 0xe9, 0x55, 0x3c, 0xd6, 0xfd, 0x80, 0x9e, 0xc1, 0x9d,
0x1e, 0x8f, 0x55, 0x0c, 0xaa, 0xae, 0xbe, 0xf4, 0x48, 0x57, 0xe9, 0x35, 0x73, 0x0d, 0x23, 0x63,
0x9b, 0x65, 0x20, 0x58, 0xf2, 0xc2, 0x58, 0x9a, 0x18, 0xf4, 0x19, 0xed, 0xc3, 0x66, 0xc2, 0x1e,
0x11, 0xe9, 0x09, 0x16, 0x7b, 0xa1, 0xdf, 0xd3, 0x2b, 0x74, 0x03, 0x5b, 0xc6, 0xd0, 0x1e, 0xeb,
0x51, 0x19, 0xb6, 0x86, 0xc1, 0x55, 0xf8, 0x92, 0x86, 0xa3, 0x89, 0x69, 0x4a, 0xd8, 0x87, 0x4d,
0xc1, 0x62, 0x49, 0x85, 0x9c, 0x81, 0x2f, 0x27, 0xde, 0x8d, 0x61, 0x0a, 0xfe, 0x19, 0xf2, 0x3a,
0x02, 0xc2, 0x03, 0xc9, 0xc4, 0x05, 0xf5, 0x75, 0xa5, 0x3f, 0xdb, 0x2f, 0x1b, 0x9a, 0xe0, 0x1a,
0x3c, 0x3a, 0x82, 0x55, 0xc9, 0x07, 0x2c, 0x1c, 0x4a, 0x5d, 0xf1, 0xcf, 0x52, 0xc7, 0xc8, 0xe2,
0x73, 0x58, 0xad, 0xf3, 0x33, 0x41, 0xc5, 0x48, 0x25, 0x28, 0xa0, 0x03, 0x36, 0x9e, 0x33, 0x75,
0x46, 0x05, 0x58, 0xbd, 0x60, 0x22, 0x56, 0xed, 0x9b, 0xe4, 0x6d, 0x2c, 0xee, 0x49, 0xc8, 0xcf,
0x6f, 0x4c, 0xb4, 0x0b, 0x0f, 0xec, 0x4e, 0xbb, 0x46, 0x8e, 0x6d, 0xb7, 0x4e, 0xec, 0x4a, 0xdb,
0x6d, 0x9c, 0x5e, 0x5a, 0x42, 0x0f, 0x61, 0xfb, 0x0a, 0x62, 0xbc, 0x26, 0xac, 0x14, 0xfa, 0x06,
0x1e, 0x2e, 0x70, 0xa0, 0x54, 0x0d, 0xec, 0xbe, 0x77, 0xaa, 0x56, 0x7a, 0xef, 0x0c, 0xac, 0xcb,
0xfb, 0x1e, 0xdd, 0x85, 0xcd, 0x7a, 0xe3, 0x17, 0xf7, 0xf2, 0xc7, 0x10, 0xe4, 0x13, 0x75, 0xa3,
0xa9, 0x3c, 0xd9, 0x75, 0x2b, 0x85, 0x6e, 0x43, 0x36, 0xd1, 0xd9, 0xd5, 0x13, 0xf7, 0xd4, 0x4a,
0x4f, 0x41, 0xd8, 0x79, 0xd3, 0x71, 0xb1, 0x53, 0xb5, 0x32, 0x7b, 0x23, 0xd8, 0x98, 0x7b, 0x95,
0xd4, 0x7b, 0xdf, 0x72, 0x2a, 0x1d, 0xec, 0x5c, 0xfd, 0x82, 0xd1, 0x4f, 0xff, 0x2a, 0x2c, 0xc8,
0x19, 0xdd, 0xa9, 0xf3, 0xd6, 0xc1, 0x56, 0x0a, 0x6d, 0xc1, 0x6d, 0xa3, 0x99, 0x5c, 0x24, 0x8d,
0x36, 0x61, 0xc3, 0x28, 0xed, 0xfa, 0x6f, 0xf6, 0xbb, 0x56, 0xf2, 0xf7, 0xf0, 0xba, 0x0f, 0x5f,
0x75, 0xc3, 0xc1, 0xa2, 0xcd, 0xf4, 0x3a, 0x67, 0x47, 0xd1, 0x3b, 0x3a, 0xf0, 0x9b, 0xaa, 0x96,
0xcd, 0xd4, 0xfb, 0x57, 0x06, 0xd4, 0x0f, 0x7d, 0x1a, 0xf4, 0x4b, 0xa1, 0xe8, 0x97, 0xfb, 0x2c,
0xd0, 0x95, 0x2e, 0x27, 0x26, 0x1a, 0xf1, 0x78, 0xee, 0x3f, 0xfa, 0xe5, 0x44, 0x38, 0x5b, 0xd1,
0xc0, 0xa3, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x96, 0x5d, 0x26, 0x6c, 0x6f, 0x0b, 0x00, 0x00,
}

1359
vendor/google.golang.org/genproto/googleapis/appengine/v1/appengine.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

222
vendor/google.golang.org/genproto/googleapis/appengine/v1/application.pb.go generated vendored Normal file
View File

@ -0,0 +1,222 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/application.proto
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf1 "github.com/golang/protobuf/ptypes/duration"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// An Application resource contains the top-level configuration of an App
// Engine application.
type Application struct {
// Full path to the Application resource in the API.
// Example: `apps/myapp`.
//
// @OutputOnly
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Identifier of the Application resource. This identifier is equivalent
// to the project ID of the Google Cloud Platform project where you want to
// deploy your application.
// Example: `myapp`.
Id string `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
// HTTP path dispatch rules for requests to the application that do not
// explicitly target a service or version. Rules are order-dependent.
//
// @OutputOnly
DispatchRules []*UrlDispatchRule `protobuf:"bytes,3,rep,name=dispatch_rules,json=dispatchRules" json:"dispatch_rules,omitempty"`
// Google Apps authentication domain that controls which users can access
// this application.
//
// Defaults to open access for any Google Account.
AuthDomain string `protobuf:"bytes,6,opt,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"`
// Location from which this application will be run. Application instances
// will run out of data centers in the chosen location, which is also where
// all of the application's end user content is stored.
//
// Defaults to `us-central`.
//
// Options are:
//
// `us-central` - Central US
//
// `europe-west` - Western Europe
//
// `us-east1` - Eastern US
LocationId string `protobuf:"bytes,7,opt,name=location_id,json=locationId" json:"location_id,omitempty"`
// Google Cloud Storage bucket that can be used for storing files
// associated with this application. This bucket is associated with the
// application and can be used by the gcloud deployment commands.
//
// @OutputOnly
CodeBucket string `protobuf:"bytes,8,opt,name=code_bucket,json=codeBucket" json:"code_bucket,omitempty"`
// Cookie expiration policy for this application.
//
// @OutputOnly
DefaultCookieExpiration *google_protobuf1.Duration `protobuf:"bytes,9,opt,name=default_cookie_expiration,json=defaultCookieExpiration" json:"default_cookie_expiration,omitempty"`
// Hostname used to reach this application, as resolved by App Engine.
//
// @OutputOnly
DefaultHostname string `protobuf:"bytes,11,opt,name=default_hostname,json=defaultHostname" json:"default_hostname,omitempty"`
// Google Cloud Storage bucket that can be used by this application to store
// content.
//
// @OutputOnly
DefaultBucket string `protobuf:"bytes,12,opt,name=default_bucket,json=defaultBucket" json:"default_bucket,omitempty"`
}
func (m *Application) Reset() { *m = Application{} }
func (m *Application) String() string { return proto.CompactTextString(m) }
func (*Application) ProtoMessage() {}
func (*Application) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *Application) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Application) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Application) GetDispatchRules() []*UrlDispatchRule {
if m != nil {
return m.DispatchRules
}
return nil
}
func (m *Application) GetAuthDomain() string {
if m != nil {
return m.AuthDomain
}
return ""
}
func (m *Application) GetLocationId() string {
if m != nil {
return m.LocationId
}
return ""
}
func (m *Application) GetCodeBucket() string {
if m != nil {
return m.CodeBucket
}
return ""
}
func (m *Application) GetDefaultCookieExpiration() *google_protobuf1.Duration {
if m != nil {
return m.DefaultCookieExpiration
}
return nil
}
func (m *Application) GetDefaultHostname() string {
if m != nil {
return m.DefaultHostname
}
return ""
}
func (m *Application) GetDefaultBucket() string {
if m != nil {
return m.DefaultBucket
}
return ""
}
// Rules to match an HTTP request and dispatch that request to a service.
type UrlDispatchRule struct {
// Domain name to match against. The wildcard "`*`" is supported if
// specified before a period: "`*.`".
//
// Defaults to matching all domains: "`*`".
Domain string `protobuf:"bytes,1,opt,name=domain" json:"domain,omitempty"`
// Pathname within the host. Must start with a "`/`". A
// single "`*`" can be included at the end of the path. The sum
// of the lengths of the domain and path may not exceed 100
// characters.
Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
// Resource ID of a service in this application that should
// serve the matched request. The service must already
// exist. Example: `default`.
Service string `protobuf:"bytes,3,opt,name=service" json:"service,omitempty"`
}
func (m *UrlDispatchRule) Reset() { *m = UrlDispatchRule{} }
func (m *UrlDispatchRule) String() string { return proto.CompactTextString(m) }
func (*UrlDispatchRule) ProtoMessage() {}
func (*UrlDispatchRule) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
func (m *UrlDispatchRule) GetDomain() string {
if m != nil {
return m.Domain
}
return ""
}
func (m *UrlDispatchRule) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *UrlDispatchRule) GetService() string {
if m != nil {
return m.Service
}
return ""
}
func init() {
proto.RegisterType((*Application)(nil), "google.appengine.v1.Application")
proto.RegisterType((*UrlDispatchRule)(nil), "google.appengine.v1.UrlDispatchRule")
}
func init() { proto.RegisterFile("google/appengine/v1/application.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 409 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x5f, 0x6b, 0xdb, 0x30,
0x14, 0xc5, 0x71, 0x3c, 0x92, 0x45, 0x5e, 0xfe, 0xa0, 0xc1, 0xa2, 0x84, 0xb1, 0x85, 0xb0, 0x40,
0xf6, 0x62, 0x93, 0xec, 0x71, 0x7b, 0x59, 0x9a, 0x42, 0x4b, 0x5f, 0x82, 0x21, 0x14, 0xfa, 0x62,
0x14, 0x4b, 0xb1, 0x45, 0x14, 0xc9, 0xd8, 0x72, 0xe8, 0x67, 0xe8, 0xa7, 0x2e, 0x96, 0x64, 0x37,
0x2d, 0x79, 0xd3, 0x3d, 0xfa, 0x1d, 0xdd, 0xeb, 0x73, 0x0d, 0xe6, 0x89, 0x94, 0x09, 0xa7, 0x01,
0xce, 0x32, 0x2a, 0x12, 0x26, 0x68, 0x70, 0x5e, 0x56, 0x05, 0x67, 0x31, 0x56, 0x4c, 0x0a, 0x3f,
0xcb, 0xa5, 0x92, 0xf0, 0xab, 0xc1, 0xfc, 0x06, 0xf3, 0xcf, 0xcb, 0xc9, 0xf7, 0xc6, 0xcb, 0x02,
0x2c, 0x84, 0x54, 0xda, 0x51, 0x18, 0xcb, 0xe4, 0x87, 0xbd, 0xd5, 0xd5, 0xbe, 0x3c, 0x04, 0xa4,
0xcc, 0x2f, 0x9e, 0x9c, 0xbd, 0xb8, 0xc0, 0xfb, 0xff, 0xd6, 0x08, 0x42, 0xf0, 0x49, 0xe0, 0x13,
0x45, 0xce, 0xd4, 0x59, 0x74, 0x43, 0x7d, 0x86, 0x7d, 0xd0, 0x62, 0x04, 0xb5, 0xb4, 0xd2, 0x62,
0x04, 0x3e, 0x80, 0x3e, 0x61, 0x45, 0x86, 0x55, 0x9c, 0x46, 0x79, 0xc9, 0x69, 0x81, 0xdc, 0xa9,
0xbb, 0xf0, 0x56, 0xbf, 0xfc, 0x2b, 0xf3, 0xf9, 0xbb, 0x9c, 0x6f, 0x2c, 0x1d, 0x96, 0x9c, 0x86,
0x3d, 0x72, 0x51, 0x15, 0xf0, 0x27, 0xf0, 0x70, 0xa9, 0xd2, 0x88, 0xc8, 0x13, 0x66, 0x02, 0xb5,
0x75, 0x17, 0x50, 0x49, 0x1b, 0xad, 0x54, 0x00, 0x97, 0x66, 0xba, 0x88, 0x11, 0xd4, 0x31, 0x40,
0x2d, 0xdd, 0x93, 0x0a, 0x88, 0x25, 0xa1, 0xd1, 0xbe, 0x8c, 0x8f, 0x54, 0xa1, 0xcf, 0x06, 0xa8,
0xa4, 0xb5, 0x56, 0xe0, 0x0e, 0x8c, 0x09, 0x3d, 0xe0, 0x92, 0xab, 0x28, 0x96, 0xf2, 0xc8, 0x68,
0x44, 0x9f, 0x33, 0x66, 0x62, 0x40, 0xdd, 0xa9, 0xb3, 0xf0, 0x56, 0xe3, 0x7a, 0xf4, 0x3a, 0x27,
0x7f, 0x63, 0x73, 0x0a, 0x47, 0xd6, 0x7b, 0xa3, 0xad, 0xb7, 0x8d, 0x13, 0xfe, 0x06, 0xc3, 0xfa,
0xd9, 0x54, 0x16, 0x4a, 0xc7, 0xe6, 0xe9, 0xe6, 0x03, 0xab, 0xdf, 0x59, 0x19, 0xce, 0x41, 0xbf,
0x46, 0xed, 0x94, 0x5f, 0x34, 0xd8, 0xb3, 0xaa, 0x19, 0x74, 0xf6, 0x08, 0x06, 0x1f, 0xd2, 0x82,
0xdf, 0x40, 0xdb, 0x26, 0x63, 0x36, 0x62, 0xab, 0x6a, 0x4f, 0x19, 0x56, 0xa9, 0xdd, 0x8a, 0x3e,
0x43, 0x04, 0x3a, 0x05, 0xcd, 0xcf, 0x2c, 0xa6, 0xc8, 0xd5, 0x72, 0x5d, 0xae, 0x8f, 0x60, 0x14,
0xcb, 0xd3, 0xb5, 0xf5, 0xac, 0x87, 0x17, 0xdb, 0xdf, 0x56, 0x1f, 0xbf, 0x75, 0x9e, 0xfe, 0x59,
0x30, 0x91, 0x1c, 0x8b, 0xc4, 0x97, 0x79, 0x12, 0x24, 0x54, 0xe8, 0x68, 0x02, 0x73, 0x85, 0x33,
0x56, 0xbc, 0xfb, 0x5b, 0xff, 0x36, 0xc5, 0xbe, 0xad, 0xc1, 0x3f, 0xaf, 0x01, 0x00, 0x00, 0xff,
0xff, 0x7a, 0x51, 0x2e, 0x3c, 0xd5, 0x02, 0x00, 0x00,
}

208
vendor/google.golang.org/genproto/googleapis/appengine/v1/audit_data.pb.go generated vendored Normal file
View File

@ -0,0 +1,208 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/audit_data.proto
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/iam/v1"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// App Engine admin service audit log.
type AuditData struct {
// Detailed information about methods that require it. Does not include
// simple Get, List or Delete methods because all significant information
// (resource name, number of returned elements for List operations) is already
// included in parent audit log message.
//
// Types that are valid to be assigned to Method:
// *AuditData_UpdateService
// *AuditData_CreateVersion
Method isAuditData_Method `protobuf_oneof:"method"`
}
func (m *AuditData) Reset() { *m = AuditData{} }
func (m *AuditData) String() string { return proto.CompactTextString(m) }
func (*AuditData) ProtoMessage() {}
func (*AuditData) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
type isAuditData_Method interface {
isAuditData_Method()
}
type AuditData_UpdateService struct {
UpdateService *UpdateServiceMethod `protobuf:"bytes,1,opt,name=update_service,json=updateService,oneof"`
}
type AuditData_CreateVersion struct {
CreateVersion *CreateVersionMethod `protobuf:"bytes,2,opt,name=create_version,json=createVersion,oneof"`
}
func (*AuditData_UpdateService) isAuditData_Method() {}
func (*AuditData_CreateVersion) isAuditData_Method() {}
func (m *AuditData) GetMethod() isAuditData_Method {
if m != nil {
return m.Method
}
return nil
}
func (m *AuditData) GetUpdateService() *UpdateServiceMethod {
if x, ok := m.GetMethod().(*AuditData_UpdateService); ok {
return x.UpdateService
}
return nil
}
func (m *AuditData) GetCreateVersion() *CreateVersionMethod {
if x, ok := m.GetMethod().(*AuditData_CreateVersion); ok {
return x.CreateVersion
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*AuditData) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _AuditData_OneofMarshaler, _AuditData_OneofUnmarshaler, _AuditData_OneofSizer, []interface{}{
(*AuditData_UpdateService)(nil),
(*AuditData_CreateVersion)(nil),
}
}
func _AuditData_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*AuditData)
// method
switch x := m.Method.(type) {
case *AuditData_UpdateService:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.UpdateService); err != nil {
return err
}
case *AuditData_CreateVersion:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.CreateVersion); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("AuditData.Method has unexpected type %T", x)
}
return nil
}
func _AuditData_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*AuditData)
switch tag {
case 1: // method.update_service
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(UpdateServiceMethod)
err := b.DecodeMessage(msg)
m.Method = &AuditData_UpdateService{msg}
return true, err
case 2: // method.create_version
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(CreateVersionMethod)
err := b.DecodeMessage(msg)
m.Method = &AuditData_CreateVersion{msg}
return true, err
default:
return false, nil
}
}
func _AuditData_OneofSizer(msg proto.Message) (n int) {
m := msg.(*AuditData)
// method
switch x := m.Method.(type) {
case *AuditData_UpdateService:
s := proto.Size(x.UpdateService)
n += proto.SizeVarint(1<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *AuditData_CreateVersion:
s := proto.Size(x.CreateVersion)
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Detailed information about UpdateService call.
type UpdateServiceMethod struct {
// Update service request.
Request *UpdateServiceRequest `protobuf:"bytes,1,opt,name=request" json:"request,omitempty"`
}
func (m *UpdateServiceMethod) Reset() { *m = UpdateServiceMethod{} }
func (m *UpdateServiceMethod) String() string { return proto.CompactTextString(m) }
func (*UpdateServiceMethod) ProtoMessage() {}
func (*UpdateServiceMethod) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
func (m *UpdateServiceMethod) GetRequest() *UpdateServiceRequest {
if m != nil {
return m.Request
}
return nil
}
// Detailed information about CreateVersion call.
type CreateVersionMethod struct {
// Create version request.
Request *CreateVersionRequest `protobuf:"bytes,1,opt,name=request" json:"request,omitempty"`
}
func (m *CreateVersionMethod) Reset() { *m = CreateVersionMethod{} }
func (m *CreateVersionMethod) String() string { return proto.CompactTextString(m) }
func (*CreateVersionMethod) ProtoMessage() {}
func (*CreateVersionMethod) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
func (m *CreateVersionMethod) GetRequest() *CreateVersionRequest {
if m != nil {
return m.Request
}
return nil
}
func init() {
proto.RegisterType((*AuditData)(nil), "google.appengine.v1.AuditData")
proto.RegisterType((*UpdateServiceMethod)(nil), "google.appengine.v1.UpdateServiceMethod")
proto.RegisterType((*CreateVersionMethod)(nil), "google.appengine.v1.CreateVersionMethod")
}
func init() { proto.RegisterFile("google/appengine/v1/audit_data.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 290 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xb1, 0x4e, 0xc3, 0x30,
0x10, 0x86, 0x09, 0x43, 0x01, 0x23, 0x3a, 0xa4, 0x03, 0x55, 0x07, 0x84, 0x0a, 0x43, 0x59, 0x1c,
0x15, 0x46, 0x58, 0x48, 0x19, 0x58, 0x90, 0x4a, 0x10, 0x0c, 0x5d, 0xa2, 0x23, 0x39, 0x19, 0x4b,
0x49, 0x6c, 0x1c, 0x27, 0x12, 0xcf, 0xc6, 0xcb, 0x21, 0xdb, 0x21, 0xb4, 0xc8, 0x82, 0x8e, 0xb9,
0xfb, 0xfe, 0x2f, 0xbf, 0x74, 0x26, 0xe7, 0x4c, 0x08, 0x56, 0x60, 0x04, 0x52, 0x62, 0xc5, 0x78,
0x85, 0x51, 0x3b, 0x8f, 0xa0, 0xc9, 0xb9, 0x4e, 0x73, 0xd0, 0x40, 0xa5, 0x12, 0x5a, 0x84, 0x23,
0x47, 0xd1, 0x9e, 0xa2, 0xed, 0x7c, 0x72, 0xe6, 0x8d, 0xf6, 0x84, 0x4d, 0x4e, 0x4e, 0x3a, 0x88,
0x43, 0x69, 0xd6, 0x1c, 0xca, 0x54, 0x8a, 0x82, 0x67, 0x1f, 0x6e, 0x3f, 0xfd, 0x0c, 0xc8, 0xc1,
0xad, 0xf9, 0xdd, 0x1d, 0x68, 0x08, 0x1f, 0xc9, 0xb0, 0x91, 0x39, 0x68, 0x4c, 0x6b, 0x54, 0x2d,
0xcf, 0x70, 0x1c, 0x9c, 0x06, 0xb3, 0xc3, 0xcb, 0x19, 0xf5, 0x14, 0xa0, 0xcf, 0x16, 0x7d, 0x72,
0xe4, 0x03, 0xea, 0x37, 0x91, 0xdf, 0xef, 0x24, 0x47, 0xcd, 0xfa, 0xd8, 0x28, 0x33, 0x85, 0x46,
0xd9, 0xa2, 0xaa, 0xb9, 0xa8, 0xc6, 0xbb, 0x7f, 0x28, 0x17, 0x16, 0x7d, 0x71, 0xe4, 0x8f, 0x32,
0x5b, 0x1f, 0xc7, 0xfb, 0x64, 0x50, 0xda, 0xd5, 0x74, 0x45, 0x46, 0x9e, 0x12, 0xe1, 0x82, 0xec,
0x29, 0x7c, 0x6f, 0xb0, 0xd6, 0x5d, 0xff, 0x8b, 0xff, 0xfb, 0x27, 0x2e, 0x90, 0x7c, 0x27, 0x8d,
0xdb, 0xd3, 0x66, 0x5b, 0xf7, 0x46, 0xf4, 0xb7, 0x3b, 0xe6, 0xe4, 0x38, 0x13, 0xa5, 0x2f, 0x18,
0x0f, 0xfb, 0x6b, 0x2c, 0xcd, 0x81, 0x96, 0xc1, 0xea, 0xa6, 0xc3, 0x98, 0x28, 0xa0, 0x62, 0x54,
0x28, 0x16, 0x31, 0xac, 0xec, 0xf9, 0x22, 0xb7, 0x02, 0xc9, 0xeb, 0x8d, 0x67, 0x70, 0xdd, 0x7f,
0xbc, 0x0e, 0x2c, 0x78, 0xf5, 0x15, 0x00, 0x00, 0xff, 0xff, 0xdb, 0x56, 0x80, 0x49, 0x69, 0x02,
0x00, 0x00,
}

183
vendor/google.golang.org/genproto/googleapis/appengine/v1/deploy.pb.go generated vendored Normal file
View File

@ -0,0 +1,183 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/deploy.proto
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Code and application artifacts used to deploy a version to App Engine.
type Deployment struct {
// Manifest of the files stored in Google Cloud Storage that are included
// as part of this version. All files must be readable using the
// credentials supplied with this call.
Files map[string]*FileInfo `protobuf:"bytes,1,rep,name=files" json:"files,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// A Docker image that App Engine uses to run the version.
// Only applicable for instances in App Engine flexible environment.
Container *ContainerInfo `protobuf:"bytes,2,opt,name=container" json:"container,omitempty"`
// The zip file for this deployment, if this is a zip deployment.
Zip *ZipInfo `protobuf:"bytes,3,opt,name=zip" json:"zip,omitempty"`
}
func (m *Deployment) Reset() { *m = Deployment{} }
func (m *Deployment) String() string { return proto.CompactTextString(m) }
func (*Deployment) ProtoMessage() {}
func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
func (m *Deployment) GetFiles() map[string]*FileInfo {
if m != nil {
return m.Files
}
return nil
}
func (m *Deployment) GetContainer() *ContainerInfo {
if m != nil {
return m.Container
}
return nil
}
func (m *Deployment) GetZip() *ZipInfo {
if m != nil {
return m.Zip
}
return nil
}
// Single source file that is part of the version to be deployed. Each source
// file that is deployed must be specified separately.
type FileInfo struct {
// URL source to use to fetch this file. Must be a URL to a resource in
// Google Cloud Storage in the form
// 'http(s)://storage.googleapis.com/\<bucket\>/\<object\>'.
SourceUrl string `protobuf:"bytes,1,opt,name=source_url,json=sourceUrl" json:"source_url,omitempty"`
// The SHA1 hash of the file, in hex.
Sha1Sum string `protobuf:"bytes,2,opt,name=sha1_sum,json=sha1Sum" json:"sha1_sum,omitempty"`
// The MIME type of the file.
//
// Defaults to the value from Google Cloud Storage.
MimeType string `protobuf:"bytes,3,opt,name=mime_type,json=mimeType" json:"mime_type,omitempty"`
}
func (m *FileInfo) Reset() { *m = FileInfo{} }
func (m *FileInfo) String() string { return proto.CompactTextString(m) }
func (*FileInfo) ProtoMessage() {}
func (*FileInfo) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
func (m *FileInfo) GetSourceUrl() string {
if m != nil {
return m.SourceUrl
}
return ""
}
func (m *FileInfo) GetSha1Sum() string {
if m != nil {
return m.Sha1Sum
}
return ""
}
func (m *FileInfo) GetMimeType() string {
if m != nil {
return m.MimeType
}
return ""
}
// Docker image that is used to start a VM container for the version you
// deploy.
type ContainerInfo struct {
// URI to the hosted container image in a Docker repository. The URI must be
// fully qualified and include a tag or digest.
// Examples: "gcr.io/my-project/image:tag" or "gcr.io/my-project/image@digest"
Image string `protobuf:"bytes,1,opt,name=image" json:"image,omitempty"`
}
func (m *ContainerInfo) Reset() { *m = ContainerInfo{} }
func (m *ContainerInfo) String() string { return proto.CompactTextString(m) }
func (*ContainerInfo) ProtoMessage() {}
func (*ContainerInfo) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} }
func (m *ContainerInfo) GetImage() string {
if m != nil {
return m.Image
}
return ""
}
type ZipInfo struct {
// URL of the zip file to deploy from. Must be a URL to a resource in
// Google Cloud Storage in the form
// 'http(s)://storage.googleapis.com/\<bucket\>/\<object\>'.
SourceUrl string `protobuf:"bytes,3,opt,name=source_url,json=sourceUrl" json:"source_url,omitempty"`
// An estimate of the number of files in a zip for a zip deployment.
// If set, must be greater than or equal to the actual number of files.
// Used for optimizing performance; if not provided, deployment may be slow.
FilesCount int32 `protobuf:"varint,4,opt,name=files_count,json=filesCount" json:"files_count,omitempty"`
}
func (m *ZipInfo) Reset() { *m = ZipInfo{} }
func (m *ZipInfo) String() string { return proto.CompactTextString(m) }
func (*ZipInfo) ProtoMessage() {}
func (*ZipInfo) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{3} }
func (m *ZipInfo) GetSourceUrl() string {
if m != nil {
return m.SourceUrl
}
return ""
}
func (m *ZipInfo) GetFilesCount() int32 {
if m != nil {
return m.FilesCount
}
return 0
}
func init() {
proto.RegisterType((*Deployment)(nil), "google.appengine.v1.Deployment")
proto.RegisterType((*FileInfo)(nil), "google.appengine.v1.FileInfo")
proto.RegisterType((*ContainerInfo)(nil), "google.appengine.v1.ContainerInfo")
proto.RegisterType((*ZipInfo)(nil), "google.appengine.v1.ZipInfo")
}
func init() { proto.RegisterFile("google/appengine/v1/deploy.proto", fileDescriptor4) }
var fileDescriptor4 = []byte{
// 394 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0xd1, 0xab, 0xd3, 0x30,
0x14, 0xc6, 0xe9, 0x6a, 0xbd, 0xeb, 0x29, 0x82, 0x44, 0xc1, 0x7a, 0xbd, 0x17, 0x4b, 0x41, 0x28,
0x3e, 0xa4, 0xec, 0xde, 0x17, 0x51, 0x1f, 0x2e, 0x9b, 0x0a, 0x7b, 0x1b, 0x55, 0x11, 0xf6, 0x52,
0x62, 0xcd, 0x62, 0xb0, 0x4d, 0x42, 0x9b, 0x0e, 0xea, 0x7f, 0xe2, 0x7f, 0x2b, 0x49, 0xba, 0x8d,
0x8d, 0xbe, 0xf5, 0x7c, 0xfd, 0x7d, 0x5f, 0x4e, 0x72, 0x0e, 0x24, 0x4c, 0x4a, 0x56, 0xd3, 0x9c,
0x28, 0x45, 0x05, 0xe3, 0x82, 0xe6, 0xfb, 0x45, 0xfe, 0x8b, 0xaa, 0x5a, 0x0e, 0x58, 0xb5, 0x52,
0x4b, 0xf4, 0xcc, 0x11, 0xf8, 0x48, 0xe0, 0xfd, 0xe2, 0xfa, 0xe6, 0x68, 0xe3, 0x39, 0x11, 0x42,
0x6a, 0xa2, 0xb9, 0x14, 0x9d, 0xb3, 0xa4, 0xff, 0x66, 0x00, 0x9f, 0x6c, 0x46, 0x43, 0x85, 0x46,
0x0f, 0x10, 0xec, 0x78, 0x4d, 0xbb, 0xd8, 0x4b, 0xfc, 0x2c, 0xba, 0x7b, 0x8b, 0x27, 0x12, 0xf1,
0x89, 0xc7, 0x5f, 0x0c, 0xfc, 0x59, 0xe8, 0x76, 0x28, 0x9c, 0x11, 0x3d, 0x40, 0x58, 0x49, 0xa1,
0x09, 0x17, 0xb4, 0x8d, 0x67, 0x89, 0x97, 0x45, 0x77, 0xe9, 0x64, 0xca, 0xea, 0x40, 0xad, 0xc5,
0x4e, 0x16, 0x27, 0x13, 0xc2, 0xe0, 0xff, 0xe5, 0x2a, 0xf6, 0xad, 0xf7, 0x66, 0xd2, 0xbb, 0xe5,
0xca, 0xba, 0x0c, 0x78, 0xfd, 0x03, 0xe0, 0xd4, 0x06, 0x7a, 0x0a, 0xfe, 0x1f, 0x3a, 0xc4, 0x5e,
0xe2, 0x65, 0x61, 0x61, 0x3e, 0xd1, 0x3d, 0x04, 0x7b, 0x52, 0xf7, 0x74, 0xec, 0xe6, 0x76, 0x32,
0xd1, 0x24, 0xd8, 0x48, 0xc7, 0xbe, 0x9f, 0xbd, 0xf3, 0x52, 0x02, 0xf3, 0x83, 0x8c, 0x6e, 0x01,
0x3a, 0xd9, 0xb7, 0x15, 0x2d, 0xfb, 0xb6, 0x1e, 0xd3, 0x43, 0xa7, 0x7c, 0x6f, 0x6b, 0xf4, 0x12,
0xe6, 0xdd, 0x6f, 0xb2, 0x28, 0xbb, 0xbe, 0xb1, 0xc7, 0x84, 0xc5, 0x95, 0xa9, 0xbf, 0xf6, 0x0d,
0x7a, 0x05, 0x61, 0xc3, 0x1b, 0x5a, 0xea, 0x41, 0x51, 0x7b, 0xa9, 0xb0, 0x98, 0x1b, 0xe1, 0xdb,
0xa0, 0x68, 0xfa, 0x06, 0x9e, 0x9c, 0xbd, 0x03, 0x7a, 0x0e, 0x01, 0x6f, 0x08, 0xa3, 0xe3, 0x11,
0xae, 0x48, 0xd7, 0x70, 0x35, 0x5e, 0xf9, 0xa2, 0x11, 0xff, 0xb2, 0x91, 0xd7, 0x10, 0xd9, 0x39,
0x94, 0x95, 0xec, 0x85, 0x8e, 0x1f, 0x25, 0x5e, 0x16, 0x14, 0x60, 0xa5, 0x95, 0x51, 0x96, 0x3b,
0x78, 0x51, 0xc9, 0x66, 0xea, 0x0d, 0x96, 0x91, 0x1b, 0xec, 0xc6, 0x2c, 0xc6, 0xc6, 0xdb, 0x7e,
0x1c, 0x19, 0x26, 0x6b, 0x22, 0x18, 0x96, 0x2d, 0xcb, 0x19, 0x15, 0x76, 0x6d, 0x72, 0xf7, 0x8b,
0x28, 0xde, 0x9d, 0xad, 0xe3, 0x87, 0x63, 0xf1, 0xf3, 0xb1, 0x05, 0xef, 0xff, 0x07, 0x00, 0x00,
0xff, 0xff, 0x6e, 0xeb, 0x52, 0x5a, 0xb6, 0x02, 0x00, 0x00,
}

266
vendor/google.golang.org/genproto/googleapis/appengine/v1/instance.pb.go generated vendored Normal file
View File

@ -0,0 +1,266 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/instance.proto
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf2 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Availability of the instance.
type Instance_Availability int32
const (
Instance_UNSPECIFIED Instance_Availability = 0
Instance_RESIDENT Instance_Availability = 1
Instance_DYNAMIC Instance_Availability = 2
)
var Instance_Availability_name = map[int32]string{
0: "UNSPECIFIED",
1: "RESIDENT",
2: "DYNAMIC",
}
var Instance_Availability_value = map[string]int32{
"UNSPECIFIED": 0,
"RESIDENT": 1,
"DYNAMIC": 2,
}
func (x Instance_Availability) String() string {
return proto.EnumName(Instance_Availability_name, int32(x))
}
func (Instance_Availability) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{0, 0} }
// An Instance resource is the computing unit that App Engine uses to
// automatically scale an application.
type Instance struct {
// Full path to the Instance resource in the API.
// Example: `apps/myapp/services/default/versions/v1/instances/instance-1`.
//
// @OutputOnly
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Relative name of the instance within the version.
// Example: `instance-1`.
//
// @OutputOnly
Id string `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
// App Engine release this instance is running on.
//
// @OutputOnly
AppEngineRelease string `protobuf:"bytes,3,opt,name=app_engine_release,json=appEngineRelease" json:"app_engine_release,omitempty"`
// Availability of the instance.
//
// @OutputOnly
Availability Instance_Availability `protobuf:"varint,4,opt,name=availability,enum=google.appengine.v1.Instance_Availability" json:"availability,omitempty"`
// Name of the virtual machine where this instance lives. Only applicable
// for instances in App Engine flexible environment.
//
// @OutputOnly
VmName string `protobuf:"bytes,5,opt,name=vm_name,json=vmName" json:"vm_name,omitempty"`
// Zone where the virtual machine is located. Only applicable for instances
// in App Engine flexible environment.
//
// @OutputOnly
VmZoneName string `protobuf:"bytes,6,opt,name=vm_zone_name,json=vmZoneName" json:"vm_zone_name,omitempty"`
// Virtual machine ID of this instance. Only applicable for instances in
// App Engine flexible environment.
//
// @OutputOnly
VmId string `protobuf:"bytes,7,opt,name=vm_id,json=vmId" json:"vm_id,omitempty"`
// Time that this instance was started.
//
// @OutputOnly
StartTime *google_protobuf2.Timestamp `protobuf:"bytes,8,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
// Number of requests since this instance was started.
//
// @OutputOnly
Requests int32 `protobuf:"varint,9,opt,name=requests" json:"requests,omitempty"`
// Number of errors since this instance was started.
//
// @OutputOnly
Errors int32 `protobuf:"varint,10,opt,name=errors" json:"errors,omitempty"`
// Average queries per second (QPS) over the last minute.
//
// @OutputOnly
Qps float32 `protobuf:"fixed32,11,opt,name=qps" json:"qps,omitempty"`
// Average latency (ms) over the last minute.
//
// @OutputOnly
AverageLatency int32 `protobuf:"varint,12,opt,name=average_latency,json=averageLatency" json:"average_latency,omitempty"`
// Total memory in use (bytes).
//
// @OutputOnly
MemoryUsage int64 `protobuf:"varint,13,opt,name=memory_usage,json=memoryUsage" json:"memory_usage,omitempty"`
// Status of the virtual machine where this instance lives. Only applicable
// for instances in App Engine flexible environment.
//
// @OutputOnly
VmStatus string `protobuf:"bytes,14,opt,name=vm_status,json=vmStatus" json:"vm_status,omitempty"`
// Whether this instance is in debug mode. Only applicable for instances in
// App Engine flexible environment.
//
// @OutputOnly
VmDebugEnabled bool `protobuf:"varint,15,opt,name=vm_debug_enabled,json=vmDebugEnabled" json:"vm_debug_enabled,omitempty"`
}
func (m *Instance) Reset() { *m = Instance{} }
func (m *Instance) String() string { return proto.CompactTextString(m) }
func (*Instance) ProtoMessage() {}
func (*Instance) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
func (m *Instance) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Instance) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Instance) GetAppEngineRelease() string {
if m != nil {
return m.AppEngineRelease
}
return ""
}
func (m *Instance) GetAvailability() Instance_Availability {
if m != nil {
return m.Availability
}
return Instance_UNSPECIFIED
}
func (m *Instance) GetVmName() string {
if m != nil {
return m.VmName
}
return ""
}
func (m *Instance) GetVmZoneName() string {
if m != nil {
return m.VmZoneName
}
return ""
}
func (m *Instance) GetVmId() string {
if m != nil {
return m.VmId
}
return ""
}
func (m *Instance) GetStartTime() *google_protobuf2.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
func (m *Instance) GetRequests() int32 {
if m != nil {
return m.Requests
}
return 0
}
func (m *Instance) GetErrors() int32 {
if m != nil {
return m.Errors
}
return 0
}
func (m *Instance) GetQps() float32 {
if m != nil {
return m.Qps
}
return 0
}
func (m *Instance) GetAverageLatency() int32 {
if m != nil {
return m.AverageLatency
}
return 0
}
func (m *Instance) GetMemoryUsage() int64 {
if m != nil {
return m.MemoryUsage
}
return 0
}
func (m *Instance) GetVmStatus() string {
if m != nil {
return m.VmStatus
}
return ""
}
func (m *Instance) GetVmDebugEnabled() bool {
if m != nil {
return m.VmDebugEnabled
}
return false
}
func init() {
proto.RegisterType((*Instance)(nil), "google.appengine.v1.Instance")
proto.RegisterEnum("google.appengine.v1.Instance_Availability", Instance_Availability_name, Instance_Availability_value)
}
func init() { proto.RegisterFile("google/appengine/v1/instance.proto", fileDescriptor5) }
var fileDescriptor5 = []byte{
// 521 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x53, 0x5d, 0x6b, 0xdb, 0x3c,
0x14, 0x7e, 0x9d, 0xb6, 0xa9, 0x73, 0xe2, 0x26, 0x46, 0x85, 0xb7, 0x22, 0x1b, 0xcc, 0xcb, 0xcd,
0xcc, 0x18, 0x36, 0xed, 0xae, 0xf6, 0x71, 0xd3, 0x36, 0x1e, 0x18, 0xb6, 0x10, 0x9c, 0xf6, 0x62,
0xbd, 0x31, 0x4a, 0xac, 0x79, 0x02, 0x4b, 0x72, 0x2d, 0x45, 0x90, 0xfd, 0xc6, 0xfd, 0xa8, 0x61,
0x39, 0x09, 0x2d, 0xf4, 0xce, 0xcf, 0xc7, 0x41, 0xcf, 0x79, 0x0e, 0x86, 0x69, 0x29, 0x65, 0x59,
0xd1, 0x98, 0xd4, 0x35, 0x15, 0x25, 0x13, 0x34, 0x36, 0x97, 0x31, 0x13, 0x4a, 0x13, 0xb1, 0xa6,
0x51, 0xdd, 0x48, 0x2d, 0xd1, 0x79, 0xe7, 0x89, 0x0e, 0x9e, 0xc8, 0x5c, 0x4e, 0x5e, 0x1f, 0x06,
0x59, 0x4c, 0x84, 0x90, 0x9a, 0x68, 0x26, 0x85, 0xea, 0x46, 0x26, 0x6f, 0x76, 0xaa, 0x45, 0xab,
0xcd, 0xaf, 0x58, 0x33, 0x4e, 0x95, 0x26, 0xbc, 0xee, 0x0c, 0xd3, 0xbf, 0xc7, 0xe0, 0xa6, 0xbb,
0x67, 0x10, 0x82, 0x63, 0x41, 0x38, 0xc5, 0x4e, 0xe0, 0x84, 0x83, 0xcc, 0x7e, 0xa3, 0x11, 0xf4,
0x58, 0x81, 0x7b, 0x96, 0xe9, 0xb1, 0x02, 0x7d, 0x00, 0x44, 0xea, 0x3a, 0xef, 0x02, 0xe4, 0x0d,
0xad, 0x28, 0x51, 0x14, 0x1f, 0x59, 0xdd, 0x27, 0x75, 0x9d, 0x58, 0x21, 0xeb, 0x78, 0x34, 0x07,
0x8f, 0x18, 0xc2, 0x2a, 0xb2, 0x62, 0x15, 0xd3, 0x5b, 0x7c, 0x1c, 0x38, 0xe1, 0xe8, 0xea, 0x7d,
0xf4, 0xc2, 0x26, 0xd1, 0x3e, 0x46, 0x74, 0xfd, 0x64, 0x22, 0x7b, 0x36, 0x8f, 0x2e, 0xe0, 0xd4,
0xf0, 0xdc, 0x86, 0x3c, 0xb1, 0x4f, 0xf6, 0x0d, 0x9f, 0xb7, 0x31, 0x03, 0xf0, 0x0c, 0xcf, 0xff,
0x48, 0x41, 0x3b, 0xb5, 0x6f, 0x55, 0x30, 0xfc, 0x41, 0x0a, 0x6a, 0x1d, 0xe7, 0x70, 0x62, 0x78,
0xce, 0x0a, 0x7c, 0xda, 0x6d, 0x67, 0x78, 0x5a, 0xa0, 0x4f, 0x00, 0x4a, 0x93, 0x46, 0xe7, 0x6d,
0x2f, 0xd8, 0x0d, 0x9c, 0x70, 0x78, 0x35, 0xd9, 0xa7, 0xdb, 0x97, 0x16, 0xdd, 0xed, 0x4b, 0xcb,
0x06, 0xd6, 0xdd, 0x62, 0x34, 0x01, 0xb7, 0xa1, 0x8f, 0x1b, 0xaa, 0xb4, 0xc2, 0x83, 0xc0, 0x09,
0x4f, 0xb2, 0x03, 0x46, 0xff, 0x43, 0x9f, 0x36, 0x8d, 0x6c, 0x14, 0x06, 0xab, 0xec, 0x10, 0xf2,
0xe1, 0xe8, 0xb1, 0x56, 0x78, 0x18, 0x38, 0x61, 0x2f, 0x6b, 0x3f, 0xd1, 0x3b, 0x18, 0x13, 0x43,
0x1b, 0x52, 0xd2, 0xbc, 0x22, 0x9a, 0x8a, 0xf5, 0x16, 0x7b, 0x76, 0x64, 0xb4, 0xa3, 0xbf, 0x77,
0x2c, 0x7a, 0x0b, 0x1e, 0xa7, 0x5c, 0x36, 0xdb, 0x7c, 0xa3, 0x48, 0x49, 0xf1, 0x59, 0xe0, 0x84,
0x47, 0xd9, 0xb0, 0xe3, 0xee, 0x5b, 0x0a, 0xbd, 0x82, 0x81, 0xe1, 0xb9, 0xd2, 0x44, 0x6f, 0x14,
0x1e, 0xd9, 0x2d, 0x5d, 0xc3, 0x97, 0x16, 0xa3, 0x10, 0x7c, 0xc3, 0xf3, 0x82, 0xae, 0x36, 0x65,
0x4e, 0x05, 0x59, 0x55, 0xb4, 0xc0, 0xe3, 0xc0, 0x09, 0xdd, 0x6c, 0x64, 0xf8, 0xac, 0xa5, 0x93,
0x8e, 0x9d, 0x7e, 0x06, 0xef, 0xe9, 0x05, 0xd0, 0x18, 0x86, 0xf7, 0xf3, 0xe5, 0x22, 0xb9, 0x4d,
0xbf, 0xa5, 0xc9, 0xcc, 0xff, 0x0f, 0x79, 0xe0, 0x66, 0xc9, 0x32, 0x9d, 0x25, 0xf3, 0x3b, 0xdf,
0x41, 0x43, 0x38, 0x9d, 0xfd, 0x9c, 0x5f, 0xff, 0x48, 0x6f, 0xfd, 0xde, 0xcd, 0x6f, 0xb8, 0x58,
0x4b, 0xfe, 0xd2, 0x79, 0x6f, 0xce, 0xf6, 0xf7, 0x5d, 0xb4, 0xb5, 0x2e, 0x9c, 0x87, 0xaf, 0x3b,
0x57, 0x29, 0x2b, 0x22, 0xca, 0x48, 0x36, 0x65, 0x5c, 0x52, 0x61, 0x4b, 0x8f, 0x3b, 0x89, 0xd4,
0x4c, 0x3d, 0xfb, 0x23, 0xbe, 0x1c, 0xc0, 0xaa, 0x6f, 0x8d, 0x1f, 0xff, 0x05, 0x00, 0x00, 0xff,
0xff, 0x97, 0xe7, 0x7d, 0x88, 0x39, 0x03, 0x00, 0x00,
}

71
vendor/google.golang.org/genproto/googleapis/appengine/v1/location.pb.go generated vendored Normal file
View File

@ -0,0 +1,71 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/location.proto
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import _ "google.golang.org/genproto/googleapis/type/latlng"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Metadata for the given [google.cloud.location.Location][google.cloud.location.Location].
type LocationMetadata struct {
// App Engine Standard Environment is available in the given location.
//
// @OutputOnly
StandardEnvironmentAvailable bool `protobuf:"varint,2,opt,name=standard_environment_available,json=standardEnvironmentAvailable" json:"standard_environment_available,omitempty"`
// App Engine Flexible Environment is available in the given location.
//
// @OutputOnly
FlexibleEnvironmentAvailable bool `protobuf:"varint,4,opt,name=flexible_environment_available,json=flexibleEnvironmentAvailable" json:"flexible_environment_available,omitempty"`
}
func (m *LocationMetadata) Reset() { *m = LocationMetadata{} }
func (m *LocationMetadata) String() string { return proto.CompactTextString(m) }
func (*LocationMetadata) ProtoMessage() {}
func (*LocationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
func (m *LocationMetadata) GetStandardEnvironmentAvailable() bool {
if m != nil {
return m.StandardEnvironmentAvailable
}
return false
}
func (m *LocationMetadata) GetFlexibleEnvironmentAvailable() bool {
if m != nil {
return m.FlexibleEnvironmentAvailable
}
return false
}
func init() {
proto.RegisterType((*LocationMetadata)(nil), "google.appengine.v1.LocationMetadata")
}
func init() { proto.RegisterFile("google/appengine/v1/location.proto", fileDescriptor6) }
var fileDescriptor6 = []byte{
// 236 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x41, 0x4b, 0xc3, 0x40,
0x10, 0x85, 0x89, 0x88, 0x48, 0x40, 0x90, 0x7a, 0xb0, 0x94, 0x22, 0xd2, 0x93, 0xa7, 0x5d, 0x8a,
0x47, 0xbd, 0x58, 0xf4, 0xa6, 0x50, 0x3c, 0x7a, 0x29, 0x93, 0x66, 0x1c, 0x17, 0xa6, 0x33, 0x4b,
0x32, 0x04, 0xfd, 0x33, 0xfe, 0x56, 0x69, 0x36, 0x1b, 0x11, 0xea, 0x71, 0x79, 0xdf, 0xfb, 0xd8,
0x37, 0xe5, 0x82, 0x54, 0x89, 0xd1, 0x43, 0x8c, 0x28, 0x14, 0x04, 0x7d, 0xb7, 0xf4, 0xac, 0x5b,
0xb0, 0xa0, 0xe2, 0x62, 0xa3, 0xa6, 0x93, 0x8b, 0xc4, 0xb8, 0x91, 0x71, 0xdd, 0x72, 0x36, 0x1f,
0x8b, 0xc1, 0x83, 0x88, 0x5a, 0xdf, 0x68, 0x53, 0x65, 0x36, 0x1d, 0x52, 0xfb, 0x8a, 0xe8, 0x19,
0x8c, 0x85, 0x52, 0xb2, 0xf8, 0x2e, 0xca, 0xf3, 0xe7, 0xc1, 0xff, 0x82, 0x06, 0x35, 0x18, 0x4c,
0x1e, 0xcb, 0xab, 0xd6, 0x40, 0x6a, 0x68, 0xea, 0x0d, 0x4a, 0x17, 0x1a, 0x95, 0x1d, 0x8a, 0x6d,
0xa0, 0x83, 0xc0, 0x50, 0x31, 0x4e, 0x8f, 0xae, 0x8b, 0x9b, 0xd3, 0xd7, 0x79, 0xa6, 0x9e, 0x7e,
0xa1, 0x87, 0xcc, 0xec, 0x2d, 0xef, 0x8c, 0x9f, 0xa1, 0x62, 0xfc, 0xc7, 0x72, 0x9c, 0x2c, 0x99,
0x3a, 0x64, 0x59, 0x7d, 0x94, 0x97, 0x5b, 0xdd, 0xb9, 0x03, 0x9b, 0x57, 0x67, 0xf9, 0xe3, 0xeb,
0xfd, 0x94, 0x75, 0xf1, 0x76, 0x3f, 0x50, 0xa4, 0x0c, 0x42, 0x4e, 0x1b, 0xf2, 0x84, 0xd2, 0x0f,
0xf5, 0x29, 0x82, 0x18, 0xda, 0x3f, 0xc7, 0xbd, 0x1b, 0x1f, 0xd5, 0x49, 0x0f, 0xde, 0xfe, 0x04,
0x00, 0x00, 0xff, 0xff, 0x93, 0x9b, 0x7c, 0xf8, 0x84, 0x01, 0x00, 0x00,
}

108
vendor/google.golang.org/genproto/googleapis/appengine/v1/operation.pb.go generated vendored Normal file
View File

@ -0,0 +1,108 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/operation.proto
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf2 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Metadata for the given [google.longrunning.Operation][google.longrunning.Operation].
type OperationMetadataV1 struct {
// API method that initiated this operation. Example:
// `google.appengine.v1.Versions.CreateVersion`.
//
// @OutputOnly
Method string `protobuf:"bytes,1,opt,name=method" json:"method,omitempty"`
// Time that this operation was created.
//
// @OutputOnly
InsertTime *google_protobuf2.Timestamp `protobuf:"bytes,2,opt,name=insert_time,json=insertTime" json:"insert_time,omitempty"`
// Time that this operation completed.
//
// @OutputOnly
EndTime *google_protobuf2.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
// User who requested this operation.
//
// @OutputOnly
User string `protobuf:"bytes,4,opt,name=user" json:"user,omitempty"`
// Name of the resource that this operation is acting on. Example:
// `apps/myapp/services/default`.
//
// @OutputOnly
Target string `protobuf:"bytes,5,opt,name=target" json:"target,omitempty"`
}
func (m *OperationMetadataV1) Reset() { *m = OperationMetadataV1{} }
func (m *OperationMetadataV1) String() string { return proto.CompactTextString(m) }
func (*OperationMetadataV1) ProtoMessage() {}
func (*OperationMetadataV1) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
func (m *OperationMetadataV1) GetMethod() string {
if m != nil {
return m.Method
}
return ""
}
func (m *OperationMetadataV1) GetInsertTime() *google_protobuf2.Timestamp {
if m != nil {
return m.InsertTime
}
return nil
}
func (m *OperationMetadataV1) GetEndTime() *google_protobuf2.Timestamp {
if m != nil {
return m.EndTime
}
return nil
}
func (m *OperationMetadataV1) GetUser() string {
if m != nil {
return m.User
}
return ""
}
func (m *OperationMetadataV1) GetTarget() string {
if m != nil {
return m.Target
}
return ""
}
func init() {
proto.RegisterType((*OperationMetadataV1)(nil), "google.appengine.v1.OperationMetadataV1")
}
func init() { proto.RegisterFile("google/appengine/v1/operation.proto", fileDescriptor7) }
var fileDescriptor7 = []byte{
// 271 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0x41, 0x4b, 0x03, 0x31,
0x10, 0x85, 0x59, 0xad, 0x55, 0x53, 0xf0, 0xb0, 0x05, 0x5d, 0x16, 0xc1, 0xa2, 0x97, 0x9e, 0x12,
0x56, 0xf1, 0x54, 0x4f, 0xbd, 0x8b, 0xa5, 0x88, 0x07, 0x2f, 0x92, 0xba, 0x63, 0x0c, 0x74, 0x67,
0x42, 0x32, 0xed, 0xbf, 0xf4, 0x3f, 0xc9, 0x26, 0xbb, 0x0b, 0x82, 0xd0, 0x5b, 0x5e, 0xe6, 0x7d,
0x79, 0x2f, 0x89, 0xb8, 0x33, 0x44, 0x66, 0x0b, 0x4a, 0x3b, 0x07, 0x68, 0x2c, 0x82, 0xda, 0x57,
0x8a, 0x1c, 0x78, 0xcd, 0x96, 0x50, 0x3a, 0x4f, 0x4c, 0xf9, 0x34, 0x99, 0xe4, 0x60, 0x92, 0xfb,
0xaa, 0xbc, 0x1e, 0x48, 0xab, 0x34, 0x22, 0x71, 0x24, 0x42, 0x42, 0xca, 0x9b, 0x6e, 0x1a, 0xd5,
0x66, 0xf7, 0xa5, 0xd8, 0x36, 0x10, 0x58, 0x37, 0x2e, 0x19, 0x6e, 0x7f, 0x32, 0x31, 0x7d, 0xe9,
0x73, 0x9e, 0x81, 0x75, 0xad, 0x59, 0xbf, 0x55, 0xf9, 0xa5, 0x18, 0x37, 0xc0, 0xdf, 0x54, 0x17,
0xd9, 0x2c, 0x9b, 0x9f, 0xaf, 0x3b, 0x95, 0x2f, 0xc4, 0xc4, 0x62, 0x00, 0xcf, 0x1f, 0xed, 0x49,
0xc5, 0xd1, 0x2c, 0x9b, 0x4f, 0xee, 0x4b, 0xd9, 0x35, 0xeb, 0x63, 0xe4, 0x6b, 0x1f, 0xb3, 0x16,
0xc9, 0xde, 0x6e, 0xe4, 0x8f, 0xe2, 0x0c, 0xb0, 0x4e, 0xe4, 0xf1, 0x41, 0xf2, 0x14, 0xb0, 0x8e,
0x58, 0x2e, 0x46, 0xbb, 0x00, 0xbe, 0x18, 0xc5, 0x26, 0x71, 0xdd, 0xf6, 0x63, 0xed, 0x0d, 0x70,
0x71, 0x92, 0xfa, 0x25, 0xb5, 0xb4, 0xe2, 0xea, 0x93, 0x1a, 0xf9, 0xcf, 0x4b, 0x2d, 0x2f, 0x86,
0x7b, 0xae, 0xda, 0xb0, 0x55, 0xf6, 0xfe, 0xd4, 0xd9, 0x0c, 0x6d, 0x35, 0x1a, 0x49, 0xde, 0x28,
0x03, 0x18, 0xab, 0xa8, 0x34, 0xd2, 0xce, 0x86, 0x3f, 0x9f, 0xb2, 0x18, 0xc4, 0x66, 0x1c, 0x8d,
0x0f, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1d, 0x8e, 0xb2, 0x00, 0xbc, 0x01, 0x00, 0x00,
}

165
vendor/google.golang.org/genproto/googleapis/appengine/v1/service.pb.go generated vendored Normal file
View File

@ -0,0 +1,165 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/appengine/v1/service.proto
package appengine
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Available sharding mechanisms.
type TrafficSplit_ShardBy int32
const (
// Diversion method unspecified.
TrafficSplit_UNSPECIFIED TrafficSplit_ShardBy = 0
// Diversion based on a specially named cookie, "GOOGAPPUID." The cookie
// must be set by the application itself or no diversion will occur.
TrafficSplit_COOKIE TrafficSplit_ShardBy = 1
// Diversion based on applying the modulus operation to a fingerprint
// of the IP address.
TrafficSplit_IP TrafficSplit_ShardBy = 2
)
var TrafficSplit_ShardBy_name = map[int32]string{
0: "UNSPECIFIED",
1: "COOKIE",
2: "IP",
}
var TrafficSplit_ShardBy_value = map[string]int32{
"UNSPECIFIED": 0,
"COOKIE": 1,
"IP": 2,
}
func (x TrafficSplit_ShardBy) String() string {
return proto.EnumName(TrafficSplit_ShardBy_name, int32(x))
}
func (TrafficSplit_ShardBy) EnumDescriptor() ([]byte, []int) { return fileDescriptor8, []int{1, 0} }
// A Service resource is a logical component of an application that can share
// state and communicate in a secure fashion with other services.
// For example, an application that handles customer requests might
// include separate services to handle tasks such as backend data
// analysis or API requests from mobile devices. Each service has a
// collection of versions that define a specific set of code used to
// implement the functionality of that service.
type Service struct {
// Full path to the Service resource in the API.
// Example: `apps/myapp/services/default`.
//
// @OutputOnly
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Relative name of the service within the application.
// Example: `default`.
//
// @OutputOnly
Id string `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
// Mapping that defines fractional HTTP traffic diversion to
// different versions within the service.
Split *TrafficSplit `protobuf:"bytes,3,opt,name=split" json:"split,omitempty"`
}
func (m *Service) Reset() { *m = Service{} }
func (m *Service) String() string { return proto.CompactTextString(m) }
func (*Service) ProtoMessage() {}
func (*Service) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
func (m *Service) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Service) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Service) GetSplit() *TrafficSplit {
if m != nil {
return m.Split
}
return nil
}
// Traffic routing configuration for versions within a single service. Traffic
// splits define how traffic directed to the service is assigned to versions.
type TrafficSplit struct {
// Mechanism used to determine which version a request is sent to.
// The traffic selection algorithm will
// be stable for either type until allocations are changed.
ShardBy TrafficSplit_ShardBy `protobuf:"varint,1,opt,name=shard_by,json=shardBy,enum=google.appengine.v1.TrafficSplit_ShardBy" json:"shard_by,omitempty"`
// Mapping from version IDs within the service to fractional
// (0.000, 1] allocations of traffic for that version. Each version can
// be specified only once, but some versions in the service may not
// have any traffic allocation. Services that have traffic allocated
// cannot be deleted until either the service is deleted or
// their traffic allocation is removed. Allocations must sum to 1.
// Up to two decimal place precision is supported for IP-based splits and
// up to three decimal places is supported for cookie-based splits.
Allocations map[string]float64 `protobuf:"bytes,2,rep,name=allocations" json:"allocations,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
}
func (m *TrafficSplit) Reset() { *m = TrafficSplit{} }
func (m *TrafficSplit) String() string { return proto.CompactTextString(m) }
func (*TrafficSplit) ProtoMessage() {}
func (*TrafficSplit) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
func (m *TrafficSplit) GetShardBy() TrafficSplit_ShardBy {
if m != nil {
return m.ShardBy
}
return TrafficSplit_UNSPECIFIED
}
func (m *TrafficSplit) GetAllocations() map[string]float64 {
if m != nil {
return m.Allocations
}
return nil
}
func init() {
proto.RegisterType((*Service)(nil), "google.appengine.v1.Service")
proto.RegisterType((*TrafficSplit)(nil), "google.appengine.v1.TrafficSplit")
proto.RegisterEnum("google.appengine.v1.TrafficSplit_ShardBy", TrafficSplit_ShardBy_name, TrafficSplit_ShardBy_value)
}
func init() { proto.RegisterFile("google/appengine/v1/service.proto", fileDescriptor8) }
var fileDescriptor8 = []byte{
// 356 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x51, 0x8b, 0xda, 0x40,
0x10, 0xc7, 0x9b, 0xb5, 0x6a, 0x3b, 0x11, 0x1b, 0xb6, 0x85, 0x06, 0xe9, 0x83, 0xfa, 0x64, 0x5f,
0x36, 0x98, 0x3e, 0xb4, 0xb4, 0xa5, 0x50, 0x35, 0x85, 0x50, 0x38, 0x43, 0xe2, 0xbd, 0xdc, 0xcb,
0xb1, 0xc6, 0x75, 0x6f, 0xb9, 0xb8, 0x1b, 0x92, 0x5c, 0x20, 0x5f, 0xe5, 0x3e, 0xed, 0x91, 0x6c,
0xf0, 0xbc, 0x43, 0xf0, 0x6d, 0x66, 0xf2, 0xfb, 0xff, 0x67, 0x32, 0xb3, 0x30, 0xe1, 0x4a, 0xf1,
0x84, 0x39, 0x34, 0x4d, 0x99, 0xe4, 0x42, 0x32, 0xa7, 0x9c, 0x3b, 0x39, 0xcb, 0x4a, 0x11, 0x33,
0x92, 0x66, 0xaa, 0x50, 0xf8, 0xa3, 0x46, 0xc8, 0x11, 0x21, 0xe5, 0x7c, 0xf4, 0xe5, 0xa8, 0x13,
0x0e, 0x95, 0x52, 0x15, 0xb4, 0x10, 0x4a, 0xe6, 0x5a, 0x32, 0xdd, 0x43, 0x3f, 0xd2, 0x1e, 0x18,
0xc3, 0x5b, 0x49, 0x0f, 0xcc, 0x36, 0xc6, 0xc6, 0xec, 0x7d, 0xd8, 0xc4, 0x78, 0x08, 0x48, 0xec,
0x6c, 0xd4, 0x54, 0x90, 0xd8, 0xe1, 0xef, 0xd0, 0xcd, 0xd3, 0x44, 0x14, 0x76, 0x67, 0x6c, 0xcc,
0x4c, 0x77, 0x42, 0xce, 0x74, 0x24, 0x9b, 0x8c, 0xee, 0xf7, 0x22, 0x8e, 0x6a, 0x30, 0xd4, 0xfc,
0xf4, 0x11, 0xc1, 0xe0, 0xb4, 0x8e, 0x57, 0xf0, 0x2e, 0xbf, 0xa3, 0xd9, 0xee, 0x76, 0x5b, 0x35,
0x1d, 0x87, 0xee, 0xd7, 0x8b, 0x66, 0x24, 0xaa, 0x15, 0x8b, 0x2a, 0xec, 0xe7, 0x3a, 0xc0, 0x1b,
0x30, 0x69, 0x92, 0xa8, 0x58, 0xff, 0x93, 0x8d, 0xc6, 0x9d, 0x99, 0xe9, 0xba, 0x97, 0x8d, 0xfe,
0x3e, 0x8b, 0x3c, 0x59, 0x64, 0x55, 0x78, 0x6a, 0x33, 0xfa, 0x03, 0xd6, 0x6b, 0x00, 0x5b, 0xd0,
0xb9, 0x67, 0x55, 0xbb, 0x9c, 0x3a, 0xc4, 0x9f, 0xa0, 0x5b, 0xd2, 0xe4, 0x81, 0x35, 0xeb, 0x31,
0x42, 0x9d, 0xfc, 0x44, 0x3f, 0x8c, 0x29, 0x81, 0x7e, 0x3b, 0x29, 0xfe, 0x00, 0xe6, 0xf5, 0x55,
0x14, 0x78, 0x4b, 0xff, 0x9f, 0xef, 0xad, 0xac, 0x37, 0x18, 0xa0, 0xb7, 0x5c, 0xaf, 0xff, 0xfb,
0x9e, 0x65, 0xe0, 0x1e, 0x20, 0x3f, 0xb0, 0xd0, 0x82, 0xc3, 0xe7, 0x58, 0x1d, 0xce, 0x4d, 0xbd,
0x18, 0xb4, 0xd7, 0x09, 0xea, 0x6b, 0x05, 0xc6, 0xcd, 0xef, 0x16, 0xe2, 0x2a, 0xa1, 0x92, 0x13,
0x95, 0x71, 0x87, 0x33, 0xd9, 0xdc, 0xd2, 0xd1, 0x9f, 0x68, 0x2a, 0xf2, 0x17, 0x8f, 0xe4, 0xd7,
0x31, 0xd9, 0xf6, 0x1a, 0xf0, 0xdb, 0x53, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5f, 0xbc, 0x13, 0xf4,
0x4c, 0x02, 0x00, 0x00,
}

1072
vendor/google.golang.org/genproto/googleapis/appengine/v1/version.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

969
vendor/google.golang.org/genproto/googleapis/assistant/embedded/v1alpha1/embedded_assistant.pb.go generated vendored Normal file
View File

@ -0,0 +1,969 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/assistant/embedded/v1alpha1/embedded_assistant.proto
/*
Package embedded is a generated protocol buffer package.
It is generated from these files:
google/assistant/embedded/v1alpha1/embedded_assistant.proto
It has these top-level messages:
ConverseConfig
AudioInConfig
AudioOutConfig
ConverseState
AudioOut
ConverseResult
ConverseRequest
ConverseResponse
*/
package embedded
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_rpc "google.golang.org/genproto/googleapis/rpc/status"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Audio encoding of the data sent in the audio message.
// Audio must be one-channel (mono). The only language supported is "en-US".
type AudioInConfig_Encoding int32
const (
// Not specified. Will return result [google.rpc.Code.INVALID_ARGUMENT][].
AudioInConfig_ENCODING_UNSPECIFIED AudioInConfig_Encoding = 0
// Uncompressed 16-bit signed little-endian samples (Linear PCM).
// This encoding includes no header, only the raw audio bytes.
AudioInConfig_LINEAR16 AudioInConfig_Encoding = 1
// [`FLAC`](https://xiph.org/flac/documentation.html) (Free Lossless Audio
// Codec) is the recommended encoding because it is
// lossless--therefore recognition is not compromised--and
// requires only about half the bandwidth of `LINEAR16`. This encoding
// includes the `FLAC` stream header followed by audio data. It supports
// 16-bit and 24-bit samples, however, not all fields in `STREAMINFO` are
// supported.
AudioInConfig_FLAC AudioInConfig_Encoding = 2
)
var AudioInConfig_Encoding_name = map[int32]string{
0: "ENCODING_UNSPECIFIED",
1: "LINEAR16",
2: "FLAC",
}
var AudioInConfig_Encoding_value = map[string]int32{
"ENCODING_UNSPECIFIED": 0,
"LINEAR16": 1,
"FLAC": 2,
}
func (x AudioInConfig_Encoding) String() string {
return proto.EnumName(AudioInConfig_Encoding_name, int32(x))
}
func (AudioInConfig_Encoding) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
// Audio encoding of the data returned in the audio message. All encodings are
// raw audio bytes with no header, except as indicated below.
type AudioOutConfig_Encoding int32
const (
// Not specified. Will return result [google.rpc.Code.INVALID_ARGUMENT][].
AudioOutConfig_ENCODING_UNSPECIFIED AudioOutConfig_Encoding = 0
// Uncompressed 16-bit signed little-endian samples (Linear PCM).
AudioOutConfig_LINEAR16 AudioOutConfig_Encoding = 1
// MP3 audio encoding. The sample rate is encoded in the payload.
AudioOutConfig_MP3 AudioOutConfig_Encoding = 2
// Opus-encoded audio wrapped in an ogg container. The result will be a
// file which can be played natively on Android and in some browsers (such
// as Chrome). The quality of the encoding is considerably higher than MP3
// while using the same bitrate. The sample rate is encoded in the payload.
AudioOutConfig_OPUS_IN_OGG AudioOutConfig_Encoding = 3
)
var AudioOutConfig_Encoding_name = map[int32]string{
0: "ENCODING_UNSPECIFIED",
1: "LINEAR16",
2: "MP3",
3: "OPUS_IN_OGG",
}
var AudioOutConfig_Encoding_value = map[string]int32{
"ENCODING_UNSPECIFIED": 0,
"LINEAR16": 1,
"MP3": 2,
"OPUS_IN_OGG": 3,
}
func (x AudioOutConfig_Encoding) String() string {
return proto.EnumName(AudioOutConfig_Encoding_name, int32(x))
}
func (AudioOutConfig_Encoding) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
// Possible states of the microphone after a `Converse` RPC completes.
type ConverseResult_MicrophoneMode int32
const (
// No mode specified.
ConverseResult_MICROPHONE_MODE_UNSPECIFIED ConverseResult_MicrophoneMode = 0
// The service is not expecting a follow-on question from the user.
// The microphone should remain off until the user re-activates it.
ConverseResult_CLOSE_MICROPHONE ConverseResult_MicrophoneMode = 1
// The service is expecting a follow-on question from the user. The
// microphone should be re-opened when the `AudioOut` playback completes
// (by starting a new `Converse` RPC call to send the new audio).
ConverseResult_DIALOG_FOLLOW_ON ConverseResult_MicrophoneMode = 2
)
var ConverseResult_MicrophoneMode_name = map[int32]string{
0: "MICROPHONE_MODE_UNSPECIFIED",
1: "CLOSE_MICROPHONE",
2: "DIALOG_FOLLOW_ON",
}
var ConverseResult_MicrophoneMode_value = map[string]int32{
"MICROPHONE_MODE_UNSPECIFIED": 0,
"CLOSE_MICROPHONE": 1,
"DIALOG_FOLLOW_ON": 2,
}
func (x ConverseResult_MicrophoneMode) String() string {
return proto.EnumName(ConverseResult_MicrophoneMode_name, int32(x))
}
func (ConverseResult_MicrophoneMode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor0, []int{5, 0}
}
// Indicates the type of event.
type ConverseResponse_EventType int32
const (
// No event specified.
ConverseResponse_EVENT_TYPE_UNSPECIFIED ConverseResponse_EventType = 0
// This event indicates that the server has detected the end of the user's
// speech utterance and expects no additional speech. Therefore, the server
// will not process additional audio (although it may subsequently return
// additional results). The client should stop sending additional audio
// data, half-close the gRPC connection, and wait for any additional results
// until the server closes the gRPC connection.
ConverseResponse_END_OF_UTTERANCE ConverseResponse_EventType = 1
)
var ConverseResponse_EventType_name = map[int32]string{
0: "EVENT_TYPE_UNSPECIFIED",
1: "END_OF_UTTERANCE",
}
var ConverseResponse_EventType_value = map[string]int32{
"EVENT_TYPE_UNSPECIFIED": 0,
"END_OF_UTTERANCE": 1,
}
func (x ConverseResponse_EventType) String() string {
return proto.EnumName(ConverseResponse_EventType_name, int32(x))
}
func (ConverseResponse_EventType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor0, []int{7, 0}
}
// Specifies how to process the `ConverseRequest` messages.
type ConverseConfig struct {
// *Required* Specifies how to process the subsequent incoming audio.
AudioInConfig *AudioInConfig `protobuf:"bytes,1,opt,name=audio_in_config,json=audioInConfig" json:"audio_in_config,omitempty"`
// *Required* Specifies how to format the audio that will be returned.
AudioOutConfig *AudioOutConfig `protobuf:"bytes,2,opt,name=audio_out_config,json=audioOutConfig" json:"audio_out_config,omitempty"`
// *Required* Represents the current dialog state.
ConverseState *ConverseState `protobuf:"bytes,3,opt,name=converse_state,json=converseState" json:"converse_state,omitempty"`
}
func (m *ConverseConfig) Reset() { *m = ConverseConfig{} }
func (m *ConverseConfig) String() string { return proto.CompactTextString(m) }
func (*ConverseConfig) ProtoMessage() {}
func (*ConverseConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *ConverseConfig) GetAudioInConfig() *AudioInConfig {
if m != nil {
return m.AudioInConfig
}
return nil
}
func (m *ConverseConfig) GetAudioOutConfig() *AudioOutConfig {
if m != nil {
return m.AudioOutConfig
}
return nil
}
func (m *ConverseConfig) GetConverseState() *ConverseState {
if m != nil {
return m.ConverseState
}
return nil
}
// Specifies how to process the `audio_in` data that will be provided in
// subsequent requests. For recommended settings, see the Google Assistant SDK
// [best practices](https://developers.google.com/assistant/sdk/develop/grpc/best-practices/audio).
type AudioInConfig struct {
// *Required* Encoding of audio data sent in all `audio_in` messages.
Encoding AudioInConfig_Encoding `protobuf:"varint,1,opt,name=encoding,enum=google.assistant.embedded.v1alpha1.AudioInConfig_Encoding" json:"encoding,omitempty"`
// *Required* Sample rate (in Hertz) of the audio data sent in all `audio_in`
// messages. Valid values are from 16000-24000, but 16000 is optimal.
// For best results, set the sampling rate of the audio source to 16000 Hz.
// If that's not possible, use the native sample rate of the audio source
// (instead of re-sampling).
SampleRateHertz int32 `protobuf:"varint,2,opt,name=sample_rate_hertz,json=sampleRateHertz" json:"sample_rate_hertz,omitempty"`
}
func (m *AudioInConfig) Reset() { *m = AudioInConfig{} }
func (m *AudioInConfig) String() string { return proto.CompactTextString(m) }
func (*AudioInConfig) ProtoMessage() {}
func (*AudioInConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *AudioInConfig) GetEncoding() AudioInConfig_Encoding {
if m != nil {
return m.Encoding
}
return AudioInConfig_ENCODING_UNSPECIFIED
}
func (m *AudioInConfig) GetSampleRateHertz() int32 {
if m != nil {
return m.SampleRateHertz
}
return 0
}
// Specifies the desired format for the server to use when it returns
// `audio_out` messages.
type AudioOutConfig struct {
// *Required* The encoding of audio data to be returned in all `audio_out`
// messages.
Encoding AudioOutConfig_Encoding `protobuf:"varint,1,opt,name=encoding,enum=google.assistant.embedded.v1alpha1.AudioOutConfig_Encoding" json:"encoding,omitempty"`
// *Required* The sample rate in Hertz of the audio data returned in
// `audio_out` messages. Valid values are: 16000-24000.
SampleRateHertz int32 `protobuf:"varint,2,opt,name=sample_rate_hertz,json=sampleRateHertz" json:"sample_rate_hertz,omitempty"`
// *Required* Current volume setting of the device's audio output.
// Valid values are 1 to 100 (corresponding to 1% to 100%).
VolumePercentage int32 `protobuf:"varint,3,opt,name=volume_percentage,json=volumePercentage" json:"volume_percentage,omitempty"`
}
func (m *AudioOutConfig) Reset() { *m = AudioOutConfig{} }
func (m *AudioOutConfig) String() string { return proto.CompactTextString(m) }
func (*AudioOutConfig) ProtoMessage() {}
func (*AudioOutConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *AudioOutConfig) GetEncoding() AudioOutConfig_Encoding {
if m != nil {
return m.Encoding
}
return AudioOutConfig_ENCODING_UNSPECIFIED
}
func (m *AudioOutConfig) GetSampleRateHertz() int32 {
if m != nil {
return m.SampleRateHertz
}
return 0
}
func (m *AudioOutConfig) GetVolumePercentage() int32 {
if m != nil {
return m.VolumePercentage
}
return 0
}
// Provides information about the current dialog state.
type ConverseState struct {
// *Required* The `conversation_state` value returned in the prior
// `ConverseResponse`. Omit (do not set the field) if there was no prior
// `ConverseResponse`. If there was a prior `ConverseResponse`, do not omit
// this field; doing so will end that conversation (and this new request will
// start a new conversation).
ConversationState []byte `protobuf:"bytes,1,opt,name=conversation_state,json=conversationState,proto3" json:"conversation_state,omitempty"`
}
func (m *ConverseState) Reset() { *m = ConverseState{} }
func (m *ConverseState) String() string { return proto.CompactTextString(m) }
func (*ConverseState) ProtoMessage() {}
func (*ConverseState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *ConverseState) GetConversationState() []byte {
if m != nil {
return m.ConversationState
}
return nil
}
// The audio containing the assistant's response to the query. Sequential chunks
// of audio data are received in sequential `ConverseResponse` messages.
type AudioOut struct {
// *Output-only* The audio data containing the assistant's response to the
// query. Sequential chunks of audio data are received in sequential
// `ConverseResponse` messages.
AudioData []byte `protobuf:"bytes,1,opt,name=audio_data,json=audioData,proto3" json:"audio_data,omitempty"`
}
func (m *AudioOut) Reset() { *m = AudioOut{} }
func (m *AudioOut) String() string { return proto.CompactTextString(m) }
func (*AudioOut) ProtoMessage() {}
func (*AudioOut) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *AudioOut) GetAudioData() []byte {
if m != nil {
return m.AudioData
}
return nil
}
// The semantic result for the user's spoken query.
type ConverseResult struct {
// *Output-only* The recognized transcript of what the user said.
SpokenRequestText string `protobuf:"bytes,1,opt,name=spoken_request_text,json=spokenRequestText" json:"spoken_request_text,omitempty"`
// *Output-only* The text of the assistant's spoken response. This is only
// returned for an IFTTT action.
SpokenResponseText string `protobuf:"bytes,2,opt,name=spoken_response_text,json=spokenResponseText" json:"spoken_response_text,omitempty"`
// *Output-only* State information for subsequent `ConverseRequest`. This
// value should be saved in the client and returned in the
// `conversation_state` with the next `ConverseRequest`. (The client does not
// need to interpret or otherwise use this value.) There is no need to save
// this information across device restarts.
ConversationState []byte `protobuf:"bytes,3,opt,name=conversation_state,json=conversationState,proto3" json:"conversation_state,omitempty"`
// *Output-only* Specifies the mode of the microphone after this `Converse`
// RPC is processed.
MicrophoneMode ConverseResult_MicrophoneMode `protobuf:"varint,4,opt,name=microphone_mode,json=microphoneMode,enum=google.assistant.embedded.v1alpha1.ConverseResult_MicrophoneMode" json:"microphone_mode,omitempty"`
// *Output-only* Updated volume level. The value will be 0 or omitted
// (indicating no change) unless a voice command such as "Increase the volume"
// or "Set volume level 4" was recognized, in which case the value will be
// between 1 and 100 (corresponding to the new volume level of 1% to 100%).
// Typically, a client should use this volume level when playing the
// `audio_out` data, and retain this value as the current volume level and
// supply it in the `AudioOutConfig` of the next `ConverseRequest`. (Some
// clients may also implement other ways to allow the current volume level to
// be changed, for example, by providing a knob that the user can turn.)
VolumePercentage int32 `protobuf:"varint,5,opt,name=volume_percentage,json=volumePercentage" json:"volume_percentage,omitempty"`
}
func (m *ConverseResult) Reset() { *m = ConverseResult{} }
func (m *ConverseResult) String() string { return proto.CompactTextString(m) }
func (*ConverseResult) ProtoMessage() {}
func (*ConverseResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *ConverseResult) GetSpokenRequestText() string {
if m != nil {
return m.SpokenRequestText
}
return ""
}
func (m *ConverseResult) GetSpokenResponseText() string {
if m != nil {
return m.SpokenResponseText
}
return ""
}
func (m *ConverseResult) GetConversationState() []byte {
if m != nil {
return m.ConversationState
}
return nil
}
func (m *ConverseResult) GetMicrophoneMode() ConverseResult_MicrophoneMode {
if m != nil {
return m.MicrophoneMode
}
return ConverseResult_MICROPHONE_MODE_UNSPECIFIED
}
func (m *ConverseResult) GetVolumePercentage() int32 {
if m != nil {
return m.VolumePercentage
}
return 0
}
// The top-level message sent by the client. Clients must send at least two, and
// typically numerous `ConverseRequest` messages. The first message must
// contain a `config` message and must not contain `audio_in` data. All
// subsequent messages must contain `audio_in` data and must not contain a
// `config` message.
type ConverseRequest struct {
// Exactly one of these fields must be specified in each `ConverseRequest`.
//
// Types that are valid to be assigned to ConverseRequest:
// *ConverseRequest_Config
// *ConverseRequest_AudioIn
ConverseRequest isConverseRequest_ConverseRequest `protobuf_oneof:"converse_request"`
}
func (m *ConverseRequest) Reset() { *m = ConverseRequest{} }
func (m *ConverseRequest) String() string { return proto.CompactTextString(m) }
func (*ConverseRequest) ProtoMessage() {}
func (*ConverseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
type isConverseRequest_ConverseRequest interface {
isConverseRequest_ConverseRequest()
}
type ConverseRequest_Config struct {
Config *ConverseConfig `protobuf:"bytes,1,opt,name=config,oneof"`
}
type ConverseRequest_AudioIn struct {
AudioIn []byte `protobuf:"bytes,2,opt,name=audio_in,json=audioIn,proto3,oneof"`
}
func (*ConverseRequest_Config) isConverseRequest_ConverseRequest() {}
func (*ConverseRequest_AudioIn) isConverseRequest_ConverseRequest() {}
func (m *ConverseRequest) GetConverseRequest() isConverseRequest_ConverseRequest {
if m != nil {
return m.ConverseRequest
}
return nil
}
func (m *ConverseRequest) GetConfig() *ConverseConfig {
if x, ok := m.GetConverseRequest().(*ConverseRequest_Config); ok {
return x.Config
}
return nil
}
func (m *ConverseRequest) GetAudioIn() []byte {
if x, ok := m.GetConverseRequest().(*ConverseRequest_AudioIn); ok {
return x.AudioIn
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*ConverseRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _ConverseRequest_OneofMarshaler, _ConverseRequest_OneofUnmarshaler, _ConverseRequest_OneofSizer, []interface{}{
(*ConverseRequest_Config)(nil),
(*ConverseRequest_AudioIn)(nil),
}
}
func _ConverseRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ConverseRequest)
// converse_request
switch x := m.ConverseRequest.(type) {
case *ConverseRequest_Config:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Config); err != nil {
return err
}
case *ConverseRequest_AudioIn:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.AudioIn)
case nil:
default:
return fmt.Errorf("ConverseRequest.ConverseRequest has unexpected type %T", x)
}
return nil
}
func _ConverseRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ConverseRequest)
switch tag {
case 1: // converse_request.config
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ConverseConfig)
err := b.DecodeMessage(msg)
m.ConverseRequest = &ConverseRequest_Config{msg}
return true, err
case 2: // converse_request.audio_in
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.ConverseRequest = &ConverseRequest_AudioIn{x}
return true, err
default:
return false, nil
}
}
func _ConverseRequest_OneofSizer(msg proto.Message) (n int) {
m := msg.(*ConverseRequest)
// converse_request
switch x := m.ConverseRequest.(type) {
case *ConverseRequest_Config:
s := proto.Size(x.Config)
n += proto.SizeVarint(1<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *ConverseRequest_AudioIn:
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.AudioIn)))
n += len(x.AudioIn)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// The top-level message received by the client. A series of one or more
// `ConverseResponse` messages are streamed back to the client.
type ConverseResponse struct {
// Exactly one of these fields will be populated in each `ConverseResponse`.
//
// Types that are valid to be assigned to ConverseResponse:
// *ConverseResponse_Error
// *ConverseResponse_EventType_
// *ConverseResponse_AudioOut
// *ConverseResponse_Result
ConverseResponse isConverseResponse_ConverseResponse `protobuf_oneof:"converse_response"`
}
func (m *ConverseResponse) Reset() { *m = ConverseResponse{} }
func (m *ConverseResponse) String() string { return proto.CompactTextString(m) }
func (*ConverseResponse) ProtoMessage() {}
func (*ConverseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
type isConverseResponse_ConverseResponse interface {
isConverseResponse_ConverseResponse()
}
type ConverseResponse_Error struct {
Error *google_rpc.Status `protobuf:"bytes,1,opt,name=error,oneof"`
}
type ConverseResponse_EventType_ struct {
EventType ConverseResponse_EventType `protobuf:"varint,2,opt,name=event_type,json=eventType,enum=google.assistant.embedded.v1alpha1.ConverseResponse_EventType,oneof"`
}
type ConverseResponse_AudioOut struct {
AudioOut *AudioOut `protobuf:"bytes,3,opt,name=audio_out,json=audioOut,oneof"`
}
type ConverseResponse_Result struct {
Result *ConverseResult `protobuf:"bytes,5,opt,name=result,oneof"`
}
func (*ConverseResponse_Error) isConverseResponse_ConverseResponse() {}
func (*ConverseResponse_EventType_) isConverseResponse_ConverseResponse() {}
func (*ConverseResponse_AudioOut) isConverseResponse_ConverseResponse() {}
func (*ConverseResponse_Result) isConverseResponse_ConverseResponse() {}
func (m *ConverseResponse) GetConverseResponse() isConverseResponse_ConverseResponse {
if m != nil {
return m.ConverseResponse
}
return nil
}
func (m *ConverseResponse) GetError() *google_rpc.Status {
if x, ok := m.GetConverseResponse().(*ConverseResponse_Error); ok {
return x.Error
}
return nil
}
func (m *ConverseResponse) GetEventType() ConverseResponse_EventType {
if x, ok := m.GetConverseResponse().(*ConverseResponse_EventType_); ok {
return x.EventType
}
return ConverseResponse_EVENT_TYPE_UNSPECIFIED
}
func (m *ConverseResponse) GetAudioOut() *AudioOut {
if x, ok := m.GetConverseResponse().(*ConverseResponse_AudioOut); ok {
return x.AudioOut
}
return nil
}
func (m *ConverseResponse) GetResult() *ConverseResult {
if x, ok := m.GetConverseResponse().(*ConverseResponse_Result); ok {
return x.Result
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*ConverseResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _ConverseResponse_OneofMarshaler, _ConverseResponse_OneofUnmarshaler, _ConverseResponse_OneofSizer, []interface{}{
(*ConverseResponse_Error)(nil),
(*ConverseResponse_EventType_)(nil),
(*ConverseResponse_AudioOut)(nil),
(*ConverseResponse_Result)(nil),
}
}
func _ConverseResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ConverseResponse)
// converse_response
switch x := m.ConverseResponse.(type) {
case *ConverseResponse_Error:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Error); err != nil {
return err
}
case *ConverseResponse_EventType_:
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.EventType))
case *ConverseResponse_AudioOut:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.AudioOut); err != nil {
return err
}
case *ConverseResponse_Result:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Result); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ConverseResponse.ConverseResponse has unexpected type %T", x)
}
return nil
}
func _ConverseResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ConverseResponse)
switch tag {
case 1: // converse_response.error
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_rpc.Status)
err := b.DecodeMessage(msg)
m.ConverseResponse = &ConverseResponse_Error{msg}
return true, err
case 2: // converse_response.event_type
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.ConverseResponse = &ConverseResponse_EventType_{ConverseResponse_EventType(x)}
return true, err
case 3: // converse_response.audio_out
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(AudioOut)
err := b.DecodeMessage(msg)
m.ConverseResponse = &ConverseResponse_AudioOut{msg}
return true, err
case 5: // converse_response.result
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ConverseResult)
err := b.DecodeMessage(msg)
m.ConverseResponse = &ConverseResponse_Result{msg}
return true, err
default:
return false, nil
}
}
func _ConverseResponse_OneofSizer(msg proto.Message) (n int) {
m := msg.(*ConverseResponse)
// converse_response
switch x := m.ConverseResponse.(type) {
case *ConverseResponse_Error:
s := proto.Size(x.Error)
n += proto.SizeVarint(1<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *ConverseResponse_EventType_:
n += proto.SizeVarint(2<<3 | proto.WireVarint)
n += proto.SizeVarint(uint64(x.EventType))
case *ConverseResponse_AudioOut:
s := proto.Size(x.AudioOut)
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *ConverseResponse_Result:
s := proto.Size(x.Result)
n += proto.SizeVarint(5<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
func init() {
proto.RegisterType((*ConverseConfig)(nil), "google.assistant.embedded.v1alpha1.ConverseConfig")
proto.RegisterType((*AudioInConfig)(nil), "google.assistant.embedded.v1alpha1.AudioInConfig")
proto.RegisterType((*AudioOutConfig)(nil), "google.assistant.embedded.v1alpha1.AudioOutConfig")
proto.RegisterType((*ConverseState)(nil), "google.assistant.embedded.v1alpha1.ConverseState")
proto.RegisterType((*AudioOut)(nil), "google.assistant.embedded.v1alpha1.AudioOut")
proto.RegisterType((*ConverseResult)(nil), "google.assistant.embedded.v1alpha1.ConverseResult")
proto.RegisterType((*ConverseRequest)(nil), "google.assistant.embedded.v1alpha1.ConverseRequest")
proto.RegisterType((*ConverseResponse)(nil), "google.assistant.embedded.v1alpha1.ConverseResponse")
proto.RegisterEnum("google.assistant.embedded.v1alpha1.AudioInConfig_Encoding", AudioInConfig_Encoding_name, AudioInConfig_Encoding_value)
proto.RegisterEnum("google.assistant.embedded.v1alpha1.AudioOutConfig_Encoding", AudioOutConfig_Encoding_name, AudioOutConfig_Encoding_value)
proto.RegisterEnum("google.assistant.embedded.v1alpha1.ConverseResult_MicrophoneMode", ConverseResult_MicrophoneMode_name, ConverseResult_MicrophoneMode_value)
proto.RegisterEnum("google.assistant.embedded.v1alpha1.ConverseResponse_EventType", ConverseResponse_EventType_name, ConverseResponse_EventType_value)
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for EmbeddedAssistant service
type EmbeddedAssistantClient interface {
// Initiates or continues a conversation with the embedded assistant service.
// Each call performs one round-trip, sending an audio request to the service
// and receiving the audio response. Uses bidirectional streaming to receive
// results, such as the `END_OF_UTTERANCE` event, while sending audio.
//
// A conversation is one or more gRPC connections, each consisting of several
// streamed requests and responses.
// For example, the user says *Add to my shopping list* and the assistant
// responds *What do you want to add?*. The sequence of streamed requests and
// responses in the first gRPC message could be:
//
// * ConverseRequest.config
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseResponse.event_type.END_OF_UTTERANCE
// * ConverseResponse.result.microphone_mode.DIALOG_FOLLOW_ON
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
//
// The user then says *bagels* and the assistant responds
// *OK, I've added bagels to your shopping list*. This is sent as another gRPC
// connection call to the `Converse` method, again with streamed requests and
// responses, such as:
//
// * ConverseRequest.config
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseResponse.event_type.END_OF_UTTERANCE
// * ConverseResponse.result.microphone_mode.CLOSE_MICROPHONE
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
//
// Although the precise order of responses is not guaranteed, sequential
// ConverseResponse.audio_out messages will always contain sequential portions
// of audio.
Converse(ctx context.Context, opts ...grpc.CallOption) (EmbeddedAssistant_ConverseClient, error)
}
type embeddedAssistantClient struct {
cc *grpc.ClientConn
}
func NewEmbeddedAssistantClient(cc *grpc.ClientConn) EmbeddedAssistantClient {
return &embeddedAssistantClient{cc}
}
func (c *embeddedAssistantClient) Converse(ctx context.Context, opts ...grpc.CallOption) (EmbeddedAssistant_ConverseClient, error) {
stream, err := grpc.NewClientStream(ctx, &_EmbeddedAssistant_serviceDesc.Streams[0], c.cc, "/google.assistant.embedded.v1alpha1.EmbeddedAssistant/Converse", opts...)
if err != nil {
return nil, err
}
x := &embeddedAssistantConverseClient{stream}
return x, nil
}
type EmbeddedAssistant_ConverseClient interface {
Send(*ConverseRequest) error
Recv() (*ConverseResponse, error)
grpc.ClientStream
}
type embeddedAssistantConverseClient struct {
grpc.ClientStream
}
func (x *embeddedAssistantConverseClient) Send(m *ConverseRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *embeddedAssistantConverseClient) Recv() (*ConverseResponse, error) {
m := new(ConverseResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for EmbeddedAssistant service
type EmbeddedAssistantServer interface {
// Initiates or continues a conversation with the embedded assistant service.
// Each call performs one round-trip, sending an audio request to the service
// and receiving the audio response. Uses bidirectional streaming to receive
// results, such as the `END_OF_UTTERANCE` event, while sending audio.
//
// A conversation is one or more gRPC connections, each consisting of several
// streamed requests and responses.
// For example, the user says *Add to my shopping list* and the assistant
// responds *What do you want to add?*. The sequence of streamed requests and
// responses in the first gRPC message could be:
//
// * ConverseRequest.config
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseResponse.event_type.END_OF_UTTERANCE
// * ConverseResponse.result.microphone_mode.DIALOG_FOLLOW_ON
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
//
// The user then says *bagels* and the assistant responds
// *OK, I've added bagels to your shopping list*. This is sent as another gRPC
// connection call to the `Converse` method, again with streamed requests and
// responses, such as:
//
// * ConverseRequest.config
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseRequest.audio_in
// * ConverseResponse.event_type.END_OF_UTTERANCE
// * ConverseResponse.result.microphone_mode.CLOSE_MICROPHONE
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
// * ConverseResponse.audio_out
//
// Although the precise order of responses is not guaranteed, sequential
// ConverseResponse.audio_out messages will always contain sequential portions
// of audio.
Converse(EmbeddedAssistant_ConverseServer) error
}
func RegisterEmbeddedAssistantServer(s *grpc.Server, srv EmbeddedAssistantServer) {
s.RegisterService(&_EmbeddedAssistant_serviceDesc, srv)
}
func _EmbeddedAssistant_Converse_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(EmbeddedAssistantServer).Converse(&embeddedAssistantConverseServer{stream})
}
type EmbeddedAssistant_ConverseServer interface {
Send(*ConverseResponse) error
Recv() (*ConverseRequest, error)
grpc.ServerStream
}
type embeddedAssistantConverseServer struct {
grpc.ServerStream
}
func (x *embeddedAssistantConverseServer) Send(m *ConverseResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *embeddedAssistantConverseServer) Recv() (*ConverseRequest, error) {
m := new(ConverseRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _EmbeddedAssistant_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.assistant.embedded.v1alpha1.EmbeddedAssistant",
HandlerType: (*EmbeddedAssistantServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "Converse",
Handler: _EmbeddedAssistant_Converse_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "google/assistant/embedded/v1alpha1/embedded_assistant.proto",
}
func init() {
proto.RegisterFile("google/assistant/embedded/v1alpha1/embedded_assistant.proto", fileDescriptor0)
}
var fileDescriptor0 = []byte{
// 892 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x51, 0x73, 0xdb, 0x44,
0x10, 0xb6, 0xec, 0xa6, 0xb5, 0xb7, 0x89, 0x2c, 0x5f, 0x33, 0x90, 0x49, 0x61, 0x60, 0xf4, 0xc0,
0x94, 0x02, 0x72, 0xe3, 0x30, 0x3c, 0x10, 0xe8, 0x8c, 0x63, 0x2b, 0xb1, 0xc1, 0x96, 0x3c, 0x67,
0xa7, 0xa5, 0x0c, 0xcc, 0xcd, 0x55, 0x3e, 0x1c, 0x81, 0x7d, 0x27, 0xa4, 0x73, 0xa6, 0xe1, 0x07,
0xf0, 0xd8, 0xe1, 0x95, 0x67, 0x7e, 0x11, 0xff, 0x88, 0xd1, 0x9d, 0xa4, 0xd8, 0x90, 0x42, 0x1c,
0x1e, 0x6f, 0xf7, 0xbe, 0x4f, 0xbb, 0xdf, 0x7e, 0xb7, 0x23, 0x38, 0x9a, 0x09, 0x31, 0x9b, 0xb3,
0x26, 0x4d, 0x92, 0x30, 0x91, 0x94, 0xcb, 0x26, 0x5b, 0xbc, 0x64, 0xd3, 0x29, 0x9b, 0x36, 0x2f,
0x0e, 0xe8, 0x3c, 0x3a, 0xa7, 0x07, 0x45, 0x84, 0x14, 0x97, 0x9c, 0x28, 0x16, 0x52, 0x20, 0x5b,
0x83, 0x9d, 0xab, 0x78, 0x7e, 0xd5, 0xc9, 0xc1, 0xfb, 0xef, 0xe4, 0x1f, 0x88, 0xc2, 0x26, 0xe5,
0x5c, 0x48, 0x2a, 0x43, 0xc1, 0x13, 0xcd, 0xb0, 0xff, 0x76, 0x96, 0x8d, 0xa3, 0xa0, 0x99, 0x48,
0x2a, 0x97, 0x59, 0xc2, 0xfe, 0xa3, 0x0c, 0x66, 0x47, 0xf0, 0x0b, 0x16, 0x27, 0xac, 0x23, 0xf8,
0x0f, 0xe1, 0x0c, 0xbd, 0x80, 0x3a, 0x5d, 0x4e, 0x43, 0x41, 0x42, 0x4e, 0x02, 0x15, 0xda, 0x33,
0xde, 0x37, 0x1e, 0xdd, 0x6f, 0x1d, 0x38, 0xff, 0x5d, 0x87, 0xd3, 0x4e, 0xa1, 0x7d, 0xae, 0xb9,
0xf0, 0x0e, 0x5d, 0x3d, 0xa2, 0xef, 0xc0, 0xd2, 0xd4, 0x62, 0x29, 0x73, 0xee, 0xb2, 0xe2, 0x6e,
0xdd, 0x98, 0xdb, 0x5f, 0xca, 0x8c, 0xdc, 0xa4, 0x6b, 0x67, 0xf4, 0x0d, 0x98, 0x41, 0xd6, 0x0a,
0x49, 0x9b, 0x64, 0x7b, 0x95, 0x9b, 0xd7, 0x9d, 0x8b, 0x30, 0x4e, 0x81, 0x78, 0x27, 0x58, 0x3d,
0xda, 0x7f, 0x1a, 0xb0, 0xb3, 0xd6, 0x18, 0x7a, 0x06, 0x55, 0xc6, 0x03, 0x31, 0x0d, 0xb9, 0x56,
0xc7, 0x6c, 0x7d, 0xbe, 0xb1, 0x3a, 0x8e, 0x9b, 0x31, 0xe0, 0x82, 0x0b, 0x3d, 0x86, 0x46, 0x42,
0x17, 0xd1, 0x9c, 0x91, 0x98, 0x4a, 0x46, 0xce, 0x59, 0x2c, 0x7f, 0x51, 0x12, 0x6d, 0xe1, 0xba,
0x4e, 0x60, 0x2a, 0x59, 0x2f, 0x0d, 0xdb, 0x5f, 0x40, 0x35, 0x67, 0x40, 0x7b, 0xb0, 0xeb, 0x7a,
0x1d, 0xbf, 0xdb, 0xf7, 0x4e, 0xc9, 0x99, 0x37, 0x1e, 0xb9, 0x9d, 0xfe, 0x49, 0xdf, 0xed, 0x5a,
0x25, 0xb4, 0x0d, 0xd5, 0x41, 0xdf, 0x73, 0xdb, 0xf8, 0xe0, 0x33, 0xcb, 0x40, 0x55, 0xb8, 0x73,
0x32, 0x68, 0x77, 0xac, 0xb2, 0xfd, 0x5b, 0x19, 0xcc, 0x75, 0x41, 0xd1, 0xf3, 0x7f, 0x34, 0x75,
0xb4, 0xf9, 0x58, 0xfe, 0x67, 0x57, 0xe8, 0x23, 0x68, 0x5c, 0x88, 0xf9, 0x72, 0xc1, 0x48, 0xc4,
0xe2, 0x80, 0x71, 0x49, 0x67, 0x7a, 0x90, 0x5b, 0xd8, 0xd2, 0x89, 0x51, 0x11, 0xb7, 0x07, 0xb7,
0x90, 0xe0, 0x1e, 0x54, 0x86, 0xa3, 0x43, 0xab, 0x8c, 0xea, 0x70, 0xdf, 0x1f, 0x9d, 0x8d, 0x49,
0xdf, 0x23, 0xfe, 0xe9, 0xa9, 0x55, 0xb1, 0x9f, 0xc2, 0xce, 0x9a, 0x0d, 0xd0, 0x27, 0x80, 0x32,
0x23, 0xa8, 0xd7, 0x94, 0xb9, 0x2a, 0x95, 0x66, 0x1b, 0x37, 0x56, 0x33, 0xda, 0x26, 0x1f, 0x42,
0x35, 0xd7, 0x02, 0xbd, 0x0b, 0xa0, 0xad, 0x3e, 0xa5, 0x92, 0x66, 0x90, 0x9a, 0x8a, 0x74, 0xa9,
0xa4, 0xf6, 0xef, 0x95, 0xab, 0x77, 0x87, 0x59, 0xb2, 0x9c, 0x4b, 0xe4, 0xc0, 0x83, 0x24, 0x12,
0x3f, 0x31, 0x4e, 0x62, 0xf6, 0xf3, 0x92, 0x25, 0x92, 0x48, 0xf6, 0x4a, 0x2a, 0x68, 0x0d, 0x37,
0x74, 0x0a, 0xeb, 0xcc, 0x84, 0xbd, 0x92, 0xe8, 0x09, 0xec, 0x16, 0xf7, 0x93, 0x48, 0xf0, 0x84,
0x69, 0x40, 0x59, 0x01, 0x50, 0x0e, 0xd0, 0x29, 0x85, 0xb8, 0xbe, 0x9d, 0xca, 0x1b, 0xda, 0x41,
0x3f, 0x42, 0x7d, 0x11, 0x06, 0xb1, 0x88, 0xce, 0x05, 0x67, 0x64, 0x21, 0xa6, 0x6c, 0xef, 0x8e,
0x72, 0x45, 0x7b, 0x93, 0x07, 0xa5, 0xbb, 0x73, 0x86, 0x05, 0xd3, 0x50, 0x4c, 0x19, 0x36, 0x17,
0x6b, 0xe7, 0xeb, 0xa7, 0xbe, 0xf5, 0x86, 0xa9, 0x7f, 0x0f, 0xe6, 0x3a, 0x1d, 0x7a, 0x0f, 0x1e,
0x0e, 0xfb, 0x1d, 0xec, 0x8f, 0x7a, 0xbe, 0xe7, 0x92, 0xa1, 0xdf, 0x75, 0xff, 0x66, 0x81, 0x5d,
0xb0, 0x3a, 0x03, 0x7f, 0xec, 0x92, 0xab, 0x6b, 0x96, 0x91, 0x46, 0xbb, 0xfd, 0xf6, 0xc0, 0x3f,
0x25, 0x27, 0xfe, 0x60, 0xe0, 0x3f, 0x27, 0xbe, 0x97, 0xbe, 0x0c, 0x03, 0xea, 0x57, 0xd5, 0x2b,
0xc1, 0xd1, 0x00, 0xee, 0xae, 0xed, 0xc2, 0xd6, 0x26, 0x12, 0xe8, 0x87, 0xd1, 0x2b, 0xe1, 0x8c,
0x03, 0x3d, 0x84, 0x6a, 0xbe, 0x62, 0xd5, 0xb8, 0xb6, 0x7b, 0x25, 0x7c, 0x2f, 0x5b, 0x95, 0xc7,
0x08, 0xac, 0x62, 0x8d, 0x65, 0x4e, 0xb0, 0x5f, 0x57, 0xc0, 0x5a, 0x11, 0x54, 0x8d, 0x14, 0x3d,
0x86, 0x2d, 0x16, 0xc7, 0x22, 0xce, 0x4a, 0x42, 0x79, 0x49, 0x71, 0x14, 0x38, 0x63, 0xb5, 0xe4,
0x7b, 0x25, 0xac, 0xaf, 0x20, 0x02, 0xc0, 0x2e, 0x18, 0x97, 0x44, 0x5e, 0x46, 0x4c, 0x7d, 0xd3,
0x6c, 0x3d, 0xdd, 0x70, 0x8c, 0xea, 0xab, 0x8e, 0x9b, 0xd2, 0x4c, 0x2e, 0x23, 0xd6, 0x2b, 0xe1,
0x1a, 0xcb, 0x0f, 0xe8, 0x6b, 0xa8, 0x15, 0xab, 0x3d, 0xdb, 0xbb, 0x1f, 0x6f, 0xb2, 0x3c, 0x7a,
0x25, 0x5c, 0xcd, 0xf7, 0x79, 0xaa, 0x76, 0xac, 0x6c, 0xa3, 0x2c, 0xb0, 0xa1, 0xda, 0xda, 0x70,
0xa9, 0xda, 0x9a, 0xc3, 0xfe, 0x12, 0x6a, 0x45, 0xd1, 0x68, 0x1f, 0xde, 0x72, 0x9f, 0xb9, 0xde,
0x84, 0x4c, 0x5e, 0x8c, 0xae, 0x31, 0x89, 0xeb, 0x75, 0x89, 0x7f, 0x42, 0xce, 0x26, 0x13, 0x17,
0xb7, 0xbd, 0x8e, 0x6b, 0x19, 0xc7, 0x0f, 0xa0, 0xb1, 0x32, 0x0f, 0xad, 0x42, 0xeb, 0xb5, 0x01,
0x0d, 0x37, 0x2b, 0xa1, 0x9d, 0x17, 0x85, 0x2e, 0xa1, 0x9a, 0x57, 0x81, 0x0e, 0x37, 0xab, 0x59,
0xcd, 0x79, 0xff, 0xd3, 0xdb, 0x8c, 0xe4, 0x91, 0xf1, 0xc4, 0x38, 0xfe, 0xd5, 0x80, 0x0f, 0x02,
0xb1, 0xb8, 0x01, 0xfe, 0xd8, 0x2c, 0x0a, 0x1e, 0xa5, 0xff, 0x00, 0x23, 0xe3, 0xdb, 0xaf, 0x32,
0xd4, 0x4c, 0xcc, 0x29, 0x9f, 0x39, 0x22, 0x9e, 0x35, 0x67, 0x8c, 0xab, 0x3f, 0x84, 0xa6, 0x4e,
0xd1, 0x28, 0x4c, 0xfe, 0xed, 0xe7, 0xe5, 0x28, 0x8f, 0xbc, 0xbc, 0xab, 0x60, 0x87, 0x7f, 0x05,
0x00, 0x00, 0xff, 0xff, 0xec, 0x7a, 0x68, 0xfa, 0xf2, 0x08, 0x00, 0x00,
}

1196
vendor/google.golang.org/genproto/googleapis/assistant/embedded/v1alpha2/embedded_assistant.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

252
vendor/google.golang.org/genproto/googleapis/bigtable/admin/cluster/v1/bigtable_cluster_data.pb.go generated vendored Normal file
View File

@ -0,0 +1,252 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto
/*
Package cluster is a generated protocol buffer package.
It is generated from these files:
google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto
google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto
google/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.proto
It has these top-level messages:
Zone
Cluster
ListZonesRequest
ListZonesResponse
GetClusterRequest
ListClustersRequest
ListClustersResponse
CreateClusterRequest
CreateClusterMetadata
UpdateClusterMetadata
DeleteClusterRequest
UndeleteClusterRequest
UndeleteClusterMetadata
V2OperationMetadata
*/
package cluster
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_longrunning "google.golang.org/genproto/googleapis/longrunning"
import _ "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type StorageType int32
const (
// The storage type used is unspecified.
StorageType_STORAGE_UNSPECIFIED StorageType = 0
// Data will be stored in SSD, providing low and consistent latencies.
StorageType_STORAGE_SSD StorageType = 1
// Data will be stored in HDD, providing high and less predictable
// latencies.
StorageType_STORAGE_HDD StorageType = 2
)
var StorageType_name = map[int32]string{
0: "STORAGE_UNSPECIFIED",
1: "STORAGE_SSD",
2: "STORAGE_HDD",
}
var StorageType_value = map[string]int32{
"STORAGE_UNSPECIFIED": 0,
"STORAGE_SSD": 1,
"STORAGE_HDD": 2,
}
func (x StorageType) String() string {
return proto.EnumName(StorageType_name, int32(x))
}
func (StorageType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
// Possible states of a zone.
type Zone_Status int32
const (
// The state of the zone is unknown or unspecified.
Zone_UNKNOWN Zone_Status = 0
// The zone is in a good state.
Zone_OK Zone_Status = 1
// The zone is down for planned maintenance.
Zone_PLANNED_MAINTENANCE Zone_Status = 2
// The zone is down for emergency or unplanned maintenance.
Zone_EMERGENCY_MAINENANCE Zone_Status = 3
)
var Zone_Status_name = map[int32]string{
0: "UNKNOWN",
1: "OK",
2: "PLANNED_MAINTENANCE",
3: "EMERGENCY_MAINENANCE",
}
var Zone_Status_value = map[string]int32{
"UNKNOWN": 0,
"OK": 1,
"PLANNED_MAINTENANCE": 2,
"EMERGENCY_MAINENANCE": 3,
}
func (x Zone_Status) String() string {
return proto.EnumName(Zone_Status_name, int32(x))
}
func (Zone_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }
// A physical location in which a particular project can allocate Cloud BigTable
// resources.
type Zone struct {
// A permanent unique identifier for the zone.
// Values are of the form projects/<project>/zones/[a-z][-a-z0-9]*
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The name of this zone as it appears in UIs.
DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
// The current state of this zone.
Status Zone_Status `protobuf:"varint,3,opt,name=status,enum=google.bigtable.admin.cluster.v1.Zone_Status" json:"status,omitempty"`
}
func (m *Zone) Reset() { *m = Zone{} }
func (m *Zone) String() string { return proto.CompactTextString(m) }
func (*Zone) ProtoMessage() {}
func (*Zone) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Zone) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Zone) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
func (m *Zone) GetStatus() Zone_Status {
if m != nil {
return m.Status
}
return Zone_UNKNOWN
}
// An isolated set of Cloud BigTable resources on which tables can be hosted.
type Cluster struct {
// A permanent unique identifier for the cluster. For technical reasons, the
// zone in which the cluster resides is included here.
// Values are of the form
// projects/<project>/zones/<zone>/clusters/[a-z][-a-z0-9]*
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The operation currently running on the cluster, if any.
// This cannot be set directly, only through CreateCluster, UpdateCluster,
// or UndeleteCluster. Calls to these methods will be rejected if
// "current_operation" is already set.
CurrentOperation *google_longrunning.Operation `protobuf:"bytes,3,opt,name=current_operation,json=currentOperation" json:"current_operation,omitempty"`
// The descriptive name for this cluster as it appears in UIs.
// Must be unique per zone.
DisplayName string `protobuf:"bytes,4,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
// The number of serve nodes allocated to this cluster.
ServeNodes int32 `protobuf:"varint,5,opt,name=serve_nodes,json=serveNodes" json:"serve_nodes,omitempty"`
// What storage type to use for tables in this cluster. Only configurable at
// cluster creation time. If unspecified, STORAGE_SSD will be used.
DefaultStorageType StorageType `protobuf:"varint,8,opt,name=default_storage_type,json=defaultStorageType,enum=google.bigtable.admin.cluster.v1.StorageType" json:"default_storage_type,omitempty"`
}
func (m *Cluster) Reset() { *m = Cluster{} }
func (m *Cluster) String() string { return proto.CompactTextString(m) }
func (*Cluster) ProtoMessage() {}
func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *Cluster) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Cluster) GetCurrentOperation() *google_longrunning.Operation {
if m != nil {
return m.CurrentOperation
}
return nil
}
func (m *Cluster) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
func (m *Cluster) GetServeNodes() int32 {
if m != nil {
return m.ServeNodes
}
return 0
}
func (m *Cluster) GetDefaultStorageType() StorageType {
if m != nil {
return m.DefaultStorageType
}
return StorageType_STORAGE_UNSPECIFIED
}
func init() {
proto.RegisterType((*Zone)(nil), "google.bigtable.admin.cluster.v1.Zone")
proto.RegisterType((*Cluster)(nil), "google.bigtable.admin.cluster.v1.Cluster")
proto.RegisterEnum("google.bigtable.admin.cluster.v1.StorageType", StorageType_name, StorageType_value)
proto.RegisterEnum("google.bigtable.admin.cluster.v1.Zone_Status", Zone_Status_name, Zone_Status_value)
}
func init() {
proto.RegisterFile("google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto", fileDescriptor0)
}
var fileDescriptor0 = []byte{
// 493 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xd1, 0x6e, 0xd3, 0x3c,
0x1c, 0xc5, 0x97, 0xae, 0xeb, 0xbe, 0xcf, 0x41, 0x10, 0xcc, 0x24, 0xa2, 0x09, 0xb4, 0x52, 0xb8,
0xa8, 0x90, 0x70, 0xb4, 0x71, 0x09, 0x37, 0x6d, 0x63, 0xba, 0x32, 0xe6, 0x56, 0x49, 0x27, 0xc4,
0x6e, 0x2c, 0xb7, 0xf5, 0xac, 0x48, 0xa9, 0x1d, 0xc5, 0x4e, 0xa5, 0x3e, 0x03, 0x12, 0x8f, 0xc7,
0xf3, 0xa0, 0x3a, 0x6e, 0x55, 0x34, 0xd0, 0xb8, 0xb3, 0xcf, 0x39, 0x3f, 0xbb, 0xff, 0x53, 0x07,
0x7c, 0x14, 0x4a, 0x89, 0x9c, 0x47, 0xb3, 0x4c, 0x18, 0x36, 0xcb, 0x79, 0xc4, 0x16, 0xcb, 0x4c,
0x46, 0xf3, 0xbc, 0xd2, 0x86, 0x97, 0xd1, 0xea, 0x7c, 0xe7, 0x50, 0xa7, 0xd1, 0x05, 0x33, 0x0c,
0x15, 0xa5, 0x32, 0x0a, 0xb6, 0x6b, 0x1a, 0x6d, 0x33, 0xc8, 0xd2, 0xc8, 0x25, 0xd1, 0xea, 0xfc,
0xf4, 0x85, 0x3b, 0x9f, 0x15, 0x59, 0xc4, 0xa4, 0x54, 0x86, 0x99, 0x4c, 0x49, 0x5d, 0xf3, 0xa7,
0xaf, 0x9d, 0x9b, 0x2b, 0x29, 0xca, 0x4a, 0xca, 0x4c, 0x8a, 0x48, 0x15, 0xbc, 0xfc, 0x2d, 0x74,
0xe6, 0x42, 0x76, 0x37, 0xab, 0xee, 0x22, 0x93, 0x2d, 0xb9, 0x36, 0x6c, 0x59, 0xd4, 0x81, 0xce,
0x4f, 0x0f, 0x34, 0x6f, 0x95, 0xe4, 0x10, 0x82, 0xa6, 0x64, 0x4b, 0x1e, 0x7a, 0x6d, 0xaf, 0xfb,
0x7f, 0x62, 0xd7, 0xf0, 0x15, 0x78, 0xb4, 0xc8, 0x74, 0x91, 0xb3, 0x35, 0xb5, 0x5e, 0xc3, 0x7a,
0xbe, 0xd3, 0xc8, 0x26, 0x82, 0x41, 0x4b, 0x1b, 0x66, 0x2a, 0x1d, 0x1e, 0xb6, 0xbd, 0xee, 0xe3,
0x8b, 0x77, 0xe8, 0xa1, 0xb1, 0xd0, 0xe6, 0x3a, 0x94, 0x5a, 0x28, 0x71, 0x70, 0x67, 0x02, 0x5a,
0xb5, 0x02, 0x7d, 0x70, 0x7c, 0x43, 0xae, 0xc8, 0xf8, 0x2b, 0x09, 0x0e, 0x60, 0x0b, 0x34, 0xc6,
0x57, 0x81, 0x07, 0x9f, 0x83, 0x67, 0x93, 0x2f, 0x3d, 0x42, 0x70, 0x4c, 0xaf, 0x7b, 0x23, 0x32,
0xc5, 0xa4, 0x47, 0x06, 0x38, 0x68, 0xc0, 0x10, 0x9c, 0xe0, 0x6b, 0x9c, 0x0c, 0x31, 0x19, 0x7c,
0xb3, 0x96, 0x73, 0x0e, 0x3b, 0x3f, 0x1a, 0xe0, 0x78, 0x50, 0x5f, 0xfa, 0xc7, 0xd9, 0x3e, 0x83,
0xa7, 0xf3, 0xaa, 0x2c, 0xb9, 0x34, 0x74, 0xd7, 0x9a, 0x9d, 0xc1, 0xbf, 0x78, 0xb9, 0x9d, 0x61,
0xaf, 0x5a, 0x34, 0xde, 0x86, 0x92, 0xc0, 0x71, 0x3b, 0xe5, 0x5e, 0x4f, 0xcd, 0xfb, 0x3d, 0x9d,
0x01, 0x5f, 0xf3, 0x72, 0xc5, 0xa9, 0x54, 0x0b, 0xae, 0xc3, 0xa3, 0xb6, 0xd7, 0x3d, 0x4a, 0x80,
0x95, 0xc8, 0x46, 0x81, 0x14, 0x9c, 0x2c, 0xf8, 0x1d, 0xab, 0x72, 0x43, 0xb5, 0x51, 0x25, 0x13,
0x9c, 0x9a, 0x75, 0xc1, 0xc3, 0xff, 0xfe, 0xb5, 0xd6, 0xb4, 0xa6, 0xa6, 0xeb, 0x82, 0x27, 0xd0,
0x1d, 0xb5, 0xa7, 0xbd, 0xbd, 0x04, 0xfe, 0xde, 0x76, 0x53, 0x69, 0x3a, 0x1d, 0x27, 0xbd, 0x21,
0xa6, 0x37, 0x24, 0x9d, 0xe0, 0xc1, 0xe8, 0xd3, 0x08, 0xc7, 0xc1, 0x01, 0x7c, 0x02, 0xfc, 0xad,
0x91, 0xa6, 0x71, 0xe0, 0xed, 0x0b, 0x97, 0x71, 0x1c, 0x34, 0xfa, 0xdf, 0x3d, 0xf0, 0x66, 0xae,
0x96, 0x0f, 0xfe, 0xa4, 0x7e, 0xd8, 0x77, 0x96, 0xfb, 0x23, 0x62, 0x66, 0xd8, 0x64, 0xf3, 0xec,
0x26, 0xde, 0xed, 0xd0, 0xd1, 0x42, 0xe5, 0x4c, 0x0a, 0xa4, 0x4a, 0x11, 0x09, 0x2e, 0xed, 0xa3,
0x8c, 0x6a, 0x8b, 0x15, 0x99, 0xfe, 0xfb, 0xb7, 0xf5, 0xc1, 0x2d, 0x67, 0x2d, 0xcb, 0xbc, 0xff,
0x15, 0x00, 0x00, 0xff, 0xff, 0xc9, 0x27, 0x25, 0xa6, 0x8e, 0x03, 0x00, 0x00,
}

472
vendor/google.golang.org/genproto/googleapis/bigtable/admin/cluster/v1/bigtable_cluster_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,472 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto
package cluster
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_longrunning "google.golang.org/genproto/googleapis/longrunning"
import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for BigtableClusterService service
type BigtableClusterServiceClient interface {
// Lists the supported zones for the given project.
ListZones(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error)
// Gets information about a particular cluster.
GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
// Lists all clusters in the given project, along with any zones for which
// cluster information could not be retrieved.
ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error)
// Creates a cluster and begins preparing it to begin serving. The returned
// cluster embeds as its "current_operation" a long-running operation which
// can be used to track the progress of turning up the new cluster.
// Immediately upon completion of this request:
// * The cluster will be readable via the API, with all requested attributes
// but no allocated resources.
// Until completion of the embedded operation:
// * Cancelling the operation will render the cluster immediately unreadable
// via the API.
// * All other attempts to modify or delete the cluster will be rejected.
// Upon completion of the embedded operation:
// * Billing for all successfully-allocated resources will begin (some types
// may have lower than the requested levels).
// * New tables can be created in the cluster.
// * The cluster's allocated resource levels will be readable via the API.
// The embedded operation's "metadata" field type is
// [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
// Updates a cluster, and begins allocating or releasing resources as
// requested. The returned cluster embeds as its "current_operation" a
// long-running operation which can be used to track the progress of updating
// the cluster.
// Immediately upon completion of this request:
// * For resource types where a decrease in the cluster's allocation has been
// requested, billing will be based on the newly-requested level.
// Until completion of the embedded operation:
// * Cancelling the operation will set its metadata's "cancelled_at_time",
// and begin restoring resources to their pre-request values. The operation
// is guaranteed to succeed at undoing all resource changes, after which
// point it will terminate with a CANCELLED status.
// * All other attempts to modify or delete the cluster will be rejected.
// * Reading the cluster via the API will continue to give the pre-request
// resource levels.
// Upon completion of the embedded operation:
// * Billing will begin for all successfully-allocated resources (some types
// may have lower than the requested levels).
// * All newly-reserved resources will be available for serving the cluster's
// tables.
// * The cluster's new resource levels will be readable via the API.
// [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
UpdateCluster(ctx context.Context, in *Cluster, opts ...grpc.CallOption) (*Cluster, error)
// Marks a cluster and all of its tables for permanent deletion in 7 days.
// Immediately upon completion of the request:
// * Billing will cease for all of the cluster's reserved resources.
// * The cluster's "delete_time" field will be set 7 days in the future.
// Soon afterward:
// * All tables within the cluster will become unavailable.
// Prior to the cluster's "delete_time":
// * The cluster can be recovered with a call to UndeleteCluster.
// * All other attempts to modify or delete the cluster will be rejected.
// At the cluster's "delete_time":
// * The cluster and *all of its tables* will immediately and irrevocably
// disappear from the API, and their data will be permanently deleted.
DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
// Cancels the scheduled deletion of an cluster and begins preparing it to
// resume serving. The returned operation will also be embedded as the
// cluster's "current_operation".
// Immediately upon completion of this request:
// * The cluster's "delete_time" field will be unset, protecting it from
// automatic deletion.
// Until completion of the returned operation:
// * The operation cannot be cancelled.
// Upon completion of the returned operation:
// * Billing for the cluster's resources will resume.
// * All tables within the cluster will be available.
// [UndeleteClusterMetadata][google.bigtable.admin.cluster.v1.UndeleteClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
UndeleteCluster(ctx context.Context, in *UndeleteClusterRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error)
}
type bigtableClusterServiceClient struct {
cc *grpc.ClientConn
}
func NewBigtableClusterServiceClient(cc *grpc.ClientConn) BigtableClusterServiceClient {
return &bigtableClusterServiceClient{cc}
}
func (c *bigtableClusterServiceClient) ListZones(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error) {
out := new(ListZonesResponse)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListZones", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
out := new(Cluster)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/GetCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error) {
out := new(ListClustersResponse)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListClusters", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
out := new(Cluster)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/CreateCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) UpdateCluster(ctx context.Context, in *Cluster, opts ...grpc.CallOption) (*Cluster, error) {
out := new(Cluster)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/UpdateCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/DeleteCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) UndeleteCluster(ctx context.Context, in *UndeleteClusterRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) {
out := new(google_longrunning.Operation)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/UndeleteCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for BigtableClusterService service
type BigtableClusterServiceServer interface {
// Lists the supported zones for the given project.
ListZones(context.Context, *ListZonesRequest) (*ListZonesResponse, error)
// Gets information about a particular cluster.
GetCluster(context.Context, *GetClusterRequest) (*Cluster, error)
// Lists all clusters in the given project, along with any zones for which
// cluster information could not be retrieved.
ListClusters(context.Context, *ListClustersRequest) (*ListClustersResponse, error)
// Creates a cluster and begins preparing it to begin serving. The returned
// cluster embeds as its "current_operation" a long-running operation which
// can be used to track the progress of turning up the new cluster.
// Immediately upon completion of this request:
// * The cluster will be readable via the API, with all requested attributes
// but no allocated resources.
// Until completion of the embedded operation:
// * Cancelling the operation will render the cluster immediately unreadable
// via the API.
// * All other attempts to modify or delete the cluster will be rejected.
// Upon completion of the embedded operation:
// * Billing for all successfully-allocated resources will begin (some types
// may have lower than the requested levels).
// * New tables can be created in the cluster.
// * The cluster's allocated resource levels will be readable via the API.
// The embedded operation's "metadata" field type is
// [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
CreateCluster(context.Context, *CreateClusterRequest) (*Cluster, error)
// Updates a cluster, and begins allocating or releasing resources as
// requested. The returned cluster embeds as its "current_operation" a
// long-running operation which can be used to track the progress of updating
// the cluster.
// Immediately upon completion of this request:
// * For resource types where a decrease in the cluster's allocation has been
// requested, billing will be based on the newly-requested level.
// Until completion of the embedded operation:
// * Cancelling the operation will set its metadata's "cancelled_at_time",
// and begin restoring resources to their pre-request values. The operation
// is guaranteed to succeed at undoing all resource changes, after which
// point it will terminate with a CANCELLED status.
// * All other attempts to modify or delete the cluster will be rejected.
// * Reading the cluster via the API will continue to give the pre-request
// resource levels.
// Upon completion of the embedded operation:
// * Billing will begin for all successfully-allocated resources (some types
// may have lower than the requested levels).
// * All newly-reserved resources will be available for serving the cluster's
// tables.
// * The cluster's new resource levels will be readable via the API.
// [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
UpdateCluster(context.Context, *Cluster) (*Cluster, error)
// Marks a cluster and all of its tables for permanent deletion in 7 days.
// Immediately upon completion of the request:
// * Billing will cease for all of the cluster's reserved resources.
// * The cluster's "delete_time" field will be set 7 days in the future.
// Soon afterward:
// * All tables within the cluster will become unavailable.
// Prior to the cluster's "delete_time":
// * The cluster can be recovered with a call to UndeleteCluster.
// * All other attempts to modify or delete the cluster will be rejected.
// At the cluster's "delete_time":
// * The cluster and *all of its tables* will immediately and irrevocably
// disappear from the API, and their data will be permanently deleted.
DeleteCluster(context.Context, *DeleteClusterRequest) (*google_protobuf2.Empty, error)
// Cancels the scheduled deletion of an cluster and begins preparing it to
// resume serving. The returned operation will also be embedded as the
// cluster's "current_operation".
// Immediately upon completion of this request:
// * The cluster's "delete_time" field will be unset, protecting it from
// automatic deletion.
// Until completion of the returned operation:
// * The operation cannot be cancelled.
// Upon completion of the returned operation:
// * Billing for the cluster's resources will resume.
// * All tables within the cluster will be available.
// [UndeleteClusterMetadata][google.bigtable.admin.cluster.v1.UndeleteClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
UndeleteCluster(context.Context, *UndeleteClusterRequest) (*google_longrunning.Operation, error)
}
func RegisterBigtableClusterServiceServer(s *grpc.Server, srv BigtableClusterServiceServer) {
s.RegisterService(&_BigtableClusterService_serviceDesc, srv)
}
func _BigtableClusterService_ListZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListZonesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableClusterServiceServer).ListZones(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListZones",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableClusterServiceServer).ListZones(ctx, req.(*ListZonesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableClusterService_GetCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetClusterRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableClusterServiceServer).GetCluster(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/GetCluster",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableClusterServiceServer).GetCluster(ctx, req.(*GetClusterRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableClusterService_ListClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListClustersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableClusterServiceServer).ListClusters(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListClusters",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableClusterServiceServer).ListClusters(ctx, req.(*ListClustersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableClusterService_CreateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateClusterRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableClusterServiceServer).CreateCluster(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/CreateCluster",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableClusterServiceServer).CreateCluster(ctx, req.(*CreateClusterRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableClusterService_UpdateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(Cluster)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableClusterServiceServer).UpdateCluster(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/UpdateCluster",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableClusterServiceServer).UpdateCluster(ctx, req.(*Cluster))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableClusterService_DeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteClusterRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableClusterServiceServer).DeleteCluster(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/DeleteCluster",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableClusterServiceServer).DeleteCluster(ctx, req.(*DeleteClusterRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableClusterService_UndeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UndeleteClusterRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableClusterServiceServer).UndeleteCluster(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/UndeleteCluster",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableClusterServiceServer).UndeleteCluster(ctx, req.(*UndeleteClusterRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BigtableClusterService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.bigtable.admin.cluster.v1.BigtableClusterService",
HandlerType: (*BigtableClusterServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ListZones",
Handler: _BigtableClusterService_ListZones_Handler,
},
{
MethodName: "GetCluster",
Handler: _BigtableClusterService_GetCluster_Handler,
},
{
MethodName: "ListClusters",
Handler: _BigtableClusterService_ListClusters_Handler,
},
{
MethodName: "CreateCluster",
Handler: _BigtableClusterService_CreateCluster_Handler,
},
{
MethodName: "UpdateCluster",
Handler: _BigtableClusterService_UpdateCluster_Handler,
},
{
MethodName: "DeleteCluster",
Handler: _BigtableClusterService_DeleteCluster_Handler,
},
{
MethodName: "UndeleteCluster",
Handler: _BigtableClusterService_UndeleteCluster_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto",
}
func init() {
proto.RegisterFile("google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto", fileDescriptor1)
}
var fileDescriptor1 = []byte{
// 515 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0x4f, 0x6b, 0x14, 0x31,
0x18, 0xc6, 0x89, 0x07, 0xa1, 0xc1, 0x45, 0xc8, 0xa1, 0x87, 0x6d, 0x0b, 0x32, 0x15, 0xb1, 0x23,
0x26, 0x6e, 0x17, 0xc5, 0xbf, 0x08, 0x5b, 0xa5, 0x1e, 0x04, 0x8b, 0xd2, 0x4b, 0x2f, 0x4b, 0x76,
0xe7, 0x35, 0x8c, 0xcc, 0x24, 0x31, 0xc9, 0x2c, 0xa8, 0xf4, 0xe2, 0xcd, 0x93, 0x88, 0x27, 0x3d,
0x78, 0xeb, 0xdd, 0xef, 0xe2, 0x57, 0xf0, 0x83, 0xc8, 0x64, 0x92, 0xb5, 0x2b, 0x6b, 0x77, 0xa6,
0xb7, 0x99, 0xc9, 0xfb, 0xbc, 0xcf, 0x6f, 0x9e, 0x24, 0x2f, 0x7e, 0x2c, 0x94, 0x12, 0x05, 0xb0,
0x49, 0x2e, 0x1c, 0x9f, 0x14, 0xc0, 0x78, 0x56, 0xe6, 0x92, 0x4d, 0x8b, 0xca, 0x3a, 0x30, 0x6c,
0x36, 0x98, 0xaf, 0x8c, 0xc3, 0xb7, 0xb1, 0x05, 0x33, 0xcb, 0xa7, 0x40, 0xb5, 0x51, 0x4e, 0x91,
0x2b, 0x4d, 0x03, 0x1a, 0xcb, 0xa8, 0x6f, 0x40, 0x43, 0x31, 0x9d, 0x0d, 0xfa, 0x9b, 0xc1, 0x82,
0xeb, 0x9c, 0x71, 0x29, 0x95, 0xe3, 0x2e, 0x57, 0xd2, 0x36, 0xfa, 0xfe, 0xc3, 0xee, 0x00, 0x19,
0x77, 0x3c, 0xa8, 0x9f, 0x9d, 0x1b, 0x7f, 0x5c, 0x82, 0xb5, 0x5c, 0x40, 0xe4, 0xd8, 0x0e, 0x9d,
0x0a, 0x25, 0x85, 0xa9, 0xa4, 0xcc, 0xa5, 0x60, 0x4a, 0x83, 0x59, 0x80, 0xdd, 0x08, 0x45, 0xfe,
0x6d, 0x52, 0xbd, 0x66, 0x50, 0x6a, 0xf7, 0xae, 0x59, 0xdc, 0xfd, 0xb4, 0x86, 0xd7, 0x47, 0xc1,
0x6d, 0xaf, 0x31, 0x7b, 0xd5, 0x78, 0x91, 0x6f, 0x08, 0xaf, 0x3d, 0xcf, 0xad, 0x3b, 0x52, 0x12,
0x2c, 0xd9, 0xa5, 0xab, 0x32, 0xa3, 0xf3, 0xe2, 0x97, 0xf0, 0xb6, 0x02, 0xeb, 0xfa, 0xc3, 0x4e,
0x1a, 0xab, 0x95, 0xb4, 0x90, 0x6c, 0x7f, 0xfc, 0xf5, 0xfb, 0xeb, 0x85, 0x2d, 0xb2, 0x51, 0x07,
0xf1, 0x41, 0xf2, 0x12, 0x1e, 0x69, 0xa3, 0xde, 0xc0, 0xd4, 0x59, 0x96, 0x1e, 0xb3, 0xf7, 0x9e,
0xe6, 0x07, 0xc2, 0x78, 0x1f, 0x5c, 0x20, 0x26, 0x2d, 0x8c, 0xfe, 0x56, 0x47, 0xba, 0x9d, 0xd5,
0xa2, 0xa0, 0x48, 0x6e, 0x79, 0xa6, 0x94, 0x5c, 0x5f, 0xc6, 0xd4, 0x20, 0xb1, 0x34, 0x6e, 0x60,
0x8d, 0x49, 0x7e, 0x22, 0x7c, 0xa9, 0xfe, 0xb7, 0xd0, 0xc1, 0x92, 0xdb, 0xed, 0xb2, 0x88, 0xf5,
0x11, 0xf2, 0x4e, 0x57, 0x59, 0x48, 0x71, 0xe0, 0x89, 0x6f, 0x90, 0x9d, 0xe5, 0x29, 0x72, 0x21,
0x0c, 0x08, 0xee, 0x20, 0x9b, 0x53, 0x93, 0x13, 0x84, 0x7b, 0x7b, 0x06, 0xb8, 0x8b, 0x07, 0x81,
0xb4, 0x30, 0x5f, 0x10, 0x9c, 0x23, 0xd9, 0xc0, 0x99, 0x5c, 0x3b, 0x2b, 0xd9, 0xe3, 0x39, 0xe4,
0x7d, 0x94, 0x92, 0xef, 0x08, 0xf7, 0x0e, 0x75, 0x76, 0x8a, 0xb3, 0xbd, 0x5f, 0x17, 0xb4, 0xa1,
0x47, 0xbb, 0xd9, 0x6f, 0xbd, 0xe9, 0x35, 0xdc, 0x17, 0x84, 0x7b, 0x4f, 0xa0, 0x80, 0x4e, 0x21,
0x2e, 0x08, 0x62, 0x88, 0xeb, 0x51, 0x17, 0xef, 0x2d, 0x7d, 0x5a, 0xdf, 0xdb, 0x78, 0x16, 0xd3,
0xf6, 0x67, 0xf1, 0x04, 0xe1, 0xcb, 0x87, 0x32, 0x5b, 0xa0, 0xba, 0xbb, 0x9a, 0xea, 0x1f, 0x49,
0xe4, 0xda, 0x8a, 0xca, 0x53, 0x43, 0x87, 0xbe, 0x88, 0x43, 0x27, 0xb9, 0xe7, 0xf1, 0x86, 0xc9,
0xa0, 0x75, 0x6a, 0x55, 0xf0, 0x19, 0x7d, 0x46, 0xf8, 0xea, 0x54, 0x95, 0x2b, 0xc9, 0x46, 0x9b,
0xcb, 0x27, 0x96, 0x3d, 0xa8, 0x93, 0x3a, 0x40, 0x47, 0xfb, 0xa1, 0x83, 0x50, 0x05, 0x97, 0x82,
0x2a, 0x23, 0x98, 0x00, 0xe9, 0x73, 0x64, 0xcd, 0x12, 0xd7, 0xb9, 0xfd, 0xff, 0xfc, 0x7d, 0x10,
0x1e, 0x27, 0x17, 0xbd, 0x66, 0xf8, 0x27, 0x00, 0x00, 0xff, 0xff, 0x50, 0x92, 0x91, 0x86, 0x71,
0x06, 0x00, 0x00,
}

376
vendor/google.golang.org/genproto/googleapis/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.pb.go generated vendored Normal file
View File

@ -0,0 +1,376 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.proto
package cluster
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Request message for BigtableClusterService.ListZones.
type ListZonesRequest struct {
// The unique name of the project for which a list of supported zones is
// requested.
// Values are of the form projects/<project>
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *ListZonesRequest) Reset() { *m = ListZonesRequest{} }
func (m *ListZonesRequest) String() string { return proto.CompactTextString(m) }
func (*ListZonesRequest) ProtoMessage() {}
func (*ListZonesRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *ListZonesRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Response message for BigtableClusterService.ListZones.
type ListZonesResponse struct {
// The list of requested zones.
Zones []*Zone `protobuf:"bytes,1,rep,name=zones" json:"zones,omitempty"`
}
func (m *ListZonesResponse) Reset() { *m = ListZonesResponse{} }
func (m *ListZonesResponse) String() string { return proto.CompactTextString(m) }
func (*ListZonesResponse) ProtoMessage() {}
func (*ListZonesResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
func (m *ListZonesResponse) GetZones() []*Zone {
if m != nil {
return m.Zones
}
return nil
}
// Request message for BigtableClusterService.GetCluster.
type GetClusterRequest struct {
// The unique name of the requested cluster.
// Values are of the form projects/<project>/zones/<zone>/clusters/<cluster>
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetClusterRequest) Reset() { *m = GetClusterRequest{} }
func (m *GetClusterRequest) String() string { return proto.CompactTextString(m) }
func (*GetClusterRequest) ProtoMessage() {}
func (*GetClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
func (m *GetClusterRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Request message for BigtableClusterService.ListClusters.
type ListClustersRequest struct {
// The unique name of the project for which a list of clusters is requested.
// Values are of the form projects/<project>
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *ListClustersRequest) Reset() { *m = ListClustersRequest{} }
func (m *ListClustersRequest) String() string { return proto.CompactTextString(m) }
func (*ListClustersRequest) ProtoMessage() {}
func (*ListClustersRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
func (m *ListClustersRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Response message for BigtableClusterService.ListClusters.
type ListClustersResponse struct {
// The list of requested Clusters.
Clusters []*Cluster `protobuf:"bytes,1,rep,name=clusters" json:"clusters,omitempty"`
// The zones for which clusters could not be retrieved.
FailedZones []*Zone `protobuf:"bytes,2,rep,name=failed_zones,json=failedZones" json:"failed_zones,omitempty"`
}
func (m *ListClustersResponse) Reset() { *m = ListClustersResponse{} }
func (m *ListClustersResponse) String() string { return proto.CompactTextString(m) }
func (*ListClustersResponse) ProtoMessage() {}
func (*ListClustersResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
func (m *ListClustersResponse) GetClusters() []*Cluster {
if m != nil {
return m.Clusters
}
return nil
}
func (m *ListClustersResponse) GetFailedZones() []*Zone {
if m != nil {
return m.FailedZones
}
return nil
}
// Request message for BigtableClusterService.CreateCluster.
type CreateClusterRequest struct {
// The unique name of the zone in which to create the cluster.
// Values are of the form projects/<project>/zones/<zone>
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The id to be used when referring to the new cluster within its zone,
// e.g. just the "test-cluster" section of the full name
// "projects/<project>/zones/<zone>/clusters/test-cluster".
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"`
// The cluster to create.
// The "name", "delete_time", and "current_operation" fields must be left
// blank.
Cluster *Cluster `protobuf:"bytes,3,opt,name=cluster" json:"cluster,omitempty"`
}
func (m *CreateClusterRequest) Reset() { *m = CreateClusterRequest{} }
func (m *CreateClusterRequest) String() string { return proto.CompactTextString(m) }
func (*CreateClusterRequest) ProtoMessage() {}
func (*CreateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }
func (m *CreateClusterRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *CreateClusterRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateClusterRequest) GetCluster() *Cluster {
if m != nil {
return m.Cluster
}
return nil
}
// Metadata type for the operation returned by
// BigtableClusterService.CreateCluster.
type CreateClusterMetadata struct {
// The request which prompted the creation of this operation.
OriginalRequest *CreateClusterRequest `protobuf:"bytes,1,opt,name=original_request,json=originalRequest" json:"original_request,omitempty"`
// The time at which original_request was received.
RequestTime *google_protobuf3.Timestamp `protobuf:"bytes,2,opt,name=request_time,json=requestTime" json:"request_time,omitempty"`
// The time at which this operation failed or was completed successfully.
FinishTime *google_protobuf3.Timestamp `protobuf:"bytes,3,opt,name=finish_time,json=finishTime" json:"finish_time,omitempty"`
}
func (m *CreateClusterMetadata) Reset() { *m = CreateClusterMetadata{} }
func (m *CreateClusterMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateClusterMetadata) ProtoMessage() {}
func (*CreateClusterMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }
func (m *CreateClusterMetadata) GetOriginalRequest() *CreateClusterRequest {
if m != nil {
return m.OriginalRequest
}
return nil
}
func (m *CreateClusterMetadata) GetRequestTime() *google_protobuf3.Timestamp {
if m != nil {
return m.RequestTime
}
return nil
}
func (m *CreateClusterMetadata) GetFinishTime() *google_protobuf3.Timestamp {
if m != nil {
return m.FinishTime
}
return nil
}
// Metadata type for the operation returned by
// BigtableClusterService.UpdateCluster.
type UpdateClusterMetadata struct {
// The request which prompted the creation of this operation.
OriginalRequest *Cluster `protobuf:"bytes,1,opt,name=original_request,json=originalRequest" json:"original_request,omitempty"`
// The time at which original_request was received.
RequestTime *google_protobuf3.Timestamp `protobuf:"bytes,2,opt,name=request_time,json=requestTime" json:"request_time,omitempty"`
// The time at which this operation was cancelled. If set, this operation is
// in the process of undoing itself (which is guaranteed to succeed) and
// cannot be cancelled again.
CancelTime *google_protobuf3.Timestamp `protobuf:"bytes,3,opt,name=cancel_time,json=cancelTime" json:"cancel_time,omitempty"`
// The time at which this operation failed or was completed successfully.
FinishTime *google_protobuf3.Timestamp `protobuf:"bytes,4,opt,name=finish_time,json=finishTime" json:"finish_time,omitempty"`
}
func (m *UpdateClusterMetadata) Reset() { *m = UpdateClusterMetadata{} }
func (m *UpdateClusterMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateClusterMetadata) ProtoMessage() {}
func (*UpdateClusterMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }
func (m *UpdateClusterMetadata) GetOriginalRequest() *Cluster {
if m != nil {
return m.OriginalRequest
}
return nil
}
func (m *UpdateClusterMetadata) GetRequestTime() *google_protobuf3.Timestamp {
if m != nil {
return m.RequestTime
}
return nil
}
func (m *UpdateClusterMetadata) GetCancelTime() *google_protobuf3.Timestamp {
if m != nil {
return m.CancelTime
}
return nil
}
func (m *UpdateClusterMetadata) GetFinishTime() *google_protobuf3.Timestamp {
if m != nil {
return m.FinishTime
}
return nil
}
// Request message for BigtableClusterService.DeleteCluster.
type DeleteClusterRequest struct {
// The unique name of the cluster to be deleted.
// Values are of the form projects/<project>/zones/<zone>/clusters/<cluster>
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *DeleteClusterRequest) Reset() { *m = DeleteClusterRequest{} }
func (m *DeleteClusterRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteClusterRequest) ProtoMessage() {}
func (*DeleteClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }
func (m *DeleteClusterRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Request message for BigtableClusterService.UndeleteCluster.
type UndeleteClusterRequest struct {
// The unique name of the cluster to be un-deleted.
// Values are of the form projects/<project>/zones/<zone>/clusters/<cluster>
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *UndeleteClusterRequest) Reset() { *m = UndeleteClusterRequest{} }
func (m *UndeleteClusterRequest) String() string { return proto.CompactTextString(m) }
func (*UndeleteClusterRequest) ProtoMessage() {}
func (*UndeleteClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} }
func (m *UndeleteClusterRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Metadata type for the operation returned by
// BigtableClusterService.UndeleteCluster.
type UndeleteClusterMetadata struct {
// The time at which the original request was received.
RequestTime *google_protobuf3.Timestamp `protobuf:"bytes,1,opt,name=request_time,json=requestTime" json:"request_time,omitempty"`
// The time at which this operation failed or was completed successfully.
FinishTime *google_protobuf3.Timestamp `protobuf:"bytes,2,opt,name=finish_time,json=finishTime" json:"finish_time,omitempty"`
}
func (m *UndeleteClusterMetadata) Reset() { *m = UndeleteClusterMetadata{} }
func (m *UndeleteClusterMetadata) String() string { return proto.CompactTextString(m) }
func (*UndeleteClusterMetadata) ProtoMessage() {}
func (*UndeleteClusterMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }
func (m *UndeleteClusterMetadata) GetRequestTime() *google_protobuf3.Timestamp {
if m != nil {
return m.RequestTime
}
return nil
}
func (m *UndeleteClusterMetadata) GetFinishTime() *google_protobuf3.Timestamp {
if m != nil {
return m.FinishTime
}
return nil
}
// Metadata type for operations initiated by the V2 BigtableAdmin service.
// More complete information for such operations is available via the V2 API.
type V2OperationMetadata struct {
}
func (m *V2OperationMetadata) Reset() { *m = V2OperationMetadata{} }
func (m *V2OperationMetadata) String() string { return proto.CompactTextString(m) }
func (*V2OperationMetadata) ProtoMessage() {}
func (*V2OperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }
func init() {
proto.RegisterType((*ListZonesRequest)(nil), "google.bigtable.admin.cluster.v1.ListZonesRequest")
proto.RegisterType((*ListZonesResponse)(nil), "google.bigtable.admin.cluster.v1.ListZonesResponse")
proto.RegisterType((*GetClusterRequest)(nil), "google.bigtable.admin.cluster.v1.GetClusterRequest")
proto.RegisterType((*ListClustersRequest)(nil), "google.bigtable.admin.cluster.v1.ListClustersRequest")
proto.RegisterType((*ListClustersResponse)(nil), "google.bigtable.admin.cluster.v1.ListClustersResponse")
proto.RegisterType((*CreateClusterRequest)(nil), "google.bigtable.admin.cluster.v1.CreateClusterRequest")
proto.RegisterType((*CreateClusterMetadata)(nil), "google.bigtable.admin.cluster.v1.CreateClusterMetadata")
proto.RegisterType((*UpdateClusterMetadata)(nil), "google.bigtable.admin.cluster.v1.UpdateClusterMetadata")
proto.RegisterType((*DeleteClusterRequest)(nil), "google.bigtable.admin.cluster.v1.DeleteClusterRequest")
proto.RegisterType((*UndeleteClusterRequest)(nil), "google.bigtable.admin.cluster.v1.UndeleteClusterRequest")
proto.RegisterType((*UndeleteClusterMetadata)(nil), "google.bigtable.admin.cluster.v1.UndeleteClusterMetadata")
proto.RegisterType((*V2OperationMetadata)(nil), "google.bigtable.admin.cluster.v1.V2OperationMetadata")
}
func init() {
proto.RegisterFile("google/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.proto", fileDescriptor2)
}
var fileDescriptor2 = []byte{
// 541 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0x4d, 0x6f, 0xd3, 0x40,
0x10, 0xd5, 0x26, 0xe5, 0xa3, 0xe3, 0x4a, 0xb4, 0x6e, 0x02, 0x51, 0x24, 0x44, 0x64, 0x50, 0x69,
0x11, 0xb2, 0xd5, 0x20, 0x71, 0x69, 0xb9, 0x24, 0xa0, 0x52, 0x89, 0x8a, 0x12, 0x5a, 0x0e, 0xbd,
0x58, 0x9b, 0x78, 0x62, 0x56, 0xb2, 0x77, 0x8d, 0x77, 0x93, 0x03, 0x3f, 0x82, 0x1b, 0xfc, 0x04,
0xc4, 0x2f, 0xe4, 0x8c, 0xec, 0xdd, 0x8d, 0x68, 0x95, 0xd6, 0xb1, 0x10, 0xb7, 0xdd, 0x99, 0xf7,
0x66, 0xde, 0x9b, 0x1d, 0x69, 0xe1, 0x6d, 0x2c, 0x44, 0x9c, 0x60, 0x30, 0x66, 0xb1, 0xa2, 0xe3,
0x04, 0x03, 0x1a, 0xa5, 0x8c, 0x07, 0x93, 0x64, 0x26, 0x15, 0xe6, 0xc1, 0x7c, 0x7f, 0x91, 0x09,
0x4d, 0x2c, 0x94, 0x98, 0xcf, 0xd9, 0x04, 0xc3, 0x14, 0xa5, 0xa4, 0x31, 0x4a, 0x3f, 0xcb, 0x85,
0x12, 0x6e, 0x4f, 0x57, 0xf2, 0x2d, 0xde, 0x2f, 0x2b, 0xf9, 0x86, 0xe5, 0xcf, 0xf7, 0xbb, 0x87,
0xf5, 0x7b, 0x45, 0x54, 0x51, 0x5d, 0xbf, 0xfb, 0xc8, 0xb0, 0xcb, 0xdb, 0x78, 0x36, 0x0d, 0x14,
0x4b, 0x51, 0x2a, 0x9a, 0x66, 0x1a, 0xe0, 0xed, 0xc0, 0xe6, 0x3b, 0x26, 0xd5, 0x85, 0xe0, 0x28,
0x47, 0xf8, 0x65, 0x86, 0x52, 0xb9, 0x2e, 0xac, 0x71, 0x9a, 0x62, 0x87, 0xf4, 0xc8, 0xee, 0xfa,
0xa8, 0x3c, 0x7b, 0x1f, 0x60, 0xeb, 0x2f, 0x9c, 0xcc, 0x04, 0x97, 0xe8, 0x1e, 0xc2, 0xad, 0xaf,
0x45, 0xa0, 0x43, 0x7a, 0xcd, 0x5d, 0xa7, 0xbf, 0xe3, 0x57, 0xb9, 0xf1, 0x0b, 0xfe, 0x48, 0x93,
0xbc, 0xa7, 0xb0, 0x75, 0x84, 0x6a, 0xa8, 0x93, 0x37, 0xf5, 0xde, 0x83, 0xed, 0xa2, 0xb7, 0x41,
0xde, 0x28, 0xf3, 0x17, 0x81, 0xd6, 0x65, 0xac, 0x91, 0xfa, 0x06, 0xee, 0x1a, 0x19, 0x56, 0xed,
0x5e, 0xb5, 0x5a, 0xab, 0x6d, 0x41, 0x75, 0x8f, 0x61, 0x63, 0x4a, 0x59, 0x82, 0x51, 0xa8, 0x8d,
0x37, 0x6a, 0x19, 0x77, 0x34, 0xb7, 0x1c, 0xa2, 0xf7, 0x8d, 0x40, 0x6b, 0x98, 0x23, 0x55, 0x58,
0x3d, 0x02, 0xf7, 0x21, 0x80, 0x7d, 0x5d, 0x16, 0x75, 0x1a, 0x65, 0x66, 0xdd, 0x44, 0x8e, 0x23,
0x77, 0x08, 0x77, 0xcc, 0xa5, 0xd3, 0xec, 0x91, 0x7a, 0xe6, 0x2c, 0xd3, 0xfb, 0x4d, 0xa0, 0x7d,
0x49, 0xd0, 0x09, 0x2a, 0x5a, 0xec, 0x92, 0x4b, 0x61, 0x53, 0xe4, 0x2c, 0x66, 0x9c, 0x26, 0x61,
0xae, 0x55, 0x96, 0xea, 0x9c, 0xfe, 0xcb, 0x15, 0xfa, 0x2c, 0xf1, 0x38, 0xba, 0x67, 0xeb, 0x59,
0xd3, 0xaf, 0x60, 0xc3, 0x54, 0x0e, 0x8b, 0x15, 0x2d, 0x2d, 0x3a, 0xfd, 0xae, 0x2d, 0x6f, 0xf7,
0xd7, 0x3f, 0xb3, 0xfb, 0x3b, 0x72, 0x0c, 0xbe, 0x88, 0xb8, 0x07, 0xe0, 0x4c, 0x19, 0x67, 0xf2,
0xb3, 0x66, 0x37, 0x2b, 0xd9, 0xa0, 0xe1, 0x45, 0xc0, 0xfb, 0xd9, 0x80, 0xf6, 0x79, 0x16, 0x2d,
0x31, 0x7e, 0x76, 0xad, 0xf1, 0x1a, 0x03, 0xfe, 0x0f, 0x5e, 0x27, 0x94, 0x4f, 0x30, 0x59, 0xd9,
0xab, 0x86, 0x2f, 0x1b, 0xd4, 0x5a, 0xad, 0x41, 0x3d, 0x83, 0xd6, 0x6b, 0x4c, 0x70, 0x95, 0x8d,
0xf5, 0x9e, 0xc3, 0xfd, 0x73, 0x1e, 0xad, 0x8a, 0xfe, 0x4e, 0xe0, 0xc1, 0x15, 0xf8, 0xe2, 0x11,
0xae, 0x8e, 0x8b, 0xfc, 0xd3, 0x6a, 0x34, 0x6a, 0x39, 0x6e, 0xc3, 0xf6, 0xa7, 0xfe, 0xfb, 0x0c,
0x73, 0xaa, 0x98, 0xe0, 0x56, 0xd2, 0xe0, 0x07, 0x81, 0x27, 0x13, 0x91, 0x56, 0xee, 0xc0, 0xe0,
0xf1, 0xc0, 0xa4, 0x8c, 0xa9, 0x8f, 0xfa, 0x1b, 0x38, 0x31, 0xbf, 0xc0, 0x69, 0xd1, 0xfd, 0x94,
0x5c, 0x1c, 0x99, 0x42, 0xb1, 0x48, 0x28, 0x8f, 0x7d, 0x91, 0xc7, 0x41, 0x8c, 0xbc, 0xd4, 0x16,
0xe8, 0x14, 0xcd, 0x98, 0xbc, 0xfe, 0x0f, 0x38, 0x30, 0xc7, 0xf1, 0xed, 0x92, 0xf3, 0xe2, 0x4f,
0x00, 0x00, 0x00, 0xff, 0xff, 0xc1, 0x75, 0x68, 0x13, 0xa2, 0x06, 0x00, 0x00,
}

451
vendor/google.golang.org/genproto/googleapis/bigtable/admin/table/v1/bigtable_table_data.pb.go generated vendored Normal file
View File

@ -0,0 +1,451 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/table/v1/bigtable_table_data.proto
/*
Package table is a generated protocol buffer package.
It is generated from these files:
google/bigtable/admin/table/v1/bigtable_table_data.proto
google/bigtable/admin/table/v1/bigtable_table_service.proto
google/bigtable/admin/table/v1/bigtable_table_service_messages.proto
It has these top-level messages:
Table
ColumnFamily
GcRule
CreateTableRequest
ListTablesRequest
ListTablesResponse
GetTableRequest
DeleteTableRequest
RenameTableRequest
CreateColumnFamilyRequest
DeleteColumnFamilyRequest
BulkDeleteRowsRequest
*/
package table
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_longrunning "google.golang.org/genproto/googleapis/longrunning"
import google_protobuf3 "github.com/golang/protobuf/ptypes/duration"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Table_TimestampGranularity int32
const (
Table_MILLIS Table_TimestampGranularity = 0
)
var Table_TimestampGranularity_name = map[int32]string{
0: "MILLIS",
}
var Table_TimestampGranularity_value = map[string]int32{
"MILLIS": 0,
}
func (x Table_TimestampGranularity) String() string {
return proto.EnumName(Table_TimestampGranularity_name, int32(x))
}
func (Table_TimestampGranularity) EnumDescriptor() ([]byte, []int) {
return fileDescriptor0, []int{0, 0}
}
// A collection of user data indexed by row, column, and timestamp.
// Each table is served using the resources of its parent cluster.
type Table struct {
// A unique identifier of the form
// <cluster_name>/tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]*
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// If this Table is in the process of being created, the Operation used to
// track its progress. As long as this operation is present, the Table will
// not accept any Table Admin or Read/Write requests.
CurrentOperation *google_longrunning.Operation `protobuf:"bytes,2,opt,name=current_operation,json=currentOperation" json:"current_operation,omitempty"`
// The column families configured for this table, mapped by column family id.
ColumnFamilies map[string]*ColumnFamily `protobuf:"bytes,3,rep,name=column_families,json=columnFamilies" json:"column_families,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// The granularity (e.g. MILLIS, MICROS) at which timestamps are stored in
// this table. Timestamps not matching the granularity will be rejected.
// Cannot be changed once the table is created.
Granularity Table_TimestampGranularity `protobuf:"varint,4,opt,name=granularity,enum=google.bigtable.admin.table.v1.Table_TimestampGranularity" json:"granularity,omitempty"`
}
func (m *Table) Reset() { *m = Table{} }
func (m *Table) String() string { return proto.CompactTextString(m) }
func (*Table) ProtoMessage() {}
func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Table) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Table) GetCurrentOperation() *google_longrunning.Operation {
if m != nil {
return m.CurrentOperation
}
return nil
}
func (m *Table) GetColumnFamilies() map[string]*ColumnFamily {
if m != nil {
return m.ColumnFamilies
}
return nil
}
func (m *Table) GetGranularity() Table_TimestampGranularity {
if m != nil {
return m.Granularity
}
return Table_MILLIS
}
// A set of columns within a table which share a common configuration.
type ColumnFamily struct {
// A unique identifier of the form <table_name>/columnFamilies/[-_.a-zA-Z0-9]+
// The last segment is the same as the "name" field in
// google.bigtable.v1.Family.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Garbage collection expression specified by the following grammar:
// GC = EXPR
// | "" ;
// EXPR = EXPR, "||", EXPR (* lowest precedence *)
// | EXPR, "&&", EXPR
// | "(", EXPR, ")" (* highest precedence *)
// | PROP ;
// PROP = "version() >", NUM32
// | "age() >", NUM64, [ UNIT ] ;
// NUM32 = non-zero-digit { digit } ; (* # NUM32 <= 2^32 - 1 *)
// NUM64 = non-zero-digit { digit } ; (* # NUM64 <= 2^63 - 1 *)
// UNIT = "d" | "h" | "m" (* d=days, h=hours, m=minutes, else micros *)
// GC expressions can be up to 500 characters in length
//
// The different types of PROP are defined as follows:
// version() - cell index, counting from most recent and starting at 1
// age() - age of the cell (current time minus cell timestamp)
//
// Example: "version() > 3 || (age() > 3d && version() > 1)"
// drop cells beyond the most recent three, and drop cells older than three
// days unless they're the most recent cell in the row/column
//
// Garbage collection executes opportunistically in the background, and so
// it's possible for reads to return a cell even if it matches the active GC
// expression for its family.
GcExpression string `protobuf:"bytes,2,opt,name=gc_expression,json=gcExpression" json:"gc_expression,omitempty"`
// Garbage collection rule specified as a protobuf.
// Supersedes `gc_expression`.
// Must serialize to at most 500 bytes.
//
// NOTE: Garbage collection executes opportunistically in the background, and
// so it's possible for reads to return a cell even if it matches the active
// GC expression for its family.
GcRule *GcRule `protobuf:"bytes,3,opt,name=gc_rule,json=gcRule" json:"gc_rule,omitempty"`
}
func (m *ColumnFamily) Reset() { *m = ColumnFamily{} }
func (m *ColumnFamily) String() string { return proto.CompactTextString(m) }
func (*ColumnFamily) ProtoMessage() {}
func (*ColumnFamily) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *ColumnFamily) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *ColumnFamily) GetGcExpression() string {
if m != nil {
return m.GcExpression
}
return ""
}
func (m *ColumnFamily) GetGcRule() *GcRule {
if m != nil {
return m.GcRule
}
return nil
}
// Rule for determining which cells to delete during garbage collection.
type GcRule struct {
// Types that are valid to be assigned to Rule:
// *GcRule_MaxNumVersions
// *GcRule_MaxAge
// *GcRule_Intersection_
// *GcRule_Union_
Rule isGcRule_Rule `protobuf_oneof:"rule"`
}
func (m *GcRule) Reset() { *m = GcRule{} }
func (m *GcRule) String() string { return proto.CompactTextString(m) }
func (*GcRule) ProtoMessage() {}
func (*GcRule) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
type isGcRule_Rule interface {
isGcRule_Rule()
}
type GcRule_MaxNumVersions struct {
MaxNumVersions int32 `protobuf:"varint,1,opt,name=max_num_versions,json=maxNumVersions,oneof"`
}
type GcRule_MaxAge struct {
MaxAge *google_protobuf3.Duration `protobuf:"bytes,2,opt,name=max_age,json=maxAge,oneof"`
}
type GcRule_Intersection_ struct {
Intersection *GcRule_Intersection `protobuf:"bytes,3,opt,name=intersection,oneof"`
}
type GcRule_Union_ struct {
Union *GcRule_Union `protobuf:"bytes,4,opt,name=union,oneof"`
}
func (*GcRule_MaxNumVersions) isGcRule_Rule() {}
func (*GcRule_MaxAge) isGcRule_Rule() {}
func (*GcRule_Intersection_) isGcRule_Rule() {}
func (*GcRule_Union_) isGcRule_Rule() {}
func (m *GcRule) GetRule() isGcRule_Rule {
if m != nil {
return m.Rule
}
return nil
}
func (m *GcRule) GetMaxNumVersions() int32 {
if x, ok := m.GetRule().(*GcRule_MaxNumVersions); ok {
return x.MaxNumVersions
}
return 0
}
func (m *GcRule) GetMaxAge() *google_protobuf3.Duration {
if x, ok := m.GetRule().(*GcRule_MaxAge); ok {
return x.MaxAge
}
return nil
}
func (m *GcRule) GetIntersection() *GcRule_Intersection {
if x, ok := m.GetRule().(*GcRule_Intersection_); ok {
return x.Intersection
}
return nil
}
func (m *GcRule) GetUnion() *GcRule_Union {
if x, ok := m.GetRule().(*GcRule_Union_); ok {
return x.Union
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*GcRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _GcRule_OneofMarshaler, _GcRule_OneofUnmarshaler, _GcRule_OneofSizer, []interface{}{
(*GcRule_MaxNumVersions)(nil),
(*GcRule_MaxAge)(nil),
(*GcRule_Intersection_)(nil),
(*GcRule_Union_)(nil),
}
}
func _GcRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*GcRule)
// rule
switch x := m.Rule.(type) {
case *GcRule_MaxNumVersions:
b.EncodeVarint(1<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.MaxNumVersions))
case *GcRule_MaxAge:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.MaxAge); err != nil {
return err
}
case *GcRule_Intersection_:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Intersection); err != nil {
return err
}
case *GcRule_Union_:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Union); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("GcRule.Rule has unexpected type %T", x)
}
return nil
}
func _GcRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*GcRule)
switch tag {
case 1: // rule.max_num_versions
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Rule = &GcRule_MaxNumVersions{int32(x)}
return true, err
case 2: // rule.max_age
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf3.Duration)
err := b.DecodeMessage(msg)
m.Rule = &GcRule_MaxAge{msg}
return true, err
case 3: // rule.intersection
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(GcRule_Intersection)
err := b.DecodeMessage(msg)
m.Rule = &GcRule_Intersection_{msg}
return true, err
case 4: // rule.union
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(GcRule_Union)
err := b.DecodeMessage(msg)
m.Rule = &GcRule_Union_{msg}
return true, err
default:
return false, nil
}
}
func _GcRule_OneofSizer(msg proto.Message) (n int) {
m := msg.(*GcRule)
// rule
switch x := m.Rule.(type) {
case *GcRule_MaxNumVersions:
n += proto.SizeVarint(1<<3 | proto.WireVarint)
n += proto.SizeVarint(uint64(x.MaxNumVersions))
case *GcRule_MaxAge:
s := proto.Size(x.MaxAge)
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *GcRule_Intersection_:
s := proto.Size(x.Intersection)
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *GcRule_Union_:
s := proto.Size(x.Union)
n += proto.SizeVarint(4<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// A GcRule which deletes cells matching all of the given rules.
type GcRule_Intersection struct {
// Only delete cells which would be deleted by every element of `rules`.
Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *GcRule_Intersection) Reset() { *m = GcRule_Intersection{} }
func (m *GcRule_Intersection) String() string { return proto.CompactTextString(m) }
func (*GcRule_Intersection) ProtoMessage() {}
func (*GcRule_Intersection) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
func (m *GcRule_Intersection) GetRules() []*GcRule {
if m != nil {
return m.Rules
}
return nil
}
// A GcRule which deletes cells matching any of the given rules.
type GcRule_Union struct {
// Delete cells which would be deleted by any element of `rules`.
Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *GcRule_Union) Reset() { *m = GcRule_Union{} }
func (m *GcRule_Union) String() string { return proto.CompactTextString(m) }
func (*GcRule_Union) ProtoMessage() {}
func (*GcRule_Union) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 1} }
func (m *GcRule_Union) GetRules() []*GcRule {
if m != nil {
return m.Rules
}
return nil
}
func init() {
proto.RegisterType((*Table)(nil), "google.bigtable.admin.table.v1.Table")
proto.RegisterType((*ColumnFamily)(nil), "google.bigtable.admin.table.v1.ColumnFamily")
proto.RegisterType((*GcRule)(nil), "google.bigtable.admin.table.v1.GcRule")
proto.RegisterType((*GcRule_Intersection)(nil), "google.bigtable.admin.table.v1.GcRule.Intersection")
proto.RegisterType((*GcRule_Union)(nil), "google.bigtable.admin.table.v1.GcRule.Union")
proto.RegisterEnum("google.bigtable.admin.table.v1.Table_TimestampGranularity", Table_TimestampGranularity_name, Table_TimestampGranularity_value)
}
func init() {
proto.RegisterFile("google/bigtable/admin/table/v1/bigtable_table_data.proto", fileDescriptor0)
}
var fileDescriptor0 = []byte{
// 579 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x61, 0x6b, 0xd3, 0x40,
0x18, 0xc7, 0x9b, 0xa5, 0xed, 0xd8, 0xb3, 0x3a, 0xeb, 0x29, 0x52, 0x0b, 0x4a, 0xc9, 0x40, 0x8a,
0xc8, 0x85, 0x6d, 0xbe, 0x98, 0x53, 0x10, 0xbb, 0xcd, 0x6d, 0x32, 0x75, 0xc4, 0x29, 0x28, 0x42,
0xb8, 0x66, 0xb7, 0x23, 0x98, 0xbb, 0x2b, 0x97, 0x5c, 0x69, 0x5f, 0xfb, 0xc6, 0x8f, 0xe2, 0xa7,
0xf0, 0xb3, 0x49, 0xee, 0x2e, 0x35, 0x83, 0xe9, 0x26, 0xbe, 0x49, 0x9e, 0x3c, 0xf7, 0xfc, 0x7f,
0xf7, 0xcf, 0xf3, 0x5c, 0x02, 0xdb, 0x4c, 0x4a, 0x96, 0xd1, 0x70, 0x9c, 0xb2, 0x82, 0x8c, 0x33,
0x1a, 0x92, 0x33, 0x9e, 0x8a, 0xd0, 0xc6, 0xd3, 0x8d, 0x45, 0x3e, 0xb6, 0xd7, 0x33, 0x52, 0x10,
0x3c, 0x51, 0xb2, 0x90, 0xe8, 0x81, 0x55, 0xe2, 0xaa, 0x02, 0x1b, 0x25, 0xb6, 0xf1, 0x74, 0xa3,
0xbf, 0xee, 0xc8, 0x99, 0x14, 0x4c, 0x69, 0x21, 0x52, 0xc1, 0x42, 0x39, 0xa1, 0x8a, 0x14, 0xa9,
0x14, 0xb9, 0x85, 0xf4, 0x1d, 0x24, 0x34, 0x4f, 0x63, 0x7d, 0x1e, 0x9e, 0x69, 0x5b, 0x60, 0xd7,
0x83, 0x9f, 0x3e, 0xb4, 0x4e, 0x4b, 0x22, 0x42, 0xd0, 0x14, 0x84, 0xd3, 0x9e, 0x37, 0xf0, 0x86,
0x2b, 0x91, 0x89, 0xd1, 0x6b, 0xb8, 0x95, 0x68, 0xa5, 0xa8, 0x28, 0xe2, 0x05, 0xb9, 0xb7, 0x34,
0xf0, 0x86, 0xab, 0x9b, 0xf7, 0xb1, 0xb3, 0x57, 0xdb, 0x1e, 0xbf, 0xab, 0x8a, 0xa2, 0xae, 0xd3,
0x2d, 0x32, 0x68, 0x0c, 0x37, 0x13, 0x99, 0x69, 0x2e, 0xe2, 0x73, 0xc2, 0xd3, 0x2c, 0xa5, 0x79,
0xcf, 0x1f, 0xf8, 0xc3, 0xd5, 0xcd, 0xa7, 0xf8, 0xef, 0x2f, 0x8a, 0x8d, 0x3f, 0xbc, 0x6b, 0xc4,
0xaf, 0x9c, 0x76, 0x5f, 0x14, 0x6a, 0x1e, 0xad, 0x25, 0x17, 0x92, 0xe8, 0x0b, 0xac, 0x32, 0x45,
0x84, 0xce, 0x88, 0x4a, 0x8b, 0x79, 0xaf, 0x39, 0xf0, 0x86, 0x6b, 0x9b, 0x3b, 0xd7, 0xe3, 0x9f,
0xa6, 0x9c, 0xe6, 0x05, 0xe1, 0x93, 0x83, 0xdf, 0x84, 0xa8, 0x8e, 0xeb, 0x4b, 0xb8, 0x7d, 0x89,
0x09, 0xd4, 0x05, 0xff, 0x2b, 0x9d, 0xbb, 0xbe, 0x95, 0x21, 0x1a, 0x41, 0x6b, 0x4a, 0x32, 0x4d,
0x5d, 0xab, 0x1e, 0x5f, 0x65, 0xa0, 0x46, 0x9d, 0x47, 0x56, 0xba, 0xb3, 0xb4, 0xed, 0x05, 0x01,
0xdc, 0xb9, 0xcc, 0x15, 0x02, 0x68, 0xbf, 0x39, 0x3a, 0x3e, 0x3e, 0x7a, 0xdf, 0x6d, 0x04, 0xdf,
0x3d, 0xe8, 0xd4, 0xf5, 0x97, 0xce, 0x71, 0x1d, 0x6e, 0xb0, 0x24, 0xa6, 0xb3, 0x89, 0xa2, 0x79,
0x5e, 0xcd, 0x70, 0x25, 0xea, 0xb0, 0x64, 0x7f, 0x91, 0x43, 0x2f, 0x60, 0x99, 0x25, 0xb1, 0xd2,
0x19, 0xed, 0xf9, 0xc6, 0xf7, 0xc3, 0xab, 0x7c, 0x1f, 0x24, 0x91, 0xce, 0x68, 0xd4, 0x66, 0xe6,
0x1e, 0xfc, 0xf0, 0xa1, 0x6d, 0x53, 0xe8, 0x11, 0x74, 0x39, 0x99, 0xc5, 0x42, 0xf3, 0x78, 0x4a,
0x55, 0x89, 0xcf, 0x8d, 0xa1, 0xd6, 0x61, 0x23, 0x5a, 0xe3, 0x64, 0xf6, 0x56, 0xf3, 0x8f, 0x2e,
0x8f, 0x9e, 0xc0, 0x72, 0x59, 0x4b, 0x58, 0xd5, 0xaf, 0x7b, 0xd5, 0xbe, 0xd5, 0xa1, 0xc5, 0x7b,
0xee, 0xd0, 0x1e, 0x36, 0xa2, 0x36, 0x27, 0xb3, 0x97, 0x8c, 0xa2, 0x4f, 0xd0, 0x49, 0x45, 0x41,
0x55, 0x4e, 0x13, 0x73, 0x2a, 0xad, 0xe5, 0xad, 0xeb, 0x59, 0xc6, 0x47, 0x35, 0xe9, 0x61, 0x23,
0xba, 0x80, 0x42, 0x7b, 0xd0, 0xd2, 0xa2, 0x64, 0x36, 0xaf, 0x37, 0x3e, 0xc7, 0xfc, 0x20, 0x2c,
0xcc, 0x8a, 0xfb, 0xc7, 0xd0, 0xa9, 0xef, 0x82, 0x9e, 0x43, 0xab, 0xec, 0x6d, 0xd9, 0x07, 0xff,
0x1f, 0x9a, 0x6b, 0x45, 0xfd, 0x7d, 0x68, 0x19, 0xfe, 0xff, 0x61, 0x46, 0x6d, 0x68, 0x96, 0xc1,
0xe8, 0x9b, 0x07, 0x41, 0x22, 0xf9, 0x15, 0xe2, 0xd1, 0xdd, 0x91, 0x5b, 0x30, 0x9f, 0xc8, 0x1e,
0x29, 0xc8, 0x49, 0x39, 0x92, 0x13, 0xef, 0xf3, 0xae, 0x53, 0x32, 0x99, 0x11, 0xc1, 0xb0, 0x54,
0x2c, 0x64, 0x54, 0x98, 0x81, 0x85, 0x76, 0x89, 0x4c, 0xd2, 0xfc, 0x4f, 0x7f, 0xbd, 0x67, 0x26,
0x18, 0xb7, 0x4d, 0xfd, 0xd6, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x80, 0x76, 0xdc, 0x24,
0x05, 0x00, 0x00,
}

423
vendor/google.golang.org/genproto/googleapis/bigtable/admin/table/v1/bigtable_table_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,423 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/table/v1/bigtable_table_service.proto
package table
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for BigtableTableService service
type BigtableTableServiceClient interface {
// Creates a new table, to be served from a specified cluster.
// The table can be created with a full set of initial column families,
// specified in the request.
CreateTable(ctx context.Context, in *CreateTableRequest, opts ...grpc.CallOption) (*Table, error)
// Lists the names of all tables served from a specified cluster.
ListTables(ctx context.Context, in *ListTablesRequest, opts ...grpc.CallOption) (*ListTablesResponse, error)
// Gets the schema of the specified table, including its column families.
GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*Table, error)
// Permanently deletes a specified table and all of its data.
DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
// Changes the name of a specified table.
// Cannot be used to move tables between clusters, zones, or projects.
RenameTable(ctx context.Context, in *RenameTableRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
// Creates a new column family within a specified table.
CreateColumnFamily(ctx context.Context, in *CreateColumnFamilyRequest, opts ...grpc.CallOption) (*ColumnFamily, error)
// Changes the configuration of a specified column family.
UpdateColumnFamily(ctx context.Context, in *ColumnFamily, opts ...grpc.CallOption) (*ColumnFamily, error)
// Permanently deletes a specified column family and all of its data.
DeleteColumnFamily(ctx context.Context, in *DeleteColumnFamilyRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
// Delete all rows in a table corresponding to a particular prefix
BulkDeleteRows(ctx context.Context, in *BulkDeleteRowsRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
}
type bigtableTableServiceClient struct {
cc *grpc.ClientConn
}
func NewBigtableTableServiceClient(cc *grpc.ClientConn) BigtableTableServiceClient {
return &bigtableTableServiceClient{cc}
}
func (c *bigtableTableServiceClient) CreateTable(ctx context.Context, in *CreateTableRequest, opts ...grpc.CallOption) (*Table, error) {
out := new(Table)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/CreateTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) ListTables(ctx context.Context, in *ListTablesRequest, opts ...grpc.CallOption) (*ListTablesResponse, error) {
out := new(ListTablesResponse)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/ListTables", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*Table, error) {
out := new(Table)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/GetTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/DeleteTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) RenameTable(ctx context.Context, in *RenameTableRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/RenameTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) CreateColumnFamily(ctx context.Context, in *CreateColumnFamilyRequest, opts ...grpc.CallOption) (*ColumnFamily, error) {
out := new(ColumnFamily)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/CreateColumnFamily", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) UpdateColumnFamily(ctx context.Context, in *ColumnFamily, opts ...grpc.CallOption) (*ColumnFamily, error) {
out := new(ColumnFamily)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/UpdateColumnFamily", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) DeleteColumnFamily(ctx context.Context, in *DeleteColumnFamilyRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/DeleteColumnFamily", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) BulkDeleteRows(ctx context.Context, in *BulkDeleteRowsRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/BulkDeleteRows", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for BigtableTableService service
type BigtableTableServiceServer interface {
// Creates a new table, to be served from a specified cluster.
// The table can be created with a full set of initial column families,
// specified in the request.
CreateTable(context.Context, *CreateTableRequest) (*Table, error)
// Lists the names of all tables served from a specified cluster.
ListTables(context.Context, *ListTablesRequest) (*ListTablesResponse, error)
// Gets the schema of the specified table, including its column families.
GetTable(context.Context, *GetTableRequest) (*Table, error)
// Permanently deletes a specified table and all of its data.
DeleteTable(context.Context, *DeleteTableRequest) (*google_protobuf2.Empty, error)
// Changes the name of a specified table.
// Cannot be used to move tables between clusters, zones, or projects.
RenameTable(context.Context, *RenameTableRequest) (*google_protobuf2.Empty, error)
// Creates a new column family within a specified table.
CreateColumnFamily(context.Context, *CreateColumnFamilyRequest) (*ColumnFamily, error)
// Changes the configuration of a specified column family.
UpdateColumnFamily(context.Context, *ColumnFamily) (*ColumnFamily, error)
// Permanently deletes a specified column family and all of its data.
DeleteColumnFamily(context.Context, *DeleteColumnFamilyRequest) (*google_protobuf2.Empty, error)
// Delete all rows in a table corresponding to a particular prefix
BulkDeleteRows(context.Context, *BulkDeleteRowsRequest) (*google_protobuf2.Empty, error)
}
func RegisterBigtableTableServiceServer(s *grpc.Server, srv BigtableTableServiceServer) {
s.RegisterService(&_BigtableTableService_serviceDesc, srv)
}
func _BigtableTableService_CreateTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateTableRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).CreateTable(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/CreateTable",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).CreateTable(ctx, req.(*CreateTableRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_ListTables_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListTablesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).ListTables(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/ListTables",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).ListTables(ctx, req.(*ListTablesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_GetTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetTableRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).GetTable(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/GetTable",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).GetTable(ctx, req.(*GetTableRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_DeleteTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteTableRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).DeleteTable(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/DeleteTable",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).DeleteTable(ctx, req.(*DeleteTableRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_RenameTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RenameTableRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).RenameTable(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/RenameTable",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).RenameTable(ctx, req.(*RenameTableRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_CreateColumnFamily_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateColumnFamilyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).CreateColumnFamily(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/CreateColumnFamily",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).CreateColumnFamily(ctx, req.(*CreateColumnFamilyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_UpdateColumnFamily_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ColumnFamily)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).UpdateColumnFamily(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/UpdateColumnFamily",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).UpdateColumnFamily(ctx, req.(*ColumnFamily))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_DeleteColumnFamily_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteColumnFamilyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).DeleteColumnFamily(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/DeleteColumnFamily",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).DeleteColumnFamily(ctx, req.(*DeleteColumnFamilyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableTableService_BulkDeleteRows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BulkDeleteRowsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableTableServiceServer).BulkDeleteRows(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.admin.table.v1.BigtableTableService/BulkDeleteRows",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableTableServiceServer).BulkDeleteRows(ctx, req.(*BulkDeleteRowsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BigtableTableService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.bigtable.admin.table.v1.BigtableTableService",
HandlerType: (*BigtableTableServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "CreateTable",
Handler: _BigtableTableService_CreateTable_Handler,
},
{
MethodName: "ListTables",
Handler: _BigtableTableService_ListTables_Handler,
},
{
MethodName: "GetTable",
Handler: _BigtableTableService_GetTable_Handler,
},
{
MethodName: "DeleteTable",
Handler: _BigtableTableService_DeleteTable_Handler,
},
{
MethodName: "RenameTable",
Handler: _BigtableTableService_RenameTable_Handler,
},
{
MethodName: "CreateColumnFamily",
Handler: _BigtableTableService_CreateColumnFamily_Handler,
},
{
MethodName: "UpdateColumnFamily",
Handler: _BigtableTableService_UpdateColumnFamily_Handler,
},
{
MethodName: "DeleteColumnFamily",
Handler: _BigtableTableService_DeleteColumnFamily_Handler,
},
{
MethodName: "BulkDeleteRows",
Handler: _BigtableTableService_BulkDeleteRows_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/bigtable/admin/table/v1/bigtable_table_service.proto",
}
func init() {
proto.RegisterFile("google/bigtable/admin/table/v1/bigtable_table_service.proto", fileDescriptor1)
}
var fileDescriptor1 = []byte{
// 560 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0xbf, 0x6f, 0xd4, 0x30,
0x14, 0xc7, 0x65, 0x06, 0x84, 0x7c, 0x88, 0xc1, 0x42, 0x0c, 0x07, 0x62, 0x88, 0xc4, 0x12, 0xa1,
0x58, 0xb9, 0x82, 0x68, 0xaf, 0xaa, 0x84, 0x72, 0xd7, 0x56, 0xa2, 0x20, 0x95, 0x03, 0x16, 0x96,
0xca, 0xc9, 0x3d, 0xa2, 0x40, 0x62, 0x87, 0xd8, 0x39, 0x54, 0x50, 0x17, 0x16, 0xfe, 0x00, 0x58,
0x61, 0x62, 0x64, 0x82, 0x1d, 0x76, 0x56, 0xfe, 0x05, 0xfe, 0x10, 0x14, 0x3b, 0xa1, 0x69, 0xf9,
0xe1, 0x73, 0xd5, 0x25, 0xe7, 0xb3, 0xbf, 0xdf, 0xf7, 0x3e, 0xcf, 0x7e, 0x96, 0xf1, 0x7a, 0x2a,
0x44, 0x9a, 0x03, 0x8d, 0xb3, 0x54, 0xb1, 0x38, 0x07, 0xca, 0xe6, 0x45, 0xc6, 0xa9, 0x19, 0x2f,
0xc2, 0xdf, 0xf3, 0x7b, 0xe6, 0x2b, 0xa1, 0x5a, 0x64, 0x09, 0x04, 0x65, 0x25, 0x94, 0x20, 0x57,
0x8d, 0x39, 0xe8, 0x44, 0x81, 0x36, 0x07, 0x66, 0xbc, 0x08, 0x87, 0x57, 0xda, 0xe0, 0xac, 0xcc,
0x28, 0xe3, 0x5c, 0x28, 0xa6, 0x32, 0xc1, 0xa5, 0x71, 0x0f, 0x57, 0xdd, 0x52, 0xcf, 0x99, 0x62,
0xad, 0x73, 0x7a, 0x22, 0xe8, 0xbd, 0x02, 0xa4, 0x64, 0x29, 0x74, 0xf9, 0x2f, 0xb7, 0x51, 0xf4,
0xbf, 0xb8, 0x7e, 0x42, 0xa1, 0x28, 0xd5, 0xbe, 0x59, 0x1c, 0x7d, 0x3d, 0x8f, 0x2f, 0x46, 0x6d,
0x98, 0x87, 0xcd, 0xe7, 0x81, 0x09, 0x42, 0x3e, 0x22, 0x3c, 0x98, 0x54, 0xc0, 0x94, 0x99, 0x26,
0xa3, 0xe0, 0xff, 0x9b, 0x10, 0xf4, 0xc4, 0x33, 0x78, 0x5e, 0x83, 0x54, 0xc3, 0x6b, 0x36, 0x8f,
0x56, 0x7b, 0xe3, 0xd7, 0x3f, 0x7e, 0xbe, 0x3d, 0x73, 0xc3, 0xa3, 0x4d, 0x4d, 0xaf, 0x38, 0x2b,
0x60, 0xa3, 0xac, 0xc4, 0x53, 0x48, 0x94, 0xa4, 0x3e, 0x7d, 0x29, 0x38, 0x34, 0xbf, 0x49, 0x5e,
0x4b, 0x05, 0x95, 0xa4, 0xfe, 0x81, 0xd9, 0x01, 0x39, 0x46, 0x3e, 0xf9, 0x84, 0x30, 0xbe, 0x9b,
0x49, 0xa5, 0x23, 0x49, 0x12, 0xda, 0x32, 0x1e, 0x6a, 0x3b, 0xc8, 0x91, 0x8b, 0x45, 0x96, 0x82,
0x4b, 0xf0, 0x6e, 0x69, 0xe2, 0x90, 0xb8, 0x12, 0x93, 0xf7, 0x08, 0x9f, 0xdb, 0x06, 0x13, 0x8e,
0x50, 0x5b, 0xe6, 0x4e, 0xe9, 0xb8, 0x9f, 0x6b, 0x9a, 0x6e, 0x85, 0x84, 0x4b, 0xd2, 0xb5, 0x70,
0xd4, 0x3f, 0x20, 0xef, 0x10, 0x1e, 0x4c, 0x21, 0x87, 0xa5, 0x4f, 0xbd, 0x27, 0xee, 0x28, 0x2f,
0x75, 0x9e, 0xae, 0xe1, 0x82, 0xcd, 0xa6, 0xe1, 0x3a, 0x2c, 0xff, 0x04, 0x58, 0x1f, 0x10, 0x1e,
0xcc, 0xa0, 0xb1, 0x2c, 0x89, 0xd5, 0x13, 0xdb, 0xb0, 0x26, 0x1a, 0x6b, 0xc3, 0x5b, 0x75, 0xc6,
0x1a, 0x57, 0x3a, 0x4b, 0xd3, 0x86, 0xdf, 0x11, 0x26, 0xe6, 0x02, 0x4c, 0x44, 0x5e, 0x17, 0x7c,
0x8b, 0x15, 0x59, 0xbe, 0x4f, 0xd6, 0x96, 0xbb, 0x34, 0x7d, 0x4f, 0x87, 0x7b, 0xdd, 0x6a, 0xed,
0x99, 0xbc, 0x1d, 0x5d, 0xc4, 0xa6, 0x77, 0xdb, 0xb9, 0x08, 0x9a, 0x1c, 0xc6, 0xc9, 0xcc, 0x9d,
0xfa, 0x86, 0x30, 0x79, 0x54, 0xce, 0x8f, 0x17, 0xe3, 0x44, 0xe4, 0xc8, 0x7f, 0x4f, 0xf3, 0x6f,
0x0f, 0x23, 0x57, 0xfe, 0x63, 0xf8, 0xcd, 0xa9, 0x20, 0x9f, 0x7c, 0x41, 0x98, 0x98, 0xce, 0x74,
0x3b, 0x8e, 0x3f, 0x3d, 0xb6, 0xee, 0xb9, 0xa3, 0xc1, 0xa7, 0xfe, 0x29, 0x80, 0x93, 0xcf, 0x08,
0x5f, 0x88, 0xea, 0xfc, 0x99, 0xa1, 0x98, 0x89, 0x17, 0x92, 0xdc, 0xb4, 0x11, 0x1f, 0xd5, 0xdb,
0x68, 0xef, 0x6b, 0xda, 0x1d, 0x6f, 0x4b, 0xd3, 0x9a, 0x57, 0xc3, 0xa9, 0xe3, 0xe3, 0x23, 0xe9,
0xc6, 0xc8, 0x8f, 0xde, 0x20, 0xec, 0x25, 0xa2, 0xb0, 0x70, 0x46, 0xc3, 0xbf, 0x3d, 0x32, 0x72,
0xb7, 0xc1, 0xdb, 0x45, 0x8f, 0x27, 0xad, 0x3b, 0x15, 0x39, 0xe3, 0x69, 0x20, 0xaa, 0x94, 0xa6,
0xc0, 0x35, 0x3c, 0x35, 0x4b, 0xac, 0xcc, 0xe4, 0xbf, 0xde, 0xc1, 0x75, 0x3d, 0x88, 0xcf, 0x6a,
0xfd, 0xca, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x03, 0x65, 0xb4, 0xe0, 0xeb, 0x07, 0x00, 0x00,
}

400
vendor/google.golang.org/genproto/googleapis/bigtable/admin/table/v1/bigtable_table_service_messages.pb.go generated vendored Normal file
View File

@ -0,0 +1,400 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/table/v1/bigtable_table_service_messages.proto
package table
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type CreateTableRequest struct {
// The unique name of the cluster in which to create the new table.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The name by which the new table should be referred to within the cluster,
// e.g. "foobar" rather than "<cluster_name>/tables/foobar".
TableId string `protobuf:"bytes,2,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
// The Table to create. The `name` field of the Table and all of its
// ColumnFamilies must be left blank, and will be populated in the response.
Table *Table `protobuf:"bytes,3,opt,name=table" json:"table,omitempty"`
// The optional list of row keys that will be used to initially split the
// table into several tablets (Tablets are similar to HBase regions).
// Given two split keys, "s1" and "s2", three tablets will be created,
// spanning the key ranges: [, s1), [s1, s2), [s2, ).
//
// Example:
// * Row keys := ["a", "apple", "custom", "customer_1", "customer_2",
// "other", "zz"]
// * initial_split_keys := ["apple", "customer_1", "customer_2", "other"]
// * Key assignment:
// - Tablet 1 [, apple) => {"a"}.
// - Tablet 2 [apple, customer_1) => {"apple", "custom"}.
// - Tablet 3 [customer_1, customer_2) => {"customer_1"}.
// - Tablet 4 [customer_2, other) => {"customer_2"}.
// - Tablet 5 [other, ) => {"other", "zz"}.
InitialSplitKeys []string `protobuf:"bytes,4,rep,name=initial_split_keys,json=initialSplitKeys" json:"initial_split_keys,omitempty"`
}
func (m *CreateTableRequest) Reset() { *m = CreateTableRequest{} }
func (m *CreateTableRequest) String() string { return proto.CompactTextString(m) }
func (*CreateTableRequest) ProtoMessage() {}
func (*CreateTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *CreateTableRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *CreateTableRequest) GetTableId() string {
if m != nil {
return m.TableId
}
return ""
}
func (m *CreateTableRequest) GetTable() *Table {
if m != nil {
return m.Table
}
return nil
}
func (m *CreateTableRequest) GetInitialSplitKeys() []string {
if m != nil {
return m.InitialSplitKeys
}
return nil
}
type ListTablesRequest struct {
// The unique name of the cluster for which tables should be listed.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *ListTablesRequest) Reset() { *m = ListTablesRequest{} }
func (m *ListTablesRequest) String() string { return proto.CompactTextString(m) }
func (*ListTablesRequest) ProtoMessage() {}
func (*ListTablesRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
func (m *ListTablesRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
type ListTablesResponse struct {
// The tables present in the requested cluster.
// At present, only the names of the tables are populated.
Tables []*Table `protobuf:"bytes,1,rep,name=tables" json:"tables,omitempty"`
}
func (m *ListTablesResponse) Reset() { *m = ListTablesResponse{} }
func (m *ListTablesResponse) String() string { return proto.CompactTextString(m) }
func (*ListTablesResponse) ProtoMessage() {}
func (*ListTablesResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
func (m *ListTablesResponse) GetTables() []*Table {
if m != nil {
return m.Tables
}
return nil
}
type GetTableRequest struct {
// The unique name of the requested table.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetTableRequest) Reset() { *m = GetTableRequest{} }
func (m *GetTableRequest) String() string { return proto.CompactTextString(m) }
func (*GetTableRequest) ProtoMessage() {}
func (*GetTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
func (m *GetTableRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
type DeleteTableRequest struct {
// The unique name of the table to be deleted.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *DeleteTableRequest) Reset() { *m = DeleteTableRequest{} }
func (m *DeleteTableRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteTableRequest) ProtoMessage() {}
func (*DeleteTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
func (m *DeleteTableRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
type RenameTableRequest struct {
// The current unique name of the table.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The new name by which the table should be referred to within its containing
// cluster, e.g. "foobar" rather than "<cluster_name>/tables/foobar".
NewId string `protobuf:"bytes,2,opt,name=new_id,json=newId" json:"new_id,omitempty"`
}
func (m *RenameTableRequest) Reset() { *m = RenameTableRequest{} }
func (m *RenameTableRequest) String() string { return proto.CompactTextString(m) }
func (*RenameTableRequest) ProtoMessage() {}
func (*RenameTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }
func (m *RenameTableRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *RenameTableRequest) GetNewId() string {
if m != nil {
return m.NewId
}
return ""
}
type CreateColumnFamilyRequest struct {
// The unique name of the table in which to create the new column family.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The name by which the new column family should be referred to within the
// table, e.g. "foobar" rather than "<table_name>/columnFamilies/foobar".
ColumnFamilyId string `protobuf:"bytes,2,opt,name=column_family_id,json=columnFamilyId" json:"column_family_id,omitempty"`
// The column family to create. The `name` field must be left blank.
ColumnFamily *ColumnFamily `protobuf:"bytes,3,opt,name=column_family,json=columnFamily" json:"column_family,omitempty"`
}
func (m *CreateColumnFamilyRequest) Reset() { *m = CreateColumnFamilyRequest{} }
func (m *CreateColumnFamilyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateColumnFamilyRequest) ProtoMessage() {}
func (*CreateColumnFamilyRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }
func (m *CreateColumnFamilyRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *CreateColumnFamilyRequest) GetColumnFamilyId() string {
if m != nil {
return m.ColumnFamilyId
}
return ""
}
func (m *CreateColumnFamilyRequest) GetColumnFamily() *ColumnFamily {
if m != nil {
return m.ColumnFamily
}
return nil
}
type DeleteColumnFamilyRequest struct {
// The unique name of the column family to be deleted.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *DeleteColumnFamilyRequest) Reset() { *m = DeleteColumnFamilyRequest{} }
func (m *DeleteColumnFamilyRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteColumnFamilyRequest) ProtoMessage() {}
func (*DeleteColumnFamilyRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }
func (m *DeleteColumnFamilyRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
type BulkDeleteRowsRequest struct {
// The unique name of the table on which to perform the bulk delete
TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
// Types that are valid to be assigned to Target:
// *BulkDeleteRowsRequest_RowKeyPrefix
// *BulkDeleteRowsRequest_DeleteAllDataFromTable
Target isBulkDeleteRowsRequest_Target `protobuf_oneof:"target"`
}
func (m *BulkDeleteRowsRequest) Reset() { *m = BulkDeleteRowsRequest{} }
func (m *BulkDeleteRowsRequest) String() string { return proto.CompactTextString(m) }
func (*BulkDeleteRowsRequest) ProtoMessage() {}
func (*BulkDeleteRowsRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }
type isBulkDeleteRowsRequest_Target interface {
isBulkDeleteRowsRequest_Target()
}
type BulkDeleteRowsRequest_RowKeyPrefix struct {
RowKeyPrefix []byte `protobuf:"bytes,2,opt,name=row_key_prefix,json=rowKeyPrefix,proto3,oneof"`
}
type BulkDeleteRowsRequest_DeleteAllDataFromTable struct {
DeleteAllDataFromTable bool `protobuf:"varint,3,opt,name=delete_all_data_from_table,json=deleteAllDataFromTable,oneof"`
}
func (*BulkDeleteRowsRequest_RowKeyPrefix) isBulkDeleteRowsRequest_Target() {}
func (*BulkDeleteRowsRequest_DeleteAllDataFromTable) isBulkDeleteRowsRequest_Target() {}
func (m *BulkDeleteRowsRequest) GetTarget() isBulkDeleteRowsRequest_Target {
if m != nil {
return m.Target
}
return nil
}
func (m *BulkDeleteRowsRequest) GetTableName() string {
if m != nil {
return m.TableName
}
return ""
}
func (m *BulkDeleteRowsRequest) GetRowKeyPrefix() []byte {
if x, ok := m.GetTarget().(*BulkDeleteRowsRequest_RowKeyPrefix); ok {
return x.RowKeyPrefix
}
return nil
}
func (m *BulkDeleteRowsRequest) GetDeleteAllDataFromTable() bool {
if x, ok := m.GetTarget().(*BulkDeleteRowsRequest_DeleteAllDataFromTable); ok {
return x.DeleteAllDataFromTable
}
return false
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*BulkDeleteRowsRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _BulkDeleteRowsRequest_OneofMarshaler, _BulkDeleteRowsRequest_OneofUnmarshaler, _BulkDeleteRowsRequest_OneofSizer, []interface{}{
(*BulkDeleteRowsRequest_RowKeyPrefix)(nil),
(*BulkDeleteRowsRequest_DeleteAllDataFromTable)(nil),
}
}
func _BulkDeleteRowsRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*BulkDeleteRowsRequest)
// target
switch x := m.Target.(type) {
case *BulkDeleteRowsRequest_RowKeyPrefix:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.RowKeyPrefix)
case *BulkDeleteRowsRequest_DeleteAllDataFromTable:
t := uint64(0)
if x.DeleteAllDataFromTable {
t = 1
}
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("BulkDeleteRowsRequest.Target has unexpected type %T", x)
}
return nil
}
func _BulkDeleteRowsRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*BulkDeleteRowsRequest)
switch tag {
case 2: // target.row_key_prefix
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.Target = &BulkDeleteRowsRequest_RowKeyPrefix{x}
return true, err
case 3: // target.delete_all_data_from_table
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Target = &BulkDeleteRowsRequest_DeleteAllDataFromTable{x != 0}
return true, err
default:
return false, nil
}
}
func _BulkDeleteRowsRequest_OneofSizer(msg proto.Message) (n int) {
m := msg.(*BulkDeleteRowsRequest)
// target
switch x := m.Target.(type) {
case *BulkDeleteRowsRequest_RowKeyPrefix:
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.RowKeyPrefix)))
n += len(x.RowKeyPrefix)
case *BulkDeleteRowsRequest_DeleteAllDataFromTable:
n += proto.SizeVarint(3<<3 | proto.WireVarint)
n += 1
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
func init() {
proto.RegisterType((*CreateTableRequest)(nil), "google.bigtable.admin.table.v1.CreateTableRequest")
proto.RegisterType((*ListTablesRequest)(nil), "google.bigtable.admin.table.v1.ListTablesRequest")
proto.RegisterType((*ListTablesResponse)(nil), "google.bigtable.admin.table.v1.ListTablesResponse")
proto.RegisterType((*GetTableRequest)(nil), "google.bigtable.admin.table.v1.GetTableRequest")
proto.RegisterType((*DeleteTableRequest)(nil), "google.bigtable.admin.table.v1.DeleteTableRequest")
proto.RegisterType((*RenameTableRequest)(nil), "google.bigtable.admin.table.v1.RenameTableRequest")
proto.RegisterType((*CreateColumnFamilyRequest)(nil), "google.bigtable.admin.table.v1.CreateColumnFamilyRequest")
proto.RegisterType((*DeleteColumnFamilyRequest)(nil), "google.bigtable.admin.table.v1.DeleteColumnFamilyRequest")
proto.RegisterType((*BulkDeleteRowsRequest)(nil), "google.bigtable.admin.table.v1.BulkDeleteRowsRequest")
}
func init() {
proto.RegisterFile("google/bigtable/admin/table/v1/bigtable_table_service_messages.proto", fileDescriptor2)
}
var fileDescriptor2 = []byte{
// 514 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xc1, 0x6e, 0xd3, 0x40,
0x10, 0xad, 0x49, 0x1b, 0x92, 0x21, 0x94, 0xb2, 0x52, 0x51, 0x52, 0x09, 0x14, 0x56, 0x2a, 0xe4,
0x50, 0xd9, 0x2a, 0x5c, 0x90, 0x0a, 0x42, 0x24, 0x51, 0x69, 0x54, 0x40, 0xc1, 0xe1, 0xc4, 0xc5,
0xda, 0xc4, 0x13, 0x6b, 0xd5, 0xb5, 0x37, 0xec, 0x6e, 0x12, 0xf2, 0x13, 0x7c, 0x06, 0x27, 0xc4,
0x37, 0x22, 0xef, 0x9a, 0x26, 0x3d, 0x10, 0x97, 0x8b, 0x35, 0x9e, 0x79, 0xf3, 0x66, 0xf6, 0xcd,
0x0c, 0xf4, 0x13, 0x29, 0x13, 0x81, 0xc1, 0x98, 0x27, 0x86, 0x8d, 0x05, 0x06, 0x2c, 0x4e, 0x79,
0x16, 0x38, 0x7b, 0x71, 0x7a, 0xed, 0x8f, 0xdc, 0x57, 0xa3, 0x5a, 0xf0, 0x09, 0x46, 0x29, 0x6a,
0xcd, 0x12, 0xd4, 0xfe, 0x4c, 0x49, 0x23, 0xc9, 0x13, 0xc7, 0xe2, 0xff, 0x45, 0xfb, 0x96, 0xc5,
0x77, 0xf6, 0xe2, 0xf4, 0xe8, 0xd5, 0xff, 0x55, 0x89, 0x99, 0x61, 0x8e, 0x99, 0xfe, 0xf6, 0x80,
0xf4, 0x14, 0x32, 0x83, 0x5f, 0xf2, 0x50, 0x88, 0xdf, 0xe6, 0xa8, 0x0d, 0x21, 0xb0, 0x9b, 0xb1,
0x14, 0x9b, 0x5e, 0xdb, 0xeb, 0xd4, 0x43, 0x6b, 0x93, 0x16, 0xd4, 0x5c, 0x3a, 0x8f, 0x9b, 0x77,
0xac, 0xff, 0xae, 0xfd, 0x1f, 0xc4, 0xe4, 0x0c, 0xf6, 0xac, 0xd9, 0xac, 0xb4, 0xbd, 0xce, 0xbd,
0x17, 0xc7, 0xfe, 0xf6, 0x7e, 0x7d, 0x57, 0xcb, 0xe5, 0x90, 0x13, 0x20, 0x3c, 0xe3, 0x86, 0x33,
0x11, 0xe9, 0x99, 0xe0, 0x26, 0xba, 0xc2, 0x95, 0x6e, 0xee, 0xb6, 0x2b, 0x9d, 0x7a, 0x78, 0x50,
0x44, 0x46, 0x79, 0xe0, 0x12, 0x57, 0x9a, 0x3e, 0x87, 0x87, 0x1f, 0xb8, 0x36, 0x96, 0x41, 0x6f,
0x69, 0x97, 0x8e, 0x80, 0x6c, 0x02, 0xf5, 0x4c, 0x66, 0x1a, 0xc9, 0x1b, 0xa8, 0xda, 0xaa, 0xba,
0xe9, 0xb5, 0x2b, 0xb7, 0x6f, 0xb5, 0x48, 0xa2, 0xc7, 0xf0, 0xe0, 0x3d, 0x9a, 0x32, 0xa9, 0x68,
0x07, 0x48, 0x1f, 0x05, 0x96, 0x8b, 0x4a, 0xdf, 0x02, 0x09, 0x31, 0xb7, 0x4a, 0xe5, 0x3f, 0x84,
0x6a, 0x86, 0xcb, 0xb5, 0xf8, 0x7b, 0x19, 0x2e, 0x07, 0x31, 0xfd, 0xe5, 0x41, 0xcb, 0x0d, 0xb0,
0x27, 0xc5, 0x3c, 0xcd, 0xce, 0x59, 0xca, 0xc5, 0x6a, 0x1b, 0x51, 0x07, 0x0e, 0x26, 0x16, 0x1a,
0x4d, 0x2d, 0x76, 0x4d, 0xb9, 0x3f, 0xd9, 0xa0, 0x18, 0xc4, 0xe4, 0x33, 0xdc, 0xbf, 0x81, 0x2c,
0xc6, 0x7b, 0x52, 0xa6, 0xd9, 0x8d, 0x4e, 0x1a, 0x9b, 0xa4, 0x34, 0x80, 0x96, 0x53, 0xe6, 0x96,
0xdd, 0xd2, 0x9f, 0x1e, 0x1c, 0x76, 0xe7, 0xe2, 0xca, 0x65, 0x85, 0x72, 0x79, 0x3d, 0xf4, 0xc7,
0x00, 0x6e, 0x1f, 0x37, 0x72, 0xea, 0xd6, 0xf3, 0x29, 0x7f, 0xe6, 0x33, 0xd8, 0x57, 0x72, 0x99,
0x2f, 0x53, 0x34, 0x53, 0x38, 0xe5, 0xdf, 0xed, 0x23, 0x1b, 0x17, 0x3b, 0x61, 0x43, 0xc9, 0xe5,
0x25, 0xae, 0x86, 0xd6, 0x4b, 0x5e, 0xc3, 0x51, 0x6c, 0xb9, 0x23, 0x26, 0x84, 0x3d, 0x8d, 0x68,
0xaa, 0x64, 0x1a, 0xad, 0x17, 0xba, 0x76, 0xb1, 0x13, 0x3e, 0x72, 0x98, 0x77, 0x42, 0xf4, 0x99,
0x61, 0xe7, 0x4a, 0xa6, 0x76, 0x60, 0xdd, 0x5a, 0xbe, 0x4f, 0x2a, 0x41, 0xd3, 0xfd, 0xe1, 0x01,
0x9d, 0xc8, 0xb4, 0x44, 0x9b, 0xee, 0xd3, 0x6e, 0x11, 0xb0, 0xf9, 0x23, 0x77, 0xef, 0x1f, 0x8b,
0x73, 0x1f, 0xe6, 0x37, 0x39, 0xf4, 0xbe, 0xf6, 0x0a, 0x92, 0x44, 0x0a, 0x96, 0x25, 0xbe, 0x54,
0x49, 0x90, 0x60, 0x66, 0x2f, 0x36, 0x70, 0x21, 0x36, 0xe3, 0xfa, 0x5f, 0xe7, 0x7e, 0x66, 0x8d,
0x71, 0xd5, 0xe2, 0x5f, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x08, 0x29, 0x16, 0x83, 0x04,
0x00, 0x00,
}

1719
vendor/google.golang.org/genproto/googleapis/bigtable/admin/v2/bigtable_instance_admin.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1725
vendor/google.golang.org/genproto/googleapis/bigtable/admin/v2/bigtable_table_admin.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

70
vendor/google.golang.org/genproto/googleapis/bigtable/admin/v2/common.pb.go generated vendored Normal file
View File

@ -0,0 +1,70 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/v2/common.proto
package admin
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import _ "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Storage media types for persisting Bigtable data.
type StorageType int32
const (
// The user did not specify a storage type.
StorageType_STORAGE_TYPE_UNSPECIFIED StorageType = 0
// Flash (SSD) storage should be used.
StorageType_SSD StorageType = 1
// Magnetic drive (HDD) storage should be used.
StorageType_HDD StorageType = 2
)
var StorageType_name = map[int32]string{
0: "STORAGE_TYPE_UNSPECIFIED",
1: "SSD",
2: "HDD",
}
var StorageType_value = map[string]int32{
"STORAGE_TYPE_UNSPECIFIED": 0,
"SSD": 1,
"HDD": 2,
}
func (x StorageType) String() string {
return proto.EnumName(StorageType_name, int32(x))
}
func (StorageType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func init() {
proto.RegisterEnum("google.bigtable.admin.v2.StorageType", StorageType_name, StorageType_value)
}
func init() { proto.RegisterFile("google/bigtable/admin/v2/common.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 270 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0xd0, 0xcf, 0x4b, 0xc3, 0x30,
0x14, 0x07, 0x70, 0x3b, 0x41, 0x21, 0xbb, 0x94, 0x9e, 0xc6, 0x28, 0x7a, 0xf2, 0xe2, 0x21, 0x81,
0x7a, 0x94, 0x1d, 0xd6, 0x1f, 0xce, 0x5d, 0xb4, 0x98, 0x3a, 0x50, 0x0a, 0x23, 0xdd, 0x62, 0x08,
0x34, 0x79, 0xa1, 0xcd, 0x06, 0xfe, 0x4b, 0x1e, 0xfc, 0x43, 0xfc, 0xab, 0x64, 0x49, 0x7b, 0x12,
0x6f, 0x2f, 0xbc, 0xcf, 0xcb, 0xf7, 0x25, 0xe8, 0x46, 0x00, 0x88, 0x96, 0x93, 0x46, 0x0a, 0xcb,
0x9a, 0x96, 0x13, 0xb6, 0x57, 0x52, 0x93, 0x63, 0x42, 0x76, 0xa0, 0x14, 0x68, 0x6c, 0x3a, 0xb0,
0x10, 0xcd, 0x3c, 0xc3, 0x23, 0xc3, 0x8e, 0xe1, 0x63, 0x32, 0x8f, 0x87, 0x0b, 0x98, 0x91, 0x84,
0x69, 0x0d, 0x96, 0x59, 0x09, 0xba, 0xf7, 0x73, 0xf3, 0xeb, 0xa1, 0xeb, 0x4e, 0xcd, 0xe1, 0x83,
0x58, 0xa9, 0x78, 0x6f, 0x99, 0x32, 0x1e, 0xdc, 0x2e, 0xd0, 0x94, 0x5a, 0xe8, 0x98, 0xe0, 0xd5,
0xa7, 0xe1, 0x51, 0x8c, 0x66, 0xb4, 0x7a, 0x7e, 0x59, 0xae, 0x8a, 0x6d, 0xf5, 0x56, 0x16, 0xdb,
0xd7, 0x27, 0x5a, 0x16, 0xd9, 0xfa, 0x61, 0x5d, 0xe4, 0xe1, 0x59, 0x74, 0x89, 0xce, 0x29, 0xcd,
0xc3, 0xe0, 0x54, 0x3c, 0xe6, 0x79, 0x38, 0x49, 0xbf, 0x03, 0x14, 0xef, 0x40, 0xe1, 0xff, 0xd6,
0x4b, 0xa7, 0x99, 0x7b, 0x46, 0x79, 0x0a, 0x2b, 0x83, 0xf7, 0xc5, 0x00, 0x05, 0xb4, 0x4c, 0x0b,
0x0c, 0x9d, 0x20, 0x82, 0x6b, 0xb7, 0x0a, 0xf1, 0x2d, 0x66, 0x64, 0xff, 0xf7, 0x37, 0xee, 0x5d,
0xf1, 0x35, 0xb9, 0x5a, 0xf9, 0xf9, 0xac, 0x85, 0xc3, 0x1e, 0xa7, 0x63, 0xdc, 0xd2, 0xc5, 0x6d,
0x92, 0x9f, 0x11, 0xd4, 0x0e, 0xd4, 0x23, 0xa8, 0x1d, 0xa8, 0x37, 0x49, 0x73, 0xe1, 0xb2, 0xee,
0x7e, 0x03, 0x00, 0x00, 0xff, 0xff, 0xaf, 0x9e, 0x61, 0x6a, 0x78, 0x01, 0x00, 0x00,
}

541
vendor/google.golang.org/genproto/googleapis/bigtable/admin/v2/instance.pb.go generated vendored Normal file
View File

@ -0,0 +1,541 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/v2/instance.proto
package admin
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Possible states of an instance.
type Instance_State int32
const (
// The state of the instance could not be determined.
Instance_STATE_NOT_KNOWN Instance_State = 0
// The instance has been successfully created and can serve requests
// to its tables.
Instance_READY Instance_State = 1
// The instance is currently being created, and may be destroyed
// if the creation process encounters an error.
Instance_CREATING Instance_State = 2
)
var Instance_State_name = map[int32]string{
0: "STATE_NOT_KNOWN",
1: "READY",
2: "CREATING",
}
var Instance_State_value = map[string]int32{
"STATE_NOT_KNOWN": 0,
"READY": 1,
"CREATING": 2,
}
func (x Instance_State) String() string {
return proto.EnumName(Instance_State_name, int32(x))
}
func (Instance_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{0, 0} }
// The type of the instance.
type Instance_Type int32
const (
// The type of the instance is unspecified. If set when creating an
// instance, a `PRODUCTION` instance will be created. If set when updating
// an instance, the type will be left unchanged.
Instance_TYPE_UNSPECIFIED Instance_Type = 0
// An instance meant for production use. `serve_nodes` must be set
// on the cluster.
Instance_PRODUCTION Instance_Type = 1
// The instance is meant for development and testing purposes only; it has
// no performance or uptime guarantees and is not covered by SLA.
// After a development instance is created, it can be upgraded by
// updating the instance to type `PRODUCTION`. An instance created
// as a production instance cannot be changed to a development instance.
// When creating a development instance, `serve_nodes` on the cluster must
// not be set.
Instance_DEVELOPMENT Instance_Type = 2
)
var Instance_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "PRODUCTION",
2: "DEVELOPMENT",
}
var Instance_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"PRODUCTION": 1,
"DEVELOPMENT": 2,
}
func (x Instance_Type) String() string {
return proto.EnumName(Instance_Type_name, int32(x))
}
func (Instance_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{0, 1} }
// Possible states of a cluster.
type Cluster_State int32
const (
// The state of the cluster could not be determined.
Cluster_STATE_NOT_KNOWN Cluster_State = 0
// The cluster has been successfully created and is ready to serve requests.
Cluster_READY Cluster_State = 1
// The cluster is currently being created, and may be destroyed
// if the creation process encounters an error.
// A cluster may not be able to serve requests while being created.
Cluster_CREATING Cluster_State = 2
// The cluster is currently being resized, and may revert to its previous
// node count if the process encounters an error.
// A cluster is still capable of serving requests while being resized,
// but may exhibit performance as if its number of allocated nodes is
// between the starting and requested states.
Cluster_RESIZING Cluster_State = 3
// The cluster has no backing nodes. The data (tables) still
// exist, but no operations can be performed on the cluster.
Cluster_DISABLED Cluster_State = 4
)
var Cluster_State_name = map[int32]string{
0: "STATE_NOT_KNOWN",
1: "READY",
2: "CREATING",
3: "RESIZING",
4: "DISABLED",
}
var Cluster_State_value = map[string]int32{
"STATE_NOT_KNOWN": 0,
"READY": 1,
"CREATING": 2,
"RESIZING": 3,
"DISABLED": 4,
}
func (x Cluster_State) String() string {
return proto.EnumName(Cluster_State_name, int32(x))
}
func (Cluster_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{1, 0} }
// A collection of Bigtable [Tables][google.bigtable.admin.v2.Table] and
// the resources that serve them.
// All tables in an instance are served from a single
// [Cluster][google.bigtable.admin.v2.Cluster].
type Instance struct {
// (`OutputOnly`)
// The unique name of the instance. Values are of the form
// `projects/<project>/instances/[a-z][a-z0-9\\-]+[a-z0-9]`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The descriptive name for this instance as it appears in UIs.
// Can be changed at any time, but should be kept globally unique
// to avoid confusion.
DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
// (`OutputOnly`)
// The current state of the instance.
State Instance_State `protobuf:"varint,3,opt,name=state,enum=google.bigtable.admin.v2.Instance_State" json:"state,omitempty"`
// The type of the instance. Defaults to `PRODUCTION`.
Type Instance_Type `protobuf:"varint,4,opt,name=type,enum=google.bigtable.admin.v2.Instance_Type" json:"type,omitempty"`
// Labels are a flexible and lightweight mechanism for organizing cloud
// resources into groups that reflect a customer's organizational needs and
// deployment strategies. They can be used to filter resources and aggregate
// metrics.
//
// * Label keys must be between 1 and 63 characters long and must conform to
// the regular expression: `[\p{Ll}\p{Lo}][\p{Ll}\p{Lo}\p{N}_-]{0,62}`.
// * Label values must be between 0 and 63 characters long and must conform to
// the regular expression: `[\p{Ll}\p{Lo}\p{N}_-]{0,63}`.
// * No more than 64 labels can be associated with a given resource.
// * Keys and values must both be under 128 bytes.
Labels map[string]string `protobuf:"bytes,5,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}
func (m *Instance) Reset() { *m = Instance{} }
func (m *Instance) String() string { return proto.CompactTextString(m) }
func (*Instance) ProtoMessage() {}
func (*Instance) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
func (m *Instance) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Instance) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
func (m *Instance) GetState() Instance_State {
if m != nil {
return m.State
}
return Instance_STATE_NOT_KNOWN
}
func (m *Instance) GetType() Instance_Type {
if m != nil {
return m.Type
}
return Instance_TYPE_UNSPECIFIED
}
func (m *Instance) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
// A resizable group of nodes in a particular cloud location, capable
// of serving all [Tables][google.bigtable.admin.v2.Table] in the parent
// [Instance][google.bigtable.admin.v2.Instance].
type Cluster struct {
// (`OutputOnly`)
// The unique name of the cluster. Values are of the form
// `projects/<project>/instances/<instance>/clusters/[a-z][-a-z0-9]*`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// (`CreationOnly`)
// The location where this cluster's nodes and storage reside. For best
// performance, clients should be located as close as possible to this
// cluster. Currently only zones are supported, so values should be of the
// form `projects/<project>/locations/<zone>`.
Location string `protobuf:"bytes,2,opt,name=location" json:"location,omitempty"`
// (`OutputOnly`)
// The current state of the cluster.
State Cluster_State `protobuf:"varint,3,opt,name=state,enum=google.bigtable.admin.v2.Cluster_State" json:"state,omitempty"`
// The number of nodes allocated to this cluster. More nodes enable higher
// throughput and more consistent performance.
ServeNodes int32 `protobuf:"varint,4,opt,name=serve_nodes,json=serveNodes" json:"serve_nodes,omitempty"`
// (`CreationOnly`)
// The type of storage used by this cluster to serve its
// parent instance's tables, unless explicitly overridden.
DefaultStorageType StorageType `protobuf:"varint,5,opt,name=default_storage_type,json=defaultStorageType,enum=google.bigtable.admin.v2.StorageType" json:"default_storage_type,omitempty"`
}
func (m *Cluster) Reset() { *m = Cluster{} }
func (m *Cluster) String() string { return proto.CompactTextString(m) }
func (*Cluster) ProtoMessage() {}
func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
func (m *Cluster) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Cluster) GetLocation() string {
if m != nil {
return m.Location
}
return ""
}
func (m *Cluster) GetState() Cluster_State {
if m != nil {
return m.State
}
return Cluster_STATE_NOT_KNOWN
}
func (m *Cluster) GetServeNodes() int32 {
if m != nil {
return m.ServeNodes
}
return 0
}
func (m *Cluster) GetDefaultStorageType() StorageType {
if m != nil {
return m.DefaultStorageType
}
return StorageType_STORAGE_TYPE_UNSPECIFIED
}
// This is a private alpha release of Cloud Bigtable replication. This feature
// is not currently available to most Cloud Bigtable customers. This feature
// might be changed in backward-incompatible ways and is not recommended for
// production use. It is not subject to any SLA or deprecation policy.
//
// A configuration object describing how Cloud Bigtable should treat traffic
// from a particular end user application.
type AppProfile struct {
// (`OutputOnly`)
// The unique name of the app profile. Values are of the form
// `projects/<project>/instances/<instance>/appProfiles/[_a-zA-Z0-9][-_.a-zA-Z0-9]*`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Strongly validated etag for optimistic concurrency control. Preserve the
// value returned from `GetAppProfile` when calling `UpdateAppProfile` to
// fail the request if there has been a modification in the mean time. The
// `update_mask` of the request need not include `etag` for this protection
// to apply.
// See [Wikipedia](https://en.wikipedia.org/wiki/HTTP_ETag) and
// [RFC 7232](https://tools.ietf.org/html/rfc7232#section-2.3) for more
// details.
Etag string `protobuf:"bytes,2,opt,name=etag" json:"etag,omitempty"`
// Optional long form description of the use case for this AppProfile.
Description string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"`
// The routing policy for all read/write requests which use this app profile.
// A value must be explicitly set.
//
// Types that are valid to be assigned to RoutingPolicy:
// *AppProfile_MultiClusterRoutingUseAny_
// *AppProfile_SingleClusterRouting_
RoutingPolicy isAppProfile_RoutingPolicy `protobuf_oneof:"routing_policy"`
}
func (m *AppProfile) Reset() { *m = AppProfile{} }
func (m *AppProfile) String() string { return proto.CompactTextString(m) }
func (*AppProfile) ProtoMessage() {}
func (*AppProfile) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
type isAppProfile_RoutingPolicy interface {
isAppProfile_RoutingPolicy()
}
type AppProfile_MultiClusterRoutingUseAny_ struct {
MultiClusterRoutingUseAny *AppProfile_MultiClusterRoutingUseAny `protobuf:"bytes,5,opt,name=multi_cluster_routing_use_any,json=multiClusterRoutingUseAny,oneof"`
}
type AppProfile_SingleClusterRouting_ struct {
SingleClusterRouting *AppProfile_SingleClusterRouting `protobuf:"bytes,6,opt,name=single_cluster_routing,json=singleClusterRouting,oneof"`
}
func (*AppProfile_MultiClusterRoutingUseAny_) isAppProfile_RoutingPolicy() {}
func (*AppProfile_SingleClusterRouting_) isAppProfile_RoutingPolicy() {}
func (m *AppProfile) GetRoutingPolicy() isAppProfile_RoutingPolicy {
if m != nil {
return m.RoutingPolicy
}
return nil
}
func (m *AppProfile) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *AppProfile) GetEtag() string {
if m != nil {
return m.Etag
}
return ""
}
func (m *AppProfile) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *AppProfile) GetMultiClusterRoutingUseAny() *AppProfile_MultiClusterRoutingUseAny {
if x, ok := m.GetRoutingPolicy().(*AppProfile_MultiClusterRoutingUseAny_); ok {
return x.MultiClusterRoutingUseAny
}
return nil
}
func (m *AppProfile) GetSingleClusterRouting() *AppProfile_SingleClusterRouting {
if x, ok := m.GetRoutingPolicy().(*AppProfile_SingleClusterRouting_); ok {
return x.SingleClusterRouting
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*AppProfile) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _AppProfile_OneofMarshaler, _AppProfile_OneofUnmarshaler, _AppProfile_OneofSizer, []interface{}{
(*AppProfile_MultiClusterRoutingUseAny_)(nil),
(*AppProfile_SingleClusterRouting_)(nil),
}
}
func _AppProfile_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*AppProfile)
// routing_policy
switch x := m.RoutingPolicy.(type) {
case *AppProfile_MultiClusterRoutingUseAny_:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.MultiClusterRoutingUseAny); err != nil {
return err
}
case *AppProfile_SingleClusterRouting_:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.SingleClusterRouting); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("AppProfile.RoutingPolicy has unexpected type %T", x)
}
return nil
}
func _AppProfile_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*AppProfile)
switch tag {
case 5: // routing_policy.multi_cluster_routing_use_any
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(AppProfile_MultiClusterRoutingUseAny)
err := b.DecodeMessage(msg)
m.RoutingPolicy = &AppProfile_MultiClusterRoutingUseAny_{msg}
return true, err
case 6: // routing_policy.single_cluster_routing
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(AppProfile_SingleClusterRouting)
err := b.DecodeMessage(msg)
m.RoutingPolicy = &AppProfile_SingleClusterRouting_{msg}
return true, err
default:
return false, nil
}
}
func _AppProfile_OneofSizer(msg proto.Message) (n int) {
m := msg.(*AppProfile)
// routing_policy
switch x := m.RoutingPolicy.(type) {
case *AppProfile_MultiClusterRoutingUseAny_:
s := proto.Size(x.MultiClusterRoutingUseAny)
n += proto.SizeVarint(5<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *AppProfile_SingleClusterRouting_:
s := proto.Size(x.SingleClusterRouting)
n += proto.SizeVarint(6<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Read/write requests may be routed to any cluster in the instance, and will
// fail over to another cluster in the event of transient errors or delays.
// Choosing this option sacrifices read-your-writes consistency to improve
// availability.
type AppProfile_MultiClusterRoutingUseAny struct {
}
func (m *AppProfile_MultiClusterRoutingUseAny) Reset() { *m = AppProfile_MultiClusterRoutingUseAny{} }
func (m *AppProfile_MultiClusterRoutingUseAny) String() string { return proto.CompactTextString(m) }
func (*AppProfile_MultiClusterRoutingUseAny) ProtoMessage() {}
func (*AppProfile_MultiClusterRoutingUseAny) Descriptor() ([]byte, []int) {
return fileDescriptor3, []int{2, 0}
}
// Unconditionally routes all read/write requests to a specific cluster.
// This option preserves read-your-writes consistency, but does not improve
// availability.
type AppProfile_SingleClusterRouting struct {
// The cluster to which read/write requests should be routed.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"`
// Whether or not `CheckAndMutateRow` and `ReadModifyWriteRow` requests are
// allowed by this app profile. It is unsafe to send these requests to
// the same table/row/column in multiple clusters.
AllowTransactionalWrites bool `protobuf:"varint,2,opt,name=allow_transactional_writes,json=allowTransactionalWrites" json:"allow_transactional_writes,omitempty"`
}
func (m *AppProfile_SingleClusterRouting) Reset() { *m = AppProfile_SingleClusterRouting{} }
func (m *AppProfile_SingleClusterRouting) String() string { return proto.CompactTextString(m) }
func (*AppProfile_SingleClusterRouting) ProtoMessage() {}
func (*AppProfile_SingleClusterRouting) Descriptor() ([]byte, []int) {
return fileDescriptor3, []int{2, 1}
}
func (m *AppProfile_SingleClusterRouting) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *AppProfile_SingleClusterRouting) GetAllowTransactionalWrites() bool {
if m != nil {
return m.AllowTransactionalWrites
}
return false
}
func init() {
proto.RegisterType((*Instance)(nil), "google.bigtable.admin.v2.Instance")
proto.RegisterType((*Cluster)(nil), "google.bigtable.admin.v2.Cluster")
proto.RegisterType((*AppProfile)(nil), "google.bigtable.admin.v2.AppProfile")
proto.RegisterType((*AppProfile_MultiClusterRoutingUseAny)(nil), "google.bigtable.admin.v2.AppProfile.MultiClusterRoutingUseAny")
proto.RegisterType((*AppProfile_SingleClusterRouting)(nil), "google.bigtable.admin.v2.AppProfile.SingleClusterRouting")
proto.RegisterEnum("google.bigtable.admin.v2.Instance_State", Instance_State_name, Instance_State_value)
proto.RegisterEnum("google.bigtable.admin.v2.Instance_Type", Instance_Type_name, Instance_Type_value)
proto.RegisterEnum("google.bigtable.admin.v2.Cluster_State", Cluster_State_name, Cluster_State_value)
}
func init() { proto.RegisterFile("google/bigtable/admin/v2/instance.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 765 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xdd, 0x8e, 0xdb, 0x44,
0x14, 0x8e, 0xf3, 0xb3, 0x64, 0x4f, 0xca, 0xd6, 0x1a, 0x22, 0x94, 0x86, 0x16, 0x42, 0xa4, 0xaa,
0xb9, 0x72, 0xa4, 0x20, 0x24, 0x4a, 0xd9, 0x4a, 0xf9, 0x71, 0x5b, 0x8b, 0xad, 0x13, 0x1c, 0xef,
0xae, 0xba, 0x8a, 0x64, 0x4d, 0xec, 0x59, 0xcb, 0x62, 0x32, 0x63, 0x3c, 0x93, 0xac, 0x7c, 0xcb,
0xe3, 0x70, 0xc5, 0x1d, 0x4f, 0xc0, 0x0d, 0x8f, 0xc3, 0x13, 0x20, 0x8f, 0x6d, 0x76, 0x17, 0x12,
0xb4, 0xe2, 0x6e, 0xce, 0x39, 0xdf, 0x77, 0xbe, 0x33, 0xdf, 0xb1, 0x07, 0x5e, 0x84, 0x9c, 0x87,
0x94, 0x0c, 0xd7, 0x51, 0x28, 0xf1, 0x9a, 0x92, 0x21, 0x0e, 0x36, 0x11, 0x1b, 0xee, 0x46, 0xc3,
0x88, 0x09, 0x89, 0x99, 0x4f, 0x8c, 0x38, 0xe1, 0x92, 0xa3, 0x4e, 0x0e, 0x34, 0x4a, 0xa0, 0xa1,
0x80, 0xc6, 0x6e, 0xd4, 0x7d, 0x5a, 0xb4, 0xc0, 0x71, 0x34, 0xc4, 0x8c, 0x71, 0x89, 0x65, 0xc4,
0x99, 0xc8, 0x79, 0xdd, 0xe7, 0x07, 0x05, 0x7c, 0xbe, 0xd9, 0x70, 0x96, 0xc3, 0xfa, 0xbf, 0xd5,
0xa0, 0x69, 0x15, 0x8a, 0x08, 0x41, 0x9d, 0xe1, 0x0d, 0xe9, 0x68, 0x3d, 0x6d, 0x70, 0xec, 0xa8,
0x33, 0xfa, 0x12, 0x1e, 0x05, 0x91, 0x88, 0x29, 0x4e, 0x3d, 0x55, 0xab, 0xaa, 0x5a, 0xab, 0xc8,
0xd9, 0x19, 0xe4, 0x35, 0x34, 0x84, 0xc4, 0x92, 0x74, 0x6a, 0x3d, 0x6d, 0x70, 0x32, 0x1a, 0x18,
0x87, 0x46, 0x36, 0x4a, 0x25, 0x63, 0x99, 0xe1, 0x9d, 0x9c, 0x86, 0x5e, 0x41, 0x5d, 0xa6, 0x31,
0xe9, 0xd4, 0x15, 0xfd, 0xc5, 0x03, 0xe8, 0x6e, 0x1a, 0x13, 0x47, 0x91, 0xd0, 0x1b, 0x38, 0xa2,
0x78, 0x4d, 0xa8, 0xe8, 0x34, 0x7a, 0xb5, 0x41, 0x6b, 0x64, 0x3c, 0x80, 0x7e, 0xa6, 0x08, 0x26,
0x93, 0x49, 0xea, 0x14, 0xec, 0xee, 0x4b, 0x68, 0xdd, 0x49, 0x23, 0x1d, 0x6a, 0x3f, 0x92, 0xb4,
0x70, 0x22, 0x3b, 0xa2, 0x36, 0x34, 0x76, 0x98, 0x6e, 0x4b, 0x07, 0xf2, 0xe0, 0xdb, 0xea, 0x37,
0x5a, 0xff, 0x6b, 0x68, 0xa8, 0xfb, 0xa0, 0x4f, 0xe0, 0xf1, 0xd2, 0x1d, 0xbb, 0xa6, 0x67, 0xcf,
0x5d, 0xef, 0x7b, 0x7b, 0x7e, 0x69, 0xeb, 0x15, 0x74, 0x0c, 0x0d, 0xc7, 0x1c, 0xcf, 0x3e, 0xe8,
0x1a, 0x7a, 0x04, 0xcd, 0xa9, 0x63, 0x8e, 0x5d, 0xcb, 0x7e, 0xab, 0x57, 0xfb, 0xa7, 0x50, 0xcf,
0xee, 0x81, 0xda, 0xa0, 0xbb, 0x1f, 0x16, 0xa6, 0x77, 0x6e, 0x2f, 0x17, 0xe6, 0xd4, 0x7a, 0x63,
0x99, 0x33, 0xbd, 0x82, 0x4e, 0x00, 0x16, 0xce, 0x7c, 0x76, 0x3e, 0x75, 0xad, 0xb9, 0xad, 0x6b,
0xe8, 0x31, 0xb4, 0x66, 0xe6, 0x85, 0x79, 0x36, 0x5f, 0xbc, 0x37, 0x6d, 0x57, 0xaf, 0xf6, 0x7f,
0xaf, 0xc2, 0x47, 0x53, 0xba, 0x15, 0x92, 0x24, 0x7b, 0x17, 0xd7, 0x85, 0x26, 0xe5, 0xbe, 0xfa,
0x26, 0x8a, 0x91, 0xff, 0x8e, 0xd1, 0xe9, 0xfd, 0x8d, 0xfd, 0x87, 0xe5, 0x85, 0xc2, 0xfd, 0x85,
0x7d, 0x01, 0x2d, 0x41, 0x92, 0x1d, 0xf1, 0x18, 0x0f, 0x88, 0x50, 0x7b, 0x6b, 0x38, 0xa0, 0x52,
0x76, 0x96, 0x41, 0x97, 0xd0, 0x0e, 0xc8, 0x35, 0xde, 0x52, 0xe9, 0x09, 0xc9, 0x13, 0x1c, 0x12,
0x4f, 0x6d, 0xb8, 0xa1, 0xe4, 0x9e, 0x1f, 0x96, 0x5b, 0xe6, 0x68, 0xb5, 0x5f, 0x54, 0xb4, 0xb8,
0x93, 0xeb, 0xff, 0xf0, 0xbf, 0xac, 0xce, 0x22, 0xc7, 0x5c, 0x5a, 0x57, 0x59, 0x54, 0xcb, 0xa2,
0x99, 0xb5, 0x1c, 0x4f, 0xce, 0xcc, 0x99, 0x5e, 0xef, 0xff, 0x59, 0x03, 0x18, 0xc7, 0xf1, 0x22,
0xe1, 0xd7, 0x11, 0xdd, 0xff, 0x0f, 0x20, 0xa8, 0x13, 0x89, 0xc3, 0xc2, 0x46, 0x75, 0x46, 0x3d,
0x68, 0x05, 0x44, 0xf8, 0x49, 0x14, 0x2b, 0x87, 0x6b, 0xc5, 0x6f, 0x71, 0x9b, 0x42, 0x3f, 0x6b,
0xf0, 0x6c, 0xb3, 0xa5, 0x32, 0xf2, 0xfc, 0xdc, 0x44, 0x2f, 0xe1, 0x5b, 0x19, 0xb1, 0xd0, 0xdb,
0x0a, 0xe2, 0x61, 0x96, 0x2a, 0x3b, 0x5a, 0xa3, 0xd7, 0x87, 0xed, 0xb8, 0x9d, 0xcb, 0x78, 0x9f,
0x75, 0x2a, 0xb6, 0xe1, 0xe4, 0x7d, 0xce, 0x05, 0x19, 0xb3, 0xf4, 0x5d, 0xc5, 0x79, 0xb2, 0x39,
0x54, 0x44, 0x3f, 0xc1, 0xa7, 0x22, 0x62, 0x21, 0x25, 0xff, 0x1c, 0xa2, 0x73, 0xa4, 0xc4, 0x5f,
0x3e, 0x48, 0x7c, 0xa9, 0x5a, 0xdc, 0x17, 0x78, 0x57, 0x71, 0xda, 0x62, 0x4f, 0xbe, 0xfb, 0x19,
0x3c, 0x39, 0x38, 0x6c, 0x57, 0x40, 0x7b, 0x5f, 0x33, 0xf4, 0x0c, 0xa0, 0x1c, 0x30, 0x0a, 0x0a,
0xf3, 0x8f, 0x8b, 0x8c, 0x15, 0xa0, 0xef, 0xa0, 0x8b, 0x29, 0xe5, 0x37, 0x9e, 0x4c, 0x30, 0x13,
0xd8, 0xcf, 0x0c, 0xc6, 0xd4, 0xbb, 0x49, 0x22, 0x49, 0x84, 0xda, 0x4b, 0xd3, 0xe9, 0x28, 0x84,
0x7b, 0x17, 0x70, 0xa9, 0xea, 0x13, 0x1d, 0x4e, 0x4a, 0xeb, 0x63, 0x4e, 0x23, 0x3f, 0x9d, 0xfc,
0xaa, 0xc1, 0x53, 0x9f, 0x6f, 0x0e, 0x5e, 0x7e, 0xf2, 0x71, 0xf9, 0x58, 0x2c, 0xb2, 0x67, 0x72,
0xa1, 0x5d, 0x9d, 0x16, 0xd0, 0x90, 0x53, 0xcc, 0x42, 0x83, 0x27, 0xe1, 0x30, 0x24, 0x4c, 0x3d,
0xa2, 0xc3, 0xbc, 0x84, 0xe3, 0x48, 0xfc, 0xfb, 0xb9, 0x7d, 0xa5, 0x0e, 0xbf, 0x54, 0x3f, 0x7f,
0x9b, 0xf3, 0xa7, 0x94, 0x6f, 0x03, 0x63, 0x52, 0x0a, 0x8e, 0x95, 0xe0, 0xc5, 0xe8, 0x8f, 0x12,
0xb0, 0x52, 0x80, 0x55, 0x09, 0x58, 0x29, 0xc0, 0xea, 0x62, 0xb4, 0x3e, 0x52, 0x5a, 0x5f, 0xfd,
0x15, 0x00, 0x00, 0xff, 0xff, 0xd9, 0x04, 0x3d, 0xfc, 0x3a, 0x06, 0x00, 0x00,
}

666
vendor/google.golang.org/genproto/googleapis/bigtable/admin/v2/table.pb.go generated vendored Normal file
View File

@ -0,0 +1,666 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/admin/v2/table.proto
package admin
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf5 "github.com/golang/protobuf/ptypes/duration"
import google_protobuf1 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Possible timestamp granularities to use when keeping multiple versions
// of data in a table.
type Table_TimestampGranularity int32
const (
// The user did not specify a granularity. Should not be returned.
// When specified during table creation, MILLIS will be used.
Table_TIMESTAMP_GRANULARITY_UNSPECIFIED Table_TimestampGranularity = 0
// The table keeps data versioned at a granularity of 1ms.
Table_MILLIS Table_TimestampGranularity = 1
)
var Table_TimestampGranularity_name = map[int32]string{
0: "TIMESTAMP_GRANULARITY_UNSPECIFIED",
1: "MILLIS",
}
var Table_TimestampGranularity_value = map[string]int32{
"TIMESTAMP_GRANULARITY_UNSPECIFIED": 0,
"MILLIS": 1,
}
func (x Table_TimestampGranularity) String() string {
return proto.EnumName(Table_TimestampGranularity_name, int32(x))
}
func (Table_TimestampGranularity) EnumDescriptor() ([]byte, []int) {
return fileDescriptor4, []int{0, 0}
}
// Defines a view over a table's fields.
type Table_View int32
const (
// Uses the default view for each method as documented in its request.
Table_VIEW_UNSPECIFIED Table_View = 0
// Only populates `name`.
Table_NAME_ONLY Table_View = 1
// Only populates `name` and fields related to the table's schema.
Table_SCHEMA_VIEW Table_View = 2
// This is a private alpha release of Cloud Bigtable replication. This
// feature is not currently available to most Cloud Bigtable customers. This
// feature might be changed in backward-incompatible ways and is not
// recommended for production use. It is not subject to any SLA or
// deprecation policy.
//
// Only populates `name` and fields related to the table's
// replication state.
Table_REPLICATION_VIEW Table_View = 3
// Populates all fields.
Table_FULL Table_View = 4
)
var Table_View_name = map[int32]string{
0: "VIEW_UNSPECIFIED",
1: "NAME_ONLY",
2: "SCHEMA_VIEW",
3: "REPLICATION_VIEW",
4: "FULL",
}
var Table_View_value = map[string]int32{
"VIEW_UNSPECIFIED": 0,
"NAME_ONLY": 1,
"SCHEMA_VIEW": 2,
"REPLICATION_VIEW": 3,
"FULL": 4,
}
func (x Table_View) String() string {
return proto.EnumName(Table_View_name, int32(x))
}
func (Table_View) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 1} }
// Table replication states.
type Table_ClusterState_ReplicationState int32
const (
// The replication state of the table is unknown in this cluster.
Table_ClusterState_STATE_NOT_KNOWN Table_ClusterState_ReplicationState = 0
// The cluster was recently created, and the table must finish copying
// over pre-existing data from other clusters before it can begin
// receiving live replication updates and serving
// [Data API][google.bigtable.v2.Bigtable] requests.
Table_ClusterState_INITIALIZING Table_ClusterState_ReplicationState = 1
// The table is temporarily unable to serve
// [Data API][google.bigtable.v2.Bigtable] requests from this
// cluster due to planned internal maintenance.
Table_ClusterState_PLANNED_MAINTENANCE Table_ClusterState_ReplicationState = 2
// The table is temporarily unable to serve
// [Data API][google.bigtable.v2.Bigtable] requests from this
// cluster due to unplanned or emergency maintenance.
Table_ClusterState_UNPLANNED_MAINTENANCE Table_ClusterState_ReplicationState = 3
// The table can serve
// [Data API][google.bigtable.v2.Bigtable] requests from this
// cluster. Depending on replication delay, reads may not immediately
// reflect the state of the table in other clusters.
Table_ClusterState_READY Table_ClusterState_ReplicationState = 4
)
var Table_ClusterState_ReplicationState_name = map[int32]string{
0: "STATE_NOT_KNOWN",
1: "INITIALIZING",
2: "PLANNED_MAINTENANCE",
3: "UNPLANNED_MAINTENANCE",
4: "READY",
}
var Table_ClusterState_ReplicationState_value = map[string]int32{
"STATE_NOT_KNOWN": 0,
"INITIALIZING": 1,
"PLANNED_MAINTENANCE": 2,
"UNPLANNED_MAINTENANCE": 3,
"READY": 4,
}
func (x Table_ClusterState_ReplicationState) String() string {
return proto.EnumName(Table_ClusterState_ReplicationState_name, int32(x))
}
func (Table_ClusterState_ReplicationState) EnumDescriptor() ([]byte, []int) {
return fileDescriptor4, []int{0, 0, 0}
}
// Possible states of a snapshot.
type Snapshot_State int32
const (
// The state of the snapshot could not be determined.
Snapshot_STATE_NOT_KNOWN Snapshot_State = 0
// The snapshot has been successfully created and can serve all requests.
Snapshot_READY Snapshot_State = 1
// The snapshot is currently being created, and may be destroyed if the
// creation process encounters an error. A snapshot may not be restored to a
// table while it is being created.
Snapshot_CREATING Snapshot_State = 2
)
var Snapshot_State_name = map[int32]string{
0: "STATE_NOT_KNOWN",
1: "READY",
2: "CREATING",
}
var Snapshot_State_value = map[string]int32{
"STATE_NOT_KNOWN": 0,
"READY": 1,
"CREATING": 2,
}
func (x Snapshot_State) String() string {
return proto.EnumName(Snapshot_State_name, int32(x))
}
func (Snapshot_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{3, 0} }
// A collection of user data indexed by row, column, and timestamp.
// Each table is served using the resources of its parent cluster.
type Table struct {
// (`OutputOnly`)
// The unique name of the table. Values are of the form
// `projects/<project>/instances/<instance>/tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]*`.
// Views: `NAME_ONLY`, `SCHEMA_VIEW`, `FULL`
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// This is a private alpha release of Cloud Bigtable replication. This feature
// is not currently available to most Cloud Bigtable customers. This feature
// might be changed in backward-incompatible ways and is not recommended for
// production use. It is not subject to any SLA or deprecation policy.
//
// (`OutputOnly`)
// Map from cluster ID to per-cluster table state.
// If it could not be determined whether or not the table has data in a
// particular cluster (for example, if its zone is unavailable), then
// there will be an entry for the cluster with UNKNOWN `replication_status`.
// Views: `FULL`
ClusterStates map[string]*Table_ClusterState `protobuf:"bytes,2,rep,name=cluster_states,json=clusterStates" json:"cluster_states,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// (`CreationOnly`)
// The column families configured for this table, mapped by column family ID.
// Views: `SCHEMA_VIEW`, `FULL`
ColumnFamilies map[string]*ColumnFamily `protobuf:"bytes,3,rep,name=column_families,json=columnFamilies" json:"column_families,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// (`CreationOnly`)
// The granularity (e.g. `MILLIS`, `MICROS`) at which timestamps are stored in
// this table. Timestamps not matching the granularity will be rejected.
// If unspecified at creation time, the value will be set to `MILLIS`.
// Views: `SCHEMA_VIEW`, `FULL`
Granularity Table_TimestampGranularity `protobuf:"varint,4,opt,name=granularity,enum=google.bigtable.admin.v2.Table_TimestampGranularity" json:"granularity,omitempty"`
}
func (m *Table) Reset() { *m = Table{} }
func (m *Table) String() string { return proto.CompactTextString(m) }
func (*Table) ProtoMessage() {}
func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
func (m *Table) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Table) GetClusterStates() map[string]*Table_ClusterState {
if m != nil {
return m.ClusterStates
}
return nil
}
func (m *Table) GetColumnFamilies() map[string]*ColumnFamily {
if m != nil {
return m.ColumnFamilies
}
return nil
}
func (m *Table) GetGranularity() Table_TimestampGranularity {
if m != nil {
return m.Granularity
}
return Table_TIMESTAMP_GRANULARITY_UNSPECIFIED
}
// This is a private alpha release of Cloud Bigtable replication. This feature
// is not currently available to most Cloud Bigtable customers. This feature
// might be changed in backward-incompatible ways and is not recommended for
// production use. It is not subject to any SLA or deprecation policy.
//
// The state of a table's data in a particular cluster.
type Table_ClusterState struct {
// (`OutputOnly`)
// The state of replication for the table in this cluster.
ReplicationState Table_ClusterState_ReplicationState `protobuf:"varint,1,opt,name=replication_state,json=replicationState,enum=google.bigtable.admin.v2.Table_ClusterState_ReplicationState" json:"replication_state,omitempty"`
}
func (m *Table_ClusterState) Reset() { *m = Table_ClusterState{} }
func (m *Table_ClusterState) String() string { return proto.CompactTextString(m) }
func (*Table_ClusterState) ProtoMessage() {}
func (*Table_ClusterState) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0, 0} }
func (m *Table_ClusterState) GetReplicationState() Table_ClusterState_ReplicationState {
if m != nil {
return m.ReplicationState
}
return Table_ClusterState_STATE_NOT_KNOWN
}
// A set of columns within a table which share a common configuration.
type ColumnFamily struct {
// Garbage collection rule specified as a protobuf.
// Must serialize to at most 500 bytes.
//
// NOTE: Garbage collection executes opportunistically in the background, and
// so it's possible for reads to return a cell even if it matches the active
// GC expression for its family.
GcRule *GcRule `protobuf:"bytes,1,opt,name=gc_rule,json=gcRule" json:"gc_rule,omitempty"`
}
func (m *ColumnFamily) Reset() { *m = ColumnFamily{} }
func (m *ColumnFamily) String() string { return proto.CompactTextString(m) }
func (*ColumnFamily) ProtoMessage() {}
func (*ColumnFamily) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
func (m *ColumnFamily) GetGcRule() *GcRule {
if m != nil {
return m.GcRule
}
return nil
}
// Rule for determining which cells to delete during garbage collection.
type GcRule struct {
// Garbage collection rules.
//
// Types that are valid to be assigned to Rule:
// *GcRule_MaxNumVersions
// *GcRule_MaxAge
// *GcRule_Intersection_
// *GcRule_Union_
Rule isGcRule_Rule `protobuf_oneof:"rule"`
}
func (m *GcRule) Reset() { *m = GcRule{} }
func (m *GcRule) String() string { return proto.CompactTextString(m) }
func (*GcRule) ProtoMessage() {}
func (*GcRule) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} }
type isGcRule_Rule interface {
isGcRule_Rule()
}
type GcRule_MaxNumVersions struct {
MaxNumVersions int32 `protobuf:"varint,1,opt,name=max_num_versions,json=maxNumVersions,oneof"`
}
type GcRule_MaxAge struct {
MaxAge *google_protobuf5.Duration `protobuf:"bytes,2,opt,name=max_age,json=maxAge,oneof"`
}
type GcRule_Intersection_ struct {
Intersection *GcRule_Intersection `protobuf:"bytes,3,opt,name=intersection,oneof"`
}
type GcRule_Union_ struct {
Union *GcRule_Union `protobuf:"bytes,4,opt,name=union,oneof"`
}
func (*GcRule_MaxNumVersions) isGcRule_Rule() {}
func (*GcRule_MaxAge) isGcRule_Rule() {}
func (*GcRule_Intersection_) isGcRule_Rule() {}
func (*GcRule_Union_) isGcRule_Rule() {}
func (m *GcRule) GetRule() isGcRule_Rule {
if m != nil {
return m.Rule
}
return nil
}
func (m *GcRule) GetMaxNumVersions() int32 {
if x, ok := m.GetRule().(*GcRule_MaxNumVersions); ok {
return x.MaxNumVersions
}
return 0
}
func (m *GcRule) GetMaxAge() *google_protobuf5.Duration {
if x, ok := m.GetRule().(*GcRule_MaxAge); ok {
return x.MaxAge
}
return nil
}
func (m *GcRule) GetIntersection() *GcRule_Intersection {
if x, ok := m.GetRule().(*GcRule_Intersection_); ok {
return x.Intersection
}
return nil
}
func (m *GcRule) GetUnion() *GcRule_Union {
if x, ok := m.GetRule().(*GcRule_Union_); ok {
return x.Union
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*GcRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _GcRule_OneofMarshaler, _GcRule_OneofUnmarshaler, _GcRule_OneofSizer, []interface{}{
(*GcRule_MaxNumVersions)(nil),
(*GcRule_MaxAge)(nil),
(*GcRule_Intersection_)(nil),
(*GcRule_Union_)(nil),
}
}
func _GcRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*GcRule)
// rule
switch x := m.Rule.(type) {
case *GcRule_MaxNumVersions:
b.EncodeVarint(1<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.MaxNumVersions))
case *GcRule_MaxAge:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.MaxAge); err != nil {
return err
}
case *GcRule_Intersection_:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Intersection); err != nil {
return err
}
case *GcRule_Union_:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Union); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("GcRule.Rule has unexpected type %T", x)
}
return nil
}
func _GcRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*GcRule)
switch tag {
case 1: // rule.max_num_versions
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Rule = &GcRule_MaxNumVersions{int32(x)}
return true, err
case 2: // rule.max_age
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(google_protobuf5.Duration)
err := b.DecodeMessage(msg)
m.Rule = &GcRule_MaxAge{msg}
return true, err
case 3: // rule.intersection
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(GcRule_Intersection)
err := b.DecodeMessage(msg)
m.Rule = &GcRule_Intersection_{msg}
return true, err
case 4: // rule.union
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(GcRule_Union)
err := b.DecodeMessage(msg)
m.Rule = &GcRule_Union_{msg}
return true, err
default:
return false, nil
}
}
func _GcRule_OneofSizer(msg proto.Message) (n int) {
m := msg.(*GcRule)
// rule
switch x := m.Rule.(type) {
case *GcRule_MaxNumVersions:
n += proto.SizeVarint(1<<3 | proto.WireVarint)
n += proto.SizeVarint(uint64(x.MaxNumVersions))
case *GcRule_MaxAge:
s := proto.Size(x.MaxAge)
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *GcRule_Intersection_:
s := proto.Size(x.Intersection)
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *GcRule_Union_:
s := proto.Size(x.Union)
n += proto.SizeVarint(4<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// A GcRule which deletes cells matching all of the given rules.
type GcRule_Intersection struct {
// Only delete cells which would be deleted by every element of `rules`.
Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *GcRule_Intersection) Reset() { *m = GcRule_Intersection{} }
func (m *GcRule_Intersection) String() string { return proto.CompactTextString(m) }
func (*GcRule_Intersection) ProtoMessage() {}
func (*GcRule_Intersection) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2, 0} }
func (m *GcRule_Intersection) GetRules() []*GcRule {
if m != nil {
return m.Rules
}
return nil
}
// A GcRule which deletes cells matching any of the given rules.
type GcRule_Union struct {
// Delete cells which would be deleted by any element of `rules`.
Rules []*GcRule `protobuf:"bytes,1,rep,name=rules" json:"rules,omitempty"`
}
func (m *GcRule_Union) Reset() { *m = GcRule_Union{} }
func (m *GcRule_Union) String() string { return proto.CompactTextString(m) }
func (*GcRule_Union) ProtoMessage() {}
func (*GcRule_Union) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2, 1} }
func (m *GcRule_Union) GetRules() []*GcRule {
if m != nil {
return m.Rules
}
return nil
}
// This is a private alpha release of Cloud Bigtable snapshots. This feature
// is not currently available to most Cloud Bigtable customers. This feature
// might be changed in backward-incompatible ways and is not recommended for
// production use. It is not subject to any SLA or deprecation policy.
//
// A snapshot of a table at a particular time. A snapshot can be used as a
// checkpoint for data restoration or a data source for a new table.
type Snapshot struct {
// (`OutputOnly`)
// The unique name of the snapshot.
// Values are of the form
// `projects/<project>/instances/<instance>/clusters/<cluster>/snapshots/<snapshot>`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// (`OutputOnly`)
// The source table at the time the snapshot was taken.
SourceTable *Table `protobuf:"bytes,2,opt,name=source_table,json=sourceTable" json:"source_table,omitempty"`
// (`OutputOnly`)
// The size of the data in the source table at the time the snapshot was
// taken. In some cases, this value may be computed asynchronously via a
// background process and a placeholder of 0 will be used in the meantime.
DataSizeBytes int64 `protobuf:"varint,3,opt,name=data_size_bytes,json=dataSizeBytes" json:"data_size_bytes,omitempty"`
// (`OutputOnly`)
// The time when the snapshot is created.
CreateTime *google_protobuf1.Timestamp `protobuf:"bytes,4,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
// (`OutputOnly`)
// The time when the snapshot will be deleted. The maximum amount of time a
// snapshot can stay active is 365 days. If 'ttl' is not specified,
// the default maximum of 365 days will be used.
DeleteTime *google_protobuf1.Timestamp `protobuf:"bytes,5,opt,name=delete_time,json=deleteTime" json:"delete_time,omitempty"`
// (`OutputOnly`)
// The current state of the snapshot.
State Snapshot_State `protobuf:"varint,6,opt,name=state,enum=google.bigtable.admin.v2.Snapshot_State" json:"state,omitempty"`
// (`OutputOnly`)
// Description of the snapshot.
Description string `protobuf:"bytes,7,opt,name=description" json:"description,omitempty"`
}
func (m *Snapshot) Reset() { *m = Snapshot{} }
func (m *Snapshot) String() string { return proto.CompactTextString(m) }
func (*Snapshot) ProtoMessage() {}
func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{3} }
func (m *Snapshot) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Snapshot) GetSourceTable() *Table {
if m != nil {
return m.SourceTable
}
return nil
}
func (m *Snapshot) GetDataSizeBytes() int64 {
if m != nil {
return m.DataSizeBytes
}
return 0
}
func (m *Snapshot) GetCreateTime() *google_protobuf1.Timestamp {
if m != nil {
return m.CreateTime
}
return nil
}
func (m *Snapshot) GetDeleteTime() *google_protobuf1.Timestamp {
if m != nil {
return m.DeleteTime
}
return nil
}
func (m *Snapshot) GetState() Snapshot_State {
if m != nil {
return m.State
}
return Snapshot_STATE_NOT_KNOWN
}
func (m *Snapshot) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*Table)(nil), "google.bigtable.admin.v2.Table")
proto.RegisterType((*Table_ClusterState)(nil), "google.bigtable.admin.v2.Table.ClusterState")
proto.RegisterType((*ColumnFamily)(nil), "google.bigtable.admin.v2.ColumnFamily")
proto.RegisterType((*GcRule)(nil), "google.bigtable.admin.v2.GcRule")
proto.RegisterType((*GcRule_Intersection)(nil), "google.bigtable.admin.v2.GcRule.Intersection")
proto.RegisterType((*GcRule_Union)(nil), "google.bigtable.admin.v2.GcRule.Union")
proto.RegisterType((*Snapshot)(nil), "google.bigtable.admin.v2.Snapshot")
proto.RegisterEnum("google.bigtable.admin.v2.Table_TimestampGranularity", Table_TimestampGranularity_name, Table_TimestampGranularity_value)
proto.RegisterEnum("google.bigtable.admin.v2.Table_View", Table_View_name, Table_View_value)
proto.RegisterEnum("google.bigtable.admin.v2.Table_ClusterState_ReplicationState", Table_ClusterState_ReplicationState_name, Table_ClusterState_ReplicationState_value)
proto.RegisterEnum("google.bigtable.admin.v2.Snapshot_State", Snapshot_State_name, Snapshot_State_value)
}
func init() { proto.RegisterFile("google/bigtable/admin/v2/table.proto", fileDescriptor4) }
var fileDescriptor4 = []byte{
// 965 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xff, 0x6e, 0xdb, 0x54,
0x18, 0xad, 0xe3, 0x38, 0x6d, 0xbf, 0xa4, 0xad, 0xb9, 0x1d, 0x22, 0x8b, 0xa6, 0x2d, 0x44, 0x30,
0x45, 0x08, 0x1c, 0xc9, 0x1b, 0x08, 0x18, 0x1b, 0x72, 0x52, 0xb7, 0xb5, 0x48, 0xdc, 0xc8, 0x71,
0x32, 0x75, 0x8a, 0x64, 0xdd, 0x38, 0x77, 0xc6, 0xe0, 0x1f, 0x91, 0x7f, 0x94, 0x66, 0x4f, 0xc1,
0x0b, 0xf0, 0x37, 0x12, 0x12, 0x2f, 0xc2, 0xf3, 0xf0, 0x00, 0xc8, 0xf7, 0xda, 0x5b, 0xda, 0x26,
0x84, 0xf1, 0x57, 0xaf, 0xbf, 0x7b, 0xce, 0xf9, 0xfc, 0x9d, 0x7b, 0x7d, 0x1a, 0xf8, 0xc4, 0x09,
0x43, 0xc7, 0x23, 0x9d, 0x99, 0xeb, 0x24, 0x78, 0xe6, 0x91, 0x0e, 0x9e, 0xfb, 0x6e, 0xd0, 0xb9,
0x92, 0x3b, 0xf4, 0x51, 0x5a, 0x44, 0x61, 0x12, 0xa2, 0x3a, 0x43, 0x49, 0x05, 0x4a, 0xa2, 0x28,
0xe9, 0x4a, 0x6e, 0x3c, 0xc8, 0xf9, 0x78, 0xe1, 0x76, 0x70, 0x10, 0x84, 0x09, 0x4e, 0xdc, 0x30,
0x88, 0x19, 0xaf, 0xf1, 0x30, 0xdf, 0xa5, 0x4f, 0xb3, 0xf4, 0x75, 0x67, 0x9e, 0x46, 0x14, 0x90,
0xef, 0x3f, 0xba, 0xbd, 0x9f, 0xb8, 0x3e, 0x89, 0x13, 0xec, 0x2f, 0x18, 0xa0, 0xf5, 0xfb, 0x2e,
0x08, 0x66, 0xd6, 0x11, 0x21, 0x28, 0x07, 0xd8, 0x27, 0x75, 0xae, 0xc9, 0xb5, 0xf7, 0x0d, 0xba,
0x46, 0x97, 0x70, 0x68, 0x7b, 0x69, 0x9c, 0x90, 0xc8, 0x8a, 0x13, 0x9c, 0x90, 0xb8, 0x5e, 0x6a,
0xf2, 0xed, 0xaa, 0x2c, 0x4b, 0x9b, 0xde, 0x57, 0xa2, 0x62, 0x52, 0x8f, 0xb1, 0x46, 0x94, 0xa4,
0x06, 0x49, 0xb4, 0x34, 0x0e, 0xec, 0xd5, 0x1a, 0x9a, 0xc2, 0x91, 0x1d, 0x7a, 0xa9, 0x1f, 0x58,
0xaf, 0xb1, 0xef, 0x7a, 0x2e, 0x89, 0xeb, 0x3c, 0xd5, 0x7e, 0xb2, 0x55, 0x9b, 0xd2, 0x4e, 0x73,
0x16, 0x13, 0x3f, 0xb4, 0x6f, 0x14, 0xd1, 0x04, 0xaa, 0x4e, 0x84, 0x83, 0xd4, 0xc3, 0x91, 0x9b,
0x2c, 0xeb, 0xe5, 0x26, 0xd7, 0x3e, 0x94, 0x9f, 0x6e, 0x53, 0x36, 0x0b, 0x73, 0xce, 0xde, 0x71,
0x8d, 0x55, 0xa1, 0xc6, 0xdf, 0x1c, 0xd4, 0x56, 0x67, 0x43, 0x3f, 0xc1, 0x07, 0x11, 0x59, 0x78,
0xae, 0x4d, 0x5d, 0x67, 0x2e, 0x51, 0x0b, 0x0f, 0xe5, 0xe7, 0xef, 0x63, 0x92, 0x64, 0xbc, 0x53,
0xa1, 0x05, 0x43, 0x8c, 0x6e, 0x55, 0x5a, 0xd7, 0x20, 0xde, 0x46, 0xa1, 0x63, 0x38, 0x1a, 0x99,
0x8a, 0xa9, 0x5a, 0xfa, 0x85, 0x69, 0xfd, 0xa0, 0x5f, 0xbc, 0xd4, 0xc5, 0x1d, 0x24, 0x42, 0x4d,
0xd3, 0x35, 0x53, 0x53, 0xfa, 0xda, 0x2b, 0x4d, 0x3f, 0x13, 0x39, 0xf4, 0x11, 0x1c, 0x0f, 0xfb,
0x8a, 0xae, 0xab, 0x27, 0xd6, 0x40, 0xd1, 0x74, 0x53, 0xd5, 0x15, 0xbd, 0xa7, 0x8a, 0x25, 0x74,
0x1f, 0x3e, 0x1c, 0xeb, 0xeb, 0xb6, 0x78, 0xb4, 0x0f, 0x82, 0xa1, 0x2a, 0x27, 0x97, 0x62, 0xb9,
0x11, 0x00, 0xba, 0x7b, 0xa2, 0x48, 0x04, 0xfe, 0x67, 0xb2, 0xcc, 0x2f, 0x4c, 0xb6, 0x44, 0x5d,
0x10, 0xae, 0xb0, 0x97, 0x92, 0x7a, 0xa9, 0xc9, 0xb5, 0xab, 0xf2, 0xe7, 0xef, 0xe3, 0x80, 0xc1,
0xa8, 0xdf, 0x96, 0xbe, 0xe6, 0x1a, 0x2e, 0x1c, 0xaf, 0x39, 0xe5, 0x35, 0x0d, 0xbf, 0xbb, 0xd9,
0xf0, 0xf1, 0xe6, 0x86, 0x2b, 0x7a, 0xcb, 0x95, 0x56, 0x2d, 0x0d, 0xee, 0xad, 0x3b, 0x76, 0xf4,
0x29, 0x7c, 0x6c, 0x6a, 0x03, 0x75, 0x64, 0x2a, 0x83, 0xa1, 0x75, 0x66, 0x28, 0xfa, 0xb8, 0xaf,
0x18, 0x9a, 0x79, 0x69, 0x8d, 0xf5, 0xd1, 0x50, 0xed, 0x69, 0xa7, 0x9a, 0x7a, 0x22, 0xee, 0x20,
0x80, 0xca, 0x40, 0xeb, 0xf7, 0xb5, 0x91, 0xc8, 0xb5, 0xa6, 0x50, 0x9e, 0xb8, 0xe4, 0x17, 0x74,
0x0f, 0xc4, 0x89, 0xa6, 0xbe, 0xbc, 0x85, 0x3c, 0x80, 0x7d, 0x5d, 0x19, 0xa8, 0xd6, 0x85, 0xde,
0xbf, 0x14, 0x39, 0x74, 0x04, 0xd5, 0x51, 0xef, 0x5c, 0x1d, 0x28, 0x56, 0x86, 0x15, 0x4b, 0x19,
0xcb, 0x50, 0x87, 0x7d, 0xad, 0xa7, 0x98, 0xda, 0x85, 0xce, 0xaa, 0x3c, 0xda, 0x83, 0xf2, 0xe9,
0xb8, 0xdf, 0x17, 0xcb, 0x2d, 0x0d, 0x6a, 0xab, 0x33, 0xa0, 0x6f, 0x60, 0xd7, 0xb1, 0xad, 0x28,
0xf5, 0xd8, 0x7d, 0xab, 0xca, 0xcd, 0xcd, 0xc3, 0x9f, 0xd9, 0x46, 0xea, 0x11, 0xa3, 0xe2, 0xd0,
0xbf, 0xad, 0x5f, 0x79, 0xa8, 0xb0, 0x12, 0xfa, 0x0c, 0x44, 0x1f, 0x5f, 0x5b, 0x41, 0xea, 0x5b,
0x57, 0x24, 0x8a, 0xb3, 0x68, 0xa1, 0x72, 0xc2, 0xf9, 0x8e, 0x71, 0xe8, 0xe3, 0x6b, 0x3d, 0xf5,
0x27, 0x79, 0x1d, 0x3d, 0x85, 0xdd, 0x0c, 0x8b, 0x9d, 0xc2, 0xee, 0xfb, 0x45, 0xc7, 0x22, 0x5e,
0xa4, 0x93, 0x3c, 0x7e, 0xce, 0x77, 0x8c, 0x8a, 0x8f, 0xaf, 0x15, 0x87, 0xa0, 0x11, 0xd4, 0xdc,
0x20, 0x21, 0x51, 0x4c, 0xec, 0x6c, 0xa7, 0xce, 0x53, 0xea, 0x17, 0xdb, 0x5e, 0x56, 0xd2, 0x56,
0x48, 0xe7, 0x3b, 0xc6, 0x0d, 0x11, 0xf4, 0x02, 0x84, 0x34, 0xc8, 0xd4, 0xca, 0xdb, 0xce, 0x3d,
0x57, 0x1b, 0x07, 0x4c, 0x86, 0xd1, 0x1a, 0xa7, 0x50, 0x5b, 0xd5, 0x47, 0x5f, 0x81, 0x90, 0x39,
0x99, 0xcd, 0xce, 0xff, 0x27, 0x2b, 0x19, 0xbc, 0xf1, 0x3d, 0x08, 0x54, 0xf9, 0xff, 0x0a, 0x74,
0x2b, 0x50, 0xce, 0x16, 0xad, 0xdf, 0x78, 0xd8, 0x1b, 0x05, 0x78, 0x11, 0xff, 0x18, 0x26, 0x6b,
0xa3, 0xb8, 0x0b, 0xb5, 0x38, 0x4c, 0x23, 0x9b, 0x58, 0x54, 0x2f, 0x3f, 0x81, 0x47, 0x5b, 0xbe,
0x30, 0xa3, 0xca, 0x48, 0x2c, 0xe2, 0x1f, 0xc3, 0xd1, 0x1c, 0x27, 0xd8, 0x8a, 0xdd, 0x37, 0xc4,
0x9a, 0x2d, 0x13, 0x9a, 0xb9, 0x5c, 0x9b, 0x37, 0x0e, 0xb2, 0xf2, 0xc8, 0x7d, 0x43, 0xba, 0x59,
0x11, 0x3d, 0x83, 0xaa, 0x1d, 0x11, 0x9c, 0x10, 0x2b, 0xfb, 0x77, 0x91, 0x7b, 0xdc, 0xb8, 0x73,
0xd8, 0x6f, 0xbf, 0x1b, 0x03, 0x18, 0x3c, 0x2b, 0x64, 0xe4, 0x39, 0xf1, 0x48, 0x41, 0x16, 0xb6,
0x93, 0x19, 0x9c, 0x92, 0x5f, 0x80, 0xc0, 0x22, 0xb4, 0x42, 0x23, 0xb4, 0xbd, 0x79, 0xbc, 0xc2,
0x2c, 0x29, 0x0f, 0x0f, 0x4a, 0x43, 0xcd, 0xac, 0x79, 0x6c, 0x47, 0xee, 0x82, 0xde, 0xb5, 0x5d,
0x6a, 0xe0, 0x6a, 0xa9, 0xf5, 0x25, 0x08, 0xff, 0x92, 0x9c, 0x6f, 0x33, 0x8f, 0x43, 0x35, 0xd8,
0xeb, 0x19, 0xaa, 0x62, 0x66, 0x01, 0x5a, 0xea, 0xfe, 0xc9, 0xc1, 0x03, 0x3b, 0xf4, 0x37, 0xbe,
0x4f, 0x17, 0xa8, 0xc5, 0xc3, 0x6c, 0xbc, 0x21, 0xf7, 0xea, 0x79, 0x8e, 0x73, 0x42, 0x0f, 0x07,
0x8e, 0x14, 0x46, 0x4e, 0xc7, 0x21, 0x01, 0x1d, 0xbe, 0xc3, 0xb6, 0xf0, 0xc2, 0x8d, 0xef, 0xfe,
0x28, 0x78, 0x46, 0x17, 0x7f, 0x94, 0x1e, 0x9e, 0x31, 0x7e, 0xcf, 0x0b, 0xd3, 0xb9, 0xd4, 0x2d,
0xba, 0x29, 0xb4, 0xdb, 0x44, 0xfe, 0xab, 0x00, 0x4c, 0x29, 0x60, 0x5a, 0x00, 0xa6, 0x14, 0x30,
0x9d, 0xc8, 0xb3, 0x0a, 0xed, 0xf5, 0xe4, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0x59, 0xa7,
0xc1, 0x7f, 0x08, 0x00, 0x00,
}

1980
vendor/google.golang.org/genproto/googleapis/bigtable/v1/bigtable_data.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

387
vendor/google.golang.org/genproto/googleapis/bigtable/v1/bigtable_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,387 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/v1/bigtable_service.proto
package bigtable
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for BigtableService service
type BigtableServiceClient interface {
// Streams back the contents of all requested rows, optionally applying
// the same Reader filter to each. Depending on their size, rows may be
// broken up across multiple responses, but atomicity of each row will still
// be preserved.
ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (BigtableService_ReadRowsClient, error)
// Returns a sample of row keys in the table. The returned row keys will
// delimit contiguous sections of the table of approximately equal size,
// which can be used to break up the data for distributed tasks like
// mapreduces.
SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (BigtableService_SampleRowKeysClient, error)
// Mutates a row atomically. Cells already present in the row are left
// unchanged unless explicitly changed by 'mutation'.
MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
// Mutates multiple rows in a batch. Each individual row is mutated
// atomically as in MutateRow, but the entire batch is not executed
// atomically.
MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (*MutateRowsResponse, error)
// Mutates a row atomically based on the output of a predicate Reader filter.
CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error)
// Modifies a row atomically, reading the latest existing timestamp/value from
// the specified columns and writing a new value at
// max(existing timestamp, current server time) based on pre-defined
// read/modify/write rules. Returns the new contents of all modified cells.
ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*Row, error)
}
type bigtableServiceClient struct {
cc *grpc.ClientConn
}
func NewBigtableServiceClient(cc *grpc.ClientConn) BigtableServiceClient {
return &bigtableServiceClient{cc}
}
func (c *bigtableServiceClient) ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (BigtableService_ReadRowsClient, error) {
stream, err := grpc.NewClientStream(ctx, &_BigtableService_serviceDesc.Streams[0], c.cc, "/google.bigtable.v1.BigtableService/ReadRows", opts...)
if err != nil {
return nil, err
}
x := &bigtableServiceReadRowsClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BigtableService_ReadRowsClient interface {
Recv() (*ReadRowsResponse, error)
grpc.ClientStream
}
type bigtableServiceReadRowsClient struct {
grpc.ClientStream
}
func (x *bigtableServiceReadRowsClient) Recv() (*ReadRowsResponse, error) {
m := new(ReadRowsResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *bigtableServiceClient) SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (BigtableService_SampleRowKeysClient, error) {
stream, err := grpc.NewClientStream(ctx, &_BigtableService_serviceDesc.Streams[1], c.cc, "/google.bigtable.v1.BigtableService/SampleRowKeys", opts...)
if err != nil {
return nil, err
}
x := &bigtableServiceSampleRowKeysClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BigtableService_SampleRowKeysClient interface {
Recv() (*SampleRowKeysResponse, error)
grpc.ClientStream
}
type bigtableServiceSampleRowKeysClient struct {
grpc.ClientStream
}
func (x *bigtableServiceSampleRowKeysClient) Recv() (*SampleRowKeysResponse, error) {
m := new(SampleRowKeysResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *bigtableServiceClient) MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
out := new(google_protobuf2.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/MutateRow", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableServiceClient) MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (*MutateRowsResponse, error) {
out := new(MutateRowsResponse)
err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/MutateRows", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableServiceClient) CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error) {
out := new(CheckAndMutateRowResponse)
err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/CheckAndMutateRow", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableServiceClient) ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*Row, error) {
out := new(Row)
err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/ReadModifyWriteRow", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for BigtableService service
type BigtableServiceServer interface {
// Streams back the contents of all requested rows, optionally applying
// the same Reader filter to each. Depending on their size, rows may be
// broken up across multiple responses, but atomicity of each row will still
// be preserved.
ReadRows(*ReadRowsRequest, BigtableService_ReadRowsServer) error
// Returns a sample of row keys in the table. The returned row keys will
// delimit contiguous sections of the table of approximately equal size,
// which can be used to break up the data for distributed tasks like
// mapreduces.
SampleRowKeys(*SampleRowKeysRequest, BigtableService_SampleRowKeysServer) error
// Mutates a row atomically. Cells already present in the row are left
// unchanged unless explicitly changed by 'mutation'.
MutateRow(context.Context, *MutateRowRequest) (*google_protobuf2.Empty, error)
// Mutates multiple rows in a batch. Each individual row is mutated
// atomically as in MutateRow, but the entire batch is not executed
// atomically.
MutateRows(context.Context, *MutateRowsRequest) (*MutateRowsResponse, error)
// Mutates a row atomically based on the output of a predicate Reader filter.
CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error)
// Modifies a row atomically, reading the latest existing timestamp/value from
// the specified columns and writing a new value at
// max(existing timestamp, current server time) based on pre-defined
// read/modify/write rules. Returns the new contents of all modified cells.
ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*Row, error)
}
func RegisterBigtableServiceServer(s *grpc.Server, srv BigtableServiceServer) {
s.RegisterService(&_BigtableService_serviceDesc, srv)
}
func _BigtableService_ReadRows_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ReadRowsRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BigtableServiceServer).ReadRows(m, &bigtableServiceReadRowsServer{stream})
}
type BigtableService_ReadRowsServer interface {
Send(*ReadRowsResponse) error
grpc.ServerStream
}
type bigtableServiceReadRowsServer struct {
grpc.ServerStream
}
func (x *bigtableServiceReadRowsServer) Send(m *ReadRowsResponse) error {
return x.ServerStream.SendMsg(m)
}
func _BigtableService_SampleRowKeys_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(SampleRowKeysRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BigtableServiceServer).SampleRowKeys(m, &bigtableServiceSampleRowKeysServer{stream})
}
type BigtableService_SampleRowKeysServer interface {
Send(*SampleRowKeysResponse) error
grpc.ServerStream
}
type bigtableServiceSampleRowKeysServer struct {
grpc.ServerStream
}
func (x *bigtableServiceSampleRowKeysServer) Send(m *SampleRowKeysResponse) error {
return x.ServerStream.SendMsg(m)
}
func _BigtableService_MutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MutateRowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableServiceServer).MutateRow(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.v1.BigtableService/MutateRow",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableServiceServer).MutateRow(ctx, req.(*MutateRowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableService_MutateRows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MutateRowsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableServiceServer).MutateRows(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.v1.BigtableService/MutateRows",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableServiceServer).MutateRows(ctx, req.(*MutateRowsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableService_CheckAndMutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CheckAndMutateRowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableServiceServer).CheckAndMutateRow(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.v1.BigtableService/CheckAndMutateRow",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableServiceServer).CheckAndMutateRow(ctx, req.(*CheckAndMutateRowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BigtableService_ReadModifyWriteRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReadModifyWriteRowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BigtableServiceServer).ReadModifyWriteRow(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bigtable.v1.BigtableService/ReadModifyWriteRow",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BigtableServiceServer).ReadModifyWriteRow(ctx, req.(*ReadModifyWriteRowRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BigtableService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.bigtable.v1.BigtableService",
HandlerType: (*BigtableServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "MutateRow",
Handler: _BigtableService_MutateRow_Handler,
},
{
MethodName: "MutateRows",
Handler: _BigtableService_MutateRows_Handler,
},
{
MethodName: "CheckAndMutateRow",
Handler: _BigtableService_CheckAndMutateRow_Handler,
},
{
MethodName: "ReadModifyWriteRow",
Handler: _BigtableService_ReadModifyWriteRow_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "ReadRows",
Handler: _BigtableService_ReadRows_Handler,
ServerStreams: true,
},
{
StreamName: "SampleRowKeys",
Handler: _BigtableService_SampleRowKeys_Handler,
ServerStreams: true,
},
},
Metadata: "google/bigtable/v1/bigtable_service.proto",
}
func init() { proto.RegisterFile("google/bigtable/v1/bigtable_service.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 521 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcd, 0x6e, 0xd4, 0x30,
0x10, 0xc7, 0x65, 0x0e, 0xa8, 0x58, 0x42, 0x08, 0x4b, 0x14, 0x69, 0xe1, 0x14, 0xa0, 0xa2, 0x11,
0x8d, 0xdb, 0x72, 0x0b, 0xe2, 0xd0, 0x45, 0x50, 0x21, 0x58, 0x51, 0xa5, 0xe2, 0x43, 0xe5, 0xb0,
0x78, 0x93, 0x69, 0x08, 0x4d, 0xe2, 0x60, 0x7b, 0x37, 0x5a, 0xaa, 0x5e, 0x38, 0x71, 0xe7, 0x11,
0x10, 0x17, 0x5e, 0x80, 0x23, 0xef, 0x00, 0x67, 0x6e, 0x3c, 0x08, 0xb2, 0x63, 0x2f, 0x2c, 0x0d,
0xcb, 0x8a, 0xee, 0x29, 0x8e, 0xe6, 0x3f, 0x33, 0xbf, 0xff, 0xf8, 0x03, 0xaf, 0xa6, 0x9c, 0xa7,
0x39, 0xd0, 0x41, 0x96, 0x2a, 0x36, 0xc8, 0x81, 0x8e, 0x36, 0x26, 0xeb, 0xbe, 0x04, 0x31, 0xca,
0x62, 0x08, 0x2a, 0xc1, 0x15, 0x27, 0xa4, 0x91, 0x06, 0x2e, 0x1c, 0x8c, 0x36, 0x3a, 0x97, 0x6d,
0x3a, 0xab, 0x32, 0xca, 0xca, 0x92, 0x2b, 0xa6, 0x32, 0x5e, 0xca, 0x26, 0xa3, 0xb3, 0x32, 0xab,
0x78, 0xc2, 0x14, 0xb3, 0xba, 0xcd, 0x39, 0x20, 0xfa, 0x05, 0x48, 0xc9, 0x52, 0x70, 0xb5, 0x2f,
0xd9, 0x1c, 0xf3, 0x37, 0x18, 0xee, 0x53, 0x28, 0x2a, 0x35, 0x6e, 0x82, 0x9b, 0xdf, 0x97, 0xf0,
0xb9, 0xae, 0x2d, 0xb0, 0xdb, 0xe4, 0x93, 0x8f, 0x08, 0x2f, 0x45, 0xc0, 0x92, 0x88, 0xd7, 0x92,
0x5c, 0x09, 0x8e, 0x9b, 0x09, 0x5c, 0x34, 0x82, 0xd7, 0x43, 0x90, 0xaa, 0x73, 0x75, 0xb6, 0x48,
0x56, 0xbc, 0x94, 0xe0, 0x3d, 0x7c, 0xfb, 0xed, 0xc7, 0xfb, 0x53, 0xf7, 0xbc, 0x2d, 0x4d, 0x7d,
0xd8, 0x30, 0x97, 0xac, 0x80, 0xdb, 0x95, 0xe0, 0xaf, 0x20, 0x56, 0x92, 0xfa, 0xf4, 0x0d, 0x2f,
0x41, 0x7f, 0xe3, 0x7c, 0x28, 0x15, 0x08, 0xbd, 0x34, 0x42, 0x49, 0xfd, 0x23, 0x2a, 0x78, 0x2d,
0x43, 0x01, 0x2c, 0x09, 0x91, 0xbf, 0x8e, 0xc8, 0x67, 0x84, 0xcf, 0xee, 0xb2, 0xa2, 0xca, 0x21,
0xe2, 0xf5, 0x03, 0x18, 0x4b, 0x72, 0xbd, 0x8d, 0x63, 0x4a, 0xe2, 0x88, 0x57, 0xe7, 0x50, 0x5a,
0xec, 0x47, 0x06, 0xfb, 0x3e, 0xd9, 0x3e, 0x11, 0xb6, 0x34, 0xb5, 0x75, 0xe1, 0x75, 0x44, 0x3e,
0x20, 0x7c, 0xa6, 0x37, 0x54, 0x4c, 0xe9, 0x66, 0xa4, 0x75, 0x7a, 0x93, 0xb0, 0x23, 0x5e, 0x76,
0x2a, 0xb7, 0x8f, 0xc1, 0x5d, 0xbd, 0x8f, 0xde, 0x33, 0x83, 0x17, 0x79, 0xbd, 0x93, 0xe0, 0xd1,
0x43, 0xc1, 0xeb, 0xfe, 0x01, 0x8c, 0x8f, 0xc2, 0xc2, 0x34, 0x0e, 0x91, 0x4f, 0x3e, 0x21, 0x8c,
0x27, 0x18, 0x92, 0x5c, 0x9b, 0x89, 0x39, 0x99, 0xec, 0xca, 0xbf, 0x64, 0x76, 0xac, 0x3d, 0xc3,
0xbd, 0xed, 0x75, 0xff, 0x93, 0xdb, 0x82, 0xea, 0x9a, 0x1a, 0xf6, 0x2b, 0xc2, 0xe7, 0xef, 0xbc,
0x84, 0xf8, 0x60, 0xab, 0x4c, 0x7e, 0x8d, 0xf6, 0x46, 0x1b, 0xcc, 0x31, 0x99, 0x43, 0x5f, 0x9b,
0x53, 0x6d, 0x1d, 0xbc, 0x30, 0x0e, 0xf6, 0xbc, 0xc7, 0x0b, 0x9a, 0x7c, 0x3c, 0xd5, 0x49, 0x9b,
0xfa, 0x82, 0x30, 0xd1, 0xd7, 0xa8, 0xc7, 0x93, 0x6c, 0x7f, 0xfc, 0x54, 0x64, 0x8d, 0xab, 0xb5,
0xbf, 0x5d, 0xb7, 0x69, 0x9d, 0xb3, 0x75, 0xb1, 0x55, 0xce, 0x6b, 0x8f, 0x19, 0x03, 0xcf, 0xbd,
0x27, 0x0b, 0x32, 0x20, 0xa6, 0x11, 0x42, 0xe4, 0x77, 0x2b, 0xbc, 0x1c, 0xf3, 0xa2, 0x05, 0xa0,
0x7b, 0xe1, 0x8f, 0x67, 0x47, 0xee, 0xe8, 0x73, 0xbd, 0x83, 0xf6, 0x42, 0x2b, 0x4e, 0x79, 0xce,
0xca, 0x34, 0xe0, 0x22, 0xa5, 0x29, 0x94, 0xe6, 0xd4, 0xd3, 0x26, 0xc4, 0xaa, 0x4c, 0xfe, 0xfe,
0x04, 0xde, 0x72, 0xeb, 0x77, 0x08, 0x0d, 0x4e, 0x1b, 0xe5, 0xcd, 0x9f, 0x01, 0x00, 0x00, 0xff,
0xff, 0x4c, 0x27, 0x6e, 0x9a, 0xb0, 0x05, 0x00, 0x00,
}

759
vendor/google.golang.org/genproto/googleapis/bigtable/v1/bigtable_service_messages.pb.go generated vendored Normal file
View File

@ -0,0 +1,759 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/v1/bigtable_service_messages.proto
package bigtable
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_rpc "google.golang.org/genproto/googleapis/rpc/status"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Request message for BigtableServer.ReadRows.
type ReadRowsRequest struct {
// The unique name of the table from which to read.
TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
// If neither row_key nor row_range is set, reads from all rows.
//
// Types that are valid to be assigned to Target:
// *ReadRowsRequest_RowKey
// *ReadRowsRequest_RowRange
// *ReadRowsRequest_RowSet
Target isReadRowsRequest_Target `protobuf_oneof:"target"`
// The filter to apply to the contents of the specified row(s). If unset,
// reads the entire table.
Filter *RowFilter `protobuf:"bytes,5,opt,name=filter" json:"filter,omitempty"`
// By default, rows are read sequentially, producing results which are
// guaranteed to arrive in increasing row order. Setting
// "allow_row_interleaving" to true allows multiple rows to be interleaved in
// the response stream, which increases throughput but breaks this guarantee,
// and may force the client to use more memory to buffer partially-received
// rows. Cannot be set to true when specifying "num_rows_limit".
AllowRowInterleaving bool `protobuf:"varint,6,opt,name=allow_row_interleaving,json=allowRowInterleaving" json:"allow_row_interleaving,omitempty"`
// The read will terminate after committing to N rows' worth of results. The
// default (zero) is to return all results.
// Note that "allow_row_interleaving" cannot be set to true when this is set.
NumRowsLimit int64 `protobuf:"varint,7,opt,name=num_rows_limit,json=numRowsLimit" json:"num_rows_limit,omitempty"`
}
func (m *ReadRowsRequest) Reset() { *m = ReadRowsRequest{} }
func (m *ReadRowsRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRowsRequest) ProtoMessage() {}
func (*ReadRowsRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
type isReadRowsRequest_Target interface {
isReadRowsRequest_Target()
}
type ReadRowsRequest_RowKey struct {
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3,oneof"`
}
type ReadRowsRequest_RowRange struct {
RowRange *RowRange `protobuf:"bytes,3,opt,name=row_range,json=rowRange,oneof"`
}
type ReadRowsRequest_RowSet struct {
RowSet *RowSet `protobuf:"bytes,8,opt,name=row_set,json=rowSet,oneof"`
}
func (*ReadRowsRequest_RowKey) isReadRowsRequest_Target() {}
func (*ReadRowsRequest_RowRange) isReadRowsRequest_Target() {}
func (*ReadRowsRequest_RowSet) isReadRowsRequest_Target() {}
func (m *ReadRowsRequest) GetTarget() isReadRowsRequest_Target {
if m != nil {
return m.Target
}
return nil
}
func (m *ReadRowsRequest) GetTableName() string {
if m != nil {
return m.TableName
}
return ""
}
func (m *ReadRowsRequest) GetRowKey() []byte {
if x, ok := m.GetTarget().(*ReadRowsRequest_RowKey); ok {
return x.RowKey
}
return nil
}
func (m *ReadRowsRequest) GetRowRange() *RowRange {
if x, ok := m.GetTarget().(*ReadRowsRequest_RowRange); ok {
return x.RowRange
}
return nil
}
func (m *ReadRowsRequest) GetRowSet() *RowSet {
if x, ok := m.GetTarget().(*ReadRowsRequest_RowSet); ok {
return x.RowSet
}
return nil
}
func (m *ReadRowsRequest) GetFilter() *RowFilter {
if m != nil {
return m.Filter
}
return nil
}
func (m *ReadRowsRequest) GetAllowRowInterleaving() bool {
if m != nil {
return m.AllowRowInterleaving
}
return false
}
func (m *ReadRowsRequest) GetNumRowsLimit() int64 {
if m != nil {
return m.NumRowsLimit
}
return 0
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*ReadRowsRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _ReadRowsRequest_OneofMarshaler, _ReadRowsRequest_OneofUnmarshaler, _ReadRowsRequest_OneofSizer, []interface{}{
(*ReadRowsRequest_RowKey)(nil),
(*ReadRowsRequest_RowRange)(nil),
(*ReadRowsRequest_RowSet)(nil),
}
}
func _ReadRowsRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ReadRowsRequest)
// target
switch x := m.Target.(type) {
case *ReadRowsRequest_RowKey:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeRawBytes(x.RowKey)
case *ReadRowsRequest_RowRange:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.RowRange); err != nil {
return err
}
case *ReadRowsRequest_RowSet:
b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.RowSet); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ReadRowsRequest.Target has unexpected type %T", x)
}
return nil
}
func _ReadRowsRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ReadRowsRequest)
switch tag {
case 2: // target.row_key
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeRawBytes(true)
m.Target = &ReadRowsRequest_RowKey{x}
return true, err
case 3: // target.row_range
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(RowRange)
err := b.DecodeMessage(msg)
m.Target = &ReadRowsRequest_RowRange{msg}
return true, err
case 8: // target.row_set
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(RowSet)
err := b.DecodeMessage(msg)
m.Target = &ReadRowsRequest_RowSet{msg}
return true, err
default:
return false, nil
}
}
func _ReadRowsRequest_OneofSizer(msg proto.Message) (n int) {
m := msg.(*ReadRowsRequest)
// target
switch x := m.Target.(type) {
case *ReadRowsRequest_RowKey:
n += proto.SizeVarint(2<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(len(x.RowKey)))
n += len(x.RowKey)
case *ReadRowsRequest_RowRange:
s := proto.Size(x.RowRange)
n += proto.SizeVarint(3<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *ReadRowsRequest_RowSet:
s := proto.Size(x.RowSet)
n += proto.SizeVarint(8<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Response message for BigtableService.ReadRows.
type ReadRowsResponse struct {
// The key of the row for which we're receiving data.
// Results will be received in increasing row key order, unless
// "allow_row_interleaving" was specified in the request.
RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
// One or more chunks of the row specified by "row_key".
Chunks []*ReadRowsResponse_Chunk `protobuf:"bytes,2,rep,name=chunks" json:"chunks,omitempty"`
}
func (m *ReadRowsResponse) Reset() { *m = ReadRowsResponse{} }
func (m *ReadRowsResponse) String() string { return proto.CompactTextString(m) }
func (*ReadRowsResponse) ProtoMessage() {}
func (*ReadRowsResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
func (m *ReadRowsResponse) GetRowKey() []byte {
if m != nil {
return m.RowKey
}
return nil
}
func (m *ReadRowsResponse) GetChunks() []*ReadRowsResponse_Chunk {
if m != nil {
return m.Chunks
}
return nil
}
// Specifies a piece of a row's contents returned as part of the read
// response stream.
type ReadRowsResponse_Chunk struct {
// Types that are valid to be assigned to Chunk:
// *ReadRowsResponse_Chunk_RowContents
// *ReadRowsResponse_Chunk_ResetRow
// *ReadRowsResponse_Chunk_CommitRow
Chunk isReadRowsResponse_Chunk_Chunk `protobuf_oneof:"chunk"`
}
func (m *ReadRowsResponse_Chunk) Reset() { *m = ReadRowsResponse_Chunk{} }
func (m *ReadRowsResponse_Chunk) String() string { return proto.CompactTextString(m) }
func (*ReadRowsResponse_Chunk) ProtoMessage() {}
func (*ReadRowsResponse_Chunk) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1, 0} }
type isReadRowsResponse_Chunk_Chunk interface {
isReadRowsResponse_Chunk_Chunk()
}
type ReadRowsResponse_Chunk_RowContents struct {
RowContents *Family `protobuf:"bytes,1,opt,name=row_contents,json=rowContents,oneof"`
}
type ReadRowsResponse_Chunk_ResetRow struct {
ResetRow bool `protobuf:"varint,2,opt,name=reset_row,json=resetRow,oneof"`
}
type ReadRowsResponse_Chunk_CommitRow struct {
CommitRow bool `protobuf:"varint,3,opt,name=commit_row,json=commitRow,oneof"`
}
func (*ReadRowsResponse_Chunk_RowContents) isReadRowsResponse_Chunk_Chunk() {}
func (*ReadRowsResponse_Chunk_ResetRow) isReadRowsResponse_Chunk_Chunk() {}
func (*ReadRowsResponse_Chunk_CommitRow) isReadRowsResponse_Chunk_Chunk() {}
func (m *ReadRowsResponse_Chunk) GetChunk() isReadRowsResponse_Chunk_Chunk {
if m != nil {
return m.Chunk
}
return nil
}
func (m *ReadRowsResponse_Chunk) GetRowContents() *Family {
if x, ok := m.GetChunk().(*ReadRowsResponse_Chunk_RowContents); ok {
return x.RowContents
}
return nil
}
func (m *ReadRowsResponse_Chunk) GetResetRow() bool {
if x, ok := m.GetChunk().(*ReadRowsResponse_Chunk_ResetRow); ok {
return x.ResetRow
}
return false
}
func (m *ReadRowsResponse_Chunk) GetCommitRow() bool {
if x, ok := m.GetChunk().(*ReadRowsResponse_Chunk_CommitRow); ok {
return x.CommitRow
}
return false
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*ReadRowsResponse_Chunk) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _ReadRowsResponse_Chunk_OneofMarshaler, _ReadRowsResponse_Chunk_OneofUnmarshaler, _ReadRowsResponse_Chunk_OneofSizer, []interface{}{
(*ReadRowsResponse_Chunk_RowContents)(nil),
(*ReadRowsResponse_Chunk_ResetRow)(nil),
(*ReadRowsResponse_Chunk_CommitRow)(nil),
}
}
func _ReadRowsResponse_Chunk_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ReadRowsResponse_Chunk)
// chunk
switch x := m.Chunk.(type) {
case *ReadRowsResponse_Chunk_RowContents:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.RowContents); err != nil {
return err
}
case *ReadRowsResponse_Chunk_ResetRow:
t := uint64(0)
if x.ResetRow {
t = 1
}
b.EncodeVarint(2<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *ReadRowsResponse_Chunk_CommitRow:
t := uint64(0)
if x.CommitRow {
t = 1
}
b.EncodeVarint(3<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("ReadRowsResponse_Chunk.Chunk has unexpected type %T", x)
}
return nil
}
func _ReadRowsResponse_Chunk_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ReadRowsResponse_Chunk)
switch tag {
case 1: // chunk.row_contents
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Family)
err := b.DecodeMessage(msg)
m.Chunk = &ReadRowsResponse_Chunk_RowContents{msg}
return true, err
case 2: // chunk.reset_row
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Chunk = &ReadRowsResponse_Chunk_ResetRow{x != 0}
return true, err
case 3: // chunk.commit_row
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Chunk = &ReadRowsResponse_Chunk_CommitRow{x != 0}
return true, err
default:
return false, nil
}
}
func _ReadRowsResponse_Chunk_OneofSizer(msg proto.Message) (n int) {
m := msg.(*ReadRowsResponse_Chunk)
// chunk
switch x := m.Chunk.(type) {
case *ReadRowsResponse_Chunk_RowContents:
s := proto.Size(x.RowContents)
n += proto.SizeVarint(1<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *ReadRowsResponse_Chunk_ResetRow:
n += proto.SizeVarint(2<<3 | proto.WireVarint)
n += 1
case *ReadRowsResponse_Chunk_CommitRow:
n += proto.SizeVarint(3<<3 | proto.WireVarint)
n += 1
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Request message for BigtableService.SampleRowKeys.
type SampleRowKeysRequest struct {
// The unique name of the table from which to sample row keys.
TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
}
func (m *SampleRowKeysRequest) Reset() { *m = SampleRowKeysRequest{} }
func (m *SampleRowKeysRequest) String() string { return proto.CompactTextString(m) }
func (*SampleRowKeysRequest) ProtoMessage() {}
func (*SampleRowKeysRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
func (m *SampleRowKeysRequest) GetTableName() string {
if m != nil {
return m.TableName
}
return ""
}
// Response message for BigtableService.SampleRowKeys.
type SampleRowKeysResponse struct {
// 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.
RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
// 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.
OffsetBytes int64 `protobuf:"varint,2,opt,name=offset_bytes,json=offsetBytes" json:"offset_bytes,omitempty"`
}
func (m *SampleRowKeysResponse) Reset() { *m = SampleRowKeysResponse{} }
func (m *SampleRowKeysResponse) String() string { return proto.CompactTextString(m) }
func (*SampleRowKeysResponse) ProtoMessage() {}
func (*SampleRowKeysResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
func (m *SampleRowKeysResponse) GetRowKey() []byte {
if m != nil {
return m.RowKey
}
return nil
}
func (m *SampleRowKeysResponse) GetOffsetBytes() int64 {
if m != nil {
return m.OffsetBytes
}
return 0
}
// Request message for BigtableService.MutateRow.
type MutateRowRequest struct {
// The unique name of the table to which the mutation should be applied.
TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
// The key of the row to which the mutation should be applied.
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
// 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.
Mutations []*Mutation `protobuf:"bytes,3,rep,name=mutations" json:"mutations,omitempty"`
}
func (m *MutateRowRequest) Reset() { *m = MutateRowRequest{} }
func (m *MutateRowRequest) String() string { return proto.CompactTextString(m) }
func (*MutateRowRequest) ProtoMessage() {}
func (*MutateRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
func (m *MutateRowRequest) GetTableName() string {
if m != nil {
return m.TableName
}
return ""
}
func (m *MutateRowRequest) GetRowKey() []byte {
if m != nil {
return m.RowKey
}
return nil
}
func (m *MutateRowRequest) GetMutations() []*Mutation {
if m != nil {
return m.Mutations
}
return nil
}
// Request message for BigtableService.MutateRows.
type MutateRowsRequest struct {
// The unique name of the table to which the mutations should be applied.
TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
// The row keys/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 may
// contain at most 100000 mutations.
Entries []*MutateRowsRequest_Entry `protobuf:"bytes,2,rep,name=entries" json:"entries,omitempty"`
}
func (m *MutateRowsRequest) Reset() { *m = MutateRowsRequest{} }
func (m *MutateRowsRequest) String() string { return proto.CompactTextString(m) }
func (*MutateRowsRequest) ProtoMessage() {}
func (*MutateRowsRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }
func (m *MutateRowsRequest) GetTableName() string {
if m != nil {
return m.TableName
}
return ""
}
func (m *MutateRowsRequest) GetEntries() []*MutateRowsRequest_Entry {
if m != nil {
return m.Entries
}
return nil
}
type MutateRowsRequest_Entry struct {
// The key of the row to which the `mutations` should be applied.
RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
// Changes to be atomically applied to the specified row. Mutations are
// applied in order, meaning that earlier mutations can be masked by
// later ones.
// At least one mutation must be specified.
Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"`
}
func (m *MutateRowsRequest_Entry) Reset() { *m = MutateRowsRequest_Entry{} }
func (m *MutateRowsRequest_Entry) String() string { return proto.CompactTextString(m) }
func (*MutateRowsRequest_Entry) ProtoMessage() {}
func (*MutateRowsRequest_Entry) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5, 0} }
func (m *MutateRowsRequest_Entry) GetRowKey() []byte {
if m != nil {
return m.RowKey
}
return nil
}
func (m *MutateRowsRequest_Entry) GetMutations() []*Mutation {
if m != nil {
return m.Mutations
}
return nil
}
// Response message for BigtableService.MutateRows.
type MutateRowsResponse struct {
// The results for each Entry from the request, presented in the order
// in which the entries were originally given.
// 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.
Statuses []*google_rpc.Status `protobuf:"bytes,1,rep,name=statuses" json:"statuses,omitempty"`
}
func (m *MutateRowsResponse) Reset() { *m = MutateRowsResponse{} }
func (m *MutateRowsResponse) String() string { return proto.CompactTextString(m) }
func (*MutateRowsResponse) ProtoMessage() {}
func (*MutateRowsResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }
func (m *MutateRowsResponse) GetStatuses() []*google_rpc.Status {
if m != nil {
return m.Statuses
}
return nil
}
// Request message for BigtableService.CheckAndMutateRowRequest
type CheckAndMutateRowRequest struct {
// The unique name of the table to which the conditional mutation should be
// applied.
TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
// The key of the row to which the conditional mutation should be applied.
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
// 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.
PredicateFilter *RowFilter `protobuf:"bytes,6,opt,name=predicate_filter,json=predicateFilter" json:"predicate_filter,omitempty"`
// 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.
TrueMutations []*Mutation `protobuf:"bytes,4,rep,name=true_mutations,json=trueMutations" json:"true_mutations,omitempty"`
// 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.
FalseMutations []*Mutation `protobuf:"bytes,5,rep,name=false_mutations,json=falseMutations" json:"false_mutations,omitempty"`
}
func (m *CheckAndMutateRowRequest) Reset() { *m = CheckAndMutateRowRequest{} }
func (m *CheckAndMutateRowRequest) String() string { return proto.CompactTextString(m) }
func (*CheckAndMutateRowRequest) ProtoMessage() {}
func (*CheckAndMutateRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }
func (m *CheckAndMutateRowRequest) GetTableName() string {
if m != nil {
return m.TableName
}
return ""
}
func (m *CheckAndMutateRowRequest) GetRowKey() []byte {
if m != nil {
return m.RowKey
}
return nil
}
func (m *CheckAndMutateRowRequest) GetPredicateFilter() *RowFilter {
if m != nil {
return m.PredicateFilter
}
return nil
}
func (m *CheckAndMutateRowRequest) GetTrueMutations() []*Mutation {
if m != nil {
return m.TrueMutations
}
return nil
}
func (m *CheckAndMutateRowRequest) GetFalseMutations() []*Mutation {
if m != nil {
return m.FalseMutations
}
return nil
}
// Response message for BigtableService.CheckAndMutateRowRequest.
type CheckAndMutateRowResponse struct {
// Whether or not the request's "predicate_filter" yielded any results for
// the specified row.
PredicateMatched bool `protobuf:"varint,1,opt,name=predicate_matched,json=predicateMatched" json:"predicate_matched,omitempty"`
}
func (m *CheckAndMutateRowResponse) Reset() { *m = CheckAndMutateRowResponse{} }
func (m *CheckAndMutateRowResponse) String() string { return proto.CompactTextString(m) }
func (*CheckAndMutateRowResponse) ProtoMessage() {}
func (*CheckAndMutateRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }
func (m *CheckAndMutateRowResponse) GetPredicateMatched() bool {
if m != nil {
return m.PredicateMatched
}
return false
}
// Request message for BigtableService.ReadModifyWriteRowRequest.
type ReadModifyWriteRowRequest struct {
// The unique name of the table to which the read/modify/write rules should be
// applied.
TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
// The key of the row to which the read/modify/write rules should be applied.
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
// 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.
Rules []*ReadModifyWriteRule `protobuf:"bytes,3,rep,name=rules" json:"rules,omitempty"`
}
func (m *ReadModifyWriteRowRequest) Reset() { *m = ReadModifyWriteRowRequest{} }
func (m *ReadModifyWriteRowRequest) String() string { return proto.CompactTextString(m) }
func (*ReadModifyWriteRowRequest) ProtoMessage() {}
func (*ReadModifyWriteRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} }
func (m *ReadModifyWriteRowRequest) GetTableName() string {
if m != nil {
return m.TableName
}
return ""
}
func (m *ReadModifyWriteRowRequest) GetRowKey() []byte {
if m != nil {
return m.RowKey
}
return nil
}
func (m *ReadModifyWriteRowRequest) GetRules() []*ReadModifyWriteRule {
if m != nil {
return m.Rules
}
return nil
}
func init() {
proto.RegisterType((*ReadRowsRequest)(nil), "google.bigtable.v1.ReadRowsRequest")
proto.RegisterType((*ReadRowsResponse)(nil), "google.bigtable.v1.ReadRowsResponse")
proto.RegisterType((*ReadRowsResponse_Chunk)(nil), "google.bigtable.v1.ReadRowsResponse.Chunk")
proto.RegisterType((*SampleRowKeysRequest)(nil), "google.bigtable.v1.SampleRowKeysRequest")
proto.RegisterType((*SampleRowKeysResponse)(nil), "google.bigtable.v1.SampleRowKeysResponse")
proto.RegisterType((*MutateRowRequest)(nil), "google.bigtable.v1.MutateRowRequest")
proto.RegisterType((*MutateRowsRequest)(nil), "google.bigtable.v1.MutateRowsRequest")
proto.RegisterType((*MutateRowsRequest_Entry)(nil), "google.bigtable.v1.MutateRowsRequest.Entry")
proto.RegisterType((*MutateRowsResponse)(nil), "google.bigtable.v1.MutateRowsResponse")
proto.RegisterType((*CheckAndMutateRowRequest)(nil), "google.bigtable.v1.CheckAndMutateRowRequest")
proto.RegisterType((*CheckAndMutateRowResponse)(nil), "google.bigtable.v1.CheckAndMutateRowResponse")
proto.RegisterType((*ReadModifyWriteRowRequest)(nil), "google.bigtable.v1.ReadModifyWriteRowRequest")
}
func init() { proto.RegisterFile("google/bigtable/v1/bigtable_service_messages.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 788 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x5f, 0x8b, 0x23, 0x45,
0x10, 0xdf, 0x49, 0xcc, 0xbf, 0x4a, 0xdc, 0xdd, 0x6b, 0xce, 0xdb, 0xd9, 0x70, 0x8b, 0x71, 0x10,
0x0d, 0x1e, 0x4c, 0xb8, 0xd5, 0x7d, 0xb9, 0x43, 0xc4, 0xc4, 0x3d, 0x22, 0x1a, 0x39, 0x3a, 0x0f,
0x82, 0x08, 0xa1, 0x33, 0xa9, 0xcc, 0x0e, 0x3b, 0xd3, 0x1d, 0xbb, 0x7b, 0x32, 0xe4, 0x59, 0xf0,
0x5d, 0x3f, 0x85, 0xdf, 0xc8, 0x17, 0x3f, 0x8c, 0x74, 0xcf, 0xe4, 0x8f, 0x6b, 0xa2, 0x11, 0xf6,
0xad, 0xa7, 0xaa, 0x7e, 0xbf, 0xaa, 0xfa, 0x75, 0x4d, 0x17, 0x5c, 0x87, 0x42, 0x84, 0x31, 0xf6,
0xa6, 0x51, 0xa8, 0xd9, 0x34, 0xc6, 0xde, 0xf2, 0xe5, 0xe6, 0x3c, 0x51, 0x28, 0x97, 0x51, 0x80,
0x93, 0x04, 0x95, 0x62, 0x21, 0x2a, 0x7f, 0x21, 0x85, 0x16, 0x84, 0xe4, 0x18, 0x7f, 0x1d, 0xe7,
0x2f, 0x5f, 0xb6, 0x3f, 0xfa, 0x37, 0x9e, 0x19, 0xd3, 0x2c, 0xc7, 0xb6, 0x2f, 0x8a, 0x38, 0xb9,
0x08, 0x7a, 0x4a, 0x33, 0x9d, 0x16, 0xa4, 0xde, 0x9f, 0x25, 0x38, 0xa3, 0xc8, 0x66, 0x54, 0x64,
0x8a, 0xe2, 0x4f, 0x29, 0x2a, 0x4d, 0xae, 0x00, 0x72, 0x02, 0xce, 0x12, 0x74, 0x9d, 0x8e, 0xd3,
0x6d, 0xd0, 0x86, 0xb5, 0x7c, 0xc7, 0x12, 0x24, 0x97, 0x50, 0x93, 0x22, 0x9b, 0xdc, 0xe3, 0xca,
0x2d, 0x75, 0x9c, 0x6e, 0x6b, 0x78, 0x42, 0xab, 0x52, 0x64, 0xdf, 0xe0, 0x8a, 0xbc, 0x86, 0x86,
0x71, 0x49, 0xc6, 0x43, 0x74, 0xcb, 0x1d, 0xa7, 0xdb, 0xbc, 0x7e, 0xee, 0xff, 0xb3, 0x6c, 0x9f,
0x8a, 0x8c, 0x9a, 0x98, 0xe1, 0x09, 0xad, 0xcb, 0xe2, 0x4c, 0x6e, 0x72, 0x5e, 0x85, 0xda, 0xad,
0x5b, 0x68, 0xfb, 0x00, 0x74, 0x8c, 0xba, 0xc8, 0x39, 0x46, 0x4d, 0x6e, 0xa0, 0x3a, 0x8f, 0x62,
0x8d, 0xd2, 0xad, 0x58, 0xd4, 0xd5, 0x01, 0xd4, 0x1b, 0x1b, 0x44, 0x8b, 0x60, 0xf2, 0x19, 0x3c,
0x63, 0x71, 0x6c, 0x8a, 0x15, 0xd9, 0x24, 0xe2, 0x1a, 0x65, 0x8c, 0x6c, 0x19, 0xf1, 0xd0, 0xad,
0x76, 0x9c, 0x6e, 0x9d, 0x3e, 0xb5, 0x5e, 0x2a, 0xb2, 0xaf, 0x77, 0x7c, 0xe4, 0x43, 0x38, 0xe5,
0x69, 0x62, 0x30, 0x6a, 0x12, 0x47, 0x49, 0xa4, 0xdd, 0x5a, 0xc7, 0xe9, 0x96, 0x69, 0x8b, 0xa7,
0x89, 0x91, 0xf0, 0x5b, 0x63, 0xeb, 0xd7, 0xa1, 0xaa, 0x99, 0x0c, 0x51, 0x7b, 0x3f, 0x97, 0xe0,
0x7c, 0x2b, 0xaf, 0x5a, 0x08, 0xae, 0x90, 0x5c, 0x6c, 0x05, 0x34, 0xe2, 0xb6, 0x36, 0xf2, 0xf5,
0xa1, 0x1a, 0xdc, 0xa5, 0xfc, 0x5e, 0xb9, 0xa5, 0x4e, 0xb9, 0xdb, 0xbc, 0xfe, 0x64, 0x6f, 0x2b,
0x0f, 0xe8, 0xfc, 0x81, 0x81, 0xd0, 0x02, 0xd9, 0xfe, 0xd5, 0x81, 0x8a, 0xb5, 0x90, 0x2f, 0xa0,
0x65, 0xd2, 0x04, 0x82, 0x6b, 0xe4, 0x5a, 0xd9, 0x5c, 0x07, 0x44, 0x7d, 0xc3, 0x92, 0x28, 0x5e,
0x0d, 0x4f, 0x68, 0x53, 0x8a, 0x6c, 0x50, 0x00, 0xc8, 0x15, 0x34, 0x24, 0x2a, 0xd4, 0xa6, 0x5d,
0x7b, 0xd5, 0x75, 0x7b, 0x5f, 0xc6, 0x44, 0x45, 0x46, 0xde, 0x07, 0x08, 0x44, 0x92, 0x44, 0xb9,
0xbf, 0x5c, 0xf8, 0x1b, 0xb9, 0x8d, 0x8a, 0xac, 0x5f, 0x83, 0x8a, 0x2d, 0xca, 0xbb, 0x81, 0xa7,
0x63, 0x96, 0x2c, 0x62, 0xa4, 0xb6, 0xcf, 0x23, 0x07, 0xcd, 0x1b, 0xc3, 0x7b, 0x0f, 0x60, 0xff,
0x25, 0xe0, 0x07, 0xd0, 0x12, 0xf3, 0xb9, 0x29, 0x79, 0xba, 0xd2, 0xa8, 0x6c, 0xd1, 0x65, 0xda,
0xcc, 0x6d, 0x7d, 0x63, 0xf2, 0x7e, 0x71, 0xe0, 0x7c, 0x94, 0x6a, 0xa6, 0x0d, 0xeb, 0x91, 0x13,
0x7f, 0xf1, 0x60, 0xe2, 0x37, 0xf9, 0x5e, 0x41, 0x23, 0x31, 0x5c, 0x91, 0xe0, 0xca, 0x2d, 0xdb,
0x3b, 0xdb, 0x3b, 0xef, 0xa3, 0x22, 0x88, 0x6e, 0xc3, 0xbd, 0x3f, 0x1c, 0x78, 0xb2, 0x29, 0xe4,
0xd8, 0x7f, 0xef, 0x16, 0x6a, 0xc8, 0xb5, 0x8c, 0x70, 0x3d, 0x22, 0x2f, 0x0e, 0xa6, 0xdb, 0xa5,
0xf5, 0x6f, 0xb9, 0x96, 0x2b, 0xba, 0xc6, 0xb6, 0x7f, 0x84, 0x8a, 0xb5, 0x1c, 0x56, 0xf2, 0x6f,
0x9d, 0x95, 0xfe, 0x5f, 0x67, 0x5f, 0x01, 0xd9, 0xad, 0xa0, 0xb8, 0x34, 0x1f, 0xea, 0xf9, 0xcb,
0x83, 0x66, 0x14, 0x0d, 0x21, 0x59, 0x13, 0xca, 0x45, 0xe0, 0x8f, 0xad, 0x8f, 0x6e, 0x62, 0xbc,
0xdf, 0x4b, 0xe0, 0x0e, 0xee, 0x30, 0xb8, 0xff, 0x92, 0xcf, 0x1e, 0xed, 0xc2, 0x86, 0x70, 0xbe,
0x90, 0x38, 0x8b, 0x02, 0xa6, 0x71, 0x52, 0x3c, 0x1b, 0xd5, 0x63, 0x9e, 0x8d, 0xb3, 0x0d, 0x2c,
0x37, 0x90, 0x01, 0x9c, 0x6a, 0x99, 0xe2, 0x64, 0xab, 0xd2, 0x3b, 0x47, 0xa8, 0xf4, 0xae, 0xc1,
0xac, 0xbf, 0x14, 0xb9, 0x85, 0xb3, 0x39, 0x8b, 0xd5, 0x2e, 0x4b, 0xe5, 0x08, 0x96, 0x53, 0x0b,
0xda, 0xd0, 0x78, 0x43, 0xb8, 0xdc, 0xa3, 0x54, 0xa1, 0xfb, 0x0b, 0x78, 0xb2, 0x6d, 0x39, 0x61,
0x3a, 0xb8, 0xc3, 0x99, 0x55, 0xac, 0x4e, 0xb7, 0x5a, 0x8c, 0x72, 0xbb, 0xf7, 0x9b, 0x03, 0x97,
0xe6, 0x81, 0x19, 0x89, 0x59, 0x34, 0x5f, 0x7d, 0x2f, 0xa3, 0x47, 0x51, 0xfd, 0x73, 0xa8, 0xc8,
0x34, 0xc6, 0xf5, 0x2f, 0xf2, 0xf1, 0xa1, 0x67, 0x6d, 0x37, 0x6b, 0x1a, 0x23, 0xcd, 0x51, 0x7d,
0x0d, 0xcf, 0x02, 0x91, 0xec, 0x01, 0xf5, 0x9f, 0xf7, 0x8b, 0x8f, 0x71, 0xbe, 0x32, 0x47, 0xc5,
0xc6, 0x7c, 0x6b, 0x76, 0xdb, 0x5b, 0xe7, 0x87, 0x57, 0x05, 0x26, 0x14, 0x31, 0xe3, 0xa1, 0x2f,
0x64, 0xd8, 0x0b, 0x91, 0xdb, 0xcd, 0xd7, 0xcb, 0x5d, 0x6c, 0x11, 0xa9, 0xdd, 0xed, 0xf9, 0x7a,
0x7d, 0x9e, 0x56, 0x6d, 0xd8, 0xa7, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x16, 0x55, 0x90, 0x95,
0xab, 0x07, 0x00, 0x00,
}

1261
vendor/google.golang.org/genproto/googleapis/bigtable/v2/bigtable.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2119
vendor/google.golang.org/genproto/googleapis/bigtable/v2/data.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

555
vendor/google.golang.org/genproto/googleapis/bytestream/bytestream.pb.go generated vendored Normal file
View File

@ -0,0 +1,555 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bytestream/bytestream.proto
/*
Package bytestream is a generated protocol buffer package.
It is generated from these files:
google/bytestream/bytestream.proto
It has these top-level messages:
ReadRequest
ReadResponse
WriteRequest
WriteResponse
QueryWriteStatusRequest
QueryWriteStatusResponse
*/
package bytestream
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import _ "github.com/golang/protobuf/ptypes/wrappers"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Request object for ByteStream.Read.
type ReadRequest struct {
// The name of the resource to read.
ResourceName string `protobuf:"bytes,1,opt,name=resource_name,json=resourceName" json:"resource_name,omitempty"`
// The offset for the first byte to return in the read, relative to the start
// of the resource.
//
// A `read_offset` that is negative or greater than the size of the resource
// will cause an `OUT_OF_RANGE` error.
ReadOffset int64 `protobuf:"varint,2,opt,name=read_offset,json=readOffset" json:"read_offset,omitempty"`
// The maximum number of `data` bytes the server is allowed to return in the
// sum of all `ReadResponse` messages. A `read_limit` of zero indicates that
// there is no limit, and a negative `read_limit` will cause an error.
//
// If the stream returns fewer bytes than allowed by the `read_limit` and no
// error occurred, the stream includes all data from the `read_offset` to the
// end of the resource.
ReadLimit int64 `protobuf:"varint,3,opt,name=read_limit,json=readLimit" json:"read_limit,omitempty"`
}
func (m *ReadRequest) Reset() { *m = ReadRequest{} }
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRequest) ProtoMessage() {}
func (*ReadRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *ReadRequest) GetResourceName() string {
if m != nil {
return m.ResourceName
}
return ""
}
func (m *ReadRequest) GetReadOffset() int64 {
if m != nil {
return m.ReadOffset
}
return 0
}
func (m *ReadRequest) GetReadLimit() int64 {
if m != nil {
return m.ReadLimit
}
return 0
}
// Response object for ByteStream.Read.
type ReadResponse struct {
// A portion of the data for the resource. The service **may** leave `data`
// empty for any given `ReadResponse`. This enables the service to inform the
// client that the request is still live while it is running an operation to
// generate more data.
Data []byte `protobuf:"bytes,10,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *ReadResponse) Reset() { *m = ReadResponse{} }
func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
func (*ReadResponse) ProtoMessage() {}
func (*ReadResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *ReadResponse) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
// Request object for ByteStream.Write.
type WriteRequest struct {
// The name of the resource to write. This **must** be set on the first
// `WriteRequest` of each `Write()` action. If it is set on subsequent calls,
// it **must** match the value of the first request.
ResourceName string `protobuf:"bytes,1,opt,name=resource_name,json=resourceName" json:"resource_name,omitempty"`
// The offset from the beginning of the resource at which the data should be
// written. It is required on all `WriteRequest`s.
//
// In the first `WriteRequest` of a `Write()` action, it indicates
// the initial offset for the `Write()` call. The value **must** be equal to
// the `committed_size` that a call to `QueryWriteStatus()` would return.
//
// On subsequent calls, this value **must** be set and **must** be equal to
// the sum of the first `write_offset` and the sizes of all `data` bundles
// sent previously on this stream.
//
// An incorrect value will cause an error.
WriteOffset int64 `protobuf:"varint,2,opt,name=write_offset,json=writeOffset" json:"write_offset,omitempty"`
// If `true`, this indicates that the write is complete. Sending any
// `WriteRequest`s subsequent to one in which `finish_write` is `true` will
// cause an error.
FinishWrite bool `protobuf:"varint,3,opt,name=finish_write,json=finishWrite" json:"finish_write,omitempty"`
// A portion of the data for the resource. The client **may** leave `data`
// empty for any given `WriteRequest`. This enables the client to inform the
// service that the request is still live while it is running an operation to
// generate more data.
Data []byte `protobuf:"bytes,10,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *WriteRequest) Reset() { *m = WriteRequest{} }
func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
func (*WriteRequest) ProtoMessage() {}
func (*WriteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *WriteRequest) GetResourceName() string {
if m != nil {
return m.ResourceName
}
return ""
}
func (m *WriteRequest) GetWriteOffset() int64 {
if m != nil {
return m.WriteOffset
}
return 0
}
func (m *WriteRequest) GetFinishWrite() bool {
if m != nil {
return m.FinishWrite
}
return false
}
func (m *WriteRequest) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
// Response object for ByteStream.Write.
type WriteResponse struct {
// The number of bytes that have been processed for the given resource.
CommittedSize int64 `protobuf:"varint,1,opt,name=committed_size,json=committedSize" json:"committed_size,omitempty"`
}
func (m *WriteResponse) Reset() { *m = WriteResponse{} }
func (m *WriteResponse) String() string { return proto.CompactTextString(m) }
func (*WriteResponse) ProtoMessage() {}
func (*WriteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *WriteResponse) GetCommittedSize() int64 {
if m != nil {
return m.CommittedSize
}
return 0
}
// Request object for ByteStream.QueryWriteStatus.
type QueryWriteStatusRequest struct {
// The name of the resource whose write status is being requested.
ResourceName string `protobuf:"bytes,1,opt,name=resource_name,json=resourceName" json:"resource_name,omitempty"`
}
func (m *QueryWriteStatusRequest) Reset() { *m = QueryWriteStatusRequest{} }
func (m *QueryWriteStatusRequest) String() string { return proto.CompactTextString(m) }
func (*QueryWriteStatusRequest) ProtoMessage() {}
func (*QueryWriteStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *QueryWriteStatusRequest) GetResourceName() string {
if m != nil {
return m.ResourceName
}
return ""
}
// Response object for ByteStream.QueryWriteStatus.
type QueryWriteStatusResponse struct {
// The number of bytes that have been processed for the given resource.
CommittedSize int64 `protobuf:"varint,1,opt,name=committed_size,json=committedSize" json:"committed_size,omitempty"`
// `complete` is `true` only if the client has sent a `WriteRequest` with
// `finish_write` set to true, and the server has processed that request.
Complete bool `protobuf:"varint,2,opt,name=complete" json:"complete,omitempty"`
}
func (m *QueryWriteStatusResponse) Reset() { *m = QueryWriteStatusResponse{} }
func (m *QueryWriteStatusResponse) String() string { return proto.CompactTextString(m) }
func (*QueryWriteStatusResponse) ProtoMessage() {}
func (*QueryWriteStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *QueryWriteStatusResponse) GetCommittedSize() int64 {
if m != nil {
return m.CommittedSize
}
return 0
}
func (m *QueryWriteStatusResponse) GetComplete() bool {
if m != nil {
return m.Complete
}
return false
}
func init() {
proto.RegisterType((*ReadRequest)(nil), "google.bytestream.ReadRequest")
proto.RegisterType((*ReadResponse)(nil), "google.bytestream.ReadResponse")
proto.RegisterType((*WriteRequest)(nil), "google.bytestream.WriteRequest")
proto.RegisterType((*WriteResponse)(nil), "google.bytestream.WriteResponse")
proto.RegisterType((*QueryWriteStatusRequest)(nil), "google.bytestream.QueryWriteStatusRequest")
proto.RegisterType((*QueryWriteStatusResponse)(nil), "google.bytestream.QueryWriteStatusResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for ByteStream service
type ByteStreamClient interface {
// `Read()` is used to retrieve the contents of a resource as a sequence
// of bytes. The bytes are returned in a sequence of responses, and the
// responses are delivered as the results of a server-side streaming RPC.
Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (ByteStream_ReadClient, error)
// `Write()` is used to send the contents of a resource as a sequence of
// bytes. The bytes are sent in a sequence of request protos of a client-side
// streaming RPC.
//
// A `Write()` action is resumable. If there is an error or the connection is
// broken during the `Write()`, the client should check the status of the
// `Write()` by calling `QueryWriteStatus()` and continue writing from the
// returned `committed_size`. This may be less than the amount of data the
// client previously sent.
//
// Calling `Write()` on a resource name that was previously written and
// finalized could cause an error, depending on whether the underlying service
// allows over-writing of previously written resources.
//
// When the client closes the request channel, the service will respond with
// a `WriteResponse`. The service will not view the resource as `complete`
// until the client has sent a `WriteRequest` with `finish_write` set to
// `true`. Sending any requests on a stream after sending a request with
// `finish_write` set to `true` will cause an error. The client **should**
// check the `WriteResponse` it receives to determine how much data the
// service was able to commit and whether the service views the resource as
// `complete` or not.
Write(ctx context.Context, opts ...grpc.CallOption) (ByteStream_WriteClient, error)
// `QueryWriteStatus()` is used to find the `committed_size` for a resource
// that is being written, which can then be used as the `write_offset` for
// the next `Write()` call.
//
// If the resource does not exist (i.e., the resource has been deleted, or the
// first `Write()` has not yet reached the service), this method returns the
// error `NOT_FOUND`.
//
// The client **may** call `QueryWriteStatus()` at any time to determine how
// much data has been processed for this resource. This is useful if the
// client is buffering data and needs to know which data can be safely
// evicted. For any sequence of `QueryWriteStatus()` calls for a given
// resource name, the sequence of returned `committed_size` values will be
// non-decreasing.
QueryWriteStatus(ctx context.Context, in *QueryWriteStatusRequest, opts ...grpc.CallOption) (*QueryWriteStatusResponse, error)
}
type byteStreamClient struct {
cc *grpc.ClientConn
}
func NewByteStreamClient(cc *grpc.ClientConn) ByteStreamClient {
return &byteStreamClient{cc}
}
func (c *byteStreamClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (ByteStream_ReadClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ByteStream_serviceDesc.Streams[0], c.cc, "/google.bytestream.ByteStream/Read", opts...)
if err != nil {
return nil, err
}
x := &byteStreamReadClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ByteStream_ReadClient interface {
Recv() (*ReadResponse, error)
grpc.ClientStream
}
type byteStreamReadClient struct {
grpc.ClientStream
}
func (x *byteStreamReadClient) Recv() (*ReadResponse, error) {
m := new(ReadResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *byteStreamClient) Write(ctx context.Context, opts ...grpc.CallOption) (ByteStream_WriteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_ByteStream_serviceDesc.Streams[1], c.cc, "/google.bytestream.ByteStream/Write", opts...)
if err != nil {
return nil, err
}
x := &byteStreamWriteClient{stream}
return x, nil
}
type ByteStream_WriteClient interface {
Send(*WriteRequest) error
CloseAndRecv() (*WriteResponse, error)
grpc.ClientStream
}
type byteStreamWriteClient struct {
grpc.ClientStream
}
func (x *byteStreamWriteClient) Send(m *WriteRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *byteStreamWriteClient) CloseAndRecv() (*WriteResponse, error) {
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
m := new(WriteResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *byteStreamClient) QueryWriteStatus(ctx context.Context, in *QueryWriteStatusRequest, opts ...grpc.CallOption) (*QueryWriteStatusResponse, error) {
out := new(QueryWriteStatusResponse)
err := grpc.Invoke(ctx, "/google.bytestream.ByteStream/QueryWriteStatus", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for ByteStream service
type ByteStreamServer interface {
// `Read()` is used to retrieve the contents of a resource as a sequence
// of bytes. The bytes are returned in a sequence of responses, and the
// responses are delivered as the results of a server-side streaming RPC.
Read(*ReadRequest, ByteStream_ReadServer) error
// `Write()` is used to send the contents of a resource as a sequence of
// bytes. The bytes are sent in a sequence of request protos of a client-side
// streaming RPC.
//
// A `Write()` action is resumable. If there is an error or the connection is
// broken during the `Write()`, the client should check the status of the
// `Write()` by calling `QueryWriteStatus()` and continue writing from the
// returned `committed_size`. This may be less than the amount of data the
// client previously sent.
//
// Calling `Write()` on a resource name that was previously written and
// finalized could cause an error, depending on whether the underlying service
// allows over-writing of previously written resources.
//
// When the client closes the request channel, the service will respond with
// a `WriteResponse`. The service will not view the resource as `complete`
// until the client has sent a `WriteRequest` with `finish_write` set to
// `true`. Sending any requests on a stream after sending a request with
// `finish_write` set to `true` will cause an error. The client **should**
// check the `WriteResponse` it receives to determine how much data the
// service was able to commit and whether the service views the resource as
// `complete` or not.
Write(ByteStream_WriteServer) error
// `QueryWriteStatus()` is used to find the `committed_size` for a resource
// that is being written, which can then be used as the `write_offset` for
// the next `Write()` call.
//
// If the resource does not exist (i.e., the resource has been deleted, or the
// first `Write()` has not yet reached the service), this method returns the
// error `NOT_FOUND`.
//
// The client **may** call `QueryWriteStatus()` at any time to determine how
// much data has been processed for this resource. This is useful if the
// client is buffering data and needs to know which data can be safely
// evicted. For any sequence of `QueryWriteStatus()` calls for a given
// resource name, the sequence of returned `committed_size` values will be
// non-decreasing.
QueryWriteStatus(context.Context, *QueryWriteStatusRequest) (*QueryWriteStatusResponse, error)
}
func RegisterByteStreamServer(s *grpc.Server, srv ByteStreamServer) {
s.RegisterService(&_ByteStream_serviceDesc, srv)
}
func _ByteStream_Read_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ReadRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ByteStreamServer).Read(m, &byteStreamReadServer{stream})
}
type ByteStream_ReadServer interface {
Send(*ReadResponse) error
grpc.ServerStream
}
type byteStreamReadServer struct {
grpc.ServerStream
}
func (x *byteStreamReadServer) Send(m *ReadResponse) error {
return x.ServerStream.SendMsg(m)
}
func _ByteStream_Write_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(ByteStreamServer).Write(&byteStreamWriteServer{stream})
}
type ByteStream_WriteServer interface {
SendAndClose(*WriteResponse) error
Recv() (*WriteRequest, error)
grpc.ServerStream
}
type byteStreamWriteServer struct {
grpc.ServerStream
}
func (x *byteStreamWriteServer) SendAndClose(m *WriteResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *byteStreamWriteServer) Recv() (*WriteRequest, error) {
m := new(WriteRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _ByteStream_QueryWriteStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryWriteStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ByteStreamServer).QueryWriteStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.bytestream.ByteStream/QueryWriteStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ByteStreamServer).QueryWriteStatus(ctx, req.(*QueryWriteStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ByteStream_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.bytestream.ByteStream",
HandlerType: (*ByteStreamServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "QueryWriteStatus",
Handler: _ByteStream_QueryWriteStatus_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "Read",
Handler: _ByteStream_Read_Handler,
ServerStreams: true,
},
{
StreamName: "Write",
Handler: _ByteStream_Write_Handler,
ClientStreams: true,
},
},
Metadata: "google/bytestream/bytestream.proto",
}
func init() { proto.RegisterFile("google/bytestream/bytestream.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 446 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x5b, 0x8b, 0x13, 0x31,
0x14, 0x66, 0xb6, 0xab, 0x74, 0x4f, 0xa7, 0x5e, 0x02, 0xe2, 0x30, 0xe8, 0x6e, 0x77, 0x44, 0x28,
0x0a, 0x33, 0xa2, 0xe0, 0xcb, 0x82, 0x0f, 0x7d, 0x13, 0x16, 0x2f, 0xd9, 0x07, 0x41, 0x90, 0x21,
0x6d, 0x4f, 0xc7, 0x60, 0x93, 0x8c, 0x49, 0x86, 0xa5, 0xfb, 0x1f, 0x7c, 0xf1, 0x17, 0x4b, 0x92,
0xb1, 0x1d, 0x6d, 0x0b, 0xdb, 0xb7, 0xe4, 0xbb, 0xcc, 0xf9, 0xe6, 0xe4, 0x1c, 0xc8, 0x2a, 0xa5,
0xaa, 0x25, 0x16, 0xd3, 0x95, 0x45, 0x63, 0x35, 0x32, 0xd1, 0x39, 0xe6, 0xb5, 0x56, 0x56, 0x91,
0x87, 0x41, 0x93, 0x6f, 0x88, 0xf4, 0x49, 0x6b, 0x63, 0x35, 0x2f, 0x98, 0x94, 0xca, 0x32, 0xcb,
0x95, 0x34, 0xc1, 0x90, 0x9e, 0xb6, 0xac, 0xbf, 0x4d, 0x9b, 0x45, 0x71, 0xad, 0x59, 0x5d, 0xa3,
0x6e, 0xf9, 0x4c, 0xc3, 0x80, 0x22, 0x9b, 0x53, 0xfc, 0xd9, 0xa0, 0xb1, 0xe4, 0x19, 0x0c, 0x35,
0x1a, 0xd5, 0xe8, 0x19, 0x96, 0x92, 0x09, 0x4c, 0xa2, 0x51, 0x34, 0x3e, 0xa1, 0xf1, 0x5f, 0xf0,
0x03, 0x13, 0x48, 0xce, 0x60, 0xa0, 0x91, 0xcd, 0x4b, 0xb5, 0x58, 0x18, 0xb4, 0xc9, 0xd1, 0x28,
0x1a, 0xf7, 0x28, 0x38, 0xe8, 0xa3, 0x47, 0xc8, 0x53, 0xf0, 0xb7, 0x72, 0xc9, 0x05, 0xb7, 0x49,
0xcf, 0xf3, 0x27, 0x0e, 0xb9, 0x74, 0x40, 0x96, 0x41, 0x1c, 0x6a, 0x9a, 0x5a, 0x49, 0x83, 0x84,
0xc0, 0xf1, 0x9c, 0x59, 0x96, 0xc0, 0x28, 0x1a, 0xc7, 0xd4, 0x9f, 0xb3, 0x5f, 0x11, 0xc4, 0x5f,
0x34, 0xb7, 0x78, 0x50, 0xb2, 0x73, 0x88, 0xaf, 0x9d, 0xe9, 0xdf, 0x68, 0x03, 0x8f, 0xb5, 0xd9,
0xce, 0x21, 0x5e, 0x70, 0xc9, 0xcd, 0xf7, 0xd2, 0xa3, 0x3e, 0x5d, 0x9f, 0x0e, 0x02, 0xe6, 0x2b,
0xee, 0xcc, 0xf3, 0x16, 0x86, 0x6d, 0x9c, 0x36, 0xf4, 0x73, 0xb8, 0x37, 0x53, 0x42, 0x70, 0x6b,
0x71, 0x5e, 0x1a, 0x7e, 0x13, 0x02, 0xf5, 0xe8, 0x70, 0x8d, 0x5e, 0xf1, 0x1b, 0xcc, 0xde, 0xc1,
0xe3, 0xcf, 0x0d, 0xea, 0x95, 0x37, 0x5f, 0x59, 0x66, 0x1b, 0x73, 0xc8, 0x1f, 0x65, 0xdf, 0x20,
0xd9, 0xf6, 0x1f, 0x14, 0x81, 0xa4, 0xd0, 0x9f, 0x29, 0x51, 0x2f, 0xd1, 0xa2, 0x6f, 0x48, 0x9f,
0xae, 0xef, 0xaf, 0x7f, 0x1f, 0x01, 0x4c, 0x56, 0xee, 0xcb, 0x6e, 0x96, 0xc8, 0x7b, 0x38, 0x76,
0x2f, 0x43, 0x4e, 0xf3, 0xad, 0x39, 0xcb, 0x3b, 0x63, 0x92, 0x9e, 0xed, 0xe5, 0x43, 0xb4, 0x57,
0x11, 0xb9, 0x84, 0x3b, 0xa1, 0x9b, 0xbb, 0xb4, 0xdd, 0x97, 0x4d, 0x47, 0xfb, 0x05, 0xe1, 0x6b,
0xe3, 0x88, 0xfc, 0x80, 0x07, 0xff, 0xb7, 0x81, 0xbc, 0xd8, 0xe1, 0xdb, 0xd3, 0xeb, 0xf4, 0xe5,
0xad, 0xb4, 0xa1, 0xdc, 0x04, 0xe1, 0xd1, 0x4c, 0x89, 0x6d, 0xc7, 0xe4, 0xfe, 0xa6, 0x55, 0x9f,
0xdc, 0xf6, 0x7c, 0xbd, 0x68, 0x35, 0x95, 0x5a, 0x32, 0x59, 0xe5, 0x4a, 0x57, 0x45, 0x85, 0xd2,
0x6f, 0x56, 0x11, 0x28, 0x56, 0x73, 0xd3, 0x59, 0xe3, 0x8b, 0xcd, 0x71, 0x7a, 0xd7, 0xeb, 0xde,
0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0x8f, 0x91, 0x09, 0xd4, 0xf8, 0x03, 0x00, 0x00,
}

310
vendor/google.golang.org/genproto/googleapis/cloud/audit/audit_log.pb.go generated vendored Normal file
View File

@ -0,0 +1,310 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/audit/audit_log.proto
/*
Package audit is a generated protocol buffer package.
It is generated from these files:
google/cloud/audit/audit_log.proto
It has these top-level messages:
AuditLog
AuthenticationInfo
AuthorizationInfo
RequestMetadata
*/
package audit
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
import google_protobuf2 "github.com/golang/protobuf/ptypes/struct"
import google_rpc "google.golang.org/genproto/googleapis/rpc/status"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Common audit log format for Google Cloud Platform API operations.
type AuditLog struct {
// The name of the API service performing the operation. For example,
// `"datastore.googleapis.com"`.
ServiceName string `protobuf:"bytes,7,opt,name=service_name,json=serviceName" json:"service_name,omitempty"`
// The name of the service method or operation.
// For API calls, this should be the name of the API method.
// For example,
//
// "google.datastore.v1.Datastore.RunQuery"
// "google.logging.v1.LoggingService.DeleteLog"
MethodName string `protobuf:"bytes,8,opt,name=method_name,json=methodName" json:"method_name,omitempty"`
// The resource or collection that is the target of the operation.
// The name is a scheme-less URI, not including the API service name.
// For example:
//
// "shelves/SHELF_ID/books"
// "shelves/SHELF_ID/books/BOOK_ID"
ResourceName string `protobuf:"bytes,11,opt,name=resource_name,json=resourceName" json:"resource_name,omitempty"`
// The number of items returned from a List or Query API method,
// if applicable.
NumResponseItems int64 `protobuf:"varint,12,opt,name=num_response_items,json=numResponseItems" json:"num_response_items,omitempty"`
// The status of the overall operation.
Status *google_rpc.Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
// Authentication information.
AuthenticationInfo *AuthenticationInfo `protobuf:"bytes,3,opt,name=authentication_info,json=authenticationInfo" json:"authentication_info,omitempty"`
// Authorization information. If there are multiple
// resources or permissions involved, then there is
// one AuthorizationInfo element for each {resource, permission} tuple.
AuthorizationInfo []*AuthorizationInfo `protobuf:"bytes,9,rep,name=authorization_info,json=authorizationInfo" json:"authorization_info,omitempty"`
// Metadata about the operation.
RequestMetadata *RequestMetadata `protobuf:"bytes,4,opt,name=request_metadata,json=requestMetadata" json:"request_metadata,omitempty"`
// The operation request. This may not include all request parameters,
// such as those that are too large, privacy-sensitive, or duplicated
// elsewhere in the log record.
// It should never include user-generated data, such as file contents.
// When the JSON object represented here has a proto equivalent, the proto
// name will be indicated in the `@type` property.
Request *google_protobuf2.Struct `protobuf:"bytes,16,opt,name=request" json:"request,omitempty"`
// The operation response. This may not include all response elements,
// such as those that are too large, privacy-sensitive, or duplicated
// elsewhere in the log record.
// It should never include user-generated data, such as file contents.
// When the JSON object represented here has a proto equivalent, the proto
// name will be indicated in the `@type` property.
Response *google_protobuf2.Struct `protobuf:"bytes,17,opt,name=response" json:"response,omitempty"`
// Other service-specific data about the request, response, and other
// activities.
ServiceData *google_protobuf1.Any `protobuf:"bytes,15,opt,name=service_data,json=serviceData" json:"service_data,omitempty"`
}
func (m *AuditLog) Reset() { *m = AuditLog{} }
func (m *AuditLog) String() string { return proto.CompactTextString(m) }
func (*AuditLog) ProtoMessage() {}
func (*AuditLog) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *AuditLog) GetServiceName() string {
if m != nil {
return m.ServiceName
}
return ""
}
func (m *AuditLog) GetMethodName() string {
if m != nil {
return m.MethodName
}
return ""
}
func (m *AuditLog) GetResourceName() string {
if m != nil {
return m.ResourceName
}
return ""
}
func (m *AuditLog) GetNumResponseItems() int64 {
if m != nil {
return m.NumResponseItems
}
return 0
}
func (m *AuditLog) GetStatus() *google_rpc.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *AuditLog) GetAuthenticationInfo() *AuthenticationInfo {
if m != nil {
return m.AuthenticationInfo
}
return nil
}
func (m *AuditLog) GetAuthorizationInfo() []*AuthorizationInfo {
if m != nil {
return m.AuthorizationInfo
}
return nil
}
func (m *AuditLog) GetRequestMetadata() *RequestMetadata {
if m != nil {
return m.RequestMetadata
}
return nil
}
func (m *AuditLog) GetRequest() *google_protobuf2.Struct {
if m != nil {
return m.Request
}
return nil
}
func (m *AuditLog) GetResponse() *google_protobuf2.Struct {
if m != nil {
return m.Response
}
return nil
}
func (m *AuditLog) GetServiceData() *google_protobuf1.Any {
if m != nil {
return m.ServiceData
}
return nil
}
// Authentication information for the operation.
type AuthenticationInfo struct {
// The email address of the authenticated user making the request.
PrincipalEmail string `protobuf:"bytes,1,opt,name=principal_email,json=principalEmail" json:"principal_email,omitempty"`
}
func (m *AuthenticationInfo) Reset() { *m = AuthenticationInfo{} }
func (m *AuthenticationInfo) String() string { return proto.CompactTextString(m) }
func (*AuthenticationInfo) ProtoMessage() {}
func (*AuthenticationInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *AuthenticationInfo) GetPrincipalEmail() string {
if m != nil {
return m.PrincipalEmail
}
return ""
}
// Authorization information for the operation.
type AuthorizationInfo struct {
// The resource being accessed, as a REST-style string. For example:
//
// bigquery.googlapis.com/projects/PROJECTID/datasets/DATASETID
Resource string `protobuf:"bytes,1,opt,name=resource" json:"resource,omitempty"`
// The required IAM permission.
Permission string `protobuf:"bytes,2,opt,name=permission" json:"permission,omitempty"`
// Whether or not authorization for `resource` and `permission`
// was granted.
Granted bool `protobuf:"varint,3,opt,name=granted" json:"granted,omitempty"`
}
func (m *AuthorizationInfo) Reset() { *m = AuthorizationInfo{} }
func (m *AuthorizationInfo) String() string { return proto.CompactTextString(m) }
func (*AuthorizationInfo) ProtoMessage() {}
func (*AuthorizationInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *AuthorizationInfo) GetResource() string {
if m != nil {
return m.Resource
}
return ""
}
func (m *AuthorizationInfo) GetPermission() string {
if m != nil {
return m.Permission
}
return ""
}
func (m *AuthorizationInfo) GetGranted() bool {
if m != nil {
return m.Granted
}
return false
}
// Metadata about the request.
type RequestMetadata struct {
// The IP address of the caller.
CallerIp string `protobuf:"bytes,1,opt,name=caller_ip,json=callerIp" json:"caller_ip,omitempty"`
// The user agent of the caller.
// This information is not authenticated and should be treated accordingly.
// For example:
//
// + `google-api-python-client/1.4.0`:
// The request was made by the Google API client for Python.
// + `Cloud SDK Command Line Tool apitools-client/1.0 gcloud/0.9.62`:
// The request was made by the Google Cloud SDK CLI (gcloud).
// + `AppEngine-Google; (+http://code.google.com/appengine; appid: s~my-project`:
// The request was made from the `my-project` App Engine app.
CallerSuppliedUserAgent string `protobuf:"bytes,2,opt,name=caller_supplied_user_agent,json=callerSuppliedUserAgent" json:"caller_supplied_user_agent,omitempty"`
}
func (m *RequestMetadata) Reset() { *m = RequestMetadata{} }
func (m *RequestMetadata) String() string { return proto.CompactTextString(m) }
func (*RequestMetadata) ProtoMessage() {}
func (*RequestMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *RequestMetadata) GetCallerIp() string {
if m != nil {
return m.CallerIp
}
return ""
}
func (m *RequestMetadata) GetCallerSuppliedUserAgent() string {
if m != nil {
return m.CallerSuppliedUserAgent
}
return ""
}
func init() {
proto.RegisterType((*AuditLog)(nil), "google.cloud.audit.AuditLog")
proto.RegisterType((*AuthenticationInfo)(nil), "google.cloud.audit.AuthenticationInfo")
proto.RegisterType((*AuthorizationInfo)(nil), "google.cloud.audit.AuthorizationInfo")
proto.RegisterType((*RequestMetadata)(nil), "google.cloud.audit.RequestMetadata")
}
func init() { proto.RegisterFile("google/cloud/audit/audit_log.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 576 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x94, 0x5f, 0x6f, 0xd3, 0x30,
0x14, 0xc5, 0x55, 0x36, 0x6d, 0xad, 0xbb, 0xd1, 0xd6, 0x20, 0x1a, 0xca, 0x04, 0xa5, 0x13, 0x50,
0x21, 0x94, 0x88, 0xed, 0x61, 0x0f, 0x13, 0x0f, 0x9d, 0xe0, 0xa1, 0x12, 0x4c, 0x53, 0x0a, 0x42,
0xe2, 0x25, 0x72, 0x93, 0xdb, 0xcc, 0x22, 0xb1, 0x8d, 0xff, 0x20, 0x8d, 0xef, 0xcc, 0x77, 0x40,
0xbd, 0x71, 0x4a, 0xd7, 0x0e, 0x5e, 0x2c, 0xf9, 0x9c, 0xdf, 0xbd, 0x76, 0xaf, 0x4f, 0x43, 0x46,
0xb9, 0x94, 0x79, 0x01, 0x51, 0x5a, 0x48, 0x97, 0x45, 0xcc, 0x65, 0xdc, 0x56, 0x6b, 0x52, 0xc8,
0x3c, 0x54, 0x5a, 0x5a, 0x49, 0x69, 0xc5, 0x84, 0xc8, 0x84, 0xe8, 0x0e, 0x8e, 0x7c, 0x1d, 0x53,
0x3c, 0x62, 0x42, 0x48, 0xcb, 0x2c, 0x97, 0xc2, 0x54, 0x15, 0x83, 0xc7, 0xde, 0xc5, 0xdd, 0xdc,
0x2d, 0x22, 0x26, 0x6e, 0xbc, 0x75, 0xb4, 0x69, 0x19, 0xab, 0x5d, 0x6a, 0xbd, 0xdb, 0xf7, 0xae,
0x56, 0x69, 0x64, 0x2c, 0xb3, 0xce, 0x77, 0x1c, 0xfd, 0xde, 0x25, 0xcd, 0xc9, 0xf2, 0xe4, 0x8f,
0x32, 0xa7, 0xcf, 0xc9, 0x81, 0x01, 0xfd, 0x93, 0xa7, 0x90, 0x08, 0x56, 0x42, 0xb0, 0x3f, 0x6c,
0x8c, 0x5b, 0x71, 0xdb, 0x6b, 0x97, 0xac, 0x04, 0xfa, 0x8c, 0xb4, 0x4b, 0xb0, 0xd7, 0x32, 0xab,
0x88, 0x26, 0x12, 0xa4, 0x92, 0x10, 0x38, 0x26, 0x87, 0x1a, 0x8c, 0x74, 0xba, 0x6e, 0xd2, 0x46,
0xe4, 0xa0, 0x16, 0x11, 0x7a, 0x43, 0xa8, 0x70, 0x65, 0xa2, 0xc1, 0x28, 0x29, 0x0c, 0x24, 0xdc,
0x42, 0x69, 0x82, 0x83, 0x61, 0x63, 0xbc, 0x13, 0x77, 0x85, 0x2b, 0x63, 0x6f, 0x4c, 0x97, 0x3a,
0x7d, 0x4d, 0xf6, 0xaa, 0x3b, 0x07, 0xf7, 0x86, 0x8d, 0x71, 0xfb, 0x84, 0x86, 0x7e, 0x70, 0x5a,
0xa5, 0xe1, 0x0c, 0x9d, 0xd8, 0x13, 0xf4, 0x2b, 0x79, 0xc0, 0x9c, 0xbd, 0x06, 0x61, 0x79, 0x8a,
0xa3, 0x4b, 0xb8, 0x58, 0xc8, 0x60, 0x07, 0x0b, 0x5f, 0x86, 0xdb, 0x13, 0x0f, 0x27, 0xb7, 0xf0,
0xa9, 0x58, 0xc8, 0x98, 0xb2, 0x2d, 0x8d, 0x7e, 0x26, 0xa8, 0x4a, 0xcd, 0x7f, 0xad, 0xf5, 0x6d,
0x0d, 0x77, 0xc6, 0xed, 0x93, 0x17, 0xff, 0xea, 0xbb, 0xa2, 0xb1, 0x6d, 0x8f, 0x6d, 0x4a, 0xf4,
0x92, 0x74, 0x35, 0xfc, 0x70, 0x60, 0x6c, 0x52, 0x82, 0x65, 0x19, 0xb3, 0x2c, 0xd8, 0xc5, 0xbb,
0x1e, 0xdf, 0xd5, 0x33, 0xae, 0xd8, 0x4f, 0x1e, 0x8d, 0x3b, 0xfa, 0xb6, 0x40, 0xdf, 0x92, 0x7d,
0x2f, 0x05, 0x5d, 0x6c, 0xd3, 0xaf, 0xdb, 0xd4, 0xb9, 0x08, 0x67, 0x98, 0x8b, 0xb8, 0xe6, 0xe8,
0x29, 0x69, 0xd6, 0xef, 0x10, 0xf4, 0xfe, 0x5f, 0xb3, 0x02, 0xe9, 0xd9, 0xdf, 0xa4, 0xe0, 0x9d,
0x3b, 0x58, 0xf8, 0x70, 0xab, 0x70, 0x22, 0x6e, 0x56, 0xf9, 0x79, 0xcf, 0x2c, 0x1b, 0xbd, 0x23,
0x74, 0x7b, 0xe0, 0xf4, 0x15, 0xe9, 0x28, 0xcd, 0x45, 0xca, 0x15, 0x2b, 0x12, 0x28, 0x19, 0x2f,
0x82, 0x06, 0xc6, 0xe6, 0xfe, 0x4a, 0xfe, 0xb0, 0x54, 0x47, 0x9c, 0xf4, 0xb6, 0xe6, 0x4a, 0x07,
0xf8, 0x0b, 0x30, 0x5d, 0xbe, 0x6c, 0xb5, 0xa7, 0x4f, 0x09, 0x51, 0xa0, 0x4b, 0x6e, 0x0c, 0x97,
0x02, 0xf3, 0xd3, 0x8a, 0xd7, 0x14, 0x1a, 0x90, 0xfd, 0x5c, 0x33, 0x61, 0x21, 0xc3, 0x8c, 0x34,
0xe3, 0x7a, 0x3b, 0xfa, 0x4e, 0x3a, 0x1b, 0xe3, 0xa6, 0x4f, 0x48, 0x2b, 0x65, 0x45, 0x01, 0x3a,
0xe1, 0xaa, 0x3e, 0xa9, 0x12, 0xa6, 0x8a, 0x9e, 0x93, 0x81, 0x37, 0x8d, 0x53, 0xaa, 0xe0, 0x90,
0x25, 0xce, 0x80, 0x4e, 0x58, 0x0e, 0xc2, 0xfa, 0x93, 0xfb, 0x15, 0x31, 0xf3, 0xc0, 0x17, 0x03,
0x7a, 0xb2, 0xb4, 0x2f, 0xe6, 0xe4, 0x51, 0x2a, 0xcb, 0x3b, 0x9e, 0xfc, 0xe2, 0xb0, 0xfe, 0x77,
0x5e, 0x2d, 0x67, 0x7a, 0xd5, 0xf8, 0x76, 0xe6, 0xa1, 0x5c, 0x16, 0x4c, 0xe4, 0xa1, 0xd4, 0x79,
0x94, 0x83, 0xc0, 0x89, 0x47, 0x95, 0xc5, 0x14, 0x37, 0xeb, 0x1f, 0x9e, 0x73, 0x5c, 0xe7, 0x7b,
0xc8, 0x9c, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0x90, 0xe4, 0x37, 0xbf, 0x9b, 0x04, 0x00, 0x00,
}

1868
vendor/google.golang.org/genproto/googleapis/cloud/bigquery/datatransfer/v1/datatransfer.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

521
vendor/google.golang.org/genproto/googleapis/cloud/bigquery/datatransfer/v1/transfer.pb.go generated vendored Normal file
View File

@ -0,0 +1,521 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/bigquery/datatransfer/v1/transfer.proto
package datatransfer
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf1 "github.com/golang/protobuf/ptypes/struct"
import google_protobuf2 "github.com/golang/protobuf/ptypes/timestamp"
import _ "google.golang.org/genproto/googleapis/rpc/status"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Represents data transfer type.
type TransferType int32
const (
// Invalid or Unknown transfer type placeholder.
TransferType_TRANSFER_TYPE_UNSPECIFIED TransferType = 0
// Batch data transfer.
TransferType_BATCH TransferType = 1
// Streaming data transfer. Streaming data source currently doesn't
// support multiple transfer configs per project.
TransferType_STREAMING TransferType = 2
)
var TransferType_name = map[int32]string{
0: "TRANSFER_TYPE_UNSPECIFIED",
1: "BATCH",
2: "STREAMING",
}
var TransferType_value = map[string]int32{
"TRANSFER_TYPE_UNSPECIFIED": 0,
"BATCH": 1,
"STREAMING": 2,
}
func (x TransferType) String() string {
return proto.EnumName(TransferType_name, int32(x))
}
func (TransferType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
// Represents data transfer run state.
type TransferState int32
const (
// State placeholder.
TransferState_TRANSFER_STATE_UNSPECIFIED TransferState = 0
// Data transfer is inactive.
TransferState_INACTIVE TransferState = 1
// Data transfer is scheduled and is waiting to be picked up by
// data transfer backend.
TransferState_PENDING TransferState = 2
// Data transfer is in progress.
TransferState_RUNNING TransferState = 3
// Data transfer completed successsfully.
TransferState_SUCCEEDED TransferState = 4
// Data transfer failed.
TransferState_FAILED TransferState = 5
// Data transfer is cancelled.
TransferState_CANCELLED TransferState = 6
)
var TransferState_name = map[int32]string{
0: "TRANSFER_STATE_UNSPECIFIED",
1: "INACTIVE",
2: "PENDING",
3: "RUNNING",
4: "SUCCEEDED",
5: "FAILED",
6: "CANCELLED",
}
var TransferState_value = map[string]int32{
"TRANSFER_STATE_UNSPECIFIED": 0,
"INACTIVE": 1,
"PENDING": 2,
"RUNNING": 3,
"SUCCEEDED": 4,
"FAILED": 5,
"CANCELLED": 6,
}
func (x TransferState) String() string {
return proto.EnumName(TransferState_name, int32(x))
}
func (TransferState) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
// Represents data transfer user facing message severity.
type TransferMessage_MessageSeverity int32
const (
// No severity specified.
TransferMessage_MESSAGE_SEVERITY_UNSPECIFIED TransferMessage_MessageSeverity = 0
// Informational message.
TransferMessage_INFO TransferMessage_MessageSeverity = 1
// Warning message.
TransferMessage_WARNING TransferMessage_MessageSeverity = 2
// Error message.
TransferMessage_ERROR TransferMessage_MessageSeverity = 3
)
var TransferMessage_MessageSeverity_name = map[int32]string{
0: "MESSAGE_SEVERITY_UNSPECIFIED",
1: "INFO",
2: "WARNING",
3: "ERROR",
}
var TransferMessage_MessageSeverity_value = map[string]int32{
"MESSAGE_SEVERITY_UNSPECIFIED": 0,
"INFO": 1,
"WARNING": 2,
"ERROR": 3,
}
func (x TransferMessage_MessageSeverity) String() string {
return proto.EnumName(TransferMessage_MessageSeverity_name, int32(x))
}
func (TransferMessage_MessageSeverity) EnumDescriptor() ([]byte, []int) {
return fileDescriptor1, []int{2, 0}
}
// Represents a data transfer configuration. A transfer configuration
// contains all metadata needed to perform a data transfer. For example,
// `destination_dataset_id` specifies where data should be stored.
// When a new transfer configuration is created, the specified
// `destination_dataset_id` is created when needed and shared with the
// appropriate data source service account.
type TransferConfig struct {
// The resource name of the transfer config.
// Transfer config names have the form
// `projects/{project_id}/transferConfigs/{config_id}`.
// Where `config_id` is usually a uuid, even though it is not
// guaranteed or required. The name is ignored when creating a transfer
// config.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The BigQuery target dataset id.
DestinationDatasetId string `protobuf:"bytes,2,opt,name=destination_dataset_id,json=destinationDatasetId" json:"destination_dataset_id,omitempty"`
// User specified display name for the data transfer.
DisplayName string `protobuf:"bytes,3,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
// Data source id. Cannot be changed once data transfer is created.
DataSourceId string `protobuf:"bytes,5,opt,name=data_source_id,json=dataSourceId" json:"data_source_id,omitempty"`
// Data transfer specific parameters.
Params *google_protobuf1.Struct `protobuf:"bytes,9,opt,name=params" json:"params,omitempty"`
// Data transfer schedule.
// If the data source does not support a custom schedule, this should be
// empty. If it is empty, the default value for the data source will be
// used.
// The specified times are in UTC.
// Examples of valid format:
// `1st,3rd monday of month 15:30`,
// `every wed,fri of jan,jun 13:15`, and
// `first sunday of quarter 00:00`.
// See more explanation about the format here:
// https://cloud.google.com/appengine/docs/flexible/python/scheduling-jobs-with-cron-yaml#the_schedule_format
// NOTE: the granularity should be at least 8 hours, or less frequent.
Schedule string `protobuf:"bytes,7,opt,name=schedule" json:"schedule,omitempty"`
// The number of days to look back to automatically refresh the data.
// For example, if `data_refresh_window_days = 10`, then every day
// BigQuery reingests data for [today-10, today-1], rather than ingesting data
// for just [today-1].
// Only valid if the data source supports the feature. Set the value to 0
// to use the default value.
DataRefreshWindowDays int32 `protobuf:"varint,12,opt,name=data_refresh_window_days,json=dataRefreshWindowDays" json:"data_refresh_window_days,omitempty"`
// Is this config disabled. When set to true, no runs are scheduled
// for a given transfer.
Disabled bool `protobuf:"varint,13,opt,name=disabled" json:"disabled,omitempty"`
// Output only. Data transfer modification time. Ignored by server on input.
UpdateTime *google_protobuf2.Timestamp `protobuf:"bytes,4,opt,name=update_time,json=updateTime" json:"update_time,omitempty"`
// Output only. Next time when data transfer will run.
NextRunTime *google_protobuf2.Timestamp `protobuf:"bytes,8,opt,name=next_run_time,json=nextRunTime" json:"next_run_time,omitempty"`
// Output only. State of the most recently updated transfer run.
State TransferState `protobuf:"varint,10,opt,name=state,enum=google.cloud.bigquery.datatransfer.v1.TransferState" json:"state,omitempty"`
// Output only. Unique ID of the user on whose behalf transfer is done.
// Applicable only to data sources that do not support service accounts.
// When set to 0, the data source service account credentials are used.
UserId int64 `protobuf:"varint,11,opt,name=user_id,json=userId" json:"user_id,omitempty"`
// Output only. Region in which BigQuery dataset is located.
DatasetRegion string `protobuf:"bytes,14,opt,name=dataset_region,json=datasetRegion" json:"dataset_region,omitempty"`
}
func (m *TransferConfig) Reset() { *m = TransferConfig{} }
func (m *TransferConfig) String() string { return proto.CompactTextString(m) }
func (*TransferConfig) ProtoMessage() {}
func (*TransferConfig) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
func (m *TransferConfig) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *TransferConfig) GetDestinationDatasetId() string {
if m != nil {
return m.DestinationDatasetId
}
return ""
}
func (m *TransferConfig) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
func (m *TransferConfig) GetDataSourceId() string {
if m != nil {
return m.DataSourceId
}
return ""
}
func (m *TransferConfig) GetParams() *google_protobuf1.Struct {
if m != nil {
return m.Params
}
return nil
}
func (m *TransferConfig) GetSchedule() string {
if m != nil {
return m.Schedule
}
return ""
}
func (m *TransferConfig) GetDataRefreshWindowDays() int32 {
if m != nil {
return m.DataRefreshWindowDays
}
return 0
}
func (m *TransferConfig) GetDisabled() bool {
if m != nil {
return m.Disabled
}
return false
}
func (m *TransferConfig) GetUpdateTime() *google_protobuf2.Timestamp {
if m != nil {
return m.UpdateTime
}
return nil
}
func (m *TransferConfig) GetNextRunTime() *google_protobuf2.Timestamp {
if m != nil {
return m.NextRunTime
}
return nil
}
func (m *TransferConfig) GetState() TransferState {
if m != nil {
return m.State
}
return TransferState_TRANSFER_STATE_UNSPECIFIED
}
func (m *TransferConfig) GetUserId() int64 {
if m != nil {
return m.UserId
}
return 0
}
func (m *TransferConfig) GetDatasetRegion() string {
if m != nil {
return m.DatasetRegion
}
return ""
}
// Represents a data transfer run.
// Next id: 23
type TransferRun struct {
// The resource name of the transfer run.
// Transfer run names have the form
// `projects/{project_id}/locations/{location}/transferConfigs/{config_id}/runs/{run_id}`.
// The name is ignored when creating a transfer run.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The BigQuery target dataset id.
DestinationDatasetId string `protobuf:"bytes,2,opt,name=destination_dataset_id,json=destinationDatasetId" json:"destination_dataset_id,omitempty"`
// Minimum time after which a transfer run can be started.
ScheduleTime *google_protobuf2.Timestamp `protobuf:"bytes,3,opt,name=schedule_time,json=scheduleTime" json:"schedule_time,omitempty"`
// Data transfer specific parameters.
Params *google_protobuf1.Struct `protobuf:"bytes,9,opt,name=params" json:"params,omitempty"`
// For batch transfer runs, specifies the date and time that
// data should be ingested.
RunTime *google_protobuf2.Timestamp `protobuf:"bytes,10,opt,name=run_time,json=runTime" json:"run_time,omitempty"`
// Output only. Time when transfer run was started.
// Parameter ignored by server for input requests.
StartTime *google_protobuf2.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
// Output only. Time when transfer run ended.
// Parameter ignored by server for input requests.
EndTime *google_protobuf2.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
// Output only. Last time the data transfer run state was updated.
UpdateTime *google_protobuf2.Timestamp `protobuf:"bytes,6,opt,name=update_time,json=updateTime" json:"update_time,omitempty"`
// Output only. Data source id.
DataSourceId string `protobuf:"bytes,7,opt,name=data_source_id,json=dataSourceId" json:"data_source_id,omitempty"`
// Data transfer run state. Ignored for input requests.
State TransferState `protobuf:"varint,8,opt,name=state,enum=google.cloud.bigquery.datatransfer.v1.TransferState" json:"state,omitempty"`
// Output only. Unique ID of the user on whose behalf transfer is done.
// Applicable only to data sources that do not support service accounts.
// When set to 0, the data source service account credentials are used.
// May be negative.
UserId int64 `protobuf:"varint,11,opt,name=user_id,json=userId" json:"user_id,omitempty"`
// Output only. Describes the schedule of this transfer run if it was
// created as part of a regular schedule. For batch transfer runs that are
// scheduled manually, this is empty.
// NOTE: the system might choose to delay the schedule depending on the
// current load, so `schedule_time` doesn't always matches this.
Schedule string `protobuf:"bytes,12,opt,name=schedule" json:"schedule,omitempty"`
}
func (m *TransferRun) Reset() { *m = TransferRun{} }
func (m *TransferRun) String() string { return proto.CompactTextString(m) }
func (*TransferRun) ProtoMessage() {}
func (*TransferRun) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
func (m *TransferRun) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *TransferRun) GetDestinationDatasetId() string {
if m != nil {
return m.DestinationDatasetId
}
return ""
}
func (m *TransferRun) GetScheduleTime() *google_protobuf2.Timestamp {
if m != nil {
return m.ScheduleTime
}
return nil
}
func (m *TransferRun) GetParams() *google_protobuf1.Struct {
if m != nil {
return m.Params
}
return nil
}
func (m *TransferRun) GetRunTime() *google_protobuf2.Timestamp {
if m != nil {
return m.RunTime
}
return nil
}
func (m *TransferRun) GetStartTime() *google_protobuf2.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
func (m *TransferRun) GetEndTime() *google_protobuf2.Timestamp {
if m != nil {
return m.EndTime
}
return nil
}
func (m *TransferRun) GetUpdateTime() *google_protobuf2.Timestamp {
if m != nil {
return m.UpdateTime
}
return nil
}
func (m *TransferRun) GetDataSourceId() string {
if m != nil {
return m.DataSourceId
}
return ""
}
func (m *TransferRun) GetState() TransferState {
if m != nil {
return m.State
}
return TransferState_TRANSFER_STATE_UNSPECIFIED
}
func (m *TransferRun) GetUserId() int64 {
if m != nil {
return m.UserId
}
return 0
}
func (m *TransferRun) GetSchedule() string {
if m != nil {
return m.Schedule
}
return ""
}
// Represents a user facing message for a particular data transfer run.
type TransferMessage struct {
// Time when message was logged.
MessageTime *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=message_time,json=messageTime" json:"message_time,omitempty"`
// Message severity.
Severity TransferMessage_MessageSeverity `protobuf:"varint,2,opt,name=severity,enum=google.cloud.bigquery.datatransfer.v1.TransferMessage_MessageSeverity" json:"severity,omitempty"`
// Message text.
MessageText string `protobuf:"bytes,3,opt,name=message_text,json=messageText" json:"message_text,omitempty"`
}
func (m *TransferMessage) Reset() { *m = TransferMessage{} }
func (m *TransferMessage) String() string { return proto.CompactTextString(m) }
func (*TransferMessage) ProtoMessage() {}
func (*TransferMessage) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
func (m *TransferMessage) GetMessageTime() *google_protobuf2.Timestamp {
if m != nil {
return m.MessageTime
}
return nil
}
func (m *TransferMessage) GetSeverity() TransferMessage_MessageSeverity {
if m != nil {
return m.Severity
}
return TransferMessage_MESSAGE_SEVERITY_UNSPECIFIED
}
func (m *TransferMessage) GetMessageText() string {
if m != nil {
return m.MessageText
}
return ""
}
func init() {
proto.RegisterType((*TransferConfig)(nil), "google.cloud.bigquery.datatransfer.v1.TransferConfig")
proto.RegisterType((*TransferRun)(nil), "google.cloud.bigquery.datatransfer.v1.TransferRun")
proto.RegisterType((*TransferMessage)(nil), "google.cloud.bigquery.datatransfer.v1.TransferMessage")
proto.RegisterEnum("google.cloud.bigquery.datatransfer.v1.TransferType", TransferType_name, TransferType_value)
proto.RegisterEnum("google.cloud.bigquery.datatransfer.v1.TransferState", TransferState_name, TransferState_value)
proto.RegisterEnum("google.cloud.bigquery.datatransfer.v1.TransferMessage_MessageSeverity", TransferMessage_MessageSeverity_name, TransferMessage_MessageSeverity_value)
}
func init() {
proto.RegisterFile("google/cloud/bigquery/datatransfer/v1/transfer.proto", fileDescriptor1)
}
var fileDescriptor1 = []byte{
// 910 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xdf, 0x6e, 0xe3, 0xc4,
0x17, 0xfe, 0xb9, 0xf9, 0x7f, 0xf2, 0x67, 0xa3, 0xd1, 0x0f, 0x6a, 0xaa, 0x05, 0x42, 0x45, 0xa5,
0xb0, 0x17, 0xb6, 0x5a, 0xba, 0x42, 0x68, 0x05, 0x28, 0x71, 0x9c, 0x60, 0xb4, 0xf5, 0x66, 0xc7,
0x6e, 0x57, 0x8b, 0x2a, 0x59, 0x93, 0x78, 0xea, 0xb5, 0x94, 0xd8, 0xc1, 0x33, 0xee, 0x36, 0x97,
0xbc, 0x0a, 0x97, 0x5c, 0xf0, 0x20, 0x5c, 0x70, 0xc9, 0x2b, 0xf0, 0x1a, 0x68, 0xc6, 0x76, 0x94,
0xcd, 0x22, 0xa5, 0x95, 0xe0, 0x2a, 0x9e, 0x73, 0xbe, 0xef, 0x9b, 0x6f, 0xce, 0x39, 0x33, 0x81,
0xf3, 0x20, 0x8e, 0x83, 0x05, 0xd5, 0xe7, 0x8b, 0x38, 0xf5, 0xf5, 0x59, 0x18, 0xfc, 0x94, 0xd2,
0x64, 0xad, 0xfb, 0x84, 0x13, 0x9e, 0x90, 0x88, 0xdd, 0xd0, 0x44, 0xbf, 0x3d, 0xd5, 0x8b, 0x6f,
0x6d, 0x95, 0xc4, 0x3c, 0x46, 0x27, 0x19, 0x4b, 0x93, 0x2c, 0xad, 0x60, 0x69, 0xdb, 0x2c, 0xed,
0xf6, 0xf4, 0xe8, 0x71, 0x2e, 0x4e, 0x56, 0xa1, 0x4e, 0xa2, 0x28, 0xe6, 0x84, 0x87, 0x71, 0xc4,
0x32, 0x91, 0x4d, 0x56, 0xae, 0x66, 0xe9, 0x8d, 0xce, 0x78, 0x92, 0xce, 0x79, 0x9e, 0xfd, 0x74,
0x37, 0xcb, 0xc3, 0x25, 0x65, 0x9c, 0x2c, 0x57, 0x39, 0xe0, 0x30, 0x07, 0x24, 0xab, 0xb9, 0xce,
0x38, 0xe1, 0x69, 0xae, 0x7b, 0xfc, 0x47, 0x19, 0x3a, 0x6e, 0xee, 0xc2, 0x88, 0xa3, 0x9b, 0x30,
0x40, 0x08, 0xca, 0x11, 0x59, 0x52, 0x55, 0xe9, 0x29, 0xfd, 0x06, 0x96, 0xdf, 0xe8, 0x1c, 0x3e,
0xf4, 0x29, 0xe3, 0x61, 0x24, 0x4d, 0x79, 0xc2, 0x3b, 0xa3, 0xdc, 0x0b, 0x7d, 0xf5, 0x40, 0xa2,
0xfe, 0xbf, 0x95, 0x1d, 0x65, 0x49, 0xcb, 0x47, 0x9f, 0x41, 0xcb, 0x0f, 0xd9, 0x6a, 0x41, 0xd6,
0x9e, 0x54, 0x2c, 0x49, 0x6c, 0x33, 0x8f, 0xd9, 0x42, 0xf8, 0x73, 0xe8, 0x08, 0x31, 0x8f, 0xc5,
0x69, 0x32, 0xa7, 0x42, 0xb0, 0x22, 0x41, 0x2d, 0x11, 0x75, 0x64, 0xd0, 0xf2, 0x91, 0x0e, 0xd5,
0x15, 0x49, 0xc8, 0x92, 0xa9, 0x8d, 0x9e, 0xd2, 0x6f, 0x9e, 0x1d, 0x6a, 0x79, 0x4d, 0x8b, 0x03,
0x6b, 0x8e, 0x2c, 0x07, 0xce, 0x61, 0xe8, 0x08, 0xea, 0x6c, 0xfe, 0x86, 0xfa, 0xe9, 0x82, 0xaa,
0x35, 0x29, 0xb8, 0x59, 0xa3, 0xaf, 0x40, 0x95, 0x5b, 0x26, 0xf4, 0x26, 0xa1, 0xec, 0x8d, 0xf7,
0x36, 0x8c, 0xfc, 0xf8, 0xad, 0xe7, 0x93, 0x35, 0x53, 0x5b, 0x3d, 0xa5, 0x5f, 0xc1, 0x1f, 0x88,
0x3c, 0xce, 0xd2, 0xaf, 0x64, 0x76, 0x44, 0xd6, 0x52, 0xd4, 0x0f, 0x19, 0x99, 0x2d, 0xa8, 0xaf,
0xb6, 0x7b, 0x4a, 0xbf, 0x8e, 0x37, 0x6b, 0xf4, 0x0c, 0x9a, 0xe9, 0xca, 0x27, 0x9c, 0x7a, 0xa2,
0xf4, 0x6a, 0x59, 0xda, 0x3c, 0x7a, 0xcf, 0xa6, 0x5b, 0xf4, 0x05, 0x43, 0x06, 0x17, 0x01, 0xf4,
0x2d, 0xb4, 0x23, 0x7a, 0xc7, 0xbd, 0x24, 0x8d, 0x32, 0x7a, 0x7d, 0x2f, 0xbd, 0x29, 0x08, 0x38,
0x8d, 0x24, 0xff, 0x07, 0xa8, 0x88, 0xa6, 0x52, 0x15, 0x7a, 0x4a, 0xbf, 0x73, 0x76, 0xae, 0xdd,
0x6b, 0xe2, 0xb4, 0xa2, 0xef, 0x8e, 0xe0, 0xe2, 0x4c, 0x02, 0x1d, 0x42, 0x2d, 0x65, 0x34, 0x11,
0x9d, 0x68, 0xf6, 0x94, 0x7e, 0x09, 0x57, 0xc5, 0xd2, 0xf2, 0xd1, 0x49, 0xd6, 0x29, 0xd1, 0xf6,
0x84, 0x06, 0x61, 0x1c, 0xa9, 0x1d, 0x59, 0xd8, 0x76, 0x1e, 0xc5, 0x32, 0x78, 0xfc, 0x67, 0x19,
0x9a, 0x85, 0x30, 0x4e, 0xa3, 0x7f, 0x71, 0x9a, 0xbe, 0x83, 0x76, 0xd1, 0xc3, 0xac, 0x4a, 0xa5,
0xbd, 0x55, 0x6a, 0x15, 0x04, 0x59, 0xa6, 0x07, 0x4f, 0xd1, 0x53, 0xa8, 0x6f, 0x5a, 0x02, 0x7b,
0x37, 0xab, 0x25, 0x79, 0x3b, 0xbe, 0x06, 0x60, 0x9c, 0x24, 0xfc, 0xbe, 0xa3, 0xd0, 0x90, 0x68,
0x49, 0x7d, 0x0a, 0x75, 0x1a, 0xf9, 0x19, 0xb1, 0xb2, 0x7f, 0x47, 0x1a, 0xf9, 0x92, 0xb6, 0x33,
0x7d, 0xd5, 0x07, 0x4d, 0xdf, 0xfb, 0x57, 0xb0, 0xf6, 0x0f, 0x57, 0x70, 0x33, 0x63, 0xf5, 0xff,
0x70, 0xc6, 0xb6, 0xaf, 0x6d, 0xeb, 0xdd, 0x6b, 0x7b, 0xfc, 0xdb, 0x01, 0x3c, 0x2a, 0xd4, 0x2e,
0x28, 0x63, 0x24, 0xa0, 0xe8, 0x1b, 0x68, 0x2d, 0xb3, 0xcf, 0xec, 0xe0, 0xca, 0xfe, 0x7b, 0x93,
0xe3, 0xe5, 0xc9, 0x67, 0x50, 0x67, 0xf4, 0x96, 0x26, 0x21, 0x5f, 0xcb, 0xc9, 0xeb, 0x9c, 0x8d,
0x1f, 0x78, 0xac, 0xdc, 0x88, 0x96, 0xff, 0x3a, 0xb9, 0x1a, 0xde, 0xe8, 0x8a, 0x37, 0x70, 0x63,
0x91, 0xde, 0xf1, 0xe2, 0x0d, 0x2c, 0x6c, 0xd0, 0x3b, 0x7e, 0x7c, 0x09, 0x8f, 0x76, 0xf8, 0xa8,
0x07, 0x8f, 0x2f, 0x4c, 0xc7, 0x19, 0x4c, 0x4c, 0xcf, 0x31, 0xaf, 0x4c, 0x6c, 0xb9, 0xaf, 0xbd,
0x4b, 0xdb, 0x99, 0x9a, 0x86, 0x35, 0xb6, 0xcc, 0x51, 0xf7, 0x7f, 0xa8, 0x0e, 0x65, 0xcb, 0x1e,
0xbf, 0xe8, 0x2a, 0xa8, 0x09, 0xb5, 0x57, 0x03, 0x6c, 0x5b, 0xf6, 0xa4, 0x7b, 0x80, 0x1a, 0x50,
0x31, 0x31, 0x7e, 0x81, 0xbb, 0xa5, 0x27, 0x13, 0x68, 0x15, 0x36, 0xdd, 0xf5, 0x8a, 0xa2, 0x8f,
0xe1, 0x23, 0x17, 0x0f, 0x6c, 0x67, 0x6c, 0x62, 0xcf, 0x7d, 0x3d, 0x35, 0x77, 0x04, 0x1b, 0x50,
0x19, 0x0e, 0x5c, 0xe3, 0xfb, 0xae, 0x82, 0xda, 0xd0, 0x70, 0x5c, 0x6c, 0x0e, 0x2e, 0xa4, 0xe6,
0x93, 0x9f, 0x15, 0x68, 0xbf, 0xd3, 0x47, 0xf4, 0x09, 0x1c, 0x6d, 0xa4, 0x1c, 0x77, 0xe0, 0xee,
0x6a, 0xb5, 0xa0, 0x6e, 0xd9, 0x03, 0xc3, 0xb5, 0xae, 0xcc, 0xcc, 0xe0, 0xd4, 0xb4, 0x47, 0x99,
0xc1, 0x26, 0xd4, 0xf0, 0xa5, 0x2d, 0xdd, 0x96, 0xe4, 0x46, 0x97, 0x86, 0x61, 0x9a, 0x23, 0x73,
0xd4, 0x2d, 0x23, 0x80, 0xea, 0x78, 0x60, 0x3d, 0x37, 0x47, 0xdd, 0x8a, 0x48, 0x19, 0x03, 0xdb,
0x30, 0x9f, 0x8b, 0x65, 0x75, 0xf8, 0x97, 0x02, 0x5f, 0xcc, 0xe3, 0xe5, 0xfd, 0xda, 0x33, 0xdc,
0xd8, 0x9d, 0x8a, 0x09, 0x98, 0x2a, 0x3f, 0xbe, 0xcc, 0x79, 0x41, 0xbc, 0x20, 0x51, 0xa0, 0xc5,
0x49, 0xa0, 0x07, 0x34, 0x92, 0xf3, 0xa1, 0x67, 0x29, 0xb2, 0x0a, 0xd9, 0x9e, 0x3f, 0xf6, 0x67,
0xdb, 0xeb, 0x5f, 0x0e, 0x2a, 0x13, 0x63, 0x38, 0x72, 0x7f, 0x3d, 0x38, 0x99, 0x64, 0xda, 0x86,
0xf4, 0x34, 0x0c, 0x83, 0x97, 0xd2, 0x93, 0x78, 0xb8, 0x0a, 0x1b, 0xda, 0xd5, 0xe9, 0xef, 0x05,
0xee, 0x5a, 0xe2, 0xae, 0x0b, 0xdc, 0xf5, 0x36, 0xee, 0xfa, 0xea, 0x74, 0x56, 0x95, 0xae, 0xbe,
0xfc, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xf0, 0xc4, 0x0e, 0x43, 0x6d, 0x08, 0x00, 0x00,
}

2225
vendor/google.golang.org/genproto/googleapis/cloud/bigquery/logging/v1/audit_data.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

688
vendor/google.golang.org/genproto/googleapis/cloud/billing/v1/cloud_billing.pb.go generated vendored Normal file
View File

@ -0,0 +1,688 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/billing/v1/cloud_billing.proto
/*
Package billing is a generated protocol buffer package.
It is generated from these files:
google/cloud/billing/v1/cloud_billing.proto
It has these top-level messages:
BillingAccount
ProjectBillingInfo
GetBillingAccountRequest
ListBillingAccountsRequest
ListBillingAccountsResponse
ListProjectBillingInfoRequest
ListProjectBillingInfoResponse
GetProjectBillingInfoRequest
UpdateProjectBillingInfoRequest
*/
package billing
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A billing account in [Google Cloud
// Console](https://console.cloud.google.com/). You can assign a billing account
// to one or more projects.
type BillingAccount struct {
// The resource name of the billing account. The resource name has the form
// `billingAccounts/{billing_account_id}`. For example,
// `billingAccounts/012345-567890-ABCDEF` would be the resource name for
// billing account `012345-567890-ABCDEF`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// True if the billing account is open, and will therefore be charged for any
// usage on associated projects. False if the billing account is closed, and
// therefore projects associated with it will be unable to use paid services.
Open bool `protobuf:"varint,2,opt,name=open" json:"open,omitempty"`
// The display name given to the billing account, such as `My Billing
// Account`. This name is displayed in the Google Cloud Console.
DisplayName string `protobuf:"bytes,3,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
}
func (m *BillingAccount) Reset() { *m = BillingAccount{} }
func (m *BillingAccount) String() string { return proto.CompactTextString(m) }
func (*BillingAccount) ProtoMessage() {}
func (*BillingAccount) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *BillingAccount) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *BillingAccount) GetOpen() bool {
if m != nil {
return m.Open
}
return false
}
func (m *BillingAccount) GetDisplayName() string {
if m != nil {
return m.DisplayName
}
return ""
}
// Encapsulation of billing information for a Cloud Console project. A project
// has at most one associated billing account at a time (but a billing account
// can be assigned to multiple projects).
type ProjectBillingInfo struct {
// The resource name for the `ProjectBillingInfo`; has the form
// `projects/{project_id}/billingInfo`. For example, the resource name for the
// billing information for project `tokyo-rain-123` would be
// `projects/tokyo-rain-123/billingInfo`. This field is read-only.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The ID of the project that this `ProjectBillingInfo` represents, such as
// `tokyo-rain-123`. This is a convenience field so that you don't need to
// parse the `name` field to obtain a project ID. This field is read-only.
ProjectId string `protobuf:"bytes,2,opt,name=project_id,json=projectId" json:"project_id,omitempty"`
// The resource name of the billing account associated with the project, if
// any. For example, `billingAccounts/012345-567890-ABCDEF`.
BillingAccountName string `protobuf:"bytes,3,opt,name=billing_account_name,json=billingAccountName" json:"billing_account_name,omitempty"`
// True if the project is associated with an open billing account, to which
// usage on the project is charged. False if the project is associated with a
// closed billing account, or no billing account at all, and therefore cannot
// use paid services. This field is read-only.
BillingEnabled bool `protobuf:"varint,4,opt,name=billing_enabled,json=billingEnabled" json:"billing_enabled,omitempty"`
}
func (m *ProjectBillingInfo) Reset() { *m = ProjectBillingInfo{} }
func (m *ProjectBillingInfo) String() string { return proto.CompactTextString(m) }
func (*ProjectBillingInfo) ProtoMessage() {}
func (*ProjectBillingInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *ProjectBillingInfo) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *ProjectBillingInfo) GetProjectId() string {
if m != nil {
return m.ProjectId
}
return ""
}
func (m *ProjectBillingInfo) GetBillingAccountName() string {
if m != nil {
return m.BillingAccountName
}
return ""
}
func (m *ProjectBillingInfo) GetBillingEnabled() bool {
if m != nil {
return m.BillingEnabled
}
return false
}
// Request message for `GetBillingAccount`.
type GetBillingAccountRequest struct {
// The resource name of the billing account to retrieve. For example,
// `billingAccounts/012345-567890-ABCDEF`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetBillingAccountRequest) Reset() { *m = GetBillingAccountRequest{} }
func (m *GetBillingAccountRequest) String() string { return proto.CompactTextString(m) }
func (*GetBillingAccountRequest) ProtoMessage() {}
func (*GetBillingAccountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *GetBillingAccountRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Request message for `ListBillingAccounts`.
type ListBillingAccountsRequest struct {
// Requested page size. The maximum page size is 100; this is also the
// default.
PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
// A token identifying a page of results to return. This should be a
// `next_page_token` value returned from a previous `ListBillingAccounts`
// call. If unspecified, the first page of results is returned.
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
}
func (m *ListBillingAccountsRequest) Reset() { *m = ListBillingAccountsRequest{} }
func (m *ListBillingAccountsRequest) String() string { return proto.CompactTextString(m) }
func (*ListBillingAccountsRequest) ProtoMessage() {}
func (*ListBillingAccountsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *ListBillingAccountsRequest) GetPageSize() int32 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListBillingAccountsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
// Response message for `ListBillingAccounts`.
type ListBillingAccountsResponse struct {
// A list of billing accounts.
BillingAccounts []*BillingAccount `protobuf:"bytes,1,rep,name=billing_accounts,json=billingAccounts" json:"billing_accounts,omitempty"`
// A token to retrieve the next page of results. To retrieve the next page,
// call `ListBillingAccounts` again with the `page_token` field set to this
// value. This field is empty if there are no more results to retrieve.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
}
func (m *ListBillingAccountsResponse) Reset() { *m = ListBillingAccountsResponse{} }
func (m *ListBillingAccountsResponse) String() string { return proto.CompactTextString(m) }
func (*ListBillingAccountsResponse) ProtoMessage() {}
func (*ListBillingAccountsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *ListBillingAccountsResponse) GetBillingAccounts() []*BillingAccount {
if m != nil {
return m.BillingAccounts
}
return nil
}
func (m *ListBillingAccountsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
// Request message for `ListProjectBillingInfo`.
type ListProjectBillingInfoRequest struct {
// The resource name of the billing account associated with the projects that
// you want to list. For example, `billingAccounts/012345-567890-ABCDEF`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Requested page size. The maximum page size is 100; this is also the
// default.
PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
// A token identifying a page of results to be returned. This should be a
// `next_page_token` value returned from a previous `ListProjectBillingInfo`
// call. If unspecified, the first page of results is returned.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
}
func (m *ListProjectBillingInfoRequest) Reset() { *m = ListProjectBillingInfoRequest{} }
func (m *ListProjectBillingInfoRequest) String() string { return proto.CompactTextString(m) }
func (*ListProjectBillingInfoRequest) ProtoMessage() {}
func (*ListProjectBillingInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *ListProjectBillingInfoRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *ListProjectBillingInfoRequest) GetPageSize() int32 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListProjectBillingInfoRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
// Request message for `ListProjectBillingInfoResponse`.
type ListProjectBillingInfoResponse struct {
// A list of `ProjectBillingInfo` resources representing the projects
// associated with the billing account.
ProjectBillingInfo []*ProjectBillingInfo `protobuf:"bytes,1,rep,name=project_billing_info,json=projectBillingInfo" json:"project_billing_info,omitempty"`
// A token to retrieve the next page of results. To retrieve the next page,
// call `ListProjectBillingInfo` again with the `page_token` field set to this
// value. This field is empty if there are no more results to retrieve.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
}
func (m *ListProjectBillingInfoResponse) Reset() { *m = ListProjectBillingInfoResponse{} }
func (m *ListProjectBillingInfoResponse) String() string { return proto.CompactTextString(m) }
func (*ListProjectBillingInfoResponse) ProtoMessage() {}
func (*ListProjectBillingInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
func (m *ListProjectBillingInfoResponse) GetProjectBillingInfo() []*ProjectBillingInfo {
if m != nil {
return m.ProjectBillingInfo
}
return nil
}
func (m *ListProjectBillingInfoResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
// Request message for `GetProjectBillingInfo`.
type GetProjectBillingInfoRequest struct {
// The resource name of the project for which billing information is
// retrieved. For example, `projects/tokyo-rain-123`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetProjectBillingInfoRequest) Reset() { *m = GetProjectBillingInfoRequest{} }
func (m *GetProjectBillingInfoRequest) String() string { return proto.CompactTextString(m) }
func (*GetProjectBillingInfoRequest) ProtoMessage() {}
func (*GetProjectBillingInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (m *GetProjectBillingInfoRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Request message for `UpdateProjectBillingInfo`.
type UpdateProjectBillingInfoRequest struct {
// The resource name of the project associated with the billing information
// that you want to update. For example, `projects/tokyo-rain-123`.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The new billing information for the project. Read-only fields are ignored;
// thus, you may leave empty all fields except `billing_account_name`.
ProjectBillingInfo *ProjectBillingInfo `protobuf:"bytes,2,opt,name=project_billing_info,json=projectBillingInfo" json:"project_billing_info,omitempty"`
}
func (m *UpdateProjectBillingInfoRequest) Reset() { *m = UpdateProjectBillingInfoRequest{} }
func (m *UpdateProjectBillingInfoRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateProjectBillingInfoRequest) ProtoMessage() {}
func (*UpdateProjectBillingInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
func (m *UpdateProjectBillingInfoRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UpdateProjectBillingInfoRequest) GetProjectBillingInfo() *ProjectBillingInfo {
if m != nil {
return m.ProjectBillingInfo
}
return nil
}
func init() {
proto.RegisterType((*BillingAccount)(nil), "google.cloud.billing.v1.BillingAccount")
proto.RegisterType((*ProjectBillingInfo)(nil), "google.cloud.billing.v1.ProjectBillingInfo")
proto.RegisterType((*GetBillingAccountRequest)(nil), "google.cloud.billing.v1.GetBillingAccountRequest")
proto.RegisterType((*ListBillingAccountsRequest)(nil), "google.cloud.billing.v1.ListBillingAccountsRequest")
proto.RegisterType((*ListBillingAccountsResponse)(nil), "google.cloud.billing.v1.ListBillingAccountsResponse")
proto.RegisterType((*ListProjectBillingInfoRequest)(nil), "google.cloud.billing.v1.ListProjectBillingInfoRequest")
proto.RegisterType((*ListProjectBillingInfoResponse)(nil), "google.cloud.billing.v1.ListProjectBillingInfoResponse")
proto.RegisterType((*GetProjectBillingInfoRequest)(nil), "google.cloud.billing.v1.GetProjectBillingInfoRequest")
proto.RegisterType((*UpdateProjectBillingInfoRequest)(nil), "google.cloud.billing.v1.UpdateProjectBillingInfoRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for CloudBilling service
type CloudBillingClient interface {
// Gets information about a billing account. The current authenticated user
// must be an [owner of the billing
// account](https://support.google.com/cloud/answer/4430947).
GetBillingAccount(ctx context.Context, in *GetBillingAccountRequest, opts ...grpc.CallOption) (*BillingAccount, error)
// Lists the billing accounts that the current authenticated user
// [owns](https://support.google.com/cloud/answer/4430947).
ListBillingAccounts(ctx context.Context, in *ListBillingAccountsRequest, opts ...grpc.CallOption) (*ListBillingAccountsResponse, error)
// Lists the projects associated with a billing account. The current
// authenticated user must be an [owner of the billing
// account](https://support.google.com/cloud/answer/4430947).
ListProjectBillingInfo(ctx context.Context, in *ListProjectBillingInfoRequest, opts ...grpc.CallOption) (*ListProjectBillingInfoResponse, error)
// Gets the billing information for a project. The current authenticated user
// must have [permission to view the
// project](https://cloud.google.com/docs/permissions-overview#h.bgs0oxofvnoo
// ).
GetProjectBillingInfo(ctx context.Context, in *GetProjectBillingInfoRequest, opts ...grpc.CallOption) (*ProjectBillingInfo, error)
// Sets or updates the billing account associated with a project. You specify
// the new billing account by setting the `billing_account_name` in the
// `ProjectBillingInfo` resource to the resource name of a billing account.
// Associating a project with an open billing account enables billing on the
// project and allows charges for resource usage. If the project already had a
// billing account, this method changes the billing account used for resource
// usage charges.
//
// *Note:* Incurred charges that have not yet been reported in the transaction
// history of the Google Cloud Console may be billed to the new billing
// account, even if the charge occurred before the new billing account was
// assigned to the project.
//
// The current authenticated user must have ownership privileges for both the
// [project](https://cloud.google.com/docs/permissions-overview#h.bgs0oxofvnoo
// ) and the [billing
// account](https://support.google.com/cloud/answer/4430947).
//
// You can disable billing on the project by setting the
// `billing_account_name` field to empty. This action disassociates the
// current billing account from the project. Any billable activity of your
// in-use services will stop, and your application could stop functioning as
// expected. Any unbilled charges to date will be billed to the previously
// associated account. The current authenticated user must be either an owner
// of the project or an owner of the billing account for the project.
//
// Note that associating a project with a *closed* billing account will have
// much the same effect as disabling billing on the project: any paid
// resources used by the project will be shut down. Thus, unless you wish to
// disable billing, you should always call this method with the name of an
// *open* billing account.
UpdateProjectBillingInfo(ctx context.Context, in *UpdateProjectBillingInfoRequest, opts ...grpc.CallOption) (*ProjectBillingInfo, error)
}
type cloudBillingClient struct {
cc *grpc.ClientConn
}
func NewCloudBillingClient(cc *grpc.ClientConn) CloudBillingClient {
return &cloudBillingClient{cc}
}
func (c *cloudBillingClient) GetBillingAccount(ctx context.Context, in *GetBillingAccountRequest, opts ...grpc.CallOption) (*BillingAccount, error) {
out := new(BillingAccount)
err := grpc.Invoke(ctx, "/google.cloud.billing.v1.CloudBilling/GetBillingAccount", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *cloudBillingClient) ListBillingAccounts(ctx context.Context, in *ListBillingAccountsRequest, opts ...grpc.CallOption) (*ListBillingAccountsResponse, error) {
out := new(ListBillingAccountsResponse)
err := grpc.Invoke(ctx, "/google.cloud.billing.v1.CloudBilling/ListBillingAccounts", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *cloudBillingClient) ListProjectBillingInfo(ctx context.Context, in *ListProjectBillingInfoRequest, opts ...grpc.CallOption) (*ListProjectBillingInfoResponse, error) {
out := new(ListProjectBillingInfoResponse)
err := grpc.Invoke(ctx, "/google.cloud.billing.v1.CloudBilling/ListProjectBillingInfo", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *cloudBillingClient) GetProjectBillingInfo(ctx context.Context, in *GetProjectBillingInfoRequest, opts ...grpc.CallOption) (*ProjectBillingInfo, error) {
out := new(ProjectBillingInfo)
err := grpc.Invoke(ctx, "/google.cloud.billing.v1.CloudBilling/GetProjectBillingInfo", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *cloudBillingClient) UpdateProjectBillingInfo(ctx context.Context, in *UpdateProjectBillingInfoRequest, opts ...grpc.CallOption) (*ProjectBillingInfo, error) {
out := new(ProjectBillingInfo)
err := grpc.Invoke(ctx, "/google.cloud.billing.v1.CloudBilling/UpdateProjectBillingInfo", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for CloudBilling service
type CloudBillingServer interface {
// Gets information about a billing account. The current authenticated user
// must be an [owner of the billing
// account](https://support.google.com/cloud/answer/4430947).
GetBillingAccount(context.Context, *GetBillingAccountRequest) (*BillingAccount, error)
// Lists the billing accounts that the current authenticated user
// [owns](https://support.google.com/cloud/answer/4430947).
ListBillingAccounts(context.Context, *ListBillingAccountsRequest) (*ListBillingAccountsResponse, error)
// Lists the projects associated with a billing account. The current
// authenticated user must be an [owner of the billing
// account](https://support.google.com/cloud/answer/4430947).
ListProjectBillingInfo(context.Context, *ListProjectBillingInfoRequest) (*ListProjectBillingInfoResponse, error)
// Gets the billing information for a project. The current authenticated user
// must have [permission to view the
// project](https://cloud.google.com/docs/permissions-overview#h.bgs0oxofvnoo
// ).
GetProjectBillingInfo(context.Context, *GetProjectBillingInfoRequest) (*ProjectBillingInfo, error)
// Sets or updates the billing account associated with a project. You specify
// the new billing account by setting the `billing_account_name` in the
// `ProjectBillingInfo` resource to the resource name of a billing account.
// Associating a project with an open billing account enables billing on the
// project and allows charges for resource usage. If the project already had a
// billing account, this method changes the billing account used for resource
// usage charges.
//
// *Note:* Incurred charges that have not yet been reported in the transaction
// history of the Google Cloud Console may be billed to the new billing
// account, even if the charge occurred before the new billing account was
// assigned to the project.
//
// The current authenticated user must have ownership privileges for both the
// [project](https://cloud.google.com/docs/permissions-overview#h.bgs0oxofvnoo
// ) and the [billing
// account](https://support.google.com/cloud/answer/4430947).
//
// You can disable billing on the project by setting the
// `billing_account_name` field to empty. This action disassociates the
// current billing account from the project. Any billable activity of your
// in-use services will stop, and your application could stop functioning as
// expected. Any unbilled charges to date will be billed to the previously
// associated account. The current authenticated user must be either an owner
// of the project or an owner of the billing account for the project.
//
// Note that associating a project with a *closed* billing account will have
// much the same effect as disabling billing on the project: any paid
// resources used by the project will be shut down. Thus, unless you wish to
// disable billing, you should always call this method with the name of an
// *open* billing account.
UpdateProjectBillingInfo(context.Context, *UpdateProjectBillingInfoRequest) (*ProjectBillingInfo, error)
}
func RegisterCloudBillingServer(s *grpc.Server, srv CloudBillingServer) {
s.RegisterService(&_CloudBilling_serviceDesc, srv)
}
func _CloudBilling_GetBillingAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBillingAccountRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(CloudBillingServer).GetBillingAccount(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.billing.v1.CloudBilling/GetBillingAccount",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(CloudBillingServer).GetBillingAccount(ctx, req.(*GetBillingAccountRequest))
}
return interceptor(ctx, in, info, handler)
}
func _CloudBilling_ListBillingAccounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBillingAccountsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(CloudBillingServer).ListBillingAccounts(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.billing.v1.CloudBilling/ListBillingAccounts",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(CloudBillingServer).ListBillingAccounts(ctx, req.(*ListBillingAccountsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _CloudBilling_ListProjectBillingInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListProjectBillingInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(CloudBillingServer).ListProjectBillingInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.billing.v1.CloudBilling/ListProjectBillingInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(CloudBillingServer).ListProjectBillingInfo(ctx, req.(*ListProjectBillingInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _CloudBilling_GetProjectBillingInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetProjectBillingInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(CloudBillingServer).GetProjectBillingInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.billing.v1.CloudBilling/GetProjectBillingInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(CloudBillingServer).GetProjectBillingInfo(ctx, req.(*GetProjectBillingInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _CloudBilling_UpdateProjectBillingInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateProjectBillingInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(CloudBillingServer).UpdateProjectBillingInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.billing.v1.CloudBilling/UpdateProjectBillingInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(CloudBillingServer).UpdateProjectBillingInfo(ctx, req.(*UpdateProjectBillingInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
var _CloudBilling_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.cloud.billing.v1.CloudBilling",
HandlerType: (*CloudBillingServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetBillingAccount",
Handler: _CloudBilling_GetBillingAccount_Handler,
},
{
MethodName: "ListBillingAccounts",
Handler: _CloudBilling_ListBillingAccounts_Handler,
},
{
MethodName: "ListProjectBillingInfo",
Handler: _CloudBilling_ListProjectBillingInfo_Handler,
},
{
MethodName: "GetProjectBillingInfo",
Handler: _CloudBilling_GetProjectBillingInfo_Handler,
},
{
MethodName: "UpdateProjectBillingInfo",
Handler: _CloudBilling_UpdateProjectBillingInfo_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/cloud/billing/v1/cloud_billing.proto",
}
func init() { proto.RegisterFile("google/cloud/billing/v1/cloud_billing.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 667 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x4e, 0xd4, 0x40,
0x14, 0xce, 0x00, 0x12, 0xf6, 0x80, 0x20, 0x03, 0xe8, 0x66, 0x17, 0x10, 0xea, 0x0f, 0x28, 0xb1,
0x15, 0xf0, 0xdf, 0xa8, 0x11, 0x63, 0x08, 0x89, 0x31, 0x9b, 0xaa, 0x89, 0xd1, 0x98, 0x66, 0x76,
0x3b, 0x34, 0xd5, 0x32, 0x53, 0x77, 0x0a, 0x51, 0x8c, 0x37, 0xbe, 0x82, 0x7a, 0xe1, 0x85, 0x37,
0x5e, 0xe8, 0x2b, 0x78, 0xed, 0x2b, 0xf8, 0x0a, 0xde, 0xfb, 0x0a, 0x66, 0xa6, 0x53, 0x65, 0xbb,
0x9d, 0x85, 0xc6, 0xbb, 0xe6, 0x9b, 0x73, 0xfa, 0x7d, 0xe7, 0x9b, 0xef, 0x6c, 0x17, 0x96, 0x02,
0xce, 0x83, 0x88, 0x3a, 0xad, 0x88, 0x6f, 0xfb, 0x4e, 0x33, 0x8c, 0xa2, 0x90, 0x05, 0xce, 0xce,
0x72, 0x0a, 0x78, 0x1a, 0xb0, 0xe3, 0x36, 0x4f, 0x38, 0x3e, 0x96, 0x16, 0xdb, 0xea, 0xcc, 0xce,
0xce, 0x76, 0x96, 0x6b, 0xd3, 0xfa, 0x2d, 0x24, 0x0e, 0x1d, 0xc2, 0x18, 0x4f, 0x48, 0x12, 0x72,
0x26, 0xd2, 0x36, 0xeb, 0x29, 0x8c, 0xae, 0xa5, 0xb5, 0xb7, 0x5b, 0x2d, 0xbe, 0xcd, 0x12, 0x8c,
0x61, 0x80, 0x91, 0x2d, 0x5a, 0x45, 0x73, 0x68, 0xb1, 0xe2, 0xaa, 0x67, 0x89, 0xf1, 0x98, 0xb2,
0x6a, 0xdf, 0x1c, 0x5a, 0x1c, 0x72, 0xd5, 0x33, 0x9e, 0x87, 0x11, 0x3f, 0x14, 0x71, 0x44, 0x5e,
0x7b, 0xaa, 0xbe, 0x5f, 0xd5, 0x0f, 0x6b, 0xec, 0x3e, 0xd9, 0xa2, 0xd6, 0x17, 0x04, 0xb8, 0xd1,
0xe6, 0xcf, 0x69, 0x2b, 0xd1, 0x24, 0x1b, 0x6c, 0x93, 0x17, 0x32, 0xcc, 0x00, 0xc4, 0x69, 0xa5,
0x17, 0xfa, 0x8a, 0xa7, 0xe2, 0x56, 0x34, 0xb2, 0xe1, 0xe3, 0xf3, 0x30, 0xa9, 0x47, 0xf2, 0x48,
0xaa, 0x73, 0x2f, 0x29, 0x6e, 0x76, 0x8c, 0x20, 0xb9, 0xf1, 0x02, 0x8c, 0x65, 0x1d, 0x94, 0x91,
0x66, 0x44, 0xfd, 0xea, 0x80, 0x52, 0x3f, 0xaa, 0xe1, 0xbb, 0x29, 0x6a, 0xd9, 0x50, 0x5d, 0xa7,
0x49, 0xa7, 0x09, 0x2e, 0x7d, 0xb9, 0x4d, 0x45, 0xa1, 0x17, 0xd6, 0x63, 0xa8, 0xdd, 0x0b, 0x45,
0xae, 0x41, 0x64, 0x1d, 0x75, 0xa8, 0xc4, 0x24, 0xa0, 0x9e, 0x08, 0x77, 0xd3, 0xb6, 0x43, 0xee,
0x90, 0x04, 0x1e, 0x84, 0xbb, 0xe9, 0x90, 0xf2, 0x30, 0xe1, 0x2f, 0xb4, 0x99, 0x72, 0x48, 0x12,
0xd0, 0x87, 0x12, 0xb0, 0x3e, 0x21, 0xa8, 0x17, 0xbe, 0x5a, 0xc4, 0x9c, 0x09, 0x8a, 0x5d, 0x38,
0x92, 0x33, 0x41, 0x54, 0xd1, 0x5c, 0xff, 0xe2, 0xf0, 0xca, 0x82, 0x6d, 0xb8, 0x7d, 0x3b, 0x37,
0xd7, 0x58, 0xa7, 0x53, 0x02, 0x9f, 0x86, 0x31, 0x46, 0x5f, 0x25, 0x5e, 0x97, 0xae, 0xc3, 0x12,
0x6e, 0xfc, 0xd5, 0xc6, 0x61, 0x46, 0x4a, 0xeb, 0xbe, 0xcd, 0x1e, 0x56, 0x75, 0x9a, 0xd1, 0xd7,
0xd3, 0x8c, 0xfe, 0xbc, 0x19, 0xdf, 0x10, 0xcc, 0x9a, 0x18, 0xb5, 0x1f, 0xcf, 0x60, 0x32, 0xcb,
0x4c, 0xe6, 0x4b, 0xc8, 0x36, 0xb9, 0xf6, 0x64, 0xc9, 0xe8, 0x49, 0xc1, 0x2b, 0x71, 0xdc, 0x1d,
0xd3, 0x83, 0x5a, 0xb3, 0x02, 0xd3, 0xeb, 0xb4, 0x9c, 0x33, 0xd6, 0x07, 0x04, 0xc7, 0x1f, 0xc5,
0x3e, 0x49, 0x68, 0x39, 0x47, 0x4d, 0x23, 0x4b, 0x61, 0xff, 0x3f, 0xf2, 0xca, 0xef, 0x41, 0x18,
0xb9, 0x23, 0x7b, 0x35, 0x88, 0x3f, 0x22, 0x18, 0xef, 0xda, 0x0e, 0xbc, 0x6c, 0xe4, 0x31, 0x6d,
0x52, 0xed, 0xa0, 0x09, 0xb5, 0x4e, 0xbe, 0xfb, 0xf9, 0xeb, 0x7d, 0xdf, 0x2c, 0x9e, 0x96, 0x3f,
0x74, 0x6f, 0xe4, 0xd0, 0x37, 0x72, 0x99, 0x75, 0xce, 0xbe, 0xc5, 0x9f, 0x11, 0x4c, 0x14, 0xac,
0x0a, 0x5e, 0x35, 0xd2, 0x98, 0x77, 0xb6, 0x76, 0xa1, 0x5c, 0x53, 0x9a, 0x3e, 0xab, 0xae, 0x84,
0x4e, 0xe1, 0x09, 0x29, 0x34, 0xbf, 0x56, 0xdf, 0x11, 0x1c, 0x2d, 0x4e, 0x2f, 0xbe, 0xd4, 0x93,
0xcd, 0x18, 0x87, 0xda, 0xe5, 0xd2, 0x7d, 0x5a, 0xe8, 0x39, 0x25, 0x74, 0x01, 0x9f, 0xea, 0xe5,
0xa8, 0xa3, 0xd3, 0x20, 0xf0, 0x57, 0x04, 0x53, 0x85, 0x79, 0xc6, 0x17, 0x7b, 0x5d, 0xbb, 0x59,
0x78, 0x99, 0x54, 0x5a, 0x67, 0x94, 0xd8, 0x13, 0x78, 0xfe, 0x9f, 0xd8, 0x4c, 0x99, 0x54, 0xd9,
0xdc, 0x23, 0xe7, 0x07, 0x82, 0xaa, 0x69, 0x87, 0xf0, 0x15, 0x23, 0xe9, 0x3e, 0x6b, 0x57, 0x4e,
0xee, 0x2d, 0x25, 0xf7, 0x6a, 0x6d, 0x7f, 0xb9, 0xd7, 0x0a, 0x17, 0x77, 0xad, 0x0d, 0xf5, 0x16,
0xdf, 0x32, 0x51, 0xae, 0x8d, 0xef, 0xdd, 0xc6, 0x86, 0xfc, 0x62, 0x37, 0xd0, 0x93, 0x9b, 0xba,
0x3a, 0xe0, 0x11, 0x61, 0x81, 0xcd, 0xdb, 0x81, 0x13, 0x50, 0xa6, 0xbe, 0xe7, 0x4e, 0x7a, 0x44,
0xe2, 0x50, 0x74, 0xfd, 0x6d, 0xb8, 0xae, 0x1f, 0x9b, 0x83, 0xaa, 0x74, 0xf5, 0x4f, 0x00, 0x00,
0x00, 0xff, 0xff, 0xc0, 0x01, 0x24, 0x32, 0x60, 0x08, 0x00, 0x00,
}

1598
vendor/google.golang.org/genproto/googleapis/cloud/dataproc/v1/clusters.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2573
vendor/google.golang.org/genproto/googleapis/cloud/dataproc/v1/jobs.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

224
vendor/google.golang.org/genproto/googleapis/cloud/dataproc/v1/operations.pb.go generated vendored Normal file
View File

@ -0,0 +1,224 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/dataproc/v1/operations.proto
package dataproc
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import _ "google.golang.org/genproto/googleapis/longrunning"
import _ "github.com/golang/protobuf/ptypes/empty"
import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// The operation state.
type ClusterOperationStatus_State int32
const (
// Unused.
ClusterOperationStatus_UNKNOWN ClusterOperationStatus_State = 0
// The operation has been created.
ClusterOperationStatus_PENDING ClusterOperationStatus_State = 1
// The operation is running.
ClusterOperationStatus_RUNNING ClusterOperationStatus_State = 2
// The operation is done; either cancelled or completed.
ClusterOperationStatus_DONE ClusterOperationStatus_State = 3
)
var ClusterOperationStatus_State_name = map[int32]string{
0: "UNKNOWN",
1: "PENDING",
2: "RUNNING",
3: "DONE",
}
var ClusterOperationStatus_State_value = map[string]int32{
"UNKNOWN": 0,
"PENDING": 1,
"RUNNING": 2,
"DONE": 3,
}
func (x ClusterOperationStatus_State) String() string {
return proto.EnumName(ClusterOperationStatus_State_name, int32(x))
}
func (ClusterOperationStatus_State) EnumDescriptor() ([]byte, []int) {
return fileDescriptor2, []int{0, 0}
}
// The status of the operation.
type ClusterOperationStatus struct {
// Output-only. A message containing the operation state.
State ClusterOperationStatus_State `protobuf:"varint,1,opt,name=state,enum=google.cloud.dataproc.v1.ClusterOperationStatus_State" json:"state,omitempty"`
// Output-only. A message containing the detailed operation state.
InnerState string `protobuf:"bytes,2,opt,name=inner_state,json=innerState" json:"inner_state,omitempty"`
// Output-only.A message containing any operation metadata details.
Details string `protobuf:"bytes,3,opt,name=details" json:"details,omitempty"`
// Output-only. The time this state was entered.
StateStartTime *google_protobuf3.Timestamp `protobuf:"bytes,4,opt,name=state_start_time,json=stateStartTime" json:"state_start_time,omitempty"`
}
func (m *ClusterOperationStatus) Reset() { *m = ClusterOperationStatus{} }
func (m *ClusterOperationStatus) String() string { return proto.CompactTextString(m) }
func (*ClusterOperationStatus) ProtoMessage() {}
func (*ClusterOperationStatus) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *ClusterOperationStatus) GetState() ClusterOperationStatus_State {
if m != nil {
return m.State
}
return ClusterOperationStatus_UNKNOWN
}
func (m *ClusterOperationStatus) GetInnerState() string {
if m != nil {
return m.InnerState
}
return ""
}
func (m *ClusterOperationStatus) GetDetails() string {
if m != nil {
return m.Details
}
return ""
}
func (m *ClusterOperationStatus) GetStateStartTime() *google_protobuf3.Timestamp {
if m != nil {
return m.StateStartTime
}
return nil
}
// Metadata describing the operation.
type ClusterOperationMetadata struct {
// Output-only. Name of the cluster for the operation.
ClusterName string `protobuf:"bytes,7,opt,name=cluster_name,json=clusterName" json:"cluster_name,omitempty"`
// Output-only. Cluster UUID for the operation.
ClusterUuid string `protobuf:"bytes,8,opt,name=cluster_uuid,json=clusterUuid" json:"cluster_uuid,omitempty"`
// Output-only. Current operation status.
Status *ClusterOperationStatus `protobuf:"bytes,9,opt,name=status" json:"status,omitempty"`
// Output-only. The previous operation status.
StatusHistory []*ClusterOperationStatus `protobuf:"bytes,10,rep,name=status_history,json=statusHistory" json:"status_history,omitempty"`
// Output-only. The operation type.
OperationType string `protobuf:"bytes,11,opt,name=operation_type,json=operationType" json:"operation_type,omitempty"`
// Output-only. Short description of operation.
Description string `protobuf:"bytes,12,opt,name=description" json:"description,omitempty"`
// Output-only. Labels associated with the operation
Labels map[string]string `protobuf:"bytes,13,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Output-only. Errors encountered during operation execution.
Warnings []string `protobuf:"bytes,14,rep,name=warnings" json:"warnings,omitempty"`
}
func (m *ClusterOperationMetadata) Reset() { *m = ClusterOperationMetadata{} }
func (m *ClusterOperationMetadata) String() string { return proto.CompactTextString(m) }
func (*ClusterOperationMetadata) ProtoMessage() {}
func (*ClusterOperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
func (m *ClusterOperationMetadata) GetClusterName() string {
if m != nil {
return m.ClusterName
}
return ""
}
func (m *ClusterOperationMetadata) GetClusterUuid() string {
if m != nil {
return m.ClusterUuid
}
return ""
}
func (m *ClusterOperationMetadata) GetStatus() *ClusterOperationStatus {
if m != nil {
return m.Status
}
return nil
}
func (m *ClusterOperationMetadata) GetStatusHistory() []*ClusterOperationStatus {
if m != nil {
return m.StatusHistory
}
return nil
}
func (m *ClusterOperationMetadata) GetOperationType() string {
if m != nil {
return m.OperationType
}
return ""
}
func (m *ClusterOperationMetadata) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *ClusterOperationMetadata) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *ClusterOperationMetadata) GetWarnings() []string {
if m != nil {
return m.Warnings
}
return nil
}
func init() {
proto.RegisterType((*ClusterOperationStatus)(nil), "google.cloud.dataproc.v1.ClusterOperationStatus")
proto.RegisterType((*ClusterOperationMetadata)(nil), "google.cloud.dataproc.v1.ClusterOperationMetadata")
proto.RegisterEnum("google.cloud.dataproc.v1.ClusterOperationStatus_State", ClusterOperationStatus_State_name, ClusterOperationStatus_State_value)
}
func init() { proto.RegisterFile("google/cloud/dataproc/v1/operations.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 553 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x61, 0x6b, 0xd3, 0x40,
0x18, 0x36, 0xcd, 0xb6, 0xb6, 0x97, 0xb5, 0x96, 0x43, 0xe4, 0x88, 0x83, 0xc5, 0x8a, 0x50, 0xbf,
0x24, 0x6e, 0x82, 0x4c, 0x05, 0x91, 0xd9, 0xe2, 0xc4, 0x99, 0x96, 0x6c, 0x75, 0xe0, 0x97, 0x72,
0x6d, 0xce, 0x18, 0x4c, 0xee, 0xc2, 0xdd, 0xa5, 0x92, 0x9f, 0xe3, 0xef, 0xf4, 0x8b, 0xdc, 0x5d,
0x52, 0xea, 0xe6, 0x40, 0xfd, 0xd4, 0x7b, 0xde, 0xf7, 0x79, 0x9e, 0xbe, 0xcf, 0xcb, 0xdb, 0x82,
0x27, 0x09, 0x63, 0x49, 0x46, 0x82, 0x55, 0xc6, 0xca, 0x38, 0x88, 0xb1, 0xc4, 0x05, 0x67, 0xab,
0x60, 0x7d, 0x14, 0xb0, 0x82, 0x70, 0x2c, 0x53, 0x46, 0x85, 0x5f, 0x70, 0x26, 0x19, 0x44, 0x86,
0xea, 0x6b, 0xaa, 0xdf, 0x50, 0xfd, 0xf5, 0x91, 0x7b, 0x50, 0x9b, 0xe0, 0x22, 0x0d, 0x30, 0xa5,
0x4c, 0x6e, 0xeb, 0xdc, 0x47, 0x75, 0x37, 0x63, 0x34, 0xe1, 0x25, 0xa5, 0x29, 0x4d, 0x6e, 0x98,
0xbb, 0x0f, 0x6a, 0x92, 0x46, 0xcb, 0xf2, 0x4b, 0x40, 0xf2, 0x42, 0x56, 0x75, 0xf3, 0xf0, 0x7a,
0x53, 0xa6, 0x39, 0x11, 0x12, 0xe7, 0x85, 0x21, 0x0c, 0x7f, 0xb4, 0xc0, 0xfd, 0xb7, 0x59, 0x29,
0x24, 0xe1, 0xd3, 0xc6, 0xf9, 0x42, 0x62, 0x59, 0x0a, 0x78, 0x0e, 0x76, 0x85, 0xc4, 0x92, 0x20,
0xcb, 0xb3, 0x46, 0xfd, 0xe3, 0xe7, 0xfe, 0x6d, 0x29, 0xfc, 0x3f, 0x1b, 0xf8, 0xea, 0x83, 0x44,
0xc6, 0x04, 0x1e, 0x02, 0x27, 0xa5, 0x94, 0xf0, 0x85, 0xf1, 0x6c, 0x79, 0xd6, 0xa8, 0x1b, 0x01,
0x5d, 0xd2, 0x3c, 0x88, 0x40, 0x3b, 0x26, 0x12, 0xa7, 0x99, 0x40, 0xb6, 0x6e, 0x36, 0x10, 0x8e,
0xc1, 0x40, 0x8b, 0x94, 0x94, 0xcb, 0x85, 0x8a, 0x80, 0x76, 0x3c, 0x6b, 0xe4, 0x1c, 0xbb, 0xcd,
0x4c, 0x4d, 0x3e, 0xff, 0xb2, 0xc9, 0x17, 0xf5, 0xb5, 0xe6, 0x42, 0x49, 0x54, 0x71, 0x78, 0x02,
0x76, 0xcd, 0x17, 0x39, 0xa0, 0x3d, 0x0f, 0x3f, 0x84, 0xd3, 0xab, 0x70, 0x70, 0x47, 0x81, 0xd9,
0x24, 0x1c, 0xbf, 0x0f, 0xdf, 0x0d, 0x2c, 0x05, 0xa2, 0x79, 0x18, 0x2a, 0xd0, 0x82, 0x1d, 0xb0,
0x33, 0x9e, 0x86, 0x93, 0x81, 0x3d, 0xfc, 0x69, 0x03, 0x74, 0x3d, 0xe2, 0x47, 0x22, 0xb1, 0x5a,
0x01, 0x7c, 0x08, 0xf6, 0x57, 0xa6, 0xb7, 0xa0, 0x38, 0x27, 0xa8, 0xad, 0x67, 0x77, 0xea, 0x5a,
0x88, 0x73, 0xb2, 0x4d, 0x29, 0xcb, 0x34, 0x46, 0x9d, 0xdf, 0x28, 0xf3, 0x32, 0x8d, 0xe1, 0x19,
0xd8, 0x13, 0x7a, 0x69, 0xa8, 0xab, 0x83, 0x3d, 0xfd, 0xd7, 0x65, 0x47, 0xb5, 0x1e, 0x5e, 0x81,
0xbe, 0x79, 0x2d, 0xbe, 0xa6, 0x42, 0x32, 0x5e, 0x21, 0xe0, 0xd9, 0xff, 0xe5, 0xd8, 0x33, 0x3e,
0x67, 0xc6, 0x06, 0x3e, 0x06, 0xfd, 0xcd, 0xed, 0x2d, 0x64, 0x55, 0x10, 0xe4, 0xe8, 0x1c, 0xbd,
0x4d, 0xf5, 0xb2, 0x2a, 0x08, 0xf4, 0x80, 0x13, 0x13, 0xb1, 0xe2, 0x69, 0xa1, 0x4a, 0x68, 0xdf,
0x64, 0xdd, 0x2a, 0xc1, 0x4f, 0x60, 0x2f, 0xc3, 0x4b, 0x92, 0x09, 0xd4, 0xd3, 0x93, 0xbd, 0xfe,
0xfb, 0xc9, 0x9a, 0xad, 0xfb, 0xe7, 0xda, 0x60, 0x42, 0x25, 0xaf, 0xa2, 0xda, 0x0d, 0xba, 0xa0,
0xf3, 0x1d, 0x73, 0xf5, 0x23, 0x11, 0xa8, 0xef, 0xd9, 0xa3, 0x6e, 0xb4, 0xc1, 0xee, 0x0b, 0xe0,
0x6c, 0x49, 0xe0, 0x00, 0xd8, 0xdf, 0x48, 0xa5, 0x0f, 0xbb, 0x1b, 0xa9, 0x27, 0xbc, 0x07, 0x76,
0xd7, 0x38, 0x2b, 0x9b, 0xc3, 0x34, 0xe0, 0x65, 0xeb, 0xc4, 0x3a, 0x15, 0xe0, 0x60, 0xc5, 0xf2,
0x5b, 0x67, 0x3c, 0xbd, 0xbb, 0x99, 0x4e, 0xcc, 0xd4, 0x15, 0xce, 0xac, 0xcf, 0x6f, 0x6a, 0x72,
0xc2, 0x32, 0x4c, 0x13, 0x9f, 0xf1, 0x24, 0x48, 0x08, 0xd5, 0x37, 0x1a, 0x98, 0x16, 0x2e, 0x52,
0x71, 0xf3, 0x9f, 0xe3, 0x55, 0xf3, 0x5e, 0xee, 0x69, 0xf2, 0xb3, 0x5f, 0x01, 0x00, 0x00, 0xff,
0xff, 0x09, 0x4c, 0x3d, 0x35, 0x65, 0x04, 0x00, 0x00,
}

1775
vendor/google.golang.org/genproto/googleapis/cloud/dataproc/v1beta2/clusters.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2573
vendor/google.golang.org/genproto/googleapis/cloud/dataproc/v1beta2/jobs.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

221
vendor/google.golang.org/genproto/googleapis/cloud/dataproc/v1beta2/operations.pb.go generated vendored Normal file
View File

@ -0,0 +1,221 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/dataproc/v1beta2/operations.proto
package dataproc
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf5 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// The operation state.
type ClusterOperationStatus_State int32
const (
// Unused.
ClusterOperationStatus_UNKNOWN ClusterOperationStatus_State = 0
// The operation has been created.
ClusterOperationStatus_PENDING ClusterOperationStatus_State = 1
// The operation is running.
ClusterOperationStatus_RUNNING ClusterOperationStatus_State = 2
// The operation is done; either cancelled or completed.
ClusterOperationStatus_DONE ClusterOperationStatus_State = 3
)
var ClusterOperationStatus_State_name = map[int32]string{
0: "UNKNOWN",
1: "PENDING",
2: "RUNNING",
3: "DONE",
}
var ClusterOperationStatus_State_value = map[string]int32{
"UNKNOWN": 0,
"PENDING": 1,
"RUNNING": 2,
"DONE": 3,
}
func (x ClusterOperationStatus_State) String() string {
return proto.EnumName(ClusterOperationStatus_State_name, int32(x))
}
func (ClusterOperationStatus_State) EnumDescriptor() ([]byte, []int) {
return fileDescriptor2, []int{0, 0}
}
// The status of the operation.
type ClusterOperationStatus struct {
// Output-only. A message containing the operation state.
State ClusterOperationStatus_State `protobuf:"varint,1,opt,name=state,enum=google.cloud.dataproc.v1beta2.ClusterOperationStatus_State" json:"state,omitempty"`
// Output-only. A message containing the detailed operation state.
InnerState string `protobuf:"bytes,2,opt,name=inner_state,json=innerState" json:"inner_state,omitempty"`
// Output-only.A message containing any operation metadata details.
Details string `protobuf:"bytes,3,opt,name=details" json:"details,omitempty"`
// Output-only. The time this state was entered.
StateStartTime *google_protobuf5.Timestamp `protobuf:"bytes,4,opt,name=state_start_time,json=stateStartTime" json:"state_start_time,omitempty"`
}
func (m *ClusterOperationStatus) Reset() { *m = ClusterOperationStatus{} }
func (m *ClusterOperationStatus) String() string { return proto.CompactTextString(m) }
func (*ClusterOperationStatus) ProtoMessage() {}
func (*ClusterOperationStatus) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *ClusterOperationStatus) GetState() ClusterOperationStatus_State {
if m != nil {
return m.State
}
return ClusterOperationStatus_UNKNOWN
}
func (m *ClusterOperationStatus) GetInnerState() string {
if m != nil {
return m.InnerState
}
return ""
}
func (m *ClusterOperationStatus) GetDetails() string {
if m != nil {
return m.Details
}
return ""
}
func (m *ClusterOperationStatus) GetStateStartTime() *google_protobuf5.Timestamp {
if m != nil {
return m.StateStartTime
}
return nil
}
// Metadata describing the operation.
type ClusterOperationMetadata struct {
// Output-only. Name of the cluster for the operation.
ClusterName string `protobuf:"bytes,7,opt,name=cluster_name,json=clusterName" json:"cluster_name,omitempty"`
// Output-only. Cluster UUID for the operation.
ClusterUuid string `protobuf:"bytes,8,opt,name=cluster_uuid,json=clusterUuid" json:"cluster_uuid,omitempty"`
// Output-only. Current operation status.
Status *ClusterOperationStatus `protobuf:"bytes,9,opt,name=status" json:"status,omitempty"`
// Output-only. The previous operation status.
StatusHistory []*ClusterOperationStatus `protobuf:"bytes,10,rep,name=status_history,json=statusHistory" json:"status_history,omitempty"`
// Output-only. The operation type.
OperationType string `protobuf:"bytes,11,opt,name=operation_type,json=operationType" json:"operation_type,omitempty"`
// Output-only. Short description of operation.
Description string `protobuf:"bytes,12,opt,name=description" json:"description,omitempty"`
// Output-only. Labels associated with the operation
Labels map[string]string `protobuf:"bytes,13,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Output-only. Errors encountered during operation execution.
Warnings []string `protobuf:"bytes,14,rep,name=warnings" json:"warnings,omitempty"`
}
func (m *ClusterOperationMetadata) Reset() { *m = ClusterOperationMetadata{} }
func (m *ClusterOperationMetadata) String() string { return proto.CompactTextString(m) }
func (*ClusterOperationMetadata) ProtoMessage() {}
func (*ClusterOperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
func (m *ClusterOperationMetadata) GetClusterName() string {
if m != nil {
return m.ClusterName
}
return ""
}
func (m *ClusterOperationMetadata) GetClusterUuid() string {
if m != nil {
return m.ClusterUuid
}
return ""
}
func (m *ClusterOperationMetadata) GetStatus() *ClusterOperationStatus {
if m != nil {
return m.Status
}
return nil
}
func (m *ClusterOperationMetadata) GetStatusHistory() []*ClusterOperationStatus {
if m != nil {
return m.StatusHistory
}
return nil
}
func (m *ClusterOperationMetadata) GetOperationType() string {
if m != nil {
return m.OperationType
}
return ""
}
func (m *ClusterOperationMetadata) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *ClusterOperationMetadata) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *ClusterOperationMetadata) GetWarnings() []string {
if m != nil {
return m.Warnings
}
return nil
}
func init() {
proto.RegisterType((*ClusterOperationStatus)(nil), "google.cloud.dataproc.v1beta2.ClusterOperationStatus")
proto.RegisterType((*ClusterOperationMetadata)(nil), "google.cloud.dataproc.v1beta2.ClusterOperationMetadata")
proto.RegisterEnum("google.cloud.dataproc.v1beta2.ClusterOperationStatus_State", ClusterOperationStatus_State_name, ClusterOperationStatus_State_value)
}
func init() { proto.RegisterFile("google/cloud/dataproc/v1beta2/operations.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 537 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x5f, 0x8b, 0xd3, 0x4e,
0x14, 0xfd, 0xa5, 0xff, 0x7b, 0xb3, 0xed, 0xaf, 0x0c, 0x22, 0x43, 0x51, 0x36, 0x5b, 0x10, 0xfa,
0x94, 0x60, 0x45, 0x58, 0xdd, 0xb7, 0xdd, 0x16, 0x15, 0xdd, 0xb4, 0x66, 0xb7, 0x08, 0x2a, 0x94,
0x69, 0x33, 0xc6, 0x60, 0x3a, 0x13, 0x66, 0x26, 0x2b, 0x7d, 0xf0, 0x0b, 0xf8, 0x41, 0xfc, 0x9c,
0x32, 0x33, 0x49, 0xa9, 0xa2, 0x0b, 0xee, 0x53, 0xe7, 0xde, 0x7b, 0xce, 0x99, 0x73, 0xa6, 0x97,
0x80, 0x9f, 0x70, 0x9e, 0x64, 0x34, 0xd8, 0x64, 0xbc, 0x88, 0x83, 0x98, 0x28, 0x92, 0x0b, 0xbe,
0x09, 0x6e, 0x1e, 0xaf, 0xa9, 0x22, 0x93, 0x80, 0xe7, 0x54, 0x10, 0x95, 0x72, 0x26, 0xfd, 0x5c,
0x70, 0xc5, 0xd1, 0x43, 0x8b, 0xf7, 0x0d, 0xde, 0xaf, 0xf0, 0x7e, 0x89, 0x1f, 0x3e, 0x28, 0xe5,
0x48, 0x9e, 0x06, 0x84, 0x31, 0xae, 0x0e, 0xc9, 0xc3, 0xe3, 0x72, 0x6a, 0xaa, 0x75, 0xf1, 0x29,
0x50, 0xe9, 0x96, 0x4a, 0x45, 0xb6, 0xb9, 0x05, 0x8c, 0x7e, 0xd4, 0xe0, 0xfe, 0x45, 0x56, 0x48,
0x45, 0xc5, 0xbc, 0xba, 0xf9, 0x4a, 0x11, 0x55, 0x48, 0xf4, 0x16, 0x9a, 0x52, 0x11, 0x45, 0xb1,
0xe3, 0x39, 0xe3, 0xfe, 0xe4, 0xcc, 0xbf, 0xd5, 0x88, 0xff, 0x67, 0x15, 0x5f, 0xff, 0xd0, 0xc8,
0x2a, 0xa1, 0x63, 0x70, 0x53, 0xc6, 0xa8, 0x58, 0x59, 0xe1, 0x9a, 0xe7, 0x8c, 0xbb, 0x11, 0x98,
0x96, 0xc1, 0x21, 0x0c, 0xed, 0x98, 0x2a, 0x92, 0x66, 0x12, 0xd7, 0xcd, 0xb0, 0x2a, 0xd1, 0x14,
0x06, 0x86, 0xa4, 0xa9, 0x42, 0xad, 0x74, 0x0e, 0xdc, 0xf0, 0x9c, 0xb1, 0x3b, 0x19, 0x56, 0xc6,
0xaa, 0x90, 0xfe, 0x75, 0x15, 0x32, 0xea, 0x1b, 0xce, 0x95, 0xa6, 0xe8, 0xe6, 0xe8, 0x14, 0x9a,
0xf6, 0x22, 0x17, 0xda, 0xcb, 0xf0, 0x75, 0x38, 0x7f, 0x17, 0x0e, 0xfe, 0xd3, 0xc5, 0x62, 0x16,
0x4e, 0x5f, 0x85, 0x2f, 0x06, 0x8e, 0x2e, 0xa2, 0x65, 0x18, 0xea, 0xa2, 0x86, 0x3a, 0xd0, 0x98,
0xce, 0xc3, 0xd9, 0xa0, 0x3e, 0xfa, 0xde, 0x00, 0xfc, 0x7b, 0xc4, 0x4b, 0xaa, 0x88, 0x7e, 0x07,
0x74, 0x02, 0x47, 0x1b, 0x3b, 0x5b, 0x31, 0xb2, 0xa5, 0xb8, 0x6d, 0xbc, 0xbb, 0x65, 0x2f, 0x24,
0x5b, 0x7a, 0x08, 0x29, 0x8a, 0x34, 0xc6, 0x9d, 0x5f, 0x20, 0xcb, 0x22, 0x8d, 0xd1, 0x25, 0xb4,
0xa4, 0x79, 0x34, 0xdc, 0x35, 0xc1, 0x9e, 0xde, 0xe9, 0xc5, 0xa3, 0x52, 0x04, 0x7d, 0x84, 0xbe,
0x3d, 0xad, 0x3e, 0xa7, 0x52, 0x71, 0xb1, 0xc3, 0xe0, 0xd5, 0xef, 0x2e, 0xdb, 0xb3, 0x62, 0x2f,
0xad, 0x16, 0x7a, 0x04, 0xfd, 0xfd, 0xaa, 0xae, 0xd4, 0x2e, 0xa7, 0xd8, 0x35, 0x89, 0x7a, 0xfb,
0xee, 0xf5, 0x2e, 0xa7, 0xc8, 0x03, 0x37, 0xa6, 0x72, 0x23, 0xd2, 0x5c, 0xb7, 0xf0, 0x91, 0x4d,
0x7d, 0xd0, 0x42, 0x1f, 0xa0, 0x95, 0x91, 0x35, 0xcd, 0x24, 0xee, 0x19, 0x7b, 0x17, 0xff, 0x68,
0xaf, 0xfa, 0x13, 0xfc, 0x37, 0x46, 0x65, 0xc6, 0x94, 0xd8, 0x45, 0xa5, 0x24, 0x1a, 0x42, 0xe7,
0x2b, 0x11, 0x2c, 0x65, 0x89, 0xc4, 0x7d, 0xaf, 0x3e, 0xee, 0x46, 0xfb, 0x7a, 0xf8, 0x0c, 0xdc,
0x03, 0x0a, 0x1a, 0x40, 0xfd, 0x0b, 0xdd, 0x99, 0x65, 0xef, 0x46, 0xfa, 0x88, 0xee, 0x41, 0xf3,
0x86, 0x64, 0x45, 0xb5, 0xa7, 0xb6, 0x78, 0x5e, 0x3b, 0x75, 0xce, 0xbf, 0xc1, 0xc9, 0x86, 0x6f,
0x6f, 0x37, 0x7a, 0xfe, 0xff, 0xde, 0xa2, 0x5c, 0xe8, 0xcd, 0x5c, 0x38, 0xef, 0x67, 0x25, 0x23,
0xe1, 0x19, 0x61, 0x89, 0xcf, 0x45, 0x12, 0x24, 0x94, 0x99, 0xbd, 0x0d, 0xec, 0x88, 0xe4, 0xa9,
0xfc, 0xcb, 0xa7, 0xe1, 0xac, 0x6a, 0xac, 0x5b, 0x86, 0xf1, 0xe4, 0x67, 0x00, 0x00, 0x00, 0xff,
0xff, 0x83, 0x10, 0x95, 0x5e, 0x4b, 0x04, 0x00, 0x00,
}

1526
vendor/google.golang.org/genproto/googleapis/cloud/dataproc/v1beta2/workflow_templates.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1203
vendor/google.golang.org/genproto/googleapis/cloud/functions/v1beta2/functions.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

116
vendor/google.golang.org/genproto/googleapis/cloud/functions/v1beta2/operations.pb.go generated vendored Normal file
View File

@ -0,0 +1,116 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/functions/v1beta2/operations.proto
package functions
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// A type of an operation.
type OperationType int32
const (
// Unknown operation type.
OperationType_OPERATION_UNSPECIFIED OperationType = 0
// Triggered by CreateFunction call
OperationType_CREATE_FUNCTION OperationType = 1
// Triggered by UpdateFunction call
OperationType_UPDATE_FUNCTION OperationType = 2
// Triggered by DeleteFunction call.
OperationType_DELETE_FUNCTION OperationType = 3
)
var OperationType_name = map[int32]string{
0: "OPERATION_UNSPECIFIED",
1: "CREATE_FUNCTION",
2: "UPDATE_FUNCTION",
3: "DELETE_FUNCTION",
}
var OperationType_value = map[string]int32{
"OPERATION_UNSPECIFIED": 0,
"CREATE_FUNCTION": 1,
"UPDATE_FUNCTION": 2,
"DELETE_FUNCTION": 3,
}
func (x OperationType) String() string {
return proto.EnumName(OperationType_name, int32(x))
}
func (OperationType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
// Metadata describing an [Operation][google.longrunning.Operation]
type OperationMetadataV1Beta2 struct {
// Target of the operation - for example
// projects/project-1/locations/region-1/functions/function-1
Target string `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"`
// Type of operation.
Type OperationType `protobuf:"varint,2,opt,name=type,enum=google.cloud.functions.v1beta2.OperationType" json:"type,omitempty"`
// The original request that started the operation.
Request *google_protobuf1.Any `protobuf:"bytes,3,opt,name=request" json:"request,omitempty"`
}
func (m *OperationMetadataV1Beta2) Reset() { *m = OperationMetadataV1Beta2{} }
func (m *OperationMetadataV1Beta2) String() string { return proto.CompactTextString(m) }
func (*OperationMetadataV1Beta2) ProtoMessage() {}
func (*OperationMetadataV1Beta2) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
func (m *OperationMetadataV1Beta2) GetTarget() string {
if m != nil {
return m.Target
}
return ""
}
func (m *OperationMetadataV1Beta2) GetType() OperationType {
if m != nil {
return m.Type
}
return OperationType_OPERATION_UNSPECIFIED
}
func (m *OperationMetadataV1Beta2) GetRequest() *google_protobuf1.Any {
if m != nil {
return m.Request
}
return nil
}
func init() {
proto.RegisterType((*OperationMetadataV1Beta2)(nil), "google.cloud.functions.v1beta2.OperationMetadataV1Beta2")
proto.RegisterEnum("google.cloud.functions.v1beta2.OperationType", OperationType_name, OperationType_value)
}
func init() { proto.RegisterFile("google/cloud/functions/v1beta2/operations.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 333 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0x4f, 0x4f, 0xf2, 0x30,
0x1c, 0xc7, 0x9f, 0xc2, 0x13, 0x8c, 0x35, 0x2a, 0x99, 0x7f, 0x32, 0x88, 0x31, 0x84, 0x13, 0x31,
0xb1, 0x0d, 0x78, 0xf4, 0x34, 0xa0, 0x18, 0x12, 0x85, 0x65, 0x82, 0x07, 0x2f, 0xa4, 0x40, 0x69,
0x96, 0xcc, 0xb6, 0x6e, 0x9d, 0xc9, 0x5e, 0x82, 0x2f, 0xc4, 0xf7, 0x69, 0x56, 0xba, 0x05, 0x0e,
0xea, 0xb1, 0x9f, 0xf6, 0xf3, 0xed, 0xf7, 0x97, 0x1f, 0xc4, 0x5c, 0x4a, 0x1e, 0x31, 0xbc, 0x8a,
0x64, 0xba, 0xc6, 0x9b, 0x54, 0xac, 0x74, 0x28, 0x45, 0x82, 0x3f, 0xba, 0x4b, 0xa6, 0x69, 0x0f,
0x4b, 0xc5, 0x62, 0x6a, 0x10, 0x52, 0xb1, 0xd4, 0xd2, 0xb9, 0xde, 0x0a, 0xc8, 0x08, 0xa8, 0x14,
0x90, 0x15, 0x9a, 0x57, 0x36, 0x90, 0xaa, 0x10, 0x53, 0x21, 0xa4, 0xde, 0xb5, 0x9b, 0x0d, 0x7b,
0x6b, 0x4e, 0xcb, 0x74, 0x83, 0xa9, 0xc8, 0xb6, 0x57, 0xed, 0x2f, 0x00, 0xdd, 0x69, 0xf1, 0xdb,
0x13, 0xd3, 0x74, 0x4d, 0x35, 0x7d, 0xe9, 0xf6, 0xf3, 0x54, 0xe7, 0x12, 0xd6, 0x34, 0x8d, 0x39,
0xd3, 0x2e, 0x68, 0x81, 0xce, 0x61, 0x60, 0x4f, 0x8e, 0x07, 0xff, 0xeb, 0x4c, 0x31, 0xb7, 0xd2,
0x02, 0x9d, 0x93, 0xde, 0x2d, 0xfa, 0xbd, 0x1c, 0x2a, 0xf3, 0x67, 0x99, 0x62, 0x81, 0x51, 0x1d,
0x04, 0x0f, 0x62, 0xf6, 0x9e, 0xb2, 0x44, 0xbb, 0xd5, 0x16, 0xe8, 0x1c, 0xf5, 0xce, 0x8b, 0x94,
0xa2, 0x24, 0xf2, 0x44, 0x16, 0x14, 0x8f, 0x6e, 0x42, 0x78, 0xbc, 0x17, 0xe3, 0x34, 0xe0, 0xc5,
0xd4, 0x27, 0x81, 0x37, 0x1b, 0x4f, 0x27, 0x8b, 0xf9, 0xe4, 0xd9, 0x27, 0x83, 0xf1, 0x68, 0x4c,
0x86, 0xf5, 0x7f, 0xce, 0x19, 0x3c, 0x1d, 0x04, 0xc4, 0x9b, 0x91, 0xc5, 0x68, 0x3e, 0x19, 0xe4,
0x0f, 0xea, 0x20, 0x87, 0x73, 0x7f, 0xb8, 0x07, 0x2b, 0x39, 0x1c, 0x92, 0x47, 0xb2, 0x0b, 0xab,
0xfd, 0x4f, 0x00, 0xdb, 0x2b, 0xf9, 0xf6, 0xc7, 0x54, 0x7d, 0x77, 0x54, 0xa0, 0xb2, 0x58, 0xe2,
0xe7, 0xdd, 0x7d, 0xf0, 0xfa, 0x60, 0x5d, 0x2e, 0x23, 0x2a, 0x38, 0x92, 0x31, 0xc7, 0x9c, 0x09,
0x33, 0x99, 0x5d, 0x3d, 0x55, 0x61, 0xf2, 0xd3, 0xfa, 0xef, 0x4b, 0xb2, 0xac, 0x19, 0xe7, 0xee,
0x3b, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x8a, 0xb1, 0x83, 0x31, 0x02, 0x00, 0x00,
}

1327
vendor/google.golang.org/genproto/googleapis/cloud/iot/v1/device_manager.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1026
vendor/google.golang.org/genproto/googleapis/cloud/iot/v1/resources.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2591
vendor/google.golang.org/genproto/googleapis/cloud/language/v1/language_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2311
vendor/google.golang.org/genproto/googleapis/cloud/language/v1beta1/language_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2596
vendor/google.golang.org/genproto/googleapis/cloud/language/v1beta2/language_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

331
vendor/google.golang.org/genproto/googleapis/cloud/location/locations.pb.go generated vendored Normal file
View File

@ -0,0 +1,331 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/location/locations.proto
/*
Package location is a generated protocol buffer package.
It is generated from these files:
google/cloud/location/locations.proto
It has these top-level messages:
ListLocationsRequest
ListLocationsResponse
GetLocationRequest
Location
*/
package location
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// The request message for [Locations.ListLocations][google.cloud.location.Locations.ListLocations].
type ListLocationsRequest struct {
// The resource that owns the locations collection, if applicable.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The standard list filter.
Filter string `protobuf:"bytes,2,opt,name=filter" json:"filter,omitempty"`
// The standard list page size.
PageSize int32 `protobuf:"varint,3,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
// The standard list page token.
PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
}
func (m *ListLocationsRequest) Reset() { *m = ListLocationsRequest{} }
func (m *ListLocationsRequest) String() string { return proto.CompactTextString(m) }
func (*ListLocationsRequest) ProtoMessage() {}
func (*ListLocationsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *ListLocationsRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *ListLocationsRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
func (m *ListLocationsRequest) GetPageSize() int32 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListLocationsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
// The response message for [Locations.ListLocations][google.cloud.location.Locations.ListLocations].
type ListLocationsResponse struct {
// A list of locations that matches the specified filter in the request.
Locations []*Location `protobuf:"bytes,1,rep,name=locations" json:"locations,omitempty"`
// The standard List next-page token.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
}
func (m *ListLocationsResponse) Reset() { *m = ListLocationsResponse{} }
func (m *ListLocationsResponse) String() string { return proto.CompactTextString(m) }
func (*ListLocationsResponse) ProtoMessage() {}
func (*ListLocationsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *ListLocationsResponse) GetLocations() []*Location {
if m != nil {
return m.Locations
}
return nil
}
func (m *ListLocationsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
// The request message for [Locations.GetLocation][google.cloud.location.Locations.GetLocation].
type GetLocationRequest struct {
// Resource name for the location.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetLocationRequest) Reset() { *m = GetLocationRequest{} }
func (m *GetLocationRequest) String() string { return proto.CompactTextString(m) }
func (*GetLocationRequest) ProtoMessage() {}
func (*GetLocationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *GetLocationRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// A resource that represents Google Cloud Platform location.
type Location struct {
// Resource name for the location, which may vary between implementations.
// For example: `"projects/example-project/locations/us-east1"`
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The canonical id for this location. For example: `"us-east1"`.
LocationId string `protobuf:"bytes,4,opt,name=location_id,json=locationId" json:"location_id,omitempty"`
// Cross-service attributes for the location. For example
//
// {"cloud.googleapis.com/region": "us-east1"}
Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Service-specific metadata. For example the available capacity at the given
// location.
Metadata *google_protobuf1.Any `protobuf:"bytes,3,opt,name=metadata" json:"metadata,omitempty"`
}
func (m *Location) Reset() { *m = Location{} }
func (m *Location) String() string { return proto.CompactTextString(m) }
func (*Location) ProtoMessage() {}
func (*Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *Location) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Location) GetLocationId() string {
if m != nil {
return m.LocationId
}
return ""
}
func (m *Location) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Location) GetMetadata() *google_protobuf1.Any {
if m != nil {
return m.Metadata
}
return nil
}
func init() {
proto.RegisterType((*ListLocationsRequest)(nil), "google.cloud.location.ListLocationsRequest")
proto.RegisterType((*ListLocationsResponse)(nil), "google.cloud.location.ListLocationsResponse")
proto.RegisterType((*GetLocationRequest)(nil), "google.cloud.location.GetLocationRequest")
proto.RegisterType((*Location)(nil), "google.cloud.location.Location")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for Locations service
type LocationsClient interface {
// Lists information about the supported locations for this service.
ListLocations(ctx context.Context, in *ListLocationsRequest, opts ...grpc.CallOption) (*ListLocationsResponse, error)
// Get information about a location.
GetLocation(ctx context.Context, in *GetLocationRequest, opts ...grpc.CallOption) (*Location, error)
}
type locationsClient struct {
cc *grpc.ClientConn
}
func NewLocationsClient(cc *grpc.ClientConn) LocationsClient {
return &locationsClient{cc}
}
func (c *locationsClient) ListLocations(ctx context.Context, in *ListLocationsRequest, opts ...grpc.CallOption) (*ListLocationsResponse, error) {
out := new(ListLocationsResponse)
err := grpc.Invoke(ctx, "/google.cloud.location.Locations/ListLocations", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *locationsClient) GetLocation(ctx context.Context, in *GetLocationRequest, opts ...grpc.CallOption) (*Location, error) {
out := new(Location)
err := grpc.Invoke(ctx, "/google.cloud.location.Locations/GetLocation", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Locations service
type LocationsServer interface {
// Lists information about the supported locations for this service.
ListLocations(context.Context, *ListLocationsRequest) (*ListLocationsResponse, error)
// Get information about a location.
GetLocation(context.Context, *GetLocationRequest) (*Location, error)
}
func RegisterLocationsServer(s *grpc.Server, srv LocationsServer) {
s.RegisterService(&_Locations_serviceDesc, srv)
}
func _Locations_ListLocations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListLocationsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(LocationsServer).ListLocations(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.location.Locations/ListLocations",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(LocationsServer).ListLocations(ctx, req.(*ListLocationsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Locations_GetLocation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetLocationRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(LocationsServer).GetLocation(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.location.Locations/GetLocation",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(LocationsServer).GetLocation(ctx, req.(*GetLocationRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Locations_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.cloud.location.Locations",
HandlerType: (*LocationsServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ListLocations",
Handler: _Locations_ListLocations_Handler,
},
{
MethodName: "GetLocation",
Handler: _Locations_GetLocation_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/cloud/location/locations.proto",
}
func init() { proto.RegisterFile("google/cloud/location/locations.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 508 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
0x10, 0xd6, 0x3a, 0x6d, 0x94, 0x8c, 0x55, 0x40, 0xa3, 0x14, 0xb9, 0x06, 0x94, 0xd4, 0x08, 0x48,
0x0b, 0xf2, 0x42, 0xb8, 0xf0, 0xa3, 0x1c, 0x28, 0x42, 0x08, 0x29, 0x87, 0xc8, 0x70, 0xe2, 0x12,
0x6d, 0x92, 0xad, 0x65, 0xea, 0xec, 0x1a, 0x7b, 0x53, 0x91, 0xa2, 0xf6, 0x80, 0x78, 0x83, 0xbe,
0x04, 0xef, 0xc3, 0x2b, 0xf0, 0x02, 0xdc, 0x38, 0x22, 0xaf, 0x7f, 0x12, 0x8a, 0x4b, 0xb8, 0xcd,
0xce, 0x7c, 0xb3, 0xdf, 0x7c, 0xf3, 0xad, 0x0d, 0x77, 0x7c, 0x29, 0xfd, 0x90, 0xd3, 0x49, 0x28,
0xe7, 0x53, 0x1a, 0xca, 0x09, 0x53, 0x81, 0x14, 0x65, 0x90, 0xb8, 0x51, 0x2c, 0x95, 0xc4, 0xed,
0x0c, 0xe6, 0x6a, 0x98, 0x5b, 0x54, 0xed, 0x9b, 0x79, 0x37, 0x8b, 0x02, 0xca, 0x84, 0x90, 0x6a,
0xb5, 0xc9, 0xde, 0xc9, 0xab, 0xfa, 0x34, 0x9e, 0x1f, 0x52, 0x26, 0x16, 0x59, 0xc9, 0x39, 0x83,
0xd6, 0x20, 0x48, 0xd4, 0xa0, 0xa0, 0xf1, 0xf8, 0xc7, 0x39, 0x4f, 0x14, 0x22, 0x6c, 0x08, 0x36,
0xe3, 0x16, 0xe9, 0x90, 0x6e, 0xd3, 0xd3, 0x31, 0x5e, 0x87, 0xfa, 0x61, 0x10, 0x2a, 0x1e, 0x5b,
0x86, 0xce, 0xe6, 0x27, 0xbc, 0x01, 0xcd, 0x88, 0xf9, 0x7c, 0x94, 0x04, 0x27, 0xdc, 0xaa, 0x75,
0x48, 0x77, 0xd3, 0x6b, 0xa4, 0x89, 0xb7, 0xc1, 0x09, 0xc7, 0x5b, 0x00, 0xba, 0xa8, 0xe4, 0x11,
0x17, 0xd6, 0x86, 0x6e, 0xd4, 0xf0, 0x77, 0x69, 0xc2, 0x39, 0x83, 0xed, 0x0b, 0xfc, 0x49, 0x24,
0x45, 0xc2, 0xb1, 0x0f, 0xcd, 0x52, 0xbb, 0x45, 0x3a, 0xb5, 0xae, 0xd9, 0x6b, 0xbb, 0x95, 0xe2,
0xdd, 0xa2, 0xd9, 0x5b, 0x76, 0xe0, 0x5d, 0xb8, 0x2a, 0xf8, 0x27, 0x35, 0x5a, 0xe1, 0xce, 0x86,
0xde, 0x4a, 0xd3, 0xc3, 0x92, 0xbf, 0x0b, 0xf8, 0x9a, 0x97, 0xf4, 0xff, 0x50, 0xef, 0xfc, 0x24,
0xd0, 0x28, 0x70, 0x95, 0xeb, 0x69, 0x83, 0x59, 0xf0, 0x8f, 0x82, 0x69, 0x2e, 0x15, 0x8a, 0xd4,
0x9b, 0x29, 0xbe, 0x84, 0x7a, 0xc8, 0xc6, 0x3c, 0x4c, 0x2c, 0x43, 0xeb, 0xb9, 0xbf, 0x46, 0x8f,
0x3b, 0xd0, 0xe8, 0x57, 0x42, 0xc5, 0x0b, 0x2f, 0x6f, 0xc5, 0x87, 0xd0, 0x98, 0x71, 0xc5, 0xa6,
0x4c, 0x31, 0xbd, 0x6b, 0xb3, 0xd7, 0x2a, 0xae, 0x29, 0xec, 0x75, 0x5f, 0x88, 0x85, 0x57, 0xa2,
0xec, 0xa7, 0x60, 0xae, 0x5c, 0x84, 0xd7, 0xa0, 0x76, 0xc4, 0x17, 0xf9, 0xe4, 0x69, 0x88, 0x2d,
0xd8, 0x3c, 0x66, 0xe1, 0x9c, 0xe7, 0x1b, 0xca, 0x0e, 0xcf, 0x8c, 0x27, 0xa4, 0xf7, 0xcd, 0x80,
0x66, 0x69, 0x0d, 0x9e, 0x13, 0xd8, 0xfa, 0xc3, 0x2c, 0xbc, 0x54, 0x41, 0xc5, 0x93, 0xb2, 0x1f,
0xfc, 0x1f, 0x38, 0xf3, 0xdf, 0xb9, 0xf7, 0xe5, 0xfb, 0x8f, 0x73, 0x63, 0x17, 0xdb, 0xf4, 0xf8,
0x11, 0xfd, 0x9c, 0x2e, 0xb8, 0x1f, 0xc5, 0xf2, 0x03, 0x9f, 0xa8, 0x84, 0xee, 0x9f, 0x2e, 0xbf,
0x0b, 0xfc, 0x4a, 0xc0, 0x5c, 0xb1, 0x10, 0xf7, 0x2e, 0xa1, 0xf9, 0xdb, 0x66, 0x7b, 0xdd, 0x83,
0x72, 0xf6, 0xf4, 0x10, 0xb7, 0x71, 0xb7, 0x6a, 0x88, 0xe5, 0x0c, 0x74, 0xff, 0xf4, 0x40, 0xc2,
0xce, 0x44, 0xce, 0xaa, 0x2f, 0x3c, 0xb8, 0x52, 0xea, 0x1b, 0xa6, 0x1e, 0x0d, 0xc9, 0xfb, 0x7e,
0x0e, 0xf4, 0x65, 0xc8, 0x84, 0xef, 0xca, 0xd8, 0xa7, 0x3e, 0x17, 0xda, 0x41, 0x9a, 0x95, 0x58,
0x14, 0x24, 0x17, 0xfe, 0x06, 0xcf, 0x8b, 0xe0, 0x17, 0x21, 0xe3, 0xba, 0x06, 0x3f, 0xfe, 0x1d,
0x00, 0x00, 0xff, 0xff, 0x0d, 0x57, 0x9e, 0xa7, 0x39, 0x04, 0x00, 0x00,
}

1822
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1/job_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1049
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1/model_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

161
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1/operation_metadata.pb.go generated vendored Normal file
View File

@ -0,0 +1,161 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/ml/v1/operation_metadata.proto
package ml
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf2 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// The operation type.
type OperationMetadata_OperationType int32
const (
// Unspecified operation type.
OperationMetadata_OPERATION_TYPE_UNSPECIFIED OperationMetadata_OperationType = 0
// An operation to create a new version.
OperationMetadata_CREATE_VERSION OperationMetadata_OperationType = 1
// An operation to delete an existing version.
OperationMetadata_DELETE_VERSION OperationMetadata_OperationType = 2
// An operation to delete an existing model.
OperationMetadata_DELETE_MODEL OperationMetadata_OperationType = 3
)
var OperationMetadata_OperationType_name = map[int32]string{
0: "OPERATION_TYPE_UNSPECIFIED",
1: "CREATE_VERSION",
2: "DELETE_VERSION",
3: "DELETE_MODEL",
}
var OperationMetadata_OperationType_value = map[string]int32{
"OPERATION_TYPE_UNSPECIFIED": 0,
"CREATE_VERSION": 1,
"DELETE_VERSION": 2,
"DELETE_MODEL": 3,
}
func (x OperationMetadata_OperationType) String() string {
return proto.EnumName(OperationMetadata_OperationType_name, int32(x))
}
func (OperationMetadata_OperationType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor2, []int{0, 0}
}
// Represents the metadata of the long-running operation.
type OperationMetadata struct {
// The time the operation was submitted.
CreateTime *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
// The time operation processing started.
StartTime *google_protobuf2.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
// The time operation processing completed.
EndTime *google_protobuf2.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
// Indicates whether a request to cancel this operation has been made.
IsCancellationRequested bool `protobuf:"varint,4,opt,name=is_cancellation_requested,json=isCancellationRequested" json:"is_cancellation_requested,omitempty"`
// The operation type.
OperationType OperationMetadata_OperationType `protobuf:"varint,5,opt,name=operation_type,json=operationType,enum=google.cloud.ml.v1.OperationMetadata_OperationType" json:"operation_type,omitempty"`
// Contains the name of the model associated with the operation.
ModelName string `protobuf:"bytes,6,opt,name=model_name,json=modelName" json:"model_name,omitempty"`
// Contains the version associated with the operation.
Version *Version `protobuf:"bytes,7,opt,name=version" json:"version,omitempty"`
}
func (m *OperationMetadata) Reset() { *m = OperationMetadata{} }
func (m *OperationMetadata) String() string { return proto.CompactTextString(m) }
func (*OperationMetadata) ProtoMessage() {}
func (*OperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *OperationMetadata) GetCreateTime() *google_protobuf2.Timestamp {
if m != nil {
return m.CreateTime
}
return nil
}
func (m *OperationMetadata) GetStartTime() *google_protobuf2.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
func (m *OperationMetadata) GetEndTime() *google_protobuf2.Timestamp {
if m != nil {
return m.EndTime
}
return nil
}
func (m *OperationMetadata) GetIsCancellationRequested() bool {
if m != nil {
return m.IsCancellationRequested
}
return false
}
func (m *OperationMetadata) GetOperationType() OperationMetadata_OperationType {
if m != nil {
return m.OperationType
}
return OperationMetadata_OPERATION_TYPE_UNSPECIFIED
}
func (m *OperationMetadata) GetModelName() string {
if m != nil {
return m.ModelName
}
return ""
}
func (m *OperationMetadata) GetVersion() *Version {
if m != nil {
return m.Version
}
return nil
}
func init() {
proto.RegisterType((*OperationMetadata)(nil), "google.cloud.ml.v1.OperationMetadata")
proto.RegisterEnum("google.cloud.ml.v1.OperationMetadata_OperationType", OperationMetadata_OperationType_name, OperationMetadata_OperationType_value)
}
func init() { proto.RegisterFile("google/cloud/ml/v1/operation_metadata.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 454 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x5f, 0x6b, 0xdb, 0x30,
0x14, 0xc5, 0xe7, 0xb6, 0x6b, 0x1a, 0x75, 0x0d, 0x99, 0x1e, 0xb6, 0xcc, 0xfb, 0x17, 0xfa, 0x30,
0x02, 0x03, 0x99, 0xb4, 0xdb, 0xc3, 0xd6, 0xa7, 0x36, 0xd1, 0x20, 0xd0, 0xc6, 0xc6, 0xf5, 0x0a,
0xeb, 0x8b, 0x51, 0xed, 0x3b, 0x23, 0x90, 0x25, 0xcf, 0x52, 0x0c, 0xfd, 0x2c, 0xfb, 0xb2, 0x23,
0x92, 0x4d, 0x33, 0x52, 0xe8, 0xa3, 0xce, 0xfd, 0x9d, 0xab, 0xab, 0x7b, 0x84, 0x3e, 0x17, 0x4a,
0x15, 0x02, 0x82, 0x4c, 0xa8, 0x55, 0x1e, 0x94, 0x22, 0x68, 0xa6, 0x81, 0xaa, 0xa0, 0x66, 0x86,
0x2b, 0x99, 0x96, 0x60, 0x58, 0xce, 0x0c, 0x23, 0x55, 0xad, 0x8c, 0xc2, 0xd8, 0xc1, 0xc4, 0xc2,
0xa4, 0x14, 0xa4, 0x99, 0xfa, 0xef, 0xda, 0x06, 0xac, 0xe2, 0x01, 0x93, 0x52, 0x19, 0xeb, 0xd4,
0xce, 0xe1, 0x7f, 0x7a, 0xa4, 0x7d, 0xa9, 0x72, 0x10, 0xa9, 0x86, 0xba, 0xe1, 0x19, 0xb4, 0xdc,
0xc7, 0x96, 0xb3, 0xa7, 0xbb, 0xd5, 0xef, 0xc0, 0xf0, 0x12, 0xb4, 0x61, 0x65, 0xe5, 0x80, 0xe3,
0xbf, 0x7b, 0xe8, 0x65, 0xd8, 0xcd, 0x75, 0xd5, 0x8e, 0x85, 0xcf, 0xd0, 0x61, 0x56, 0x03, 0x33,
0x90, 0xae, 0xf9, 0x91, 0x37, 0xf6, 0x26, 0x87, 0x27, 0x3e, 0x69, 0xc7, 0xec, 0x9a, 0x91, 0xa4,
0x6b, 0x16, 0x23, 0x87, 0xaf, 0x05, 0xfc, 0x0d, 0x21, 0x6d, 0x58, 0x6d, 0x9c, 0x77, 0xe7, 0x49,
0x6f, 0xdf, 0xd2, 0xd6, 0xfa, 0x15, 0x1d, 0x80, 0xcc, 0x9d, 0x71, 0xf7, 0x49, 0x63, 0x0f, 0x64,
0x6e, 0x6d, 0xdf, 0xd1, 0x1b, 0xae, 0xd3, 0x8c, 0xc9, 0x0c, 0x84, 0x70, 0x1b, 0xae, 0xe1, 0xcf,
0x0a, 0xb4, 0x81, 0x7c, 0xb4, 0x37, 0xf6, 0x26, 0x07, 0xf1, 0x6b, 0xae, 0x67, 0x1b, 0xf5, 0xb8,
0x2b, 0xe3, 0x5b, 0x34, 0x78, 0xc8, 0xc5, 0xdc, 0x57, 0x30, 0x7a, 0x3e, 0xf6, 0x26, 0x83, 0x93,
0x53, 0xb2, 0x1d, 0x0a, 0xd9, 0xda, 0xd4, 0x83, 0x92, 0xdc, 0x57, 0x10, 0x1f, 0xa9, 0xcd, 0x23,
0x7e, 0x8f, 0x90, 0x0b, 0x45, 0xb2, 0x12, 0x46, 0xfb, 0x63, 0x6f, 0xd2, 0x8f, 0xfb, 0x56, 0x59,
0x32, 0xfb, 0xda, 0x5e, 0x03, 0xb5, 0xe6, 0x4a, 0x8e, 0x7a, 0xf6, 0xb1, 0x6f, 0x1f, 0xbb, 0xf3,
0xc6, 0x21, 0x71, 0xc7, 0x1e, 0x73, 0x74, 0xf4, 0xdf, 0xad, 0xf8, 0x03, 0xf2, 0xc3, 0x88, 0xc6,
0xe7, 0xc9, 0x22, 0x5c, 0xa6, 0xc9, 0xaf, 0x88, 0xa6, 0x3f, 0x97, 0xd7, 0x11, 0x9d, 0x2d, 0x7e,
0x2c, 0xe8, 0x7c, 0xf8, 0x0c, 0x63, 0x34, 0x98, 0xc5, 0xf4, 0x3c, 0xa1, 0xe9, 0x0d, 0x8d, 0xaf,
0x17, 0xe1, 0x72, 0xe8, 0xad, 0xb5, 0x39, 0xbd, 0xa4, 0x1b, 0xda, 0x0e, 0x1e, 0xa2, 0x17, 0xad,
0x76, 0x15, 0xce, 0xe9, 0xe5, 0x70, 0xf7, 0x42, 0x20, 0x3f, 0x53, 0xe5, 0xd6, 0x54, 0xac, 0xe2,
0xa4, 0x99, 0x5e, 0xbc, 0xda, 0x5a, 0x47, 0xb4, 0x0e, 0x29, 0xf2, 0x6e, 0xbf, 0xb4, 0x8e, 0x42,
0x09, 0x26, 0x0b, 0xa2, 0xea, 0x22, 0x28, 0x40, 0xda, 0x08, 0x03, 0x57, 0x62, 0x15, 0xd7, 0x9b,
0xbf, 0xf7, 0xac, 0x14, 0x77, 0xfb, 0x16, 0x38, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x03, 0xf9,
0xcc, 0xf1, 0x3c, 0x03, 0x00, 0x00,
}

343
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1/prediction_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,343 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/ml/v1/prediction_service.proto
package ml
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_api3 "google.golang.org/genproto/googleapis/api/httpbody"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Request for predictions to be issued against a trained model.
//
// The body of the request is a single JSON object with a single top-level
// field:
//
// <dl>
// <dt>instances</dt>
// <dd>A JSON array containing values representing the instances to use for
// prediction.</dd>
// </dl>
//
// The structure of each element of the instances list is determined by your
// model's input definition. Instances can include named inputs or can contain
// only unlabeled values.
//
// Not all data includes named inputs. Some instances will be simple
// JSON values (boolean, number, or string). However, instances are often lists
// of simple values, or complex nested lists. Here are some examples of request
// bodies:
//
// CSV data with each row encoded as a string value:
// <pre>
// {"instances": ["1.0,true,\\"x\\"", "-2.0,false,\\"y\\""]}
// </pre>
// Plain text:
// <pre>
// {"instances": ["the quick brown fox", "la bruja le dio"]}
// </pre>
// Sentences encoded as lists of words (vectors of strings):
// <pre>
// {
// "instances": [
// ["the","quick","brown"],
// ["la","bruja","le"],
// ...
// ]
// }
// </pre>
// Floating point scalar values:
// <pre>
// {"instances": [0.0, 1.1, 2.2]}
// </pre>
// Vectors of integers:
// <pre>
// {
// "instances": [
// [0, 1, 2],
// [3, 4, 5],
// ...
// ]
// }
// </pre>
// Tensors (in this case, two-dimensional tensors):
// <pre>
// {
// "instances": [
// [
// [0, 1, 2],
// [3, 4, 5]
// ],
// ...
// ]
// }
// </pre>
// Images can be represented different ways. In this encoding scheme the first
// two dimensions represent the rows and columns of the image, and the third
// contains lists (vectors) of the R, G, and B values for each pixel.
// <pre>
// {
// "instances": [
// [
// [
// [138, 30, 66],
// [130, 20, 56],
// ...
// ],
// [
// [126, 38, 61],
// [122, 24, 57],
// ...
// ],
// ...
// ],
// ...
// ]
// }
// </pre>
// JSON strings must be encoded as UTF-8. To send binary data, you must
// base64-encode the data and mark it as binary. To mark a JSON string
// as binary, replace it with a JSON object with a single attribute named `b64`:
// <pre>{"b64": "..."} </pre>
// For example:
//
// Two Serialized tf.Examples (fake data, for illustrative purposes only):
// <pre>
// {"instances": [{"b64": "X5ad6u"}, {"b64": "IA9j4nx"}]}
// </pre>
// Two JPEG image byte strings (fake data, for illustrative purposes only):
// <pre>
// {"instances": [{"b64": "ASa8asdf"}, {"b64": "JLK7ljk3"}]}
// </pre>
// If your data includes named references, format each instance as a JSON object
// with the named references as the keys:
//
// JSON input data to be preprocessed:
// <pre>
// {
// "instances": [
// {
// "a": 1.0,
// "b": true,
// "c": "x"
// },
// {
// "a": -2.0,
// "b": false,
// "c": "y"
// }
// ]
// }
// </pre>
// Some models have an underlying TensorFlow graph that accepts multiple input
// tensors. In this case, you should use the names of JSON name/value pairs to
// identify the input tensors, as shown in the following exmaples:
//
// For a graph with input tensor aliases "tag" (string) and "image"
// (base64-encoded string):
// <pre>
// {
// "instances": [
// {
// "tag": "beach",
// "image": {"b64": "ASa8asdf"}
// },
// {
// "tag": "car",
// "image": {"b64": "JLK7ljk3"}
// }
// ]
// }
// </pre>
// For a graph with input tensor aliases "tag" (string) and "image"
// (3-dimensional array of 8-bit ints):
// <pre>
// {
// "instances": [
// {
// "tag": "beach",
// "image": [
// [
// [138, 30, 66],
// [130, 20, 56],
// ...
// ],
// [
// [126, 38, 61],
// [122, 24, 57],
// ...
// ],
// ...
// ]
// },
// {
// "tag": "car",
// "image": [
// [
// [255, 0, 102],
// [255, 0, 97],
// ...
// ],
// [
// [254, 1, 101],
// [254, 2, 93],
// ...
// ],
// ...
// ]
// },
// ...
// ]
// }
// </pre>
// If the call is successful, the response body will contain one prediction
// entry per instance in the request body. If prediction fails for any
// instance, the response body will contain no predictions and will contian
// a single error entry instead.
type PredictRequest struct {
// Required. The resource name of a model or a version.
//
// Authorization: requires `Viewer` role on the parent project.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
//
// Required. The prediction request body.
HttpBody *google_api3.HttpBody `protobuf:"bytes,2,opt,name=http_body,json=httpBody" json:"http_body,omitempty"`
}
func (m *PredictRequest) Reset() { *m = PredictRequest{} }
func (m *PredictRequest) String() string { return proto.CompactTextString(m) }
func (*PredictRequest) ProtoMessage() {}
func (*PredictRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
func (m *PredictRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *PredictRequest) GetHttpBody() *google_api3.HttpBody {
if m != nil {
return m.HttpBody
}
return nil
}
func init() {
proto.RegisterType((*PredictRequest)(nil), "google.cloud.ml.v1.PredictRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for OnlinePredictionService service
type OnlinePredictionServiceClient interface {
// Performs prediction on the data in the request.
//
// **** REMOVE FROM GENERATED DOCUMENTATION
Predict(ctx context.Context, in *PredictRequest, opts ...grpc.CallOption) (*google_api3.HttpBody, error)
}
type onlinePredictionServiceClient struct {
cc *grpc.ClientConn
}
func NewOnlinePredictionServiceClient(cc *grpc.ClientConn) OnlinePredictionServiceClient {
return &onlinePredictionServiceClient{cc}
}
func (c *onlinePredictionServiceClient) Predict(ctx context.Context, in *PredictRequest, opts ...grpc.CallOption) (*google_api3.HttpBody, error) {
out := new(google_api3.HttpBody)
err := grpc.Invoke(ctx, "/google.cloud.ml.v1.OnlinePredictionService/Predict", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for OnlinePredictionService service
type OnlinePredictionServiceServer interface {
// Performs prediction on the data in the request.
//
// **** REMOVE FROM GENERATED DOCUMENTATION
Predict(context.Context, *PredictRequest) (*google_api3.HttpBody, error)
}
func RegisterOnlinePredictionServiceServer(s *grpc.Server, srv OnlinePredictionServiceServer) {
s.RegisterService(&_OnlinePredictionService_serviceDesc, srv)
}
func _OnlinePredictionService_Predict_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PredictRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OnlinePredictionServiceServer).Predict(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.ml.v1.OnlinePredictionService/Predict",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OnlinePredictionServiceServer).Predict(ctx, req.(*PredictRequest))
}
return interceptor(ctx, in, info, handler)
}
var _OnlinePredictionService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.cloud.ml.v1.OnlinePredictionService",
HandlerType: (*OnlinePredictionServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Predict",
Handler: _OnlinePredictionService_Predict_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/cloud/ml/v1/prediction_service.proto",
}
func init() { proto.RegisterFile("google/cloud/ml/v1/prediction_service.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 308 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0x4f, 0x4b, 0xfb, 0x30,
0x18, 0xa6, 0xe3, 0xc7, 0x4f, 0x17, 0xc1, 0x43, 0x10, 0x9d, 0x45, 0x64, 0xd4, 0xcb, 0x9c, 0x90,
0xd0, 0xe9, 0x69, 0xe2, 0x65, 0x27, 0x6f, 0x96, 0x79, 0x10, 0xbc, 0x8c, 0xac, 0x0d, 0x59, 0x24,
0xcd, 0x1b, 0xdb, 0xac, 0x30, 0xc4, 0x8b, 0x37, 0xcf, 0x7e, 0x34, 0xbf, 0x82, 0x1f, 0x44, 0xd2,
0x04, 0x99, 0xd4, 0xdb, 0x4b, 0xde, 0xe7, 0x79, 0x9f, 0x3f, 0x41, 0x17, 0x02, 0x40, 0x28, 0x4e,
0x73, 0x05, 0xeb, 0x82, 0x96, 0x8a, 0x36, 0x29, 0x35, 0x15, 0x2f, 0x64, 0x6e, 0x25, 0xe8, 0x45,
0xcd, 0xab, 0x46, 0xe6, 0x9c, 0x98, 0x0a, 0x2c, 0x60, 0xec, 0xc1, 0xa4, 0x05, 0x93, 0x52, 0x91,
0x26, 0x8d, 0x4f, 0xc2, 0x01, 0x66, 0x24, 0x65, 0x5a, 0x83, 0x65, 0x8e, 0x58, 0x7b, 0x46, 0x7c,
0xbc, 0xb5, 0x5d, 0x59, 0x6b, 0x96, 0x50, 0x6c, 0xfc, 0x2a, 0x79, 0x40, 0xfb, 0x99, 0x17, 0x9a,
0xf3, 0xe7, 0x35, 0xaf, 0x2d, 0xc6, 0xe8, 0x9f, 0x66, 0x25, 0x1f, 0x44, 0xc3, 0x68, 0xd4, 0x9f,
0xb7, 0x33, 0x4e, 0x51, 0xdf, 0xf1, 0x16, 0x8e, 0x38, 0xe8, 0x0d, 0xa3, 0xd1, 0xde, 0xe4, 0x80,
0x04, 0x1b, 0xcc, 0x48, 0x72, 0x6b, 0xad, 0x99, 0x41, 0xb1, 0x99, 0xef, 0xae, 0xc2, 0x34, 0x79,
0x8f, 0xd0, 0xd1, 0x9d, 0x56, 0x52, 0xf3, 0xec, 0x27, 0xc8, 0xbd, 0xcf, 0x81, 0x35, 0xda, 0x09,
0x8f, 0x38, 0x21, 0xdd, 0x34, 0xe4, 0xb7, 0xa3, 0xf8, 0x4f, 0xa9, 0xe4, 0xfc, 0xed, 0xf3, 0xeb,
0xa3, 0x77, 0x96, 0x9c, 0xba, 0xb2, 0x5e, 0x9c, 0xcd, 0x1b, 0x53, 0xc1, 0x13, 0xcf, 0x6d, 0x4d,
0xc7, 0xe3, 0xd7, 0x69, 0xe8, 0x6f, 0x1a, 0x8d, 0x67, 0x0a, 0xc5, 0x39, 0x94, 0x1d, 0x25, 0x77,
0xae, 0x49, 0x67, 0x87, 0x1d, 0x83, 0x99, 0xab, 0x26, 0x8b, 0x1e, 0xaf, 0x02, 0x43, 0x80, 0x62,
0x5a, 0x10, 0xa8, 0x04, 0x15, 0x5c, 0xb7, 0xc5, 0x51, 0xbf, 0x62, 0x46, 0xd6, 0xdb, 0xbf, 0x76,
0x5d, 0xaa, 0xe5, 0xff, 0x16, 0x70, 0xf9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x81, 0x8e, 0x25, 0xca,
0xd5, 0x01, 0x00, 0x00,
}

177
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1/project_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,177 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/ml/v1/project_service.proto
package ml
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Requests service account information associated with a project.
type GetConfigRequest struct {
// Required. The project name.
//
// Authorization: requires `Viewer` role on the specified project.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetConfigRequest) Reset() { *m = GetConfigRequest{} }
func (m *GetConfigRequest) String() string { return proto.CompactTextString(m) }
func (*GetConfigRequest) ProtoMessage() {}
func (*GetConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
func (m *GetConfigRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Returns service account information associated with a project.
type GetConfigResponse struct {
// The service account Cloud ML uses to access resources in the project.
ServiceAccount string `protobuf:"bytes,1,opt,name=service_account,json=serviceAccount" json:"service_account,omitempty"`
// The project number for `service_account`.
ServiceAccountProject int64 `protobuf:"varint,2,opt,name=service_account_project,json=serviceAccountProject" json:"service_account_project,omitempty"`
}
func (m *GetConfigResponse) Reset() { *m = GetConfigResponse{} }
func (m *GetConfigResponse) String() string { return proto.CompactTextString(m) }
func (*GetConfigResponse) ProtoMessage() {}
func (*GetConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
func (m *GetConfigResponse) GetServiceAccount() string {
if m != nil {
return m.ServiceAccount
}
return ""
}
func (m *GetConfigResponse) GetServiceAccountProject() int64 {
if m != nil {
return m.ServiceAccountProject
}
return 0
}
func init() {
proto.RegisterType((*GetConfigRequest)(nil), "google.cloud.ml.v1.GetConfigRequest")
proto.RegisterType((*GetConfigResponse)(nil), "google.cloud.ml.v1.GetConfigResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for ProjectManagementService service
type ProjectManagementServiceClient interface {
// Get the service account information associated with your project. You need
// this information in order to grant the service account persmissions for
// the Google Cloud Storage location where you put your model training code
// for training the model with Google Cloud Machine Learning.
GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error)
}
type projectManagementServiceClient struct {
cc *grpc.ClientConn
}
func NewProjectManagementServiceClient(cc *grpc.ClientConn) ProjectManagementServiceClient {
return &projectManagementServiceClient{cc}
}
func (c *projectManagementServiceClient) GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error) {
out := new(GetConfigResponse)
err := grpc.Invoke(ctx, "/google.cloud.ml.v1.ProjectManagementService/GetConfig", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for ProjectManagementService service
type ProjectManagementServiceServer interface {
// Get the service account information associated with your project. You need
// this information in order to grant the service account persmissions for
// the Google Cloud Storage location where you put your model training code
// for training the model with Google Cloud Machine Learning.
GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error)
}
func RegisterProjectManagementServiceServer(s *grpc.Server, srv ProjectManagementServiceServer) {
s.RegisterService(&_ProjectManagementService_serviceDesc, srv)
}
func _ProjectManagementService_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetConfigRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProjectManagementServiceServer).GetConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.ml.v1.ProjectManagementService/GetConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProjectManagementServiceServer).GetConfig(ctx, req.(*GetConfigRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ProjectManagementService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.cloud.ml.v1.ProjectManagementService",
HandlerType: (*ProjectManagementServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetConfig",
Handler: _ProjectManagementService_GetConfig_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/cloud/ml/v1/project_service.proto",
}
func init() { proto.RegisterFile("google/cloud/ml/v1/project_service.proto", fileDescriptor4) }
var fileDescriptor4 = []byte{
// 319 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xbf, 0x4a, 0x43, 0x31,
0x14, 0xc6, 0xb9, 0x55, 0x84, 0x66, 0xf0, 0x4f, 0x44, 0x2c, 0x45, 0xb0, 0x16, 0xb5, 0xc5, 0x21,
0xa1, 0x2a, 0x0e, 0x8a, 0x83, 0x75, 0x70, 0x12, 0x4a, 0xdd, 0x5c, 0x4a, 0xbc, 0x1e, 0x43, 0x24,
0xc9, 0x89, 0x37, 0xe9, 0x5d, 0xc4, 0x41, 0x5f, 0xc1, 0xdd, 0x97, 0xf2, 0x15, 0x7c, 0x10, 0xe9,
0x4d, 0x94, 0xda, 0x0e, 0x6e, 0x87, 0x73, 0x7e, 0x5f, 0xf2, 0x7d, 0xe7, 0x90, 0xae, 0x44, 0x94,
0x1a, 0x78, 0xae, 0x71, 0x7c, 0xcf, 0x8d, 0xe6, 0x65, 0x8f, 0xbb, 0x02, 0x1f, 0x21, 0x0f, 0x23,
0x0f, 0x45, 0xa9, 0x72, 0x60, 0xae, 0xc0, 0x80, 0x94, 0x46, 0x92, 0x55, 0x24, 0x33, 0x9a, 0x95,
0xbd, 0xe6, 0x56, 0x52, 0x0b, 0xa7, 0xb8, 0xb0, 0x16, 0x83, 0x08, 0x0a, 0xad, 0x8f, 0x8a, 0xf6,
0x3e, 0x59, 0xbd, 0x82, 0x70, 0x89, 0xf6, 0x41, 0xc9, 0x21, 0x3c, 0x8d, 0xc1, 0x07, 0x4a, 0xc9,
0xa2, 0x15, 0x06, 0x1a, 0x59, 0x2b, 0xeb, 0xd6, 0x87, 0x55, 0xdd, 0x0e, 0x64, 0x6d, 0x8a, 0xf3,
0x0e, 0xad, 0x07, 0xda, 0x21, 0x2b, 0xe9, 0xff, 0x91, 0xc8, 0x73, 0x1c, 0xdb, 0x90, 0x34, 0xcb,
0xa9, 0x7d, 0x11, 0xbb, 0xf4, 0x84, 0x6c, 0xce, 0x80, 0xa3, 0x14, 0xa0, 0x51, 0x6b, 0x65, 0xdd,
0x85, 0xe1, 0xc6, 0x5f, 0xc1, 0x20, 0x0e, 0x0f, 0x3f, 0x32, 0xd2, 0x48, 0xf5, 0xb5, 0xb0, 0x42,
0x82, 0x01, 0x1b, 0x6e, 0x22, 0x4a, 0x5f, 0x33, 0x52, 0xff, 0xf5, 0x44, 0x77, 0xd9, 0x7c, 0x76,
0x36, 0x1b, 0xad, 0xb9, 0xf7, 0x0f, 0x15, 0x83, 0xb5, 0x3b, 0x6f, 0x9f, 0x5f, 0xef, 0xb5, 0x1d,
0xba, 0x3d, 0x59, 0xf5, 0xf3, 0x64, 0x01, 0xe7, 0xc9, 0xaf, 0xe7, 0x07, 0x2f, 0xa7, 0xf2, 0x47,
0xd0, 0x57, 0xa4, 0x99, 0xa3, 0x99, 0x7b, 0x54, 0x38, 0xc5, 0xca, 0x5e, 0x7f, 0x3d, 0x79, 0x4f,
0x8e, 0x07, 0x93, 0x8d, 0x0f, 0xb2, 0xdb, 0xe3, 0x84, 0x4b, 0xd4, 0xc2, 0x4a, 0x86, 0x85, 0xe4,
0x12, 0x6c, 0x75, 0x0f, 0x1e, 0x47, 0xc2, 0x29, 0x3f, 0x7d, 0xee, 0x33, 0xa3, 0xef, 0x96, 0x2a,
0xe0, 0xe8, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xd0, 0xa5, 0x43, 0x33, 0x0e, 0x02, 0x00, 0x00,
}

1823
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1beta1/job_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1050
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1beta1/model_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

161
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1beta1/operation_metadata.pb.go generated vendored Normal file
View File

@ -0,0 +1,161 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/ml/v1beta1/operation_metadata.proto
package ml
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf2 "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// The operation type.
type OperationMetadata_OperationType int32
const (
// Unspecified operation type.
OperationMetadata_OPERATION_TYPE_UNSPECIFIED OperationMetadata_OperationType = 0
// An operation to create a new version.
OperationMetadata_CREATE_VERSION OperationMetadata_OperationType = 1
// An operation to delete an existing version.
OperationMetadata_DELETE_VERSION OperationMetadata_OperationType = 2
// An operation to delete an existing model.
OperationMetadata_DELETE_MODEL OperationMetadata_OperationType = 3
)
var OperationMetadata_OperationType_name = map[int32]string{
0: "OPERATION_TYPE_UNSPECIFIED",
1: "CREATE_VERSION",
2: "DELETE_VERSION",
3: "DELETE_MODEL",
}
var OperationMetadata_OperationType_value = map[string]int32{
"OPERATION_TYPE_UNSPECIFIED": 0,
"CREATE_VERSION": 1,
"DELETE_VERSION": 2,
"DELETE_MODEL": 3,
}
func (x OperationMetadata_OperationType) String() string {
return proto.EnumName(OperationMetadata_OperationType_name, int32(x))
}
func (OperationMetadata_OperationType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor2, []int{0, 0}
}
// Represents the metadata of the long-running operation.
type OperationMetadata struct {
// The time the operation was submitted.
CreateTime *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
// The time operation processing started.
StartTime *google_protobuf2.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
// The time operation processing completed.
EndTime *google_protobuf2.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
// Indicates whether a request to cancel this operation has been made.
IsCancellationRequested bool `protobuf:"varint,4,opt,name=is_cancellation_requested,json=isCancellationRequested" json:"is_cancellation_requested,omitempty"`
// The operation type.
OperationType OperationMetadata_OperationType `protobuf:"varint,5,opt,name=operation_type,json=operationType,enum=google.cloud.ml.v1beta1.OperationMetadata_OperationType" json:"operation_type,omitempty"`
// Contains the name of the model associated with the operation.
ModelName string `protobuf:"bytes,6,opt,name=model_name,json=modelName" json:"model_name,omitempty"`
// Contains the version associated with the operation.
Version *Version `protobuf:"bytes,7,opt,name=version" json:"version,omitempty"`
}
func (m *OperationMetadata) Reset() { *m = OperationMetadata{} }
func (m *OperationMetadata) String() string { return proto.CompactTextString(m) }
func (*OperationMetadata) ProtoMessage() {}
func (*OperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *OperationMetadata) GetCreateTime() *google_protobuf2.Timestamp {
if m != nil {
return m.CreateTime
}
return nil
}
func (m *OperationMetadata) GetStartTime() *google_protobuf2.Timestamp {
if m != nil {
return m.StartTime
}
return nil
}
func (m *OperationMetadata) GetEndTime() *google_protobuf2.Timestamp {
if m != nil {
return m.EndTime
}
return nil
}
func (m *OperationMetadata) GetIsCancellationRequested() bool {
if m != nil {
return m.IsCancellationRequested
}
return false
}
func (m *OperationMetadata) GetOperationType() OperationMetadata_OperationType {
if m != nil {
return m.OperationType
}
return OperationMetadata_OPERATION_TYPE_UNSPECIFIED
}
func (m *OperationMetadata) GetModelName() string {
if m != nil {
return m.ModelName
}
return ""
}
func (m *OperationMetadata) GetVersion() *Version {
if m != nil {
return m.Version
}
return nil
}
func init() {
proto.RegisterType((*OperationMetadata)(nil), "google.cloud.ml.v1beta1.OperationMetadata")
proto.RegisterEnum("google.cloud.ml.v1beta1.OperationMetadata_OperationType", OperationMetadata_OperationType_name, OperationMetadata_OperationType_value)
}
func init() { proto.RegisterFile("google/cloud/ml/v1beta1/operation_metadata.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 457 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x5f, 0x6b, 0xdb, 0x30,
0x14, 0xc5, 0xe7, 0xb6, 0x6b, 0x1b, 0x75, 0x0d, 0x99, 0x1f, 0x56, 0x2f, 0x6c, 0xab, 0xe9, 0x53,
0x60, 0x60, 0xaf, 0x1d, 0x83, 0x75, 0x7d, 0x6a, 0x13, 0x0d, 0x02, 0x6d, 0x6c, 0x54, 0xaf, 0xb0,
0xbd, 0x18, 0xc5, 0xbe, 0x33, 0x02, 0xfd, 0xf1, 0x2c, 0x25, 0xd0, 0x0f, 0xb4, 0xef, 0x39, 0x22,
0xd9, 0x34, 0x23, 0x84, 0x3e, 0xea, 0xdc, 0xf3, 0xbb, 0xf7, 0xf8, 0x5e, 0xa3, 0x4f, 0x95, 0x52,
0x15, 0x87, 0xb8, 0xe0, 0x6a, 0x51, 0xc6, 0x82, 0xc7, 0xcb, 0xf3, 0x39, 0x18, 0x7a, 0x1e, 0xab,
0x1a, 0x1a, 0x6a, 0x98, 0x92, 0xb9, 0x00, 0x43, 0x4b, 0x6a, 0x68, 0x54, 0x37, 0xca, 0x28, 0xff,
0xc4, 0x11, 0x91, 0x25, 0x22, 0xc1, 0xa3, 0x96, 0x18, 0xbe, 0x6b, 0x5b, 0xd1, 0x9a, 0xc5, 0x54,
0x4a, 0x65, 0x2c, 0xae, 0x1d, 0x36, 0xfc, 0xb8, 0x6d, 0x90, 0x50, 0x25, 0xf0, 0x5c, 0x43, 0xb3,
0x64, 0x05, 0xb4, 0xe6, 0xd3, 0xd6, 0x6c, 0x5f, 0xf3, 0xc5, 0xef, 0xd8, 0x30, 0x01, 0xda, 0x50,
0x51, 0x3b, 0xc3, 0xd9, 0xdf, 0x3d, 0xf4, 0x3a, 0xe9, 0x12, 0xde, 0xb5, 0x01, 0xfd, 0x2b, 0x74,
0x54, 0x34, 0x40, 0x0d, 0xe4, 0x2b, 0x7f, 0xe0, 0x85, 0xde, 0xe8, 0xe8, 0x62, 0x18, 0xb5, 0x81,
0xbb, 0x66, 0x51, 0xd6, 0x35, 0x23, 0xc8, 0xd9, 0x57, 0x82, 0x7f, 0x89, 0x90, 0x36, 0xb4, 0x31,
0x8e, 0xdd, 0x79, 0x96, 0xed, 0x59, 0xb7, 0x45, 0xbf, 0xa0, 0x43, 0x90, 0xa5, 0x03, 0x77, 0x9f,
0x05, 0x0f, 0x40, 0x96, 0x16, 0xfb, 0x86, 0xde, 0x32, 0x9d, 0x17, 0x54, 0x16, 0xc0, 0xb9, 0xdb,
0x75, 0x03, 0x7f, 0x16, 0xa0, 0x0d, 0x94, 0xc1, 0x5e, 0xe8, 0x8d, 0x0e, 0xc9, 0x09, 0xd3, 0xe3,
0xb5, 0x3a, 0xe9, 0xca, 0x7e, 0x8e, 0xfa, 0x4f, 0x17, 0x32, 0x8f, 0x35, 0x04, 0x2f, 0x43, 0x6f,
0xd4, 0xbf, 0xf8, 0x1a, 0x6d, 0x39, 0x4f, 0xb4, 0xb1, 0xae, 0x27, 0x25, 0x7b, 0xac, 0x81, 0x1c,
0xab, 0xf5, 0xa7, 0xff, 0x1e, 0x21, 0x77, 0x19, 0x49, 0x05, 0x04, 0xfb, 0xa1, 0x37, 0xea, 0x91,
0x9e, 0x55, 0x66, 0xd4, 0x66, 0x3f, 0x58, 0x42, 0xa3, 0x99, 0x92, 0xc1, 0x81, 0xfd, 0xe2, 0x70,
0xeb, 0xe0, 0x07, 0xe7, 0x23, 0x1d, 0x70, 0xc6, 0xd0, 0xf1, 0x7f, 0xa3, 0xfd, 0x0f, 0x68, 0x98,
0xa4, 0x98, 0x5c, 0x67, 0xd3, 0x64, 0x96, 0x67, 0x3f, 0x53, 0x9c, 0xff, 0x98, 0xdd, 0xa7, 0x78,
0x3c, 0xfd, 0x3e, 0xc5, 0x93, 0xc1, 0x0b, 0xdf, 0x47, 0xfd, 0x31, 0xc1, 0xd7, 0x19, 0xce, 0x1f,
0x30, 0xb9, 0x9f, 0x26, 0xb3, 0x81, 0xb7, 0xd2, 0x26, 0xf8, 0x16, 0xaf, 0x69, 0x3b, 0xfe, 0x00,
0xbd, 0x6a, 0xb5, 0xbb, 0x64, 0x82, 0x6f, 0x07, 0xbb, 0x37, 0x4b, 0x74, 0x5a, 0x28, 0xb1, 0x11,
0x8d, 0xd6, 0xac, 0x8b, 0x77, 0xf3, 0x66, 0x63, 0x31, 0xe9, 0xea, 0x66, 0xa9, 0xf7, 0xeb, 0xb2,
0xc5, 0x2a, 0xc5, 0xa9, 0xac, 0x22, 0xd5, 0x54, 0x71, 0x05, 0xd2, 0x5e, 0x34, 0x76, 0x25, 0x5a,
0x33, 0xbd, 0xf1, 0x47, 0x5f, 0x09, 0x3e, 0xdf, 0xb7, 0xae, 0xcf, 0xff, 0x02, 0x00, 0x00, 0xff,
0xff, 0x89, 0xf8, 0x21, 0xa7, 0x5f, 0x03, 0x00, 0x00,
}

343
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1beta1/prediction_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,343 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/ml/v1beta1/prediction_service.proto
package ml
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_api3 "google.golang.org/genproto/googleapis/api/httpbody"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Request for predictions to be issued against a trained model.
//
// The body of the request is a single JSON object with a single top-level
// field:
//
// <dl>
// <dt>instances</dt>
// <dd>A JSON array containing values representing the instances to use for
// prediction.</dd>
// </dl>
//
// The structure of each element of the instances list is determined by your
// model's input definition. Instances can include named inputs or can contain
// only unlabeled values.
//
// Not all data includes named inputs. Some instances will be simple
// JSON values (boolean, number, or string). However, instances are often lists
// of simple values, or complex nested lists. Here are some examples of request
// bodies:
//
// CSV data with each row encoded as a string value:
// <pre>
// {"instances": ["1.0,true,\\"x\\"", "-2.0,false,\\"y\\""]}
// </pre>
// Plain text:
// <pre>
// {"instances": ["the quick brown fox", "la bruja le dio"]}
// </pre>
// Sentences encoded as lists of words (vectors of strings):
// <pre>
// {
// "instances": [
// ["the","quick","brown"],
// ["la","bruja","le"],
// ...
// ]
// }
// </pre>
// Floating point scalar values:
// <pre>
// {"instances": [0.0, 1.1, 2.2]}
// </pre>
// Vectors of integers:
// <pre>
// {
// "instances": [
// [0, 1, 2],
// [3, 4, 5],
// ...
// ]
// }
// </pre>
// Tensors (in this case, two-dimensional tensors):
// <pre>
// {
// "instances": [
// [
// [0, 1, 2],
// [3, 4, 5]
// ],
// ...
// ]
// }
// </pre>
// Images can be represented different ways. In this encoding scheme the first
// two dimensions represent the rows and columns of the image, and the third
// contains lists (vectors) of the R, G, and B values for each pixel.
// <pre>
// {
// "instances": [
// [
// [
// [138, 30, 66],
// [130, 20, 56],
// ...
// ],
// [
// [126, 38, 61],
// [122, 24, 57],
// ...
// ],
// ...
// ],
// ...
// ]
// }
// </pre>
// JSON strings must be encoded as UTF-8. To send binary data, you must
// base64-encode the data and mark it as binary. To mark a JSON string
// as binary, replace it with a JSON object with a single attribute named `b64`:
// <pre>{"b64": "..."} </pre>
// For example:
//
// Two Serialized tf.Examples (fake data, for illustrative purposes only):
// <pre>
// {"instances": [{"b64": "X5ad6u"}, {"b64": "IA9j4nx"}]}
// </pre>
// Two JPEG image byte strings (fake data, for illustrative purposes only):
// <pre>
// {"instances": [{"b64": "ASa8asdf"}, {"b64": "JLK7ljk3"}]}
// </pre>
// If your data includes named references, format each instance as a JSON object
// with the named references as the keys:
//
// JSON input data to be preprocessed:
// <pre>
// {
// "instances": [
// {
// "a": 1.0,
// "b": true,
// "c": "x"
// },
// {
// "a": -2.0,
// "b": false,
// "c": "y"
// }
// ]
// }
// </pre>
// Some models have an underlying TensorFlow graph that accepts multiple input
// tensors. In this case, you should use the names of JSON name/value pairs to
// identify the input tensors, as shown in the following exmaples:
//
// For a graph with input tensor aliases "tag" (string) and "image"
// (base64-encoded string):
// <pre>
// {
// "instances": [
// {
// "tag": "beach",
// "image": {"b64": "ASa8asdf"}
// },
// {
// "tag": "car",
// "image": {"b64": "JLK7ljk3"}
// }
// ]
// }
// </pre>
// For a graph with input tensor aliases "tag" (string) and "image"
// (3-dimensional array of 8-bit ints):
// <pre>
// {
// "instances": [
// {
// "tag": "beach",
// "image": [
// [
// [138, 30, 66],
// [130, 20, 56],
// ...
// ],
// [
// [126, 38, 61],
// [122, 24, 57],
// ...
// ],
// ...
// ]
// },
// {
// "tag": "car",
// "image": [
// [
// [255, 0, 102],
// [255, 0, 97],
// ...
// ],
// [
// [254, 1, 101],
// [254, 2, 93],
// ...
// ],
// ...
// ]
// },
// ...
// ]
// }
// </pre>
// If the call is successful, the response body will contain one prediction
// entry per instance in the request body. If prediction fails for any
// instance, the response body will contain no predictions and will contian
// a single error entry instead.
type PredictRequest struct {
// Required. The resource name of a model or a version.
//
// Authorization: requires `Viewer` role on the parent project.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
//
// Required. The prediction request body.
HttpBody *google_api3.HttpBody `protobuf:"bytes,2,opt,name=http_body,json=httpBody" json:"http_body,omitempty"`
}
func (m *PredictRequest) Reset() { *m = PredictRequest{} }
func (m *PredictRequest) String() string { return proto.CompactTextString(m) }
func (*PredictRequest) ProtoMessage() {}
func (*PredictRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
func (m *PredictRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *PredictRequest) GetHttpBody() *google_api3.HttpBody {
if m != nil {
return m.HttpBody
}
return nil
}
func init() {
proto.RegisterType((*PredictRequest)(nil), "google.cloud.ml.v1beta1.PredictRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for OnlinePredictionService service
type OnlinePredictionServiceClient interface {
// Performs prediction on the data in the request.
//
// **** REMOVE FROM GENERATED DOCUMENTATION
Predict(ctx context.Context, in *PredictRequest, opts ...grpc.CallOption) (*google_api3.HttpBody, error)
}
type onlinePredictionServiceClient struct {
cc *grpc.ClientConn
}
func NewOnlinePredictionServiceClient(cc *grpc.ClientConn) OnlinePredictionServiceClient {
return &onlinePredictionServiceClient{cc}
}
func (c *onlinePredictionServiceClient) Predict(ctx context.Context, in *PredictRequest, opts ...grpc.CallOption) (*google_api3.HttpBody, error) {
out := new(google_api3.HttpBody)
err := grpc.Invoke(ctx, "/google.cloud.ml.v1beta1.OnlinePredictionService/Predict", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for OnlinePredictionService service
type OnlinePredictionServiceServer interface {
// Performs prediction on the data in the request.
//
// **** REMOVE FROM GENERATED DOCUMENTATION
Predict(context.Context, *PredictRequest) (*google_api3.HttpBody, error)
}
func RegisterOnlinePredictionServiceServer(s *grpc.Server, srv OnlinePredictionServiceServer) {
s.RegisterService(&_OnlinePredictionService_serviceDesc, srv)
}
func _OnlinePredictionService_Predict_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PredictRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OnlinePredictionServiceServer).Predict(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.ml.v1beta1.OnlinePredictionService/Predict",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OnlinePredictionServiceServer).Predict(ctx, req.(*PredictRequest))
}
return interceptor(ctx, in, info, handler)
}
var _OnlinePredictionService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.cloud.ml.v1beta1.OnlinePredictionService",
HandlerType: (*OnlinePredictionServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Predict",
Handler: _OnlinePredictionService_Predict_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/cloud/ml/v1beta1/prediction_service.proto",
}
func init() { proto.RegisterFile("google/cloud/ml/v1beta1/prediction_service.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 312 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0x4d, 0x4a, 0x03, 0x31,
0x14, 0xc7, 0x49, 0x11, 0xb5, 0x11, 0x5c, 0x04, 0xb1, 0xb5, 0x08, 0x96, 0xba, 0xb0, 0x74, 0x91,
0xd8, 0xba, 0xb2, 0xe2, 0xa6, 0x2b, 0x77, 0x0e, 0x75, 0x21, 0xb8, 0x29, 0xe9, 0x4c, 0x48, 0x23,
0x99, 0xbc, 0x38, 0x93, 0x16, 0x8b, 0xb8, 0xf1, 0x0a, 0x3d, 0x9a, 0x57, 0xf0, 0x20, 0x92, 0x49,
0x28, 0xca, 0xe8, 0xee, 0x31, 0x6f, 0x7e, 0xef, 0xff, 0x11, 0x7c, 0x29, 0x01, 0xa4, 0x16, 0x2c,
0xd5, 0xb0, 0xcc, 0x58, 0xae, 0xd9, 0x6a, 0x38, 0x17, 0x8e, 0x0f, 0x99, 0x2d, 0x44, 0xa6, 0x52,
0xa7, 0xc0, 0xcc, 0x4a, 0x51, 0xac, 0x54, 0x2a, 0xa8, 0x2d, 0xc0, 0x01, 0x69, 0x05, 0x82, 0x56,
0x04, 0xcd, 0x35, 0x8d, 0x44, 0xe7, 0x34, 0x9e, 0xe2, 0x56, 0x31, 0x6e, 0x0c, 0x38, 0xee, 0xe9,
0x32, 0x60, 0x9d, 0x93, 0x1f, 0xdb, 0x85, 0x73, 0x76, 0x0e, 0xd9, 0x3a, 0xac, 0x7a, 0x8f, 0xf8,
0x30, 0x09, 0x6a, 0x53, 0xf1, 0xb2, 0x14, 0xa5, 0x23, 0x04, 0xef, 0x18, 0x9e, 0x8b, 0x36, 0xea,
0xa2, 0x7e, 0x73, 0x5a, 0xcd, 0x64, 0x88, 0x9b, 0x9e, 0x9b, 0x79, 0xb0, 0xdd, 0xe8, 0xa2, 0xfe,
0xc1, 0xe8, 0x88, 0x46, 0x2f, 0xdc, 0x2a, 0x7a, 0xe7, 0x9c, 0x9d, 0x40, 0xb6, 0x9e, 0xee, 0x2f,
0xe2, 0x34, 0xda, 0x20, 0xdc, 0xba, 0x37, 0x5a, 0x19, 0x91, 0x6c, 0xd3, 0x3c, 0x84, 0x30, 0xe4,
0x15, 0xef, 0xc5, 0x8f, 0xe4, 0x82, 0xfe, 0x13, 0x89, 0xfe, 0xb6, 0xd5, 0xf9, 0x53, 0xaf, 0x47,
0x3f, 0x3e, 0xbf, 0x36, 0x8d, 0x7e, 0xef, 0x7c, 0xdb, 0xdd, 0x9b, 0x37, 0x7c, 0x6b, 0x0b, 0x78,
0x16, 0xa9, 0x2b, 0xd9, 0x60, 0xf0, 0x3e, 0x8e, 0x75, 0x8e, 0xd1, 0x60, 0xb2, 0xc2, 0x67, 0x29,
0xe4, 0x35, 0x4d, 0x7f, 0x33, 0x1e, 0x98, 0x1c, 0xd7, 0xfc, 0x26, 0xbe, 0xa9, 0x04, 0x3d, 0x5d,
0x47, 0x4c, 0x82, 0xe6, 0x46, 0x52, 0x28, 0x24, 0x93, 0xc2, 0x54, 0x3d, 0xb2, 0xb0, 0xe2, 0x56,
0x95, 0xb5, 0xe7, 0xbc, 0xc9, 0xf5, 0x7c, 0xb7, 0xfa, 0xeb, 0xea, 0x3b, 0x00, 0x00, 0xff, 0xff,
0x00, 0x26, 0x25, 0x67, 0xf3, 0x01, 0x00, 0x00,
}

178
vendor/google.golang.org/genproto/googleapis/cloud/ml/v1beta1/project_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,178 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/cloud/ml/v1beta1/project_service.proto
package ml
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// Requests service account information associated with a project.
type GetConfigRequest struct {
// Required. The project name.
//
// Authorization: requires `Viewer` role on the specified project.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetConfigRequest) Reset() { *m = GetConfigRequest{} }
func (m *GetConfigRequest) String() string { return proto.CompactTextString(m) }
func (*GetConfigRequest) ProtoMessage() {}
func (*GetConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
func (m *GetConfigRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
// Returns service account information associated with a project.
type GetConfigResponse struct {
// The service account Cloud ML uses to access resources in the project.
ServiceAccount string `protobuf:"bytes,1,opt,name=service_account,json=serviceAccount" json:"service_account,omitempty"`
// The project number for `service_account`.
ServiceAccountProject int64 `protobuf:"varint,2,opt,name=service_account_project,json=serviceAccountProject" json:"service_account_project,omitempty"`
}
func (m *GetConfigResponse) Reset() { *m = GetConfigResponse{} }
func (m *GetConfigResponse) String() string { return proto.CompactTextString(m) }
func (*GetConfigResponse) ProtoMessage() {}
func (*GetConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
func (m *GetConfigResponse) GetServiceAccount() string {
if m != nil {
return m.ServiceAccount
}
return ""
}
func (m *GetConfigResponse) GetServiceAccountProject() int64 {
if m != nil {
return m.ServiceAccountProject
}
return 0
}
func init() {
proto.RegisterType((*GetConfigRequest)(nil), "google.cloud.ml.v1beta1.GetConfigRequest")
proto.RegisterType((*GetConfigResponse)(nil), "google.cloud.ml.v1beta1.GetConfigResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// Client API for ProjectManagementService service
type ProjectManagementServiceClient interface {
// Get the service account information associated with your project. You need
// this information in order to grant the service account persmissions for
// the Google Cloud Storage location where you put your model training code
// for training the model with Google Cloud Machine Learning.
GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error)
}
type projectManagementServiceClient struct {
cc *grpc.ClientConn
}
func NewProjectManagementServiceClient(cc *grpc.ClientConn) ProjectManagementServiceClient {
return &projectManagementServiceClient{cc}
}
func (c *projectManagementServiceClient) GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error) {
out := new(GetConfigResponse)
err := grpc.Invoke(ctx, "/google.cloud.ml.v1beta1.ProjectManagementService/GetConfig", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for ProjectManagementService service
type ProjectManagementServiceServer interface {
// Get the service account information associated with your project. You need
// this information in order to grant the service account persmissions for
// the Google Cloud Storage location where you put your model training code
// for training the model with Google Cloud Machine Learning.
GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error)
}
func RegisterProjectManagementServiceServer(s *grpc.Server, srv ProjectManagementServiceServer) {
s.RegisterService(&_ProjectManagementService_serviceDesc, srv)
}
func _ProjectManagementService_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetConfigRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProjectManagementServiceServer).GetConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.cloud.ml.v1beta1.ProjectManagementService/GetConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProjectManagementServiceServer).GetConfig(ctx, req.(*GetConfigRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ProjectManagementService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.cloud.ml.v1beta1.ProjectManagementService",
HandlerType: (*ProjectManagementServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetConfig",
Handler: _ProjectManagementService_GetConfig_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/cloud/ml/v1beta1/project_service.proto",
}
func init() { proto.RegisterFile("google/cloud/ml/v1beta1/project_service.proto", fileDescriptor4) }
var fileDescriptor4 = []byte{
// 327 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x4a, 0x43, 0x31,
0x10, 0xc6, 0x79, 0x55, 0x84, 0x66, 0xe1, 0x9f, 0x88, 0xb4, 0x14, 0xc1, 0x52, 0xa4, 0xd6, 0xa2,
0x09, 0x55, 0x10, 0x54, 0x5c, 0x58, 0x17, 0xae, 0x84, 0x52, 0x77, 0x6e, 0x4a, 0xfa, 0x1c, 0xc3,
0x93, 0x24, 0x13, 0x5f, 0xd2, 0x6e, 0xc4, 0x8d, 0x27, 0x10, 0x3c, 0x87, 0xa7, 0xf1, 0x0a, 0x1e,
0x44, 0xfa, 0x92, 0x16, 0x6d, 0x11, 0xdc, 0x0d, 0x33, 0xbf, 0x6f, 0x32, 0xdf, 0x4c, 0xc8, 0xa1,
0x44, 0x94, 0x0a, 0x78, 0xaa, 0x70, 0x74, 0xcf, 0xb5, 0xe2, 0xe3, 0xce, 0x10, 0xbc, 0xe8, 0x70,
0x9b, 0xe3, 0x23, 0xa4, 0x7e, 0xe0, 0x20, 0x1f, 0x67, 0x29, 0x30, 0x9b, 0xa3, 0x47, 0x5a, 0x09,
0x38, 0x2b, 0x70, 0xa6, 0x15, 0x8b, 0x78, 0x6d, 0x3b, 0xf6, 0x11, 0x36, 0xe3, 0xc2, 0x18, 0xf4,
0xc2, 0x67, 0x68, 0x5c, 0x90, 0x35, 0x9a, 0x64, 0xfd, 0x1a, 0xfc, 0x15, 0x9a, 0x87, 0x4c, 0xf6,
0xe1, 0x69, 0x04, 0xce, 0x53, 0x4a, 0x96, 0x8d, 0xd0, 0x50, 0x4d, 0xea, 0x49, 0xab, 0xdc, 0x2f,
0xe2, 0x86, 0x27, 0x1b, 0x3f, 0x38, 0x67, 0xd1, 0x38, 0xa0, 0x7b, 0x64, 0x2d, 0x0e, 0x31, 0x10,
0x69, 0x8a, 0x23, 0xe3, 0xa3, 0x66, 0x35, 0xa6, 0x2f, 0x43, 0x96, 0x9e, 0x90, 0xca, 0x1c, 0x38,
0x88, 0x2e, 0xaa, 0xa5, 0x7a, 0xd2, 0x5a, 0xea, 0x6f, 0xfd, 0x16, 0xf4, 0x42, 0xf1, 0xe8, 0x23,
0x21, 0xd5, 0x18, 0xdf, 0x08, 0x23, 0x24, 0x68, 0x30, 0xfe, 0x36, 0xa0, 0xf4, 0x2d, 0x21, 0xe5,
0xd9, 0x4c, 0x74, 0x9f, 0xfd, 0xb1, 0x00, 0x36, 0xef, 0xaf, 0xd6, 0xfe, 0x0f, 0x1a, 0x2c, 0x36,
0x0e, 0x5e, 0x3f, 0xbf, 0xde, 0x4b, 0x4d, 0xba, 0x3b, 0x5b, 0xff, 0xf3, 0x64, 0x1f, 0x17, 0x71,
0x7c, 0xc7, 0xdb, 0x2f, 0x67, 0x72, 0xaa, 0xea, 0x3a, 0xb2, 0x93, 0xa2, 0x5e, 0x68, 0x2f, 0x6c,
0x36, 0x7d, 0xa2, 0xbb, 0x19, 0xfd, 0x44, 0x17, 0xbd, 0xc9, 0x15, 0x7a, 0xc9, 0xdd, 0x69, 0xd4,
0x48, 0x54, 0xc2, 0x48, 0x86, 0xb9, 0xe4, 0x12, 0x4c, 0x71, 0x23, 0x1e, 0x4a, 0xc2, 0x66, 0x6e,
0xe1, 0x33, 0x9c, 0x6b, 0x35, 0x5c, 0x29, 0xa8, 0xe3, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x76,
0x59, 0xc4, 0x91, 0x31, 0x02, 0x00, 0x00,
}

Some files were not shown because too many files have changed in this diff Show More