diff --git a/internal/gengapic/gengapic.go b/internal/gengapic/gengapic.go index d70d97f69b0..f0320bb8abd 100644 --- a/internal/gengapic/gengapic.go +++ b/internal/gengapic/gengapic.go @@ -263,7 +263,9 @@ func (g *generator) gen(serv *descriptor.ServiceDescriptorProto, pkgName string) return aux.lros[i].GetName() < aux.lros[j].GetName() }) for _, m := range aux.lros { - g.lroType(servName, m) + if err := g.lroType(servName, serv, m); err != nil { + return errors.E(err, "while generating LRO type for %q", m.GetName()) + } } var iters []iterType diff --git a/internal/gengapic/gengapic_test.go b/internal/gengapic/gengapic_test.go index 22bdad20730..2cba16e9068 100644 --- a/internal/gengapic/gengapic_test.go +++ b/internal/gengapic/gengapic_test.go @@ -21,6 +21,7 @@ import ( "github.com/golang/protobuf/proto" "github.com/golang/protobuf/protoc-gen-go/descriptor" "github.com/googleapis/gapic-generator-go/internal/pbinfo" + "google.golang.org/genproto/googleapis/api/annotations" ) func TestComment(t *testing.T) { @@ -162,6 +163,7 @@ func TestGenMethod(t *testing.T) { } file := &descriptor.FileDescriptorProto{ + Package: proto.String("my.pkg"), Options: &descriptor.FileOptions{ GoPackage: proto.String("mypackage"), }, @@ -195,6 +197,7 @@ func TestGenMethod(t *testing.T) { Name: proto.String("GetBigThing"), InputType: proto.String(".my.pkg.InputType"), OutputType: proto.String(".google.longrunning.Operation"), + Options: &descriptor.MethodOptions{}, }, { Name: proto.String("GetManyThings"), @@ -210,14 +213,37 @@ func TestGenMethod(t *testing.T) { }, } +methods: for _, m := range meths { + g.pt.Reset() + + // Just add this everywhere. Only LRO method will pick it up. + if m.Options != nil { + lroType := &annotations.LongrunningOperationTypes{ + Response: "OutputType", + } + proto.SetExtension(m.Options, annotations.E_LongrunningOperationTypes, lroType) + } + aux := auxTypes{ iters: map[string]iterType{}, } if err := g.genMethod("Foo", serv, m, &aux); err != nil { t.Error(err) - } else { - diff(t, m.GetName(), g.pt.String(), filepath.Join("testdata", "method_"+m.GetName()+".want")) + continue } + + for _, m := range aux.lros { + if err := g.lroType("MyService", serv, m); err != nil { + t.Error(err) + continue methods + } + } + + for _, iter := range aux.iters { + g.pagingIter(iter) + } + + diff(t, m.GetName(), g.pt.String(), filepath.Join("testdata", "method_"+m.GetName()+".want")) } } diff --git a/internal/gengapic/lro.go b/internal/gengapic/lro.go index 5e1769fdc5f..a1eca6d1615 100644 --- a/internal/gengapic/lro.go +++ b/internal/gengapic/lro.go @@ -15,8 +15,14 @@ package gengapic import ( + "fmt" + "strings" + + "github.com/golang/protobuf/proto" "github.com/golang/protobuf/protoc-gen-go/descriptor" + "github.com/googleapis/gapic-generator-go/internal/errors" "github.com/googleapis/gapic-generator-go/internal/pbinfo" + "google.golang.org/genproto/googleapis/api/annotations" ) func (g *generator) lroCall(servName string, m *descriptor.MethodDescriptorProto) error { @@ -63,14 +69,55 @@ func (g *generator) lroCall(servName string, m *descriptor.MethodDescriptorProto return nil } -func (g *generator) lroType(servName string, m *descriptor.MethodDescriptorProto) { +func (g *generator) lroType(servName string, serv *descriptor.ServiceDescriptorProto, m *descriptor.MethodDescriptorProto) error { lroType := lroTypeName(*m.Name) p := g.printf - // TODO(pongad): programmatically fill these. - respType := "Foo.Bar" - metaType := "Foo.MetaBar" - hasMeta := true + eLRO, err := proto.GetExtension(m.Options, annotations.E_LongrunningOperationTypes) + if err != nil { + return errors.E(err, "cannot read LRO types") + } + eLROType := eLRO.(*annotations.LongrunningOperationTypes) + + var respType string + { + fullName := eLROType.Response + + // eLRO.ResponseType is either fully-qualified or in the same package as the method. + if strings.IndexByte(fullName, '.') < 0 { + fullName = g.descInfo.ParentFile[serv].GetPackage() + "." + fullName + } + + // When we build a map[name]Type in pbinfo, we prefix names with '.' to signify that they are fully qualified. + // The string in ResponseType does not have the prefix, so we add it. + fullName = "." + fullName + + typ := g.descInfo.Type[fullName] + respSpec, err := g.descInfo.ImportSpec(typ) + if err != nil { + return errors.E(err, "cannot find LRO type %q; type not linked?", fullName) + } + g.imports[respSpec] = true + respType = fmt.Sprintf("%s.%s", respSpec.Name, typ.GetName()) + } + + hasMeta := eLROType.Metadata != "" + var metaType string + if hasMeta { + fullName := eLROType.Metadata + if strings.IndexByte(fullName, '.') < 0 { + fullName = g.descInfo.ParentFile[serv].GetPackage() + "." + fullName + } + fullName = "." + fullName + + typ := g.descInfo.Type[fullName] + meta, err := g.descInfo.ImportSpec(typ) + if err != nil { + return errors.E(err, "cannot find LRO metadata type %q; type not linked?", fullName) + } + g.imports[meta] = true + metaType = fmt.Sprintf("%s.%s", meta.Name, typ.GetName()) + } // Type definition { @@ -144,7 +191,7 @@ func (g *generator) lroType(servName string, m *descriptor.MethodDescriptorProto p("// Metadata itself does not contact the server, but Poll does.") p("// To get the latest metadata, call this method after a successful call to Poll.") p("// If the metadata is not available, the returned metadata and error are both nil.") - p("func (op *%s) Metadata() (*%s, error) {", lroType, respType) + p("func (op *%s) Metadata() (*%s, error) {", lroType, metaType) p(" var meta %s", metaType) p(" if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {") p(" return nil, nil") @@ -174,7 +221,7 @@ func (g *generator) lroType(servName string, m *descriptor.MethodDescriptorProto p("}") p("") } - + return nil } func lroTypeName(methodName string) string { diff --git a/internal/gengapic/testdata/method_BidiThings.want b/internal/gengapic/testdata/method_BidiThings.want index 89f48f06961..f9389a3b4ff 100644 --- a/internal/gengapic/testdata/method_BidiThings.want +++ b/internal/gengapic/testdata/method_BidiThings.want @@ -1,82 +1,3 @@ -func (c *FooClient) GetEmptyThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) error { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetEmptyThing[0:len(c.CallOptions.GetEmptyThing):len(c.CallOptions.GetEmptyThing)], opts...) - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - _, err = c.fooClient.GetEmptyThing(ctx, req, settings.GRPC...) - return err - }, opts...) - return err -} - -func (c *FooClient) GetOneThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) (*mypackagepb.OutputType, error) { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetOneThing[0:len(c.CallOptions.GetOneThing):len(c.CallOptions.GetOneThing)], opts...) - var resp *mypackagepb.OutputType - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - resp, err = c.fooClient.GetOneThing(ctx, req, settings.GRPC...) - return err - }, opts...) - if err != nil { - return nil, err - } - return resp, nil -} - -func (c *FooClient) GetBigThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) (*GetBigThingOperation, error) { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetBigThing[0:len(c.CallOptions.GetBigThing):len(c.CallOptions.GetBigThing)], opts...) - var resp *longrunningpb.Operation - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - resp, err = c.fooClient.GetBigThing(ctx, req, settings.GRPC...) - return err - }, opts...) - if err != nil { - return nil, err - } - return &GetBigThingOperation{ - lro: longrunning.InternalNewOperation(c.LROClient, resp), - }, nil -} - -func (c *FooClient) GetManyThings(ctx context.Context, req *mypackagepb.PageInputType, opts ...gax.CallOption) *StringIterator { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetManyThings[0:len(c.CallOptions.GetManyThings):len(c.CallOptions.GetManyThings)], opts...) - it := &StringIterator{} - req = proto.Clone(req).(*mypackagepb.PageInputType) - it.InternalFetch = func(pageSize int, pageToken string) ([]string, string, error) { - var resp *mypackagepb.PageOutputType - req.PageToken = pageToken - if pageSize > math.MaxInt32 { - req.PageSize = math.MaxInt32 - } else { - req.PageSize = int32(pageSize) - } - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - resp, err = c.fooClient.GetManyThings(ctx, req, settings.GRPC...) - return err - }, opts...) - if err != nil { - return nil, "", err - } - return resp.Items, resp.NextPageToken, nil - } - fetch := func(pageSize int, pageToken string) (string, error) { - items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) - if err != nil { - return "", err - } - it.items = append(it.items, items...) - return nextPageToken, nil - } - it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) - it.pageInfo.MaxSize = int(req.PageSize) - return it -} - func (c *FooClient) BidiThings(ctx context.Context, opts ...gax.CallOption) (mypackagepb._BidiThingsClient, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.BidiThings[0:len(c.CallOptions.BidiThings):len(c.CallOptions.BidiThings)], opts...) diff --git a/internal/gengapic/testdata/method_GetBigThing.want b/internal/gengapic/testdata/method_GetBigThing.want index 6be0d5fd747..5f8ce04c04c 100644 --- a/internal/gengapic/testdata/method_GetBigThing.want +++ b/internal/gengapic/testdata/method_GetBigThing.want @@ -1,29 +1,3 @@ -func (c *FooClient) GetEmptyThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) error { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetEmptyThing[0:len(c.CallOptions.GetEmptyThing):len(c.CallOptions.GetEmptyThing)], opts...) - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - _, err = c.fooClient.GetEmptyThing(ctx, req, settings.GRPC...) - return err - }, opts...) - return err -} - -func (c *FooClient) GetOneThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) (*mypackagepb.OutputType, error) { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetOneThing[0:len(c.CallOptions.GetOneThing):len(c.CallOptions.GetOneThing)], opts...) - var resp *mypackagepb.OutputType - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - resp, err = c.fooClient.GetOneThing(ctx, req, settings.GRPC...) - return err - }, opts...) - if err != nil { - return nil, err - } - return resp, nil -} - func (c *FooClient) GetBigThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) (*GetBigThingOperation, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.GetBigThing[0:len(c.CallOptions.GetBigThing):len(c.CallOptions.GetBigThing)], opts...) @@ -41,3 +15,56 @@ func (c *FooClient) GetBigThing(ctx context.Context, req *mypackagepb.InputType, }, nil } +// GetBigThingOperation manages a long-running operation from GetBigThing. +type GetBigThingOperation struct { + lro *longrunning.Operation +} + +// GetBigThingOperation returns a new GetBigThingOperation from a given name. +// The name must be that of a previously created GetBigThingOperation, possibly from a different process. +func (c *MyServiceClient) GetBigThingOperation(name string) *GetBigThingOperation { + return &GetBigThingOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *GetBigThingOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*mypackagepb.OutputType, error) { + var resp mypackagepb.OutputType + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// Poll fetches the latest state of the long-running operation. +// +// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and +// the operation has completed with failure, the error is returned and op.Done will return true. +// If Poll succeeds and the operation has completed successfully, +// op.Done will return true, and the response of the operation is returned. +// If Poll succeeds and the operation has not completed, the returned response and error are both nil. +func (op *GetBigThingOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*mypackagepb.OutputType, error) { + var resp mypackagepb.OutputType + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// Done reports whether the long-running operation has completed. +func (op *GetBigThingOperation) Done() bool { + return op.lro.Done() +} + +// Name returns the name of the long-running operation. +// The name is assigned by the server and is unique within the service from which the operation is created. +func (op *GetBigThingOperation) Name() string { + return op.lro.Name() +} + diff --git a/internal/gengapic/testdata/method_GetManyThings.want b/internal/gengapic/testdata/method_GetManyThings.want index 7e1794e9825..a0cc5944624 100644 --- a/internal/gengapic/testdata/method_GetManyThings.want +++ b/internal/gengapic/testdata/method_GetManyThings.want @@ -1,46 +1,3 @@ -func (c *FooClient) GetEmptyThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) error { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetEmptyThing[0:len(c.CallOptions.GetEmptyThing):len(c.CallOptions.GetEmptyThing)], opts...) - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - _, err = c.fooClient.GetEmptyThing(ctx, req, settings.GRPC...) - return err - }, opts...) - return err -} - -func (c *FooClient) GetOneThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) (*mypackagepb.OutputType, error) { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetOneThing[0:len(c.CallOptions.GetOneThing):len(c.CallOptions.GetOneThing)], opts...) - var resp *mypackagepb.OutputType - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - resp, err = c.fooClient.GetOneThing(ctx, req, settings.GRPC...) - return err - }, opts...) - if err != nil { - return nil, err - } - return resp, nil -} - -func (c *FooClient) GetBigThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) (*GetBigThingOperation, error) { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetBigThing[0:len(c.CallOptions.GetBigThing):len(c.CallOptions.GetBigThing)], opts...) - var resp *longrunningpb.Operation - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - resp, err = c.fooClient.GetBigThing(ctx, req, settings.GRPC...) - return err - }, opts...) - if err != nil { - return nil, err - } - return &GetBigThingOperation{ - lro: longrunning.InternalNewOperation(c.LROClient, resp), - }, nil -} - func (c *FooClient) GetManyThings(ctx context.Context, req *mypackagepb.PageInputType, opts ...gax.CallOption) *StringIterator { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.GetManyThings[0:len(c.CallOptions.GetManyThings):len(c.CallOptions.GetManyThings)], opts...) @@ -77,3 +34,45 @@ func (c *FooClient) GetManyThings(ctx context.Context, req *mypackagepb.PageInpu return it } +// StringIterator manages a stream of string. +type StringIterator struct { + items []string + pageInfo *iterator.PageInfo + nextFunc func() error + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []string, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *StringIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *StringIterator) Next() (string, error) { + var item string + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *StringIterator) bufLen() int { + return len(it.items) +} + +func (it *StringIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + diff --git a/internal/gengapic/testdata/method_GetOneThing.want b/internal/gengapic/testdata/method_GetOneThing.want index 2068e6eb948..e0e272acad9 100644 --- a/internal/gengapic/testdata/method_GetOneThing.want +++ b/internal/gengapic/testdata/method_GetOneThing.want @@ -1,14 +1,3 @@ -func (c *FooClient) GetEmptyThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) error { - ctx = insertMetadata(ctx, c.xGoogMetadata) - opts = append(c.CallOptions.GetEmptyThing[0:len(c.CallOptions.GetEmptyThing):len(c.CallOptions.GetEmptyThing)], opts...) - err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { - var err error - _, err = c.fooClient.GetEmptyThing(ctx, req, settings.GRPC...) - return err - }, opts...) - return err -} - func (c *FooClient) GetOneThing(ctx context.Context, req *mypackagepb.InputType, opts ...gax.CallOption) (*mypackagepb.OutputType, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.GetOneThing[0:len(c.CallOptions.GetOneThing):len(c.CallOptions.GetOneThing)], opts...) diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go index e7ec471a801..476b35f2003 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/annotations.pb.go @@ -1,12 +1,14 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // source: google/api/annotations.proto -package annotations // import "google.golang.org/genproto/googleapis/api/annotations" +package annotations -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" -import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -33,16 +35,17 @@ func (m *Project) Reset() { *m = Project{} } func (m *Project) String() string { return proto.CompactTextString(m) } func (*Project) ProtoMessage() {} func (*Project) Descriptor() ([]byte, []int) { - return fileDescriptor_annotations_35a2112b558ef844, []int{0} + return fileDescriptor_c591c5aa9fb79aab, []int{0} } + func (m *Project) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Project.Unmarshal(m, b) } func (m *Project) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Project.Marshal(b, m, deterministic) } -func (dst *Project) XXX_Merge(src proto.Message) { - xxx_messageInfo_Project.Merge(dst, src) +func (m *Project) XXX_Merge(src proto.Message) { + xxx_messageInfo_Project.Merge(m, src) } func (m *Project) XXX_Size() int { return xxx_messageInfo_Project.Size(m) @@ -75,16 +78,17 @@ func (m *Organization) Reset() { *m = Organization{} } func (m *Organization) String() string { return proto.CompactTextString(m) } func (*Organization) ProtoMessage() {} func (*Organization) Descriptor() ([]byte, []int) { - return fileDescriptor_annotations_35a2112b558ef844, []int{1} + return fileDescriptor_c591c5aa9fb79aab, []int{1} } + func (m *Organization) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Organization.Unmarshal(m, b) } func (m *Organization) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Organization.Marshal(b, m, deterministic) } -func (dst *Organization) XXX_Merge(src proto.Message) { - xxx_messageInfo_Organization.Merge(dst, src) +func (m *Organization) XXX_Merge(src proto.Message) { + xxx_messageInfo_Organization.Merge(m, src) } func (m *Organization) XXX_Size() int { return xxx_messageInfo_Organization.Size(m) @@ -116,7 +120,7 @@ var E_DefaultHost = &proto.ExtensionDesc{ ExtensionType: (*string)(nil), Field: 1049, Name: "google.api.default_host", - Tag: "bytes,1049,opt,name=default_host,json=defaultHost", + Tag: "bytes,1049,opt,name=default_host", Filename: "google/api/annotations.proto", } @@ -143,7 +147,7 @@ var E_ResourceSet = &proto.ExtensionDesc{ ExtensionType: (*ResourceSet)(nil), Field: 1054, Name: "google.api.resource_set", - Tag: "bytes,1054,opt,name=resource_set,json=resourceSet", + Tag: "bytes,1054,opt,name=resource_set", Filename: "google/api/annotations.proto", } @@ -152,7 +156,7 @@ var E_ResourceType = &proto.ExtensionDesc{ ExtensionType: (*string)(nil), Field: 1055, Name: "google.api.resource_type", - Tag: "bytes,1055,opt,name=resource_type,json=resourceType", + Tag: "bytes,1055,opt,name=resource_type", Filename: "google/api/annotations.proto", } @@ -179,7 +183,7 @@ var E_MethodSignature = &proto.ExtensionDesc{ ExtensionType: (*MethodSignature)(nil), Field: 1051, Name: "google.api.method_signature", - Tag: "bytes,1051,opt,name=method_signature,json=methodSignature", + Tag: "bytes,1051,opt,name=method_signature", Filename: "google/api/annotations.proto", } @@ -192,6 +196,15 @@ var E_Http = &proto.ExtensionDesc{ Filename: "google/api/annotations.proto", } +var E_LongrunningOperationTypes = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MethodOptions)(nil), + ExtensionType: (*LongrunningOperationTypes)(nil), + Field: 1049, + Name: "google.api.longrunning_operation_types", + Tag: "bytes,1049,opt,name=longrunning_operation_types", + Filename: "google/api/annotations.proto", +} + func init() { proto.RegisterType((*Project)(nil), "google.api.Project") proto.RegisterType((*Organization)(nil), "google.api.Organization") @@ -205,45 +218,47 @@ func init() { proto.RegisterExtension(E_Retry) proto.RegisterExtension(E_MethodSignature) proto.RegisterExtension(E_Http) + proto.RegisterExtension(E_LongrunningOperationTypes) } -func init() { - proto.RegisterFile("google/api/annotations.proto", fileDescriptor_annotations_35a2112b558ef844) -} - -var fileDescriptor_annotations_35a2112b558ef844 = []byte{ - // 526 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x94, 0x4f, 0x6e, 0xd3, 0x40, - 0x14, 0x87, 0x15, 0x94, 0x42, 0x3a, 0x09, 0xa4, 0xb5, 0x0a, 0x94, 0x50, 0x20, 0x0a, 0x9b, 0x88, - 0x85, 0x2d, 0xc1, 0x06, 0x0d, 0x2b, 0xa7, 0x12, 0xa4, 0x42, 0x55, 0xa2, 0x09, 0xab, 0x6e, 0xa2, - 0xa9, 0x3d, 0xb5, 0x07, 0xd9, 0x9e, 0x61, 0xfc, 0x8c, 0x14, 0x4e, 0xc2, 0x7f, 0x10, 0x27, 0xe0, - 0x00, 0x9c, 0x80, 0xa3, 0xf4, 0x14, 0x95, 0x3d, 0xb6, 0xe3, 0x34, 0x96, 0xbc, 0xb3, 0xfd, 0x7b, - 0xdf, 0x97, 0xf7, 0x9e, 0x27, 0x46, 0x47, 0x9e, 0x10, 0x5e, 0xc0, 0x2c, 0x2a, 0xb9, 0x45, 0xa3, - 0x48, 0x00, 0x05, 0x2e, 0xa2, 0xd8, 0x94, 0x4a, 0x80, 0x30, 0x90, 0x4e, 0x4d, 0x2a, 0xf9, 0xe0, - 0x6e, 0xa5, 0xd2, 0x07, 0x90, 0xba, 0x64, 0xf0, 0xa0, 0xf2, 0x38, 0x64, 0x40, 0x5d, 0x0a, 0x34, - 0x8f, 0x06, 0x95, 0x48, 0xb1, 0x58, 0x24, 0xca, 0x61, 0xb9, 0x79, 0x70, 0x6f, 0x23, 0x03, 0xb5, - 0xaa, 0x61, 0x62, 0xee, 0x45, 0x14, 0x12, 0xc5, 0xf2, 0x6c, 0x98, 0x67, 0xd9, 0xdd, 0x79, 0x72, - 0x61, 0xb9, 0x2c, 0x76, 0x14, 0x97, 0x20, 0x94, 0xae, 0x18, 0x99, 0xe8, 0xd6, 0x5c, 0x89, 0xf7, - 0xcc, 0x01, 0xe3, 0x29, 0x6a, 0x47, 0x34, 0x64, 0x87, 0xad, 0x61, 0x6b, 0xbc, 0x3b, 0xe9, 0x5f, - 0xda, 0x3d, 0x84, 0xa4, 0xce, 0x62, 0xeb, 0x19, 0xc9, 0xc2, 0xd1, 0x4b, 0xd4, 0x9b, 0x29, 0x8f, - 0x46, 0xfc, 0x53, 0x36, 0xb6, 0x31, 0xde, 0x80, 0x0e, 0x2e, 0xed, 0x7d, 0xd4, 0x17, 0x95, 0x82, - 0x92, 0xc4, 0x33, 0xd4, 0x29, 0xa6, 0x35, 0x8e, 0xcc, 0x7c, 0x4d, 0x45, 0x63, 0xe6, 0x6b, 0x1e, - 0xb0, 0x99, 0xcc, 0x88, 0xc3, 0xcf, 0x9d, 0x61, 0x6b, 0xdc, 0x7d, 0x7e, 0x60, 0xae, 0x77, 0x69, - 0x9e, 0xe6, 0x28, 0x29, 0x25, 0xf8, 0x18, 0xf5, 0x5c, 0x76, 0x41, 0x93, 0x00, 0x96, 0xbe, 0x88, - 0xc1, 0x78, 0xb2, 0x25, 0x5d, 0x30, 0xf5, 0x91, 0x3b, 0xa5, 0xf7, 0x4b, 0xea, 0xdd, 0x25, 0xdd, - 0x9c, 0x9a, 0x8a, 0x18, 0xf0, 0x09, 0xda, 0x11, 0x34, 0x01, 0xbf, 0x99, 0xfe, 0xaa, 0xbb, 0xda, - 0xaf, 0x76, 0x35, 0xb3, 0x13, 0xf0, 0x89, 0x36, 0xe0, 0x39, 0xea, 0x14, 0xef, 0xcc, 0x78, 0x54, - 0x33, 0x20, 0x0b, 0xdc, 0xc2, 0xf5, 0xa3, 0x66, 0x42, 0x92, 0xb3, 0xa4, 0xb4, 0xe0, 0x33, 0xd4, - 0x2b, 0xae, 0x97, 0x31, 0x83, 0x26, 0xeb, 0x4f, 0x6d, 0xbd, 0x5f, 0x67, 0x5d, 0x30, 0x20, 0x5d, - 0xb5, 0xbe, 0xc1, 0xc7, 0xe8, 0x76, 0xe9, 0x86, 0x95, 0x6c, 0x6c, 0xf9, 0x97, 0x5e, 0x5e, 0xd9, - 0xd0, 0xbb, 0x95, 0x64, 0x18, 0xa7, 0x23, 0x7f, 0x48, 0xb8, 0x62, 0x6e, 0x13, 0xff, 0x3d, 0xe5, - 0x3b, 0xa4, 0xac, 0xc7, 0x53, 0xb4, 0x93, 0x1d, 0x63, 0xe3, 0xf1, 0x16, 0x78, 0xca, 0xc0, 0x17, - 0x25, 0xf9, 0xbb, 0x66, 0xf1, 0x24, 0x25, 0x89, 0x16, 0x60, 0x0f, 0xed, 0x85, 0x19, 0xb1, 0x2c, - 0xcf, 0x7f, 0xa3, 0xf4, 0x9b, 0x96, 0x3e, 0xbc, 0x76, 0xc6, 0x7c, 0xe1, 0x2e, 0x0a, 0x07, 0xe9, - 0x87, 0x9b, 0x0f, 0xf0, 0x5b, 0xd4, 0x4e, 0xff, 0xc7, 0x8d, 0xf2, 0xbf, 0xff, 0xff, 0x8d, 0xb6, - 0x5f, 0xf0, 0x14, 0x40, 0x92, 0x24, 0x60, 0x24, 0x93, 0x4c, 0x22, 0x74, 0xc7, 0x11, 0x61, 0xa5, - 0x60, 0xb2, 0x67, 0xaf, 0x3f, 0x27, 0xf3, 0xd4, 0x3c, 0x6f, 0x9d, 0xd9, 0x79, 0xee, 0x89, 0x80, - 0x46, 0x9e, 0x29, 0x94, 0x67, 0x79, 0x2c, 0xca, 0x7e, 0xd7, 0xd2, 0x11, 0x95, 0x3c, 0xbe, 0xfe, - 0x31, 0x7a, 0x55, 0xb9, 0xfe, 0x73, 0xa3, 0xfd, 0xc6, 0x9e, 0x9f, 0x9c, 0xdf, 0xcc, 0xa0, 0x17, - 0x57, 0x01, 0x00, 0x00, 0xff, 0xff, 0x16, 0x8e, 0x5d, 0x33, 0xc0, 0x04, 0x00, 0x00, +func init() { proto.RegisterFile("google/api/annotations.proto", fileDescriptor_c591c5aa9fb79aab) } + +var fileDescriptor_c591c5aa9fb79aab = []byte{ + // 576 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x94, 0xdd, 0x6e, 0xd3, 0x30, + 0x14, 0xc7, 0x55, 0xb4, 0x41, 0xe7, 0x16, 0xba, 0x45, 0x03, 0xb6, 0x6e, 0x40, 0x55, 0x84, 0x54, + 0x71, 0x91, 0x48, 0x70, 0x83, 0xcc, 0x55, 0x3a, 0x09, 0x3a, 0xc1, 0xd4, 0xca, 0xe5, 0x6a, 0x37, + 0x95, 0xd7, 0x78, 0x49, 0x50, 0x6a, 0x1b, 0xe7, 0x04, 0xa9, 0x3c, 0x00, 0xcf, 0xc0, 0xf8, 0x16, + 0x4f, 0xc0, 0x03, 0xf0, 0x04, 0x3c, 0xca, 0x9e, 0x02, 0xc5, 0x4e, 0xd2, 0x74, 0x2d, 0xca, 0x5d, + 0x92, 0xff, 0xf9, 0xff, 0xce, 0x97, 0x63, 0x74, 0xe8, 0x0b, 0xe1, 0x47, 0xcc, 0xa1, 0x32, 0x74, + 0x28, 0xe7, 0x02, 0x28, 0x84, 0x82, 0xc7, 0xb6, 0x54, 0x02, 0x84, 0x85, 0x8c, 0x6a, 0x53, 0x19, + 0xb6, 0x6f, 0x97, 0x22, 0x03, 0x00, 0x69, 0x42, 0xda, 0x65, 0x40, 0x24, 0xb8, 0xaf, 0x12, 0xce, + 0x43, 0xee, 0x67, 0xea, 0x7e, 0x49, 0x9d, 0x31, 0xa0, 0x1e, 0x05, 0x9a, 0x49, 0xed, 0x92, 0xa4, + 0x58, 0x2c, 0x12, 0x35, 0x65, 0x59, 0xde, 0xf6, 0x9d, 0x25, 0x0d, 0xd4, 0x7c, 0x8d, 0x27, 0x0e, + 0x7d, 0x4e, 0x21, 0x51, 0x2c, 0xd3, 0x3a, 0x99, 0xa6, 0xdf, 0xce, 0x92, 0x73, 0xc7, 0x63, 0xf1, + 0x54, 0x85, 0x12, 0x84, 0x32, 0x11, 0x5d, 0x1b, 0xdd, 0x18, 0x29, 0xf1, 0x96, 0x4d, 0xc1, 0x7a, + 0x88, 0x36, 0x38, 0x9d, 0xb1, 0xbd, 0x5a, 0xa7, 0xd6, 0xdb, 0xea, 0xb7, 0x2e, 0xdd, 0x26, 0x42, + 0xd2, 0x68, 0xb1, 0xf3, 0x98, 0x68, 0xb1, 0xfb, 0x0c, 0x35, 0x87, 0xca, 0xa7, 0x3c, 0xfc, 0xa0, + 0x87, 0x62, 0xf5, 0x96, 0x4c, 0xbb, 0x97, 0xee, 0x0e, 0x6a, 0x89, 0x52, 0x40, 0xe1, 0xc4, 0x43, + 0x54, 0xcf, 0xbb, 0xb5, 0x0e, 0xed, 0x6c, 0x88, 0x79, 0x61, 0xf6, 0x8b, 0x30, 0x62, 0x43, 0xa9, + 0x1d, 0x7b, 0x9f, 0xea, 0x9d, 0x5a, 0xaf, 0xf1, 0x64, 0xd7, 0x5e, 0x4c, 0xda, 0x3e, 0xc9, 0xac, + 0xa4, 0x80, 0xe0, 0x23, 0xd4, 0xf4, 0xd8, 0x39, 0x4d, 0x22, 0x98, 0x04, 0x22, 0x06, 0xeb, 0xc1, + 0x0a, 0x74, 0xcc, 0xd4, 0xfb, 0x70, 0x5a, 0x70, 0x2f, 0x52, 0xee, 0x16, 0x69, 0x64, 0xae, 0x81, + 0x88, 0x01, 0x1f, 0xa3, 0x4d, 0x41, 0x13, 0x08, 0xaa, 0xdd, 0x9f, 0x4d, 0x55, 0x3b, 0xe5, 0xaa, + 0x86, 0x6e, 0x02, 0x01, 0x31, 0x04, 0x3c, 0x42, 0xf5, 0x7c, 0x67, 0xd6, 0xbd, 0x35, 0x0d, 0xb2, + 0xc8, 0xcb, 0x59, 0xdf, 0xd6, 0x74, 0x48, 0x32, 0x2f, 0x29, 0x28, 0xf8, 0x14, 0x35, 0xf3, 0xe7, + 0x49, 0xcc, 0xa0, 0x8a, 0xfa, 0xdd, 0x50, 0xef, 0xae, 0xa3, 0x8e, 0x19, 0x90, 0x86, 0x5a, 0xbc, + 0xe0, 0x23, 0x74, 0xb3, 0x60, 0xc3, 0x5c, 0x56, 0x96, 0xfc, 0xc3, 0x0c, 0xaf, 0x28, 0xe8, 0xcd, + 0x5c, 0x32, 0x8c, 0xd3, 0x96, 0xdf, 0x25, 0xa1, 0x62, 0x5e, 0x95, 0xff, 0x6b, 0xea, 0xaf, 0x93, + 0x22, 0x1e, 0x0f, 0xd0, 0xa6, 0x3e, 0xc6, 0xd6, 0xfd, 0x15, 0xe3, 0x09, 0x83, 0x40, 0x14, 0xce, + 0x9f, 0x6b, 0x06, 0x4f, 0x52, 0x27, 0x31, 0x00, 0xec, 0xa3, 0xed, 0x99, 0x76, 0x4c, 0x8a, 0xf3, + 0x5f, 0x09, 0xfd, 0x62, 0xa0, 0x07, 0x57, 0xce, 0x58, 0x20, 0xbc, 0x71, 0xce, 0x20, 0xad, 0xd9, + 0xf2, 0x07, 0xfc, 0x0a, 0x6d, 0xa4, 0x7f, 0x79, 0x25, 0xfc, 0xf7, 0xdf, 0x3f, 0xdd, 0xd5, 0x05, + 0x0f, 0x00, 0x24, 0x49, 0x22, 0x46, 0x34, 0x04, 0x7f, 0xac, 0xa1, 0x83, 0xd2, 0xe5, 0x30, 0x11, + 0x92, 0x29, 0xfd, 0xcb, 0xe8, 0x75, 0xc4, 0x95, 0x49, 0x2e, 0x4c, 0x07, 0x8f, 0xca, 0x29, 0x5e, + 0x2f, 0x78, 0xc3, 0x1c, 0x97, 0x2e, 0x2a, 0x26, 0xfb, 0xd1, 0xff, 0xa4, 0x3e, 0x47, 0xb7, 0xa6, + 0x62, 0x56, 0xc2, 0xf4, 0xb7, 0xdd, 0xc5, 0xad, 0x37, 0x4a, 0xb3, 0x8f, 0x6a, 0xa7, 0x6e, 0xa6, + 0xfb, 0x22, 0xa2, 0xdc, 0xb7, 0x85, 0xf2, 0x1d, 0x9f, 0x71, 0x5d, 0x9b, 0x63, 0x24, 0x2a, 0xc3, + 0xf8, 0xea, 0x9d, 0xf9, 0xbc, 0xf4, 0xfc, 0xeb, 0xda, 0xc6, 0x4b, 0x77, 0x74, 0x7c, 0x76, 0x5d, + 0x9b, 0x9e, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xde, 0x2d, 0x79, 0xe0, 0x67, 0x05, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go index b06f42fe65d..af3a73f9210 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/http.pb.go @@ -1,11 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // source: google/api/http.proto -package annotations // import "google.golang.org/genproto/googleapis/api/annotations" +package annotations -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -42,16 +44,17 @@ func (m *Http) Reset() { *m = Http{} } func (m *Http) String() string { return proto.CompactTextString(m) } func (*Http) ProtoMessage() {} func (*Http) Descriptor() ([]byte, []int) { - return fileDescriptor_http_98c2ff955ca74b42, []int{0} + return fileDescriptor_ff9994be407cdcc9, []int{0} } + func (m *Http) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Http.Unmarshal(m, b) } func (m *Http) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Http.Marshal(b, m, deterministic) } -func (dst *Http) XXX_Merge(src proto.Message) { - xxx_messageInfo_Http.Merge(dst, src) +func (m *Http) XXX_Merge(src proto.Message) { + xxx_messageInfo_Http.Merge(m, src) } func (m *Http) XXX_Size() int { return xxx_messageInfo_Http.Size(m) @@ -328,16 +331,17 @@ func (m *HttpRule) Reset() { *m = HttpRule{} } func (m *HttpRule) String() string { return proto.CompactTextString(m) } func (*HttpRule) ProtoMessage() {} func (*HttpRule) Descriptor() ([]byte, []int) { - return fileDescriptor_http_98c2ff955ca74b42, []int{1} + return fileDescriptor_ff9994be407cdcc9, []int{1} } + func (m *HttpRule) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_HttpRule.Unmarshal(m, b) } func (m *HttpRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_HttpRule.Marshal(b, m, deterministic) } -func (dst *HttpRule) XXX_Merge(src proto.Message) { - xxx_messageInfo_HttpRule.Merge(dst, src) +func (m *HttpRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_HttpRule.Merge(m, src) } func (m *HttpRule) XXX_Size() int { return xxx_messageInfo_HttpRule.Size(m) @@ -603,16 +607,17 @@ func (m *CustomHttpPattern) Reset() { *m = CustomHttpPattern{} } func (m *CustomHttpPattern) String() string { return proto.CompactTextString(m) } func (*CustomHttpPattern) ProtoMessage() {} func (*CustomHttpPattern) Descriptor() ([]byte, []int) { - return fileDescriptor_http_98c2ff955ca74b42, []int{2} + return fileDescriptor_ff9994be407cdcc9, []int{2} } + func (m *CustomHttpPattern) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CustomHttpPattern.Unmarshal(m, b) } func (m *CustomHttpPattern) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_CustomHttpPattern.Marshal(b, m, deterministic) } -func (dst *CustomHttpPattern) XXX_Merge(src proto.Message) { - xxx_messageInfo_CustomHttpPattern.Merge(dst, src) +func (m *CustomHttpPattern) XXX_Merge(src proto.Message) { + xxx_messageInfo_CustomHttpPattern.Merge(m, src) } func (m *CustomHttpPattern) XXX_Size() int { return xxx_messageInfo_CustomHttpPattern.Size(m) @@ -643,9 +648,9 @@ func init() { proto.RegisterType((*CustomHttpPattern)(nil), "google.api.CustomHttpPattern") } -func init() { proto.RegisterFile("google/api/http.proto", fileDescriptor_http_98c2ff955ca74b42) } +func init() { proto.RegisterFile("google/api/http.proto", fileDescriptor_ff9994be407cdcc9) } -var fileDescriptor_http_98c2ff955ca74b42 = []byte{ +var fileDescriptor_ff9994be407cdcc9 = []byte{ // 401 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0x41, 0xab, 0x13, 0x31, 0x10, 0xc7, 0xdd, 0x76, 0xdb, 0xd7, 0x4e, 0x41, 0x30, 0x3e, 0x25, 0x88, 0x62, 0xe9, 0xa9, 0x78, diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/longrunning.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/longrunning.pb.go new file mode 100644 index 00000000000..97563b842db --- /dev/null +++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/longrunning.pb.go @@ -0,0 +1,98 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/api/longrunning.proto + +package annotations + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + 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 + +// A message representing types returned by a longrunning operation. +type LongrunningOperationTypes struct { + // Required. The message name of the primary return type for this + // long-running operation. + // This type will be used to deserialize the LRO's response. + // + // If the response is in a different package from the rpc, a fully-qualified + // message name must be used (e.g. "google.protobuf.Empty"). + Response string `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"` + // The metadata message name for this long-running operation. + Metadata string `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LongrunningOperationTypes) Reset() { *m = LongrunningOperationTypes{} } +func (m *LongrunningOperationTypes) String() string { return proto.CompactTextString(m) } +func (*LongrunningOperationTypes) ProtoMessage() {} +func (*LongrunningOperationTypes) Descriptor() ([]byte, []int) { + return fileDescriptor_061c64bc8e148e7d, []int{0} +} + +func (m *LongrunningOperationTypes) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LongrunningOperationTypes.Unmarshal(m, b) +} +func (m *LongrunningOperationTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LongrunningOperationTypes.Marshal(b, m, deterministic) +} +func (m *LongrunningOperationTypes) XXX_Merge(src proto.Message) { + xxx_messageInfo_LongrunningOperationTypes.Merge(m, src) +} +func (m *LongrunningOperationTypes) XXX_Size() int { + return xxx_messageInfo_LongrunningOperationTypes.Size(m) +} +func (m *LongrunningOperationTypes) XXX_DiscardUnknown() { + xxx_messageInfo_LongrunningOperationTypes.DiscardUnknown(m) +} + +var xxx_messageInfo_LongrunningOperationTypes proto.InternalMessageInfo + +func (m *LongrunningOperationTypes) GetResponse() string { + if m != nil { + return m.Response + } + return "" +} + +func (m *LongrunningOperationTypes) GetMetadata() string { + if m != nil { + return m.Metadata + } + return "" +} + +func init() { + proto.RegisterType((*LongrunningOperationTypes)(nil), "google.api.LongrunningOperationTypes") +} + +func init() { proto.RegisterFile("google/api/longrunning.proto", fileDescriptor_061c64bc8e148e7d) } + +var fileDescriptor_061c64bc8e148e7d = []byte{ + // 191 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x8f, 0x31, 0xab, 0xc2, 0x30, + 0x10, 0xc7, 0x69, 0x79, 0x3c, 0xde, 0xcb, 0x20, 0xd2, 0xa9, 0x8a, 0x83, 0x38, 0x39, 0x25, 0x83, + 0xa3, 0x53, 0xbb, 0x88, 0x20, 0x58, 0xd4, 0xc9, 0xed, 0xd4, 0x70, 0x04, 0xda, 0xbb, 0x90, 0xc4, + 0xc1, 0xaf, 0xe3, 0x27, 0x95, 0xa6, 0x6a, 0xbb, 0xdd, 0x9f, 0xdf, 0x1d, 0xff, 0xdf, 0x89, 0x19, + 0x32, 0x63, 0xad, 0x15, 0x58, 0xa3, 0x6a, 0x26, 0x74, 0x77, 0x22, 0x43, 0x28, 0xad, 0xe3, 0xc0, + 0x99, 0xe8, 0xa8, 0x04, 0x6b, 0x16, 0x47, 0x31, 0xd9, 0xf5, 0x0b, 0x7b, 0xab, 0x1d, 0x04, 0xc3, + 0x74, 0x7a, 0x58, 0xed, 0xb3, 0xa9, 0xf8, 0x73, 0xda, 0x5b, 0x26, 0xaf, 0xf3, 0x64, 0x9e, 0x2c, + 0xff, 0x0f, 0xdf, 0xdc, 0xb2, 0x46, 0x07, 0xb8, 0x41, 0x80, 0x3c, 0xed, 0xd8, 0x27, 0x97, 0x24, + 0x46, 0x57, 0x6e, 0x64, 0x5f, 0x53, 0x8e, 0x07, 0x25, 0x55, 0x2b, 0x51, 0x25, 0xe7, 0xe2, 0xcd, + 0x91, 0x6b, 0x20, 0x94, 0xec, 0x50, 0xa1, 0xa6, 0xa8, 0xa8, 0x3a, 0x04, 0xd6, 0xf8, 0xf8, 0x03, + 0x10, 0x71, 0x88, 0x62, 0x7e, 0x3d, 0x98, 0x9f, 0xe9, 0xcf, 0xa6, 0xa8, 0xb6, 0x97, 0xdf, 0x78, + 0xb4, 0x7a, 0x05, 0x00, 0x00, 0xff, 0xff, 0x08, 0x11, 0xa9, 0x60, 0xf7, 0x00, 0x00, 0x00, +} diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/metadata.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/metadata.pb.go index 03fc2e8ee23..88cd16decd6 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/annotations/metadata.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/metadata.pb.go @@ -1,12 +1,14 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // source: google/api/metadata.proto -package annotations // import "google.golang.org/genproto/googleapis/api/annotations" +package annotations -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" -import _ "github.com/golang/protobuf/protoc-gen-go/descriptor" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + _ "github.com/golang/protobuf/protoc-gen-go/descriptor" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -60,16 +62,17 @@ func (m *Metadata) Reset() { *m = Metadata{} } func (m *Metadata) String() string { return proto.CompactTextString(m) } func (*Metadata) ProtoMessage() {} func (*Metadata) Descriptor() ([]byte, []int) { - return fileDescriptor_metadata_966056deeb158427, []int{0} + return fileDescriptor_05bd2c5f08e0074c, []int{0} } + func (m *Metadata) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Metadata.Unmarshal(m, b) } func (m *Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Metadata.Marshal(b, m, deterministic) } -func (dst *Metadata) XXX_Merge(src proto.Message) { - xxx_messageInfo_Metadata.Merge(dst, src) +func (m *Metadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_Metadata.Merge(m, src) } func (m *Metadata) XXX_Size() int { return xxx_messageInfo_Metadata.Size(m) @@ -123,16 +126,17 @@ func (m *OAuth) Reset() { *m = OAuth{} } func (m *OAuth) String() string { return proto.CompactTextString(m) } func (*OAuth) ProtoMessage() {} func (*OAuth) Descriptor() ([]byte, []int) { - return fileDescriptor_metadata_966056deeb158427, []int{1} + return fileDescriptor_05bd2c5f08e0074c, []int{1} } + func (m *OAuth) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_OAuth.Unmarshal(m, b) } func (m *OAuth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_OAuth.Marshal(b, m, deterministic) } -func (dst *OAuth) XXX_Merge(src proto.Message) { - xxx_messageInfo_OAuth.Merge(dst, src) +func (m *OAuth) XXX_Merge(src proto.Message) { + xxx_messageInfo_OAuth.Merge(m, src) } func (m *OAuth) XXX_Size() int { return xxx_messageInfo_OAuth.Size(m) @@ -155,9 +159,9 @@ func init() { proto.RegisterType((*OAuth)(nil), "google.api.OAuth") } -func init() { proto.RegisterFile("google/api/metadata.proto", fileDescriptor_metadata_966056deeb158427) } +func init() { proto.RegisterFile("google/api/metadata.proto", fileDescriptor_05bd2c5f08e0074c) } -var fileDescriptor_metadata_966056deeb158427 = []byte{ +var fileDescriptor_05bd2c5f08e0074c = []byte{ // 255 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x90, 0x4d, 0x4b, 0x33, 0x31, 0x14, 0x85, 0xc9, 0xdb, 0xd7, 0x62, 0xaf, 0x1f, 0xe8, 0x2c, 0x64, 0x74, 0xd3, 0xb1, 0xab, 0x82, diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/resources.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/resources.pb.go index 636740355cd..3ad78d03a5f 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/annotations/resources.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/resources.pb.go @@ -1,12 +1,14 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // source: google/api/resources.proto -package annotations // import "google.golang.org/genproto/googleapis/api/annotations" +package annotations -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" -import _ "github.com/golang/protobuf/protoc-gen-go/descriptor" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + _ "github.com/golang/protobuf/protoc-gen-go/descriptor" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -38,16 +40,17 @@ func (m *Resource) Reset() { *m = Resource{} } func (m *Resource) String() string { return proto.CompactTextString(m) } func (*Resource) ProtoMessage() {} func (*Resource) Descriptor() ([]byte, []int) { - return fileDescriptor_resources_145c60b7009c27cc, []int{0} + return fileDescriptor_04331d0dfede1972, []int{0} } + func (m *Resource) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Resource.Unmarshal(m, b) } func (m *Resource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Resource.Marshal(b, m, deterministic) } -func (dst *Resource) XXX_Merge(src proto.Message) { - xxx_messageInfo_Resource.Merge(dst, src) +func (m *Resource) XXX_Merge(src proto.Message) { + xxx_messageInfo_Resource.Merge(m, src) } func (m *Resource) XXX_Size() int { return xxx_messageInfo_Resource.Size(m) @@ -89,16 +92,17 @@ func (m *ResourceSet) Reset() { *m = ResourceSet{} } func (m *ResourceSet) String() string { return proto.CompactTextString(m) } func (*ResourceSet) ProtoMessage() {} func (*ResourceSet) Descriptor() ([]byte, []int) { - return fileDescriptor_resources_145c60b7009c27cc, []int{1} + return fileDescriptor_04331d0dfede1972, []int{1} } + func (m *ResourceSet) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ResourceSet.Unmarshal(m, b) } func (m *ResourceSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ResourceSet.Marshal(b, m, deterministic) } -func (dst *ResourceSet) XXX_Merge(src proto.Message) { - xxx_messageInfo_ResourceSet.Merge(dst, src) +func (m *ResourceSet) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResourceSet.Merge(m, src) } func (m *ResourceSet) XXX_Size() int { return xxx_messageInfo_ResourceSet.Size(m) @@ -128,11 +132,9 @@ func init() { proto.RegisterType((*ResourceSet)(nil), "google.api.ResourceSet") } -func init() { - proto.RegisterFile("google/api/resources.proto", fileDescriptor_resources_145c60b7009c27cc) -} +func init() { proto.RegisterFile("google/api/resources.proto", fileDescriptor_04331d0dfede1972) } -var fileDescriptor_resources_145c60b7009c27cc = []byte{ +var fileDescriptor_04331d0dfede1972 = []byte{ // 226 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0x31, 0x6b, 0xc3, 0x30, 0x10, 0x85, 0x51, 0x5a, 0x4a, 0x7c, 0x81, 0x0c, 0xa2, 0x83, 0x49, 0x17, 0x93, 0x29, 0x93, 0x04, diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/retry.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/retry.pb.go index 9fc73805a75..c7aa1f4916c 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/annotations/retry.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/retry.pb.go @@ -1,13 +1,15 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // source: google/api/retry.proto -package annotations // import "google.golang.org/genproto/googleapis/api/annotations" +package annotations -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" -import _ "github.com/golang/protobuf/protoc-gen-go/descriptor" -import code "google.golang.org/genproto/googleapis/rpc/code" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + _ "github.com/golang/protobuf/protoc-gen-go/descriptor" + code "google.golang.org/genproto/googleapis/rpc/code" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -38,16 +40,17 @@ func (m *Retry) Reset() { *m = Retry{} } func (m *Retry) String() string { return proto.CompactTextString(m) } func (*Retry) ProtoMessage() {} func (*Retry) Descriptor() ([]byte, []int) { - return fileDescriptor_retry_8a8cb4f6022190fb, []int{0} + return fileDescriptor_05f90a07fa47e5e4, []int{0} } + func (m *Retry) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Retry.Unmarshal(m, b) } func (m *Retry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Retry.Marshal(b, m, deterministic) } -func (dst *Retry) XXX_Merge(src proto.Message) { - xxx_messageInfo_Retry.Merge(dst, src) +func (m *Retry) XXX_Merge(src proto.Message) { + xxx_messageInfo_Retry.Merge(m, src) } func (m *Retry) XXX_Size() int { return xxx_messageInfo_Retry.Size(m) @@ -69,9 +72,9 @@ func init() { proto.RegisterType((*Retry)(nil), "google.api.Retry") } -func init() { proto.RegisterFile("google/api/retry.proto", fileDescriptor_retry_8a8cb4f6022190fb) } +func init() { proto.RegisterFile("google/api/retry.proto", fileDescriptor_05f90a07fa47e5e4) } -var fileDescriptor_retry_8a8cb4f6022190fb = []byte{ +var fileDescriptor_05f90a07fa47e5e4 = []byte{ // 187 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x8f, 0x31, 0x0b, 0xc2, 0x30, 0x10, 0x46, 0x29, 0x52, 0x87, 0x0c, 0x45, 0x0a, 0x8a, 0x74, 0x2a, 0x0e, 0xe2, 0x94, 0x80, 0x8e, diff --git a/vendor/google.golang.org/genproto/googleapis/api/annotations/signature.pb.go b/vendor/google.golang.org/genproto/googleapis/api/annotations/signature.pb.go index 02e306e93b5..0d602591bf8 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/annotations/signature.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/annotations/signature.pb.go @@ -1,12 +1,14 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // source: google/api/signature.proto -package annotations // import "google.golang.org/genproto/googleapis/api/annotations" +package annotations -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" -import _ "github.com/golang/protobuf/protoc-gen-go/descriptor" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + _ "github.com/golang/protobuf/protoc-gen-go/descriptor" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -38,16 +40,17 @@ func (m *MethodSignature) Reset() { *m = MethodSignature{} } func (m *MethodSignature) String() string { return proto.CompactTextString(m) } func (*MethodSignature) ProtoMessage() {} func (*MethodSignature) Descriptor() ([]byte, []int) { - return fileDescriptor_signature_bf68c379d9adbcc8, []int{0} + return fileDescriptor_9f931f636a360bde, []int{0} } + func (m *MethodSignature) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_MethodSignature.Unmarshal(m, b) } func (m *MethodSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_MethodSignature.Marshal(b, m, deterministic) } -func (dst *MethodSignature) XXX_Merge(src proto.Message) { - xxx_messageInfo_MethodSignature.Merge(dst, src) +func (m *MethodSignature) XXX_Merge(src proto.Message) { + xxx_messageInfo_MethodSignature.Merge(m, src) } func (m *MethodSignature) XXX_Size() int { return xxx_messageInfo_MethodSignature.Size(m) @@ -83,11 +86,9 @@ func init() { proto.RegisterType((*MethodSignature)(nil), "google.api.MethodSignature") } -func init() { - proto.RegisterFile("google/api/signature.proto", fileDescriptor_signature_bf68c379d9adbcc8) -} +func init() { proto.RegisterFile("google/api/signature.proto", fileDescriptor_9f931f636a360bde) } -var fileDescriptor_signature_bf68c379d9adbcc8 = []byte{ +var fileDescriptor_9f931f636a360bde = []byte{ // 240 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x90, 0x41, 0x4b, 0xc4, 0x30, 0x10, 0x85, 0xa9, 0x85, 0x85, 0x8d, 0xba, 0x42, 0x51, 0x29, 0xeb, 0xa5, 0xe8, 0xa5, 0xa7, 0x04,