| // Copyright 2024 Google LLC | |
| // | |
| // 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 | |
| // | |
| // https://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. | |
| // Code generated by protoc-gen-go_gapic. DO NOT EDIT. | |
| package longrunning | |
| import ( | |
| "bytes" | |
| "context" | |
| "fmt" | |
| "io" | |
| "math" | |
| "net/http" | |
| "net/url" | |
| "time" | |
| longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb" | |
| gax "github.com/googleapis/gax-go/v2" | |
| "google.golang.org/api/googleapi" | |
| "google.golang.org/api/iterator" | |
| "google.golang.org/api/option" | |
| "google.golang.org/api/option/internaloption" | |
| gtransport "google.golang.org/api/transport/grpc" | |
| httptransport "google.golang.org/api/transport/http" | |
| "google.golang.org/grpc" | |
| "google.golang.org/grpc/codes" | |
| "google.golang.org/protobuf/encoding/protojson" | |
| "google.golang.org/protobuf/proto" | |
| ) | |
| var newOperationsClientHook clientHook | |
| // OperationsCallOptions contains the retry settings for each method of OperationsClient. | |
| type OperationsCallOptions struct { | |
| ListOperations []gax.CallOption | |
| GetOperation []gax.CallOption | |
| DeleteOperation []gax.CallOption | |
| CancelOperation []gax.CallOption | |
| WaitOperation []gax.CallOption | |
| } | |
| func defaultOperationsGRPCClientOptions() []option.ClientOption { | |
| return []option.ClientOption{ | |
| internaloption.WithDefaultEndpoint("longrunning.googleapis.com:443"), | |
| internaloption.WithDefaultEndpointTemplate("longrunning.UNIVERSE_DOMAIN:443"), | |
| internaloption.WithDefaultMTLSEndpoint("longrunning.mtls.googleapis.com:443"), | |
| internaloption.WithDefaultUniverseDomain("googleapis.com"), | |
| internaloption.WithDefaultAudience("https://longrunning.googleapis.com/"), | |
| internaloption.WithDefaultScopes(DefaultAuthScopes()...), | |
| internaloption.EnableJwtWithScope(), | |
| option.WithGRPCDialOption(grpc.WithDefaultCallOptions( | |
| grpc.MaxCallRecvMsgSize(math.MaxInt32))), | |
| } | |
| } | |
| func defaultOperationsCallOptions() *OperationsCallOptions { | |
| return &OperationsCallOptions{ | |
| ListOperations: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnCodes([]codes.Code{ | |
| codes.Unavailable, | |
| }, gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }) | |
| }), | |
| }, | |
| GetOperation: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnCodes([]codes.Code{ | |
| codes.Unavailable, | |
| }, gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }) | |
| }), | |
| }, | |
| DeleteOperation: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnCodes([]codes.Code{ | |
| codes.Unavailable, | |
| }, gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }) | |
| }), | |
| }, | |
| CancelOperation: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnCodes([]codes.Code{ | |
| codes.Unavailable, | |
| }, gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }) | |
| }), | |
| }, | |
| WaitOperation: []gax.CallOption{}, | |
| } | |
| } | |
| func defaultOperationsRESTCallOptions() *OperationsCallOptions { | |
| return &OperationsCallOptions{ | |
| ListOperations: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnHTTPCodes(gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }, | |
| http.StatusServiceUnavailable) | |
| }), | |
| }, | |
| GetOperation: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnHTTPCodes(gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }, | |
| http.StatusServiceUnavailable) | |
| }), | |
| }, | |
| DeleteOperation: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnHTTPCodes(gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }, | |
| http.StatusServiceUnavailable) | |
| }), | |
| }, | |
| CancelOperation: []gax.CallOption{ | |
| gax.WithTimeout(10000 * time.Millisecond), | |
| gax.WithRetry(func() gax.Retryer { | |
| return gax.OnHTTPCodes(gax.Backoff{ | |
| Initial: 500 * time.Millisecond, | |
| Max: 10000 * time.Millisecond, | |
| Multiplier: 2.00, | |
| }, | |
| http.StatusServiceUnavailable) | |
| }), | |
| }, | |
| WaitOperation: []gax.CallOption{}, | |
| } | |
| } | |
| // internalOperationsClient is an interface that defines the methods available from Long Running Operations API. | |
| type internalOperationsClient interface { | |
| Close() error | |
| setGoogleClientInfo(...string) | |
| Connection() *grpc.ClientConn | |
| ListOperations(context.Context, *longrunningpb.ListOperationsRequest, ...gax.CallOption) *OperationIterator | |
| GetOperation(context.Context, *longrunningpb.GetOperationRequest, ...gax.CallOption) (*longrunningpb.Operation, error) | |
| DeleteOperation(context.Context, *longrunningpb.DeleteOperationRequest, ...gax.CallOption) error | |
| CancelOperation(context.Context, *longrunningpb.CancelOperationRequest, ...gax.CallOption) error | |
| WaitOperation(context.Context, *longrunningpb.WaitOperationRequest, ...gax.CallOption) (*longrunningpb.Operation, error) | |
| } | |
| // OperationsClient is a client for interacting with Long Running Operations API. | |
| // Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. | |
| // | |
| // Manages long-running operations with an API service. | |
| // | |
| // When an API method normally takes long time to complete, it can be designed | |
| // to return Operation to the client, and the client can use this | |
| // interface to receive the real response asynchronously by polling the | |
| // operation resource, or pass the operation resource to another API (such as | |
| // Google Cloud Pub/Sub API) to receive the response. Any API service that | |
| // returns long-running operations should implement the Operations interface | |
| // so developers can have a consistent client experience. | |
| type OperationsClient struct { | |
| // The internal transport-dependent client. | |
| internalClient internalOperationsClient | |
| // The call options for this service. | |
| CallOptions *OperationsCallOptions | |
| } | |
| // Wrapper methods routed to the internal client. | |
| // Close closes the connection to the API service. The user should invoke this when | |
| // the client is no longer required. | |
| func (c *OperationsClient) Close() error { | |
| return c.internalClient.Close() | |
| } | |
| // setGoogleClientInfo sets the name and version of the application in | |
| // the `x-goog-api-client` header passed on each request. Intended for | |
| // use by Google-written clients. | |
| func (c *OperationsClient) setGoogleClientInfo(keyval ...string) { | |
| c.internalClient.setGoogleClientInfo(keyval...) | |
| } | |
| // Connection returns a connection to the API service. | |
| // | |
| // Deprecated: Connections are now pooled so this method does not always | |
| // return the same resource. | |
| func (c *OperationsClient) Connection() *grpc.ClientConn { | |
| return c.internalClient.Connection() | |
| } | |
| // ListOperations lists operations that match the specified filter in the request. If the | |
| // server doesn’t support this method, it returns UNIMPLEMENTED. | |
| // | |
| // NOTE: the name binding allows API services to override the binding | |
| // to use different resource name schemes, such as users/*/operations. To | |
| // override the binding, API services can add a binding such as | |
| // "/v1/{name=users/*}/operations" to their service configuration. | |
| // For backwards compatibility, the default name includes the operations | |
| // collection id, however overriding users must ensure the name binding | |
| // is the parent resource, without the operations collection id. | |
| func (c *OperationsClient) ListOperations(ctx context.Context, req *longrunningpb.ListOperationsRequest, opts ...gax.CallOption) *OperationIterator { | |
| return c.internalClient.ListOperations(ctx, req, opts...) | |
| } | |
| // GetOperation gets the latest state of a long-running operation. Clients can use this | |
| // method to poll the operation result at intervals as recommended by the API | |
| // service. | |
| func (c *OperationsClient) GetOperation(ctx context.Context, req *longrunningpb.GetOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error) { | |
| return c.internalClient.GetOperation(ctx, req, opts...) | |
| } | |
| // DeleteOperation deletes a long-running operation. This method indicates that the client is | |
| // no longer interested in the operation result. It does not cancel the | |
| // operation. If the server doesn’t support this method, it returns | |
| // google.rpc.Code.UNIMPLEMENTED. | |
| func (c *OperationsClient) DeleteOperation(ctx context.Context, req *longrunningpb.DeleteOperationRequest, opts ...gax.CallOption) error { | |
| return c.internalClient.DeleteOperation(ctx, req, opts...) | |
| } | |
| // CancelOperation starts asynchronous cancellation on a long-running operation. The server | |
| // makes a best effort to cancel the operation, but success is not | |
| // guaranteed. If the server doesn’t support this method, it returns | |
| // google.rpc.Code.UNIMPLEMENTED. Clients can use | |
| // Operations.GetOperation or | |
| // other methods to check whether the cancellation succeeded or whether the | |
| // operation completed despite cancellation. On successful cancellation, | |
| // the operation is not deleted; instead, it becomes an operation with | |
| // an Operation.error value with a google.rpc.Status.code of 1, | |
| // corresponding to Code.CANCELLED. | |
| func (c *OperationsClient) CancelOperation(ctx context.Context, req *longrunningpb.CancelOperationRequest, opts ...gax.CallOption) error { | |
| return c.internalClient.CancelOperation(ctx, req, opts...) | |
| } | |
| // WaitOperation waits until the specified long-running operation is done or reaches at most | |
| // a specified timeout, returning the latest state. If the operation is | |
| // already done, the latest state is immediately returned. If the timeout | |
| // specified is greater than the default HTTP/RPC timeout, the HTTP/RPC | |
| // timeout is used. If the server does not support this method, it returns | |
| // google.rpc.Code.UNIMPLEMENTED. | |
| // Note that this method is on a best-effort basis. It may return the latest | |
| // state before the specified timeout (including immediately), meaning even an | |
| // immediate response is no guarantee that the operation is done. | |
| func (c *OperationsClient) WaitOperation(ctx context.Context, req *longrunningpb.WaitOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error) { | |
| return c.internalClient.WaitOperation(ctx, req, opts...) | |
| } | |
| // operationsGRPCClient is a client for interacting with Long Running Operations API over gRPC transport. | |
| // | |
| // Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. | |
| type operationsGRPCClient struct { | |
| // Connection pool of gRPC connections to the service. | |
| connPool gtransport.ConnPool | |
| // Points back to the CallOptions field of the containing OperationsClient | |
| CallOptions **OperationsCallOptions | |
| // The gRPC API client. | |
| operationsClient longrunningpb.OperationsClient | |
| // The x-goog-* metadata to be sent with each request. | |
| xGoogHeaders []string | |
| } | |
| // NewOperationsClient creates a new operations client based on gRPC. | |
| // The returned client must be Closed when it is done being used to clean up its underlying connections. | |
| // | |
| // Manages long-running operations with an API service. | |
| // | |
| // When an API method normally takes long time to complete, it can be designed | |
| // to return Operation to the client, and the client can use this | |
| // interface to receive the real response asynchronously by polling the | |
| // operation resource, or pass the operation resource to another API (such as | |
| // Google Cloud Pub/Sub API) to receive the response. Any API service that | |
| // returns long-running operations should implement the Operations interface | |
| // so developers can have a consistent client experience. | |
| func NewOperationsClient(ctx context.Context, opts ...option.ClientOption) (*OperationsClient, error) { | |
| clientOpts := defaultOperationsGRPCClientOptions() | |
| if newOperationsClientHook != nil { | |
| hookOpts, err := newOperationsClientHook(ctx, clientHookParams{}) | |
| if err != nil { | |
| return nil, err | |
| } | |
| clientOpts = append(clientOpts, hookOpts...) | |
| } | |
| connPool, err := gtransport.DialPool(ctx, append(clientOpts, opts...)...) | |
| if err != nil { | |
| return nil, err | |
| } | |
| client := OperationsClient{CallOptions: defaultOperationsCallOptions()} | |
| c := &operationsGRPCClient{ | |
| connPool: connPool, | |
| operationsClient: longrunningpb.NewOperationsClient(connPool), | |
| CallOptions: &client.CallOptions, | |
| } | |
| c.setGoogleClientInfo() | |
| client.internalClient = c | |
| return &client, nil | |
| } | |
| // Connection returns a connection to the API service. | |
| // | |
| // Deprecated: Connections are now pooled so this method does not always | |
| // return the same resource. | |
| func (c *operationsGRPCClient) Connection() *grpc.ClientConn { | |
| return c.connPool.Conn() | |
| } | |
| // setGoogleClientInfo sets the name and version of the application in | |
| // the `x-goog-api-client` header passed on each request. Intended for | |
| // use by Google-written clients. | |
| func (c *operationsGRPCClient) setGoogleClientInfo(keyval ...string) { | |
| kv := append([]string{"gl-go", gax.GoVersion}, keyval...) | |
| kv = append(kv, "gapic", getVersionClient(), "gax", gax.Version, "grpc", grpc.Version) | |
| c.xGoogHeaders = []string{ | |
| "x-goog-api-client", gax.XGoogHeader(kv...), | |
| } | |
| } | |
| // Close closes the connection to the API service. The user should invoke this when | |
| // the client is no longer required. | |
| func (c *operationsGRPCClient) Close() error { | |
| return c.connPool.Close() | |
| } | |
| // Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. | |
| type operationsRESTClient struct { | |
| // The http endpoint to connect to. | |
| endpoint string | |
| // The http client. | |
| httpClient *http.Client | |
| // The x-goog-* headers to be sent with each request. | |
| xGoogHeaders []string | |
| // Points back to the CallOptions field of the containing OperationsClient | |
| CallOptions **OperationsCallOptions | |
| } | |
| // NewOperationsRESTClient creates a new operations rest client. | |
| // | |
| // Manages long-running operations with an API service. | |
| // | |
| // When an API method normally takes long time to complete, it can be designed | |
| // to return Operation to the client, and the client can use this | |
| // interface to receive the real response asynchronously by polling the | |
| // operation resource, or pass the operation resource to another API (such as | |
| // Google Cloud Pub/Sub API) to receive the response. Any API service that | |
| // returns long-running operations should implement the Operations interface | |
| // so developers can have a consistent client experience. | |
| func NewOperationsRESTClient(ctx context.Context, opts ...option.ClientOption) (*OperationsClient, error) { | |
| clientOpts := append(defaultOperationsRESTClientOptions(), opts...) | |
| httpClient, endpoint, err := httptransport.NewClient(ctx, clientOpts...) | |
| if err != nil { | |
| return nil, err | |
| } | |
| callOpts := defaultOperationsRESTCallOptions() | |
| c := &operationsRESTClient{ | |
| endpoint: endpoint, | |
| httpClient: httpClient, | |
| CallOptions: &callOpts, | |
| } | |
| c.setGoogleClientInfo() | |
| return &OperationsClient{internalClient: c, CallOptions: callOpts}, nil | |
| } | |
| func defaultOperationsRESTClientOptions() []option.ClientOption { | |
| return []option.ClientOption{ | |
| internaloption.WithDefaultEndpoint("https://longrunning.googleapis.com"), | |
| internaloption.WithDefaultEndpointTemplate("https://longrunning.UNIVERSE_DOMAIN"), | |
| internaloption.WithDefaultMTLSEndpoint("https://longrunning.mtls.googleapis.com"), | |
| internaloption.WithDefaultUniverseDomain("googleapis.com"), | |
| internaloption.WithDefaultAudience("https://longrunning.googleapis.com/"), | |
| internaloption.WithDefaultScopes(DefaultAuthScopes()...), | |
| } | |
| } | |
| // setGoogleClientInfo sets the name and version of the application in | |
| // the `x-goog-api-client` header passed on each request. Intended for | |
| // use by Google-written clients. | |
| func (c *operationsRESTClient) setGoogleClientInfo(keyval ...string) { | |
| kv := append([]string{"gl-go", gax.GoVersion}, keyval...) | |
| kv = append(kv, "gapic", getVersionClient(), "gax", gax.Version, "rest", "UNKNOWN") | |
| c.xGoogHeaders = []string{ | |
| "x-goog-api-client", gax.XGoogHeader(kv...), | |
| } | |
| } | |
| // Close closes the connection to the API service. The user should invoke this when | |
| // the client is no longer required. | |
| func (c *operationsRESTClient) Close() error { | |
| // Replace httpClient with nil to force cleanup. | |
| c.httpClient = nil | |
| return nil | |
| } | |
| // Connection returns a connection to the API service. | |
| // | |
| // Deprecated: This method always returns nil. | |
| func (c *operationsRESTClient) Connection() *grpc.ClientConn { | |
| return nil | |
| } | |
| func (c *operationsGRPCClient) ListOperations(ctx context.Context, req *longrunningpb.ListOperationsRequest, opts ...gax.CallOption) *OperationIterator { | |
| hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))} | |
| hds = append(c.xGoogHeaders, hds...) | |
| ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...) | |
| opts = append((*c.CallOptions).ListOperations[0:len((*c.CallOptions).ListOperations):len((*c.CallOptions).ListOperations)], opts...) | |
| it := &OperationIterator{} | |
| req = proto.Clone(req).(*longrunningpb.ListOperationsRequest) | |
| it.InternalFetch = func(pageSize int, pageToken string) ([]*longrunningpb.Operation, string, error) { | |
| resp := &longrunningpb.ListOperationsResponse{} | |
| if pageToken != "" { | |
| req.PageToken = pageToken | |
| } | |
| if pageSize > math.MaxInt32 { | |
| req.PageSize = math.MaxInt32 | |
| } else if pageSize != 0 { | |
| req.PageSize = int32(pageSize) | |
| } | |
| err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| var err error | |
| resp, err = c.operationsClient.ListOperations(ctx, req, settings.GRPC...) | |
| return err | |
| }, opts...) | |
| if err != nil { | |
| return nil, "", err | |
| } | |
| it.Response = resp | |
| return resp.GetOperations(), resp.GetNextPageToken(), 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.GetPageSize()) | |
| it.pageInfo.Token = req.GetPageToken() | |
| return it | |
| } | |
| func (c *operationsGRPCClient) GetOperation(ctx context.Context, req *longrunningpb.GetOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error) { | |
| hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))} | |
| hds = append(c.xGoogHeaders, hds...) | |
| ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...) | |
| opts = append((*c.CallOptions).GetOperation[0:len((*c.CallOptions).GetOperation):len((*c.CallOptions).GetOperation)], opts...) | |
| var resp *longrunningpb.Operation | |
| err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| var err error | |
| resp, err = c.operationsClient.GetOperation(ctx, req, settings.GRPC...) | |
| return err | |
| }, opts...) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return resp, nil | |
| } | |
| func (c *operationsGRPCClient) DeleteOperation(ctx context.Context, req *longrunningpb.DeleteOperationRequest, opts ...gax.CallOption) error { | |
| hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))} | |
| hds = append(c.xGoogHeaders, hds...) | |
| ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...) | |
| opts = append((*c.CallOptions).DeleteOperation[0:len((*c.CallOptions).DeleteOperation):len((*c.CallOptions).DeleteOperation)], opts...) | |
| err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| var err error | |
| _, err = c.operationsClient.DeleteOperation(ctx, req, settings.GRPC...) | |
| return err | |
| }, opts...) | |
| return err | |
| } | |
| func (c *operationsGRPCClient) CancelOperation(ctx context.Context, req *longrunningpb.CancelOperationRequest, opts ...gax.CallOption) error { | |
| hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))} | |
| hds = append(c.xGoogHeaders, hds...) | |
| ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...) | |
| opts = append((*c.CallOptions).CancelOperation[0:len((*c.CallOptions).CancelOperation):len((*c.CallOptions).CancelOperation)], opts...) | |
| err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| var err error | |
| _, err = c.operationsClient.CancelOperation(ctx, req, settings.GRPC...) | |
| return err | |
| }, opts...) | |
| return err | |
| } | |
| func (c *operationsGRPCClient) WaitOperation(ctx context.Context, req *longrunningpb.WaitOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error) { | |
| ctx = gax.InsertMetadataIntoOutgoingContext(ctx, c.xGoogHeaders...) | |
| opts = append((*c.CallOptions).WaitOperation[0:len((*c.CallOptions).WaitOperation):len((*c.CallOptions).WaitOperation)], opts...) | |
| var resp *longrunningpb.Operation | |
| err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| var err error | |
| resp, err = c.operationsClient.WaitOperation(ctx, req, settings.GRPC...) | |
| return err | |
| }, opts...) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return resp, nil | |
| } | |
| // ListOperations lists operations that match the specified filter in the request. If the | |
| // server doesn’t support this method, it returns UNIMPLEMENTED. | |
| // | |
| // NOTE: the name binding allows API services to override the binding | |
| // to use different resource name schemes, such as users/*/operations. To | |
| // override the binding, API services can add a binding such as | |
| // "/v1/{name=users/*}/operations" to their service configuration. | |
| // For backwards compatibility, the default name includes the operations | |
| // collection id, however overriding users must ensure the name binding | |
| // is the parent resource, without the operations collection id. | |
| func (c *operationsRESTClient) ListOperations(ctx context.Context, req *longrunningpb.ListOperationsRequest, opts ...gax.CallOption) *OperationIterator { | |
| it := &OperationIterator{} | |
| req = proto.Clone(req).(*longrunningpb.ListOperationsRequest) | |
| unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true} | |
| it.InternalFetch = func(pageSize int, pageToken string) ([]*longrunningpb.Operation, string, error) { | |
| resp := &longrunningpb.ListOperationsResponse{} | |
| if pageToken != "" { | |
| req.PageToken = pageToken | |
| } | |
| if pageSize > math.MaxInt32 { | |
| req.PageSize = math.MaxInt32 | |
| } else if pageSize != 0 { | |
| req.PageSize = int32(pageSize) | |
| } | |
| baseUrl, err := url.Parse(c.endpoint) | |
| if err != nil { | |
| return nil, "", err | |
| } | |
| baseUrl.Path += fmt.Sprintf("/v1/%v", req.GetName()) | |
| params := url.Values{} | |
| if req.GetFilter() != "" { | |
| params.Add("filter", fmt.Sprintf("%v", req.GetFilter())) | |
| } | |
| if req.GetPageSize() != 0 { | |
| params.Add("pageSize", fmt.Sprintf("%v", req.GetPageSize())) | |
| } | |
| if req.GetPageToken() != "" { | |
| params.Add("pageToken", fmt.Sprintf("%v", req.GetPageToken())) | |
| } | |
| baseUrl.RawQuery = params.Encode() | |
| // Build HTTP headers from client and context metadata. | |
| hds := append(c.xGoogHeaders, "Content-Type", "application/json") | |
| headers := gax.BuildHeaders(ctx, hds...) | |
| e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| if settings.Path != "" { | |
| baseUrl.Path = settings.Path | |
| } | |
| httpReq, err := http.NewRequest("GET", baseUrl.String(), nil) | |
| if err != nil { | |
| return err | |
| } | |
| httpReq.Header = headers | |
| httpRsp, err := c.httpClient.Do(httpReq) | |
| if err != nil { | |
| return err | |
| } | |
| defer httpRsp.Body.Close() | |
| if err = googleapi.CheckResponse(httpRsp); err != nil { | |
| return err | |
| } | |
| buf, err := io.ReadAll(httpRsp.Body) | |
| if err != nil { | |
| return err | |
| } | |
| if err := unm.Unmarshal(buf, resp); err != nil { | |
| return err | |
| } | |
| return nil | |
| }, opts...) | |
| if e != nil { | |
| return nil, "", e | |
| } | |
| it.Response = resp | |
| return resp.GetOperations(), resp.GetNextPageToken(), 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.GetPageSize()) | |
| it.pageInfo.Token = req.GetPageToken() | |
| return it | |
| } | |
| // GetOperation gets the latest state of a long-running operation. Clients can use this | |
| // method to poll the operation result at intervals as recommended by the API | |
| // service. | |
| func (c *operationsRESTClient) GetOperation(ctx context.Context, req *longrunningpb.GetOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error) { | |
| baseUrl, err := url.Parse(c.endpoint) | |
| if err != nil { | |
| return nil, err | |
| } | |
| baseUrl.Path += fmt.Sprintf("/v1/%v", req.GetName()) | |
| // Build HTTP headers from client and context metadata. | |
| hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))} | |
| hds = append(c.xGoogHeaders, hds...) | |
| hds = append(hds, "Content-Type", "application/json") | |
| headers := gax.BuildHeaders(ctx, hds...) | |
| opts = append((*c.CallOptions).GetOperation[0:len((*c.CallOptions).GetOperation):len((*c.CallOptions).GetOperation)], opts...) | |
| unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true} | |
| resp := &longrunningpb.Operation{} | |
| e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| if settings.Path != "" { | |
| baseUrl.Path = settings.Path | |
| } | |
| httpReq, err := http.NewRequest("GET", baseUrl.String(), nil) | |
| if err != nil { | |
| return err | |
| } | |
| httpReq = httpReq.WithContext(ctx) | |
| httpReq.Header = headers | |
| httpRsp, err := c.httpClient.Do(httpReq) | |
| if err != nil { | |
| return err | |
| } | |
| defer httpRsp.Body.Close() | |
| if err = googleapi.CheckResponse(httpRsp); err != nil { | |
| return err | |
| } | |
| buf, err := io.ReadAll(httpRsp.Body) | |
| if err != nil { | |
| return err | |
| } | |
| if err := unm.Unmarshal(buf, resp); err != nil { | |
| return err | |
| } | |
| return nil | |
| }, opts...) | |
| if e != nil { | |
| return nil, e | |
| } | |
| return resp, nil | |
| } | |
| // DeleteOperation deletes a long-running operation. This method indicates that the client is | |
| // no longer interested in the operation result. It does not cancel the | |
| // operation. If the server doesn’t support this method, it returns | |
| // google.rpc.Code.UNIMPLEMENTED. | |
| func (c *operationsRESTClient) DeleteOperation(ctx context.Context, req *longrunningpb.DeleteOperationRequest, opts ...gax.CallOption) error { | |
| baseUrl, err := url.Parse(c.endpoint) | |
| if err != nil { | |
| return err | |
| } | |
| baseUrl.Path += fmt.Sprintf("/v1/%v", req.GetName()) | |
| // Build HTTP headers from client and context metadata. | |
| hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))} | |
| hds = append(c.xGoogHeaders, hds...) | |
| hds = append(hds, "Content-Type", "application/json") | |
| headers := gax.BuildHeaders(ctx, hds...) | |
| return gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| if settings.Path != "" { | |
| baseUrl.Path = settings.Path | |
| } | |
| httpReq, err := http.NewRequest("DELETE", baseUrl.String(), nil) | |
| if err != nil { | |
| return err | |
| } | |
| httpReq = httpReq.WithContext(ctx) | |
| httpReq.Header = headers | |
| httpRsp, err := c.httpClient.Do(httpReq) | |
| if err != nil { | |
| return err | |
| } | |
| defer httpRsp.Body.Close() | |
| // Returns nil if there is no error, otherwise wraps | |
| // the response code and body into a non-nil error | |
| return googleapi.CheckResponse(httpRsp) | |
| }, opts...) | |
| } | |
| // CancelOperation starts asynchronous cancellation on a long-running operation. The server | |
| // makes a best effort to cancel the operation, but success is not | |
| // guaranteed. If the server doesn’t support this method, it returns | |
| // google.rpc.Code.UNIMPLEMENTED. Clients can use | |
| // Operations.GetOperation or | |
| // other methods to check whether the cancellation succeeded or whether the | |
| // operation completed despite cancellation. On successful cancellation, | |
| // the operation is not deleted; instead, it becomes an operation with | |
| // an Operation.error value with a google.rpc.Status.code of 1, | |
| // corresponding to Code.CANCELLED. | |
| func (c *operationsRESTClient) CancelOperation(ctx context.Context, req *longrunningpb.CancelOperationRequest, opts ...gax.CallOption) error { | |
| m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true} | |
| jsonReq, err := m.Marshal(req) | |
| if err != nil { | |
| return err | |
| } | |
| baseUrl, err := url.Parse(c.endpoint) | |
| if err != nil { | |
| return err | |
| } | |
| baseUrl.Path += fmt.Sprintf("/v1/%v:cancel", req.GetName()) | |
| // Build HTTP headers from client and context metadata. | |
| hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))} | |
| hds = append(c.xGoogHeaders, hds...) | |
| hds = append(hds, "Content-Type", "application/json") | |
| headers := gax.BuildHeaders(ctx, hds...) | |
| return gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| if settings.Path != "" { | |
| baseUrl.Path = settings.Path | |
| } | |
| httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq)) | |
| if err != nil { | |
| return err | |
| } | |
| httpReq = httpReq.WithContext(ctx) | |
| httpReq.Header = headers | |
| httpRsp, err := c.httpClient.Do(httpReq) | |
| if err != nil { | |
| return err | |
| } | |
| defer httpRsp.Body.Close() | |
| // Returns nil if there is no error, otherwise wraps | |
| // the response code and body into a non-nil error | |
| return googleapi.CheckResponse(httpRsp) | |
| }, opts...) | |
| } | |
| // WaitOperation waits until the specified long-running operation is done or reaches at most | |
| // a specified timeout, returning the latest state. If the operation is | |
| // already done, the latest state is immediately returned. If the timeout | |
| // specified is greater than the default HTTP/RPC timeout, the HTTP/RPC | |
| // timeout is used. If the server does not support this method, it returns | |
| // google.rpc.Code.UNIMPLEMENTED. | |
| // Note that this method is on a best-effort basis. It may return the latest | |
| // state before the specified timeout (including immediately), meaning even an | |
| // immediate response is no guarantee that the operation is done. | |
| func (c *operationsRESTClient) WaitOperation(ctx context.Context, req *longrunningpb.WaitOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error) { | |
| baseUrl, err := url.Parse(c.endpoint) | |
| if err != nil { | |
| return nil, err | |
| } | |
| baseUrl.Path += fmt.Sprintf("") | |
| params := url.Values{} | |
| if req.GetName() != "" { | |
| params.Add("name", fmt.Sprintf("%v", req.GetName())) | |
| } | |
| if req.GetTimeout() != nil { | |
| timeout, err := protojson.Marshal(req.GetTimeout()) | |
| if err != nil { | |
| return nil, err | |
| } | |
| params.Add("timeout", string(timeout[1:len(timeout)-1])) | |
| } | |
| baseUrl.RawQuery = params.Encode() | |
| // Build HTTP headers from client and context metadata. | |
| hds := append(c.xGoogHeaders, "Content-Type", "application/json") | |
| headers := gax.BuildHeaders(ctx, hds...) | |
| opts = append((*c.CallOptions).WaitOperation[0:len((*c.CallOptions).WaitOperation):len((*c.CallOptions).WaitOperation)], opts...) | |
| unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true} | |
| resp := &longrunningpb.Operation{} | |
| e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { | |
| if settings.Path != "" { | |
| baseUrl.Path = settings.Path | |
| } | |
| httpReq, err := http.NewRequest("", baseUrl.String(), nil) | |
| if err != nil { | |
| return err | |
| } | |
| httpReq = httpReq.WithContext(ctx) | |
| httpReq.Header = headers | |
| httpRsp, err := c.httpClient.Do(httpReq) | |
| if err != nil { | |
| return err | |
| } | |
| defer httpRsp.Body.Close() | |
| if err = googleapi.CheckResponse(httpRsp); err != nil { | |
| return err | |
| } | |
| buf, err := io.ReadAll(httpRsp.Body) | |
| if err != nil { | |
| return err | |
| } | |
| if err := unm.Unmarshal(buf, resp); err != nil { | |
| return err | |
| } | |
| return nil | |
| }, opts...) | |
| if e != nil { | |
| return nil, e | |
| } | |
| return resp, nil | |
| } |