mirror of
https://github.com/moby/moby.git
synced 2026-01-11 18:51:37 +00:00
822 lines
30 KiB
Go
822 lines
30 KiB
Go
// Copyright 2025 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"
|
||
"log/slog"
|
||
"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/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(),
|
||
internaloption.EnableNewAuthLibrary(),
|
||
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 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.
|
||
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
|
||
|
||
logger *slog.Logger
|
||
}
|
||
|
||
// 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 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,
|
||
logger: internaloption.GetLogger(opts),
|
||
}
|
||
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
|
||
|
||
logger *slog.Logger
|
||
}
|
||
|
||
// 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 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,
|
||
logger: internaloption.GetLogger(opts),
|
||
}
|
||
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()...),
|
||
internaloption.EnableNewAuthLibrary(),
|
||
}
|
||
}
|
||
|
||
// 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 = executeRPC(ctx, c.operationsClient.ListOperations, req, settings.GRPC, c.logger, "ListOperations")
|
||
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 = executeRPC(ctx, c.operationsClient.GetOperation, req, settings.GRPC, c.logger, "GetOperation")
|
||
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 = executeRPC(ctx, c.operationsClient.DeleteOperation, req, settings.GRPC, c.logger, "DeleteOperation")
|
||
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 = executeRPC(ctx, c.operationsClient.CancelOperation, req, settings.GRPC, c.logger, "CancelOperation")
|
||
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 = executeRPC(ctx, c.operationsClient.WaitOperation, req, settings.GRPC, c.logger, "WaitOperation")
|
||
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.
|
||
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
|
||
|
||
buf, err := executeHTTPRequest(ctx, c.httpClient, httpReq, c.logger, nil, "ListOperations")
|
||
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
|
||
|
||
buf, err := executeHTTPRequest(ctx, c.httpClient, httpReq, c.logger, nil, "GetOperation")
|
||
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
|
||
|
||
_, err = executeHTTPRequest(ctx, c.httpClient, httpReq, c.logger, nil, "DeleteOperation")
|
||
return err
|
||
}, 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
|
||
|
||
_, err = executeHTTPRequest(ctx, c.httpClient, httpReq, c.logger, jsonReq, "CancelOperation")
|
||
return err
|
||
}, 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 {
|
||
field, err := protojson.Marshal(req.GetTimeout())
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
params.Add("timeout", string(field[1:len(field)-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
|
||
|
||
buf, err := executeHTTPRequest(ctx, c.httpClient, httpReq, c.logger, nil, "WaitOperation")
|
||
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
|
||
}
|