Source file src/cloud.google.com/go/secretmanager/apiv1beta2/secret_manager_client.go

Documentation: cloud.google.com/go/secretmanager/apiv1beta2

     1  // Copyright 2024 Google LLC
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     https://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // Code generated by protoc-gen-go_gapic. DO NOT EDIT.
    16  
    17  package secretmanager
    18  
    19  import (
    20  	"bytes"
    21  	"context"
    22  	"fmt"
    23  	"io"
    24  	"math"
    25  	"net/http"
    26  	"net/url"
    27  	"time"
    28  
    29  	iampb "cloud.google.com/go/iam/apiv1/iampb"
    30  	secretmanagerpb "cloud.google.com/go/secretmanager/apiv1beta2/secretmanagerpb"
    31  	gax "github.com/googleapis/gax-go/v2"
    32  	"google.golang.org/api/googleapi"
    33  	"google.golang.org/api/iterator"
    34  	"google.golang.org/api/option"
    35  	"google.golang.org/api/option/internaloption"
    36  	gtransport "google.golang.org/api/transport/grpc"
    37  	httptransport "google.golang.org/api/transport/http"
    38  	locationpb "google.golang.org/genproto/googleapis/cloud/location"
    39  	"google.golang.org/grpc"
    40  	"google.golang.org/grpc/codes"
    41  	"google.golang.org/protobuf/encoding/protojson"
    42  	"google.golang.org/protobuf/proto"
    43  )
    44  
    45  var newClientHook clientHook
    46  
    47  // CallOptions contains the retry settings for each method of Client.
    48  type CallOptions struct {
    49  	ListSecrets          []gax.CallOption
    50  	CreateSecret         []gax.CallOption
    51  	AddSecretVersion     []gax.CallOption
    52  	GetSecret            []gax.CallOption
    53  	UpdateSecret         []gax.CallOption
    54  	DeleteSecret         []gax.CallOption
    55  	ListSecretVersions   []gax.CallOption
    56  	GetSecretVersion     []gax.CallOption
    57  	AccessSecretVersion  []gax.CallOption
    58  	DisableSecretVersion []gax.CallOption
    59  	EnableSecretVersion  []gax.CallOption
    60  	DestroySecretVersion []gax.CallOption
    61  	SetIamPolicy         []gax.CallOption
    62  	GetIamPolicy         []gax.CallOption
    63  	TestIamPermissions   []gax.CallOption
    64  	GetLocation          []gax.CallOption
    65  	ListLocations        []gax.CallOption
    66  }
    67  
    68  func defaultGRPCClientOptions() []option.ClientOption {
    69  	return []option.ClientOption{
    70  		internaloption.WithDefaultEndpoint("secretmanager.googleapis.com:443"),
    71  		internaloption.WithDefaultEndpointTemplate("secretmanager.UNIVERSE_DOMAIN:443"),
    72  		internaloption.WithDefaultMTLSEndpoint("secretmanager.mtls.googleapis.com:443"),
    73  		internaloption.WithDefaultUniverseDomain("googleapis.com"),
    74  		internaloption.WithDefaultAudience("https://secretmanager.googleapis.com/"),
    75  		internaloption.WithDefaultScopes(DefaultAuthScopes()...),
    76  		internaloption.EnableJwtWithScope(),
    77  		option.WithGRPCDialOption(grpc.WithDefaultCallOptions(
    78  			grpc.MaxCallRecvMsgSize(math.MaxInt32))),
    79  	}
    80  }
    81  
    82  func defaultCallOptions() *CallOptions {
    83  	return &CallOptions{
    84  		ListSecrets: []gax.CallOption{
    85  			gax.WithTimeout(60000 * time.Millisecond),
    86  		},
    87  		CreateSecret: []gax.CallOption{
    88  			gax.WithTimeout(60000 * time.Millisecond),
    89  		},
    90  		AddSecretVersion: []gax.CallOption{
    91  			gax.WithTimeout(60000 * time.Millisecond),
    92  		},
    93  		GetSecret: []gax.CallOption{
    94  			gax.WithTimeout(60000 * time.Millisecond),
    95  		},
    96  		UpdateSecret: []gax.CallOption{
    97  			gax.WithTimeout(60000 * time.Millisecond),
    98  		},
    99  		DeleteSecret: []gax.CallOption{
   100  			gax.WithTimeout(60000 * time.Millisecond),
   101  		},
   102  		ListSecretVersions: []gax.CallOption{
   103  			gax.WithTimeout(60000 * time.Millisecond),
   104  		},
   105  		GetSecretVersion: []gax.CallOption{
   106  			gax.WithTimeout(60000 * time.Millisecond),
   107  		},
   108  		AccessSecretVersion: []gax.CallOption{
   109  			gax.WithTimeout(60000 * time.Millisecond),
   110  			gax.WithRetry(func() gax.Retryer {
   111  				return gax.OnCodes([]codes.Code{
   112  					codes.Unavailable,
   113  					codes.ResourceExhausted,
   114  				}, gax.Backoff{
   115  					Initial:    2000 * time.Millisecond,
   116  					Max:        60000 * time.Millisecond,
   117  					Multiplier: 2.00,
   118  				})
   119  			}),
   120  		},
   121  		DisableSecretVersion: []gax.CallOption{
   122  			gax.WithTimeout(60000 * time.Millisecond),
   123  		},
   124  		EnableSecretVersion: []gax.CallOption{
   125  			gax.WithTimeout(60000 * time.Millisecond),
   126  		},
   127  		DestroySecretVersion: []gax.CallOption{
   128  			gax.WithTimeout(60000 * time.Millisecond),
   129  		},
   130  		SetIamPolicy: []gax.CallOption{
   131  			gax.WithTimeout(60000 * time.Millisecond),
   132  		},
   133  		GetIamPolicy: []gax.CallOption{
   134  			gax.WithTimeout(60000 * time.Millisecond),
   135  		},
   136  		TestIamPermissions: []gax.CallOption{
   137  			gax.WithTimeout(60000 * time.Millisecond),
   138  		},
   139  		GetLocation:   []gax.CallOption{},
   140  		ListLocations: []gax.CallOption{},
   141  	}
   142  }
   143  
   144  func defaultRESTCallOptions() *CallOptions {
   145  	return &CallOptions{
   146  		ListSecrets: []gax.CallOption{
   147  			gax.WithTimeout(60000 * time.Millisecond),
   148  		},
   149  		CreateSecret: []gax.CallOption{
   150  			gax.WithTimeout(60000 * time.Millisecond),
   151  		},
   152  		AddSecretVersion: []gax.CallOption{
   153  			gax.WithTimeout(60000 * time.Millisecond),
   154  		},
   155  		GetSecret: []gax.CallOption{
   156  			gax.WithTimeout(60000 * time.Millisecond),
   157  		},
   158  		UpdateSecret: []gax.CallOption{
   159  			gax.WithTimeout(60000 * time.Millisecond),
   160  		},
   161  		DeleteSecret: []gax.CallOption{
   162  			gax.WithTimeout(60000 * time.Millisecond),
   163  		},
   164  		ListSecretVersions: []gax.CallOption{
   165  			gax.WithTimeout(60000 * time.Millisecond),
   166  		},
   167  		GetSecretVersion: []gax.CallOption{
   168  			gax.WithTimeout(60000 * time.Millisecond),
   169  		},
   170  		AccessSecretVersion: []gax.CallOption{
   171  			gax.WithTimeout(60000 * time.Millisecond),
   172  			gax.WithRetry(func() gax.Retryer {
   173  				return gax.OnHTTPCodes(gax.Backoff{
   174  					Initial:    2000 * time.Millisecond,
   175  					Max:        60000 * time.Millisecond,
   176  					Multiplier: 2.00,
   177  				},
   178  					http.StatusServiceUnavailable,
   179  					http.StatusTooManyRequests)
   180  			}),
   181  		},
   182  		DisableSecretVersion: []gax.CallOption{
   183  			gax.WithTimeout(60000 * time.Millisecond),
   184  		},
   185  		EnableSecretVersion: []gax.CallOption{
   186  			gax.WithTimeout(60000 * time.Millisecond),
   187  		},
   188  		DestroySecretVersion: []gax.CallOption{
   189  			gax.WithTimeout(60000 * time.Millisecond),
   190  		},
   191  		SetIamPolicy: []gax.CallOption{
   192  			gax.WithTimeout(60000 * time.Millisecond),
   193  		},
   194  		GetIamPolicy: []gax.CallOption{
   195  			gax.WithTimeout(60000 * time.Millisecond),
   196  		},
   197  		TestIamPermissions: []gax.CallOption{
   198  			gax.WithTimeout(60000 * time.Millisecond),
   199  		},
   200  		GetLocation:   []gax.CallOption{},
   201  		ListLocations: []gax.CallOption{},
   202  	}
   203  }
   204  
   205  // internalClient is an interface that defines the methods available from Secret Manager API.
   206  type internalClient interface {
   207  	Close() error
   208  	setGoogleClientInfo(...string)
   209  	Connection() *grpc.ClientConn
   210  	ListSecrets(context.Context, *secretmanagerpb.ListSecretsRequest, ...gax.CallOption) *SecretIterator
   211  	CreateSecret(context.Context, *secretmanagerpb.CreateSecretRequest, ...gax.CallOption) (*secretmanagerpb.Secret, error)
   212  	AddSecretVersion(context.Context, *secretmanagerpb.AddSecretVersionRequest, ...gax.CallOption) (*secretmanagerpb.SecretVersion, error)
   213  	GetSecret(context.Context, *secretmanagerpb.GetSecretRequest, ...gax.CallOption) (*secretmanagerpb.Secret, error)
   214  	UpdateSecret(context.Context, *secretmanagerpb.UpdateSecretRequest, ...gax.CallOption) (*secretmanagerpb.Secret, error)
   215  	DeleteSecret(context.Context, *secretmanagerpb.DeleteSecretRequest, ...gax.CallOption) error
   216  	ListSecretVersions(context.Context, *secretmanagerpb.ListSecretVersionsRequest, ...gax.CallOption) *SecretVersionIterator
   217  	GetSecretVersion(context.Context, *secretmanagerpb.GetSecretVersionRequest, ...gax.CallOption) (*secretmanagerpb.SecretVersion, error)
   218  	AccessSecretVersion(context.Context, *secretmanagerpb.AccessSecretVersionRequest, ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error)
   219  	DisableSecretVersion(context.Context, *secretmanagerpb.DisableSecretVersionRequest, ...gax.CallOption) (*secretmanagerpb.SecretVersion, error)
   220  	EnableSecretVersion(context.Context, *secretmanagerpb.EnableSecretVersionRequest, ...gax.CallOption) (*secretmanagerpb.SecretVersion, error)
   221  	DestroySecretVersion(context.Context, *secretmanagerpb.DestroySecretVersionRequest, ...gax.CallOption) (*secretmanagerpb.SecretVersion, error)
   222  	SetIamPolicy(context.Context, *iampb.SetIamPolicyRequest, ...gax.CallOption) (*iampb.Policy, error)
   223  	GetIamPolicy(context.Context, *iampb.GetIamPolicyRequest, ...gax.CallOption) (*iampb.Policy, error)
   224  	TestIamPermissions(context.Context, *iampb.TestIamPermissionsRequest, ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error)
   225  	GetLocation(context.Context, *locationpb.GetLocationRequest, ...gax.CallOption) (*locationpb.Location, error)
   226  	ListLocations(context.Context, *locationpb.ListLocationsRequest, ...gax.CallOption) *LocationIterator
   227  }
   228  
   229  // Client is a client for interacting with Secret Manager API.
   230  // Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.
   231  //
   232  // # Secret Manager Service
   233  //
   234  // Manages secrets and operations using those secrets. Implements a REST
   235  // model with the following objects:
   236  //
   237  //	Secret
   238  //
   239  //	SecretVersion
   240  type Client struct {
   241  	// The internal transport-dependent client.
   242  	internalClient internalClient
   243  
   244  	// The call options for this service.
   245  	CallOptions *CallOptions
   246  }
   247  
   248  // Wrapper methods routed to the internal client.
   249  
   250  // Close closes the connection to the API service. The user should invoke this when
   251  // the client is no longer required.
   252  func (c *Client) Close() error {
   253  	return c.internalClient.Close()
   254  }
   255  
   256  // setGoogleClientInfo sets the name and version of the application in
   257  // the `x-goog-api-client` header passed on each request. Intended for
   258  // use by Google-written clients.
   259  func (c *Client) setGoogleClientInfo(keyval ...string) {
   260  	c.internalClient.setGoogleClientInfo(keyval...)
   261  }
   262  
   263  // Connection returns a connection to the API service.
   264  //
   265  // Deprecated: Connections are now pooled so this method does not always
   266  // return the same resource.
   267  func (c *Client) Connection() *grpc.ClientConn {
   268  	return c.internalClient.Connection()
   269  }
   270  
   271  // ListSecrets lists Secrets.
   272  func (c *Client) ListSecrets(ctx context.Context, req *secretmanagerpb.ListSecretsRequest, opts ...gax.CallOption) *SecretIterator {
   273  	return c.internalClient.ListSecrets(ctx, req, opts...)
   274  }
   275  
   276  // CreateSecret creates a new Secret
   277  // containing no
   278  // SecretVersions.
   279  func (c *Client) CreateSecret(ctx context.Context, req *secretmanagerpb.CreateSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
   280  	return c.internalClient.CreateSecret(ctx, req, opts...)
   281  }
   282  
   283  // AddSecretVersion creates a new
   284  // SecretVersion
   285  // containing secret data and attaches it to an existing
   286  // Secret.
   287  func (c *Client) AddSecretVersion(ctx context.Context, req *secretmanagerpb.AddSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   288  	return c.internalClient.AddSecretVersion(ctx, req, opts...)
   289  }
   290  
   291  // GetSecret gets metadata for a given
   292  // Secret.
   293  func (c *Client) GetSecret(ctx context.Context, req *secretmanagerpb.GetSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
   294  	return c.internalClient.GetSecret(ctx, req, opts...)
   295  }
   296  
   297  // UpdateSecret updates metadata of an existing
   298  // Secret.
   299  func (c *Client) UpdateSecret(ctx context.Context, req *secretmanagerpb.UpdateSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
   300  	return c.internalClient.UpdateSecret(ctx, req, opts...)
   301  }
   302  
   303  // DeleteSecret deletes a Secret.
   304  func (c *Client) DeleteSecret(ctx context.Context, req *secretmanagerpb.DeleteSecretRequest, opts ...gax.CallOption) error {
   305  	return c.internalClient.DeleteSecret(ctx, req, opts...)
   306  }
   307  
   308  // ListSecretVersions lists SecretVersions.
   309  // This call does not return secret data.
   310  func (c *Client) ListSecretVersions(ctx context.Context, req *secretmanagerpb.ListSecretVersionsRequest, opts ...gax.CallOption) *SecretVersionIterator {
   311  	return c.internalClient.ListSecretVersions(ctx, req, opts...)
   312  }
   313  
   314  // GetSecretVersion gets metadata for a
   315  // SecretVersion.
   316  //
   317  // projects/*/secrets/*/versions/latest is an alias to the most recently
   318  // created SecretVersion.
   319  func (c *Client) GetSecretVersion(ctx context.Context, req *secretmanagerpb.GetSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   320  	return c.internalClient.GetSecretVersion(ctx, req, opts...)
   321  }
   322  
   323  // AccessSecretVersion accesses a
   324  // SecretVersion. This
   325  // call returns the secret data.
   326  //
   327  // projects/*/secrets/*/versions/latest is an alias to the most recently
   328  // created SecretVersion.
   329  func (c *Client) AccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error) {
   330  	return c.internalClient.AccessSecretVersion(ctx, req, opts...)
   331  }
   332  
   333  // DisableSecretVersion disables a
   334  // SecretVersion.
   335  //
   336  // Sets the state of
   337  // the SecretVersion to
   338  // DISABLED.
   339  func (c *Client) DisableSecretVersion(ctx context.Context, req *secretmanagerpb.DisableSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   340  	return c.internalClient.DisableSecretVersion(ctx, req, opts...)
   341  }
   342  
   343  // EnableSecretVersion enables a
   344  // SecretVersion.
   345  //
   346  // Sets the state of
   347  // the SecretVersion to
   348  // ENABLED.
   349  func (c *Client) EnableSecretVersion(ctx context.Context, req *secretmanagerpb.EnableSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   350  	return c.internalClient.EnableSecretVersion(ctx, req, opts...)
   351  }
   352  
   353  // DestroySecretVersion destroys a
   354  // SecretVersion.
   355  //
   356  // Sets the state of
   357  // the SecretVersion to
   358  // DESTROYED
   359  // and irrevocably destroys the secret data.
   360  func (c *Client) DestroySecretVersion(ctx context.Context, req *secretmanagerpb.DestroySecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   361  	return c.internalClient.DestroySecretVersion(ctx, req, opts...)
   362  }
   363  
   364  // SetIamPolicy sets the access control policy on the specified secret. Replaces any
   365  // existing policy.
   366  //
   367  // Permissions on
   368  // SecretVersions are
   369  // enforced according to the policy set on the associated
   370  // Secret.
   371  func (c *Client) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
   372  	return c.internalClient.SetIamPolicy(ctx, req, opts...)
   373  }
   374  
   375  // GetIamPolicy gets the access control policy for a secret.
   376  // Returns empty policy if the secret exists and does not have a policy set.
   377  func (c *Client) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
   378  	return c.internalClient.GetIamPolicy(ctx, req, opts...)
   379  }
   380  
   381  // TestIamPermissions returns permissions that a caller has for the specified secret.
   382  // If the secret does not exist, this call returns an empty set of
   383  // permissions, not a NOT_FOUND error.
   384  //
   385  // Note: This operation is designed to be used for building permission-aware
   386  // UIs and command-line tools, not for authorization checking. This operation
   387  // may “fail open” without warning.
   388  func (c *Client) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest, opts ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error) {
   389  	return c.internalClient.TestIamPermissions(ctx, req, opts...)
   390  }
   391  
   392  // GetLocation gets information about a location.
   393  func (c *Client) GetLocation(ctx context.Context, req *locationpb.GetLocationRequest, opts ...gax.CallOption) (*locationpb.Location, error) {
   394  	return c.internalClient.GetLocation(ctx, req, opts...)
   395  }
   396  
   397  // ListLocations lists information about the supported locations for this service.
   398  func (c *Client) ListLocations(ctx context.Context, req *locationpb.ListLocationsRequest, opts ...gax.CallOption) *LocationIterator {
   399  	return c.internalClient.ListLocations(ctx, req, opts...)
   400  }
   401  
   402  // gRPCClient is a client for interacting with Secret Manager API over gRPC transport.
   403  //
   404  // Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.
   405  type gRPCClient struct {
   406  	// Connection pool of gRPC connections to the service.
   407  	connPool gtransport.ConnPool
   408  
   409  	// Points back to the CallOptions field of the containing Client
   410  	CallOptions **CallOptions
   411  
   412  	// The gRPC API client.
   413  	client secretmanagerpb.SecretManagerServiceClient
   414  
   415  	locationsClient locationpb.LocationsClient
   416  
   417  	// The x-goog-* metadata to be sent with each request.
   418  	xGoogHeaders []string
   419  }
   420  
   421  // NewClient creates a new secret manager service client based on gRPC.
   422  // The returned client must be Closed when it is done being used to clean up its underlying connections.
   423  //
   424  // # Secret Manager Service
   425  //
   426  // Manages secrets and operations using those secrets. Implements a REST
   427  // model with the following objects:
   428  //
   429  //	Secret
   430  //
   431  //	SecretVersion
   432  func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error) {
   433  	clientOpts := defaultGRPCClientOptions()
   434  	if newClientHook != nil {
   435  		hookOpts, err := newClientHook(ctx, clientHookParams{})
   436  		if err != nil {
   437  			return nil, err
   438  		}
   439  		clientOpts = append(clientOpts, hookOpts...)
   440  	}
   441  
   442  	connPool, err := gtransport.DialPool(ctx, append(clientOpts, opts...)...)
   443  	if err != nil {
   444  		return nil, err
   445  	}
   446  	client := Client{CallOptions: defaultCallOptions()}
   447  
   448  	c := &gRPCClient{
   449  		connPool:        connPool,
   450  		client:          secretmanagerpb.NewSecretManagerServiceClient(connPool),
   451  		CallOptions:     &client.CallOptions,
   452  		locationsClient: locationpb.NewLocationsClient(connPool),
   453  	}
   454  	c.setGoogleClientInfo()
   455  
   456  	client.internalClient = c
   457  
   458  	return &client, nil
   459  }
   460  
   461  // Connection returns a connection to the API service.
   462  //
   463  // Deprecated: Connections are now pooled so this method does not always
   464  // return the same resource.
   465  func (c *gRPCClient) Connection() *grpc.ClientConn {
   466  	return c.connPool.Conn()
   467  }
   468  
   469  // setGoogleClientInfo sets the name and version of the application in
   470  // the `x-goog-api-client` header passed on each request. Intended for
   471  // use by Google-written clients.
   472  func (c *gRPCClient) setGoogleClientInfo(keyval ...string) {
   473  	kv := append([]string{"gl-go", gax.GoVersion}, keyval...)
   474  	kv = append(kv, "gapic", getVersionClient(), "gax", gax.Version, "grpc", grpc.Version)
   475  	c.xGoogHeaders = []string{"x-goog-api-client", gax.XGoogHeader(kv...)}
   476  }
   477  
   478  // Close closes the connection to the API service. The user should invoke this when
   479  // the client is no longer required.
   480  func (c *gRPCClient) Close() error {
   481  	return c.connPool.Close()
   482  }
   483  
   484  // Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.
   485  type restClient struct {
   486  	// The http endpoint to connect to.
   487  	endpoint string
   488  
   489  	// The http client.
   490  	httpClient *http.Client
   491  
   492  	// The x-goog-* headers to be sent with each request.
   493  	xGoogHeaders []string
   494  
   495  	// Points back to the CallOptions field of the containing Client
   496  	CallOptions **CallOptions
   497  }
   498  
   499  // NewRESTClient creates a new secret manager service rest client.
   500  //
   501  // # Secret Manager Service
   502  //
   503  // Manages secrets and operations using those secrets. Implements a REST
   504  // model with the following objects:
   505  //
   506  //	Secret
   507  //
   508  //	SecretVersion
   509  func NewRESTClient(ctx context.Context, opts ...option.ClientOption) (*Client, error) {
   510  	clientOpts := append(defaultRESTClientOptions(), opts...)
   511  	httpClient, endpoint, err := httptransport.NewClient(ctx, clientOpts...)
   512  	if err != nil {
   513  		return nil, err
   514  	}
   515  
   516  	callOpts := defaultRESTCallOptions()
   517  	c := &restClient{
   518  		endpoint:    endpoint,
   519  		httpClient:  httpClient,
   520  		CallOptions: &callOpts,
   521  	}
   522  	c.setGoogleClientInfo()
   523  
   524  	return &Client{internalClient: c, CallOptions: callOpts}, nil
   525  }
   526  
   527  func defaultRESTClientOptions() []option.ClientOption {
   528  	return []option.ClientOption{
   529  		internaloption.WithDefaultEndpoint("https://secretmanager.googleapis.com"),
   530  		internaloption.WithDefaultEndpointTemplate("https://secretmanager.UNIVERSE_DOMAIN"),
   531  		internaloption.WithDefaultMTLSEndpoint("https://secretmanager.mtls.googleapis.com"),
   532  		internaloption.WithDefaultUniverseDomain("googleapis.com"),
   533  		internaloption.WithDefaultAudience("https://secretmanager.googleapis.com/"),
   534  		internaloption.WithDefaultScopes(DefaultAuthScopes()...),
   535  	}
   536  }
   537  
   538  // setGoogleClientInfo sets the name and version of the application in
   539  // the `x-goog-api-client` header passed on each request. Intended for
   540  // use by Google-written clients.
   541  func (c *restClient) setGoogleClientInfo(keyval ...string) {
   542  	kv := append([]string{"gl-go", gax.GoVersion}, keyval...)
   543  	kv = append(kv, "gapic", getVersionClient(), "gax", gax.Version, "rest", "UNKNOWN")
   544  	c.xGoogHeaders = []string{"x-goog-api-client", gax.XGoogHeader(kv...)}
   545  }
   546  
   547  // Close closes the connection to the API service. The user should invoke this when
   548  // the client is no longer required.
   549  func (c *restClient) Close() error {
   550  	// Replace httpClient with nil to force cleanup.
   551  	c.httpClient = nil
   552  	return nil
   553  }
   554  
   555  // Connection returns a connection to the API service.
   556  //
   557  // Deprecated: This method always returns nil.
   558  func (c *restClient) Connection() *grpc.ClientConn {
   559  	return nil
   560  }
   561  func (c *gRPCClient) ListSecrets(ctx context.Context, req *secretmanagerpb.ListSecretsRequest, opts ...gax.CallOption) *SecretIterator {
   562  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))}
   563  
   564  	hds = append(c.xGoogHeaders, hds...)
   565  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   566  	opts = append((*c.CallOptions).ListSecrets[0:len((*c.CallOptions).ListSecrets):len((*c.CallOptions).ListSecrets)], opts...)
   567  	it := &SecretIterator{}
   568  	req = proto.Clone(req).(*secretmanagerpb.ListSecretsRequest)
   569  	it.InternalFetch = func(pageSize int, pageToken string) ([]*secretmanagerpb.Secret, string, error) {
   570  		resp := &secretmanagerpb.ListSecretsResponse{}
   571  		if pageToken != "" {
   572  			req.PageToken = pageToken
   573  		}
   574  		if pageSize > math.MaxInt32 {
   575  			req.PageSize = math.MaxInt32
   576  		} else if pageSize != 0 {
   577  			req.PageSize = int32(pageSize)
   578  		}
   579  		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   580  			var err error
   581  			resp, err = c.client.ListSecrets(ctx, req, settings.GRPC...)
   582  			return err
   583  		}, opts...)
   584  		if err != nil {
   585  			return nil, "", err
   586  		}
   587  
   588  		it.Response = resp
   589  		return resp.GetSecrets(), resp.GetNextPageToken(), nil
   590  	}
   591  	fetch := func(pageSize int, pageToken string) (string, error) {
   592  		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
   593  		if err != nil {
   594  			return "", err
   595  		}
   596  		it.items = append(it.items, items...)
   597  		return nextPageToken, nil
   598  	}
   599  
   600  	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
   601  	it.pageInfo.MaxSize = int(req.GetPageSize())
   602  	it.pageInfo.Token = req.GetPageToken()
   603  
   604  	return it
   605  }
   606  
   607  func (c *gRPCClient) CreateSecret(ctx context.Context, req *secretmanagerpb.CreateSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
   608  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))}
   609  
   610  	hds = append(c.xGoogHeaders, hds...)
   611  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   612  	opts = append((*c.CallOptions).CreateSecret[0:len((*c.CallOptions).CreateSecret):len((*c.CallOptions).CreateSecret)], opts...)
   613  	var resp *secretmanagerpb.Secret
   614  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   615  		var err error
   616  		resp, err = c.client.CreateSecret(ctx, req, settings.GRPC...)
   617  		return err
   618  	}, opts...)
   619  	if err != nil {
   620  		return nil, err
   621  	}
   622  	return resp, nil
   623  }
   624  
   625  func (c *gRPCClient) AddSecretVersion(ctx context.Context, req *secretmanagerpb.AddSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   626  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))}
   627  
   628  	hds = append(c.xGoogHeaders, hds...)
   629  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   630  	opts = append((*c.CallOptions).AddSecretVersion[0:len((*c.CallOptions).AddSecretVersion):len((*c.CallOptions).AddSecretVersion)], opts...)
   631  	var resp *secretmanagerpb.SecretVersion
   632  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   633  		var err error
   634  		resp, err = c.client.AddSecretVersion(ctx, req, settings.GRPC...)
   635  		return err
   636  	}, opts...)
   637  	if err != nil {
   638  		return nil, err
   639  	}
   640  	return resp, nil
   641  }
   642  
   643  func (c *gRPCClient) GetSecret(ctx context.Context, req *secretmanagerpb.GetSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
   644  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   645  
   646  	hds = append(c.xGoogHeaders, hds...)
   647  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   648  	opts = append((*c.CallOptions).GetSecret[0:len((*c.CallOptions).GetSecret):len((*c.CallOptions).GetSecret)], opts...)
   649  	var resp *secretmanagerpb.Secret
   650  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   651  		var err error
   652  		resp, err = c.client.GetSecret(ctx, req, settings.GRPC...)
   653  		return err
   654  	}, opts...)
   655  	if err != nil {
   656  		return nil, err
   657  	}
   658  	return resp, nil
   659  }
   660  
   661  func (c *gRPCClient) UpdateSecret(ctx context.Context, req *secretmanagerpb.UpdateSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
   662  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "secret.name", url.QueryEscape(req.GetSecret().GetName()))}
   663  
   664  	hds = append(c.xGoogHeaders, hds...)
   665  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   666  	opts = append((*c.CallOptions).UpdateSecret[0:len((*c.CallOptions).UpdateSecret):len((*c.CallOptions).UpdateSecret)], opts...)
   667  	var resp *secretmanagerpb.Secret
   668  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   669  		var err error
   670  		resp, err = c.client.UpdateSecret(ctx, req, settings.GRPC...)
   671  		return err
   672  	}, opts...)
   673  	if err != nil {
   674  		return nil, err
   675  	}
   676  	return resp, nil
   677  }
   678  
   679  func (c *gRPCClient) DeleteSecret(ctx context.Context, req *secretmanagerpb.DeleteSecretRequest, opts ...gax.CallOption) error {
   680  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   681  
   682  	hds = append(c.xGoogHeaders, hds...)
   683  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   684  	opts = append((*c.CallOptions).DeleteSecret[0:len((*c.CallOptions).DeleteSecret):len((*c.CallOptions).DeleteSecret)], opts...)
   685  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   686  		var err error
   687  		_, err = c.client.DeleteSecret(ctx, req, settings.GRPC...)
   688  		return err
   689  	}, opts...)
   690  	return err
   691  }
   692  
   693  func (c *gRPCClient) ListSecretVersions(ctx context.Context, req *secretmanagerpb.ListSecretVersionsRequest, opts ...gax.CallOption) *SecretVersionIterator {
   694  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))}
   695  
   696  	hds = append(c.xGoogHeaders, hds...)
   697  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   698  	opts = append((*c.CallOptions).ListSecretVersions[0:len((*c.CallOptions).ListSecretVersions):len((*c.CallOptions).ListSecretVersions)], opts...)
   699  	it := &SecretVersionIterator{}
   700  	req = proto.Clone(req).(*secretmanagerpb.ListSecretVersionsRequest)
   701  	it.InternalFetch = func(pageSize int, pageToken string) ([]*secretmanagerpb.SecretVersion, string, error) {
   702  		resp := &secretmanagerpb.ListSecretVersionsResponse{}
   703  		if pageToken != "" {
   704  			req.PageToken = pageToken
   705  		}
   706  		if pageSize > math.MaxInt32 {
   707  			req.PageSize = math.MaxInt32
   708  		} else if pageSize != 0 {
   709  			req.PageSize = int32(pageSize)
   710  		}
   711  		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   712  			var err error
   713  			resp, err = c.client.ListSecretVersions(ctx, req, settings.GRPC...)
   714  			return err
   715  		}, opts...)
   716  		if err != nil {
   717  			return nil, "", err
   718  		}
   719  
   720  		it.Response = resp
   721  		return resp.GetVersions(), resp.GetNextPageToken(), nil
   722  	}
   723  	fetch := func(pageSize int, pageToken string) (string, error) {
   724  		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
   725  		if err != nil {
   726  			return "", err
   727  		}
   728  		it.items = append(it.items, items...)
   729  		return nextPageToken, nil
   730  	}
   731  
   732  	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
   733  	it.pageInfo.MaxSize = int(req.GetPageSize())
   734  	it.pageInfo.Token = req.GetPageToken()
   735  
   736  	return it
   737  }
   738  
   739  func (c *gRPCClient) GetSecretVersion(ctx context.Context, req *secretmanagerpb.GetSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   740  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   741  
   742  	hds = append(c.xGoogHeaders, hds...)
   743  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   744  	opts = append((*c.CallOptions).GetSecretVersion[0:len((*c.CallOptions).GetSecretVersion):len((*c.CallOptions).GetSecretVersion)], opts...)
   745  	var resp *secretmanagerpb.SecretVersion
   746  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   747  		var err error
   748  		resp, err = c.client.GetSecretVersion(ctx, req, settings.GRPC...)
   749  		return err
   750  	}, opts...)
   751  	if err != nil {
   752  		return nil, err
   753  	}
   754  	return resp, nil
   755  }
   756  
   757  func (c *gRPCClient) AccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error) {
   758  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   759  
   760  	hds = append(c.xGoogHeaders, hds...)
   761  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   762  	opts = append((*c.CallOptions).AccessSecretVersion[0:len((*c.CallOptions).AccessSecretVersion):len((*c.CallOptions).AccessSecretVersion)], opts...)
   763  	var resp *secretmanagerpb.AccessSecretVersionResponse
   764  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   765  		var err error
   766  		resp, err = c.client.AccessSecretVersion(ctx, req, settings.GRPC...)
   767  		return err
   768  	}, opts...)
   769  	if err != nil {
   770  		return nil, err
   771  	}
   772  	return resp, nil
   773  }
   774  
   775  func (c *gRPCClient) DisableSecretVersion(ctx context.Context, req *secretmanagerpb.DisableSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   776  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   777  
   778  	hds = append(c.xGoogHeaders, hds...)
   779  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   780  	opts = append((*c.CallOptions).DisableSecretVersion[0:len((*c.CallOptions).DisableSecretVersion):len((*c.CallOptions).DisableSecretVersion)], opts...)
   781  	var resp *secretmanagerpb.SecretVersion
   782  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   783  		var err error
   784  		resp, err = c.client.DisableSecretVersion(ctx, req, settings.GRPC...)
   785  		return err
   786  	}, opts...)
   787  	if err != nil {
   788  		return nil, err
   789  	}
   790  	return resp, nil
   791  }
   792  
   793  func (c *gRPCClient) EnableSecretVersion(ctx context.Context, req *secretmanagerpb.EnableSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   794  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   795  
   796  	hds = append(c.xGoogHeaders, hds...)
   797  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   798  	opts = append((*c.CallOptions).EnableSecretVersion[0:len((*c.CallOptions).EnableSecretVersion):len((*c.CallOptions).EnableSecretVersion)], opts...)
   799  	var resp *secretmanagerpb.SecretVersion
   800  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   801  		var err error
   802  		resp, err = c.client.EnableSecretVersion(ctx, req, settings.GRPC...)
   803  		return err
   804  	}, opts...)
   805  	if err != nil {
   806  		return nil, err
   807  	}
   808  	return resp, nil
   809  }
   810  
   811  func (c *gRPCClient) DestroySecretVersion(ctx context.Context, req *secretmanagerpb.DestroySecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
   812  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   813  
   814  	hds = append(c.xGoogHeaders, hds...)
   815  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   816  	opts = append((*c.CallOptions).DestroySecretVersion[0:len((*c.CallOptions).DestroySecretVersion):len((*c.CallOptions).DestroySecretVersion)], opts...)
   817  	var resp *secretmanagerpb.SecretVersion
   818  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   819  		var err error
   820  		resp, err = c.client.DestroySecretVersion(ctx, req, settings.GRPC...)
   821  		return err
   822  	}, opts...)
   823  	if err != nil {
   824  		return nil, err
   825  	}
   826  	return resp, nil
   827  }
   828  
   829  func (c *gRPCClient) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
   830  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "resource", url.QueryEscape(req.GetResource()))}
   831  
   832  	hds = append(c.xGoogHeaders, hds...)
   833  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   834  	opts = append((*c.CallOptions).SetIamPolicy[0:len((*c.CallOptions).SetIamPolicy):len((*c.CallOptions).SetIamPolicy)], opts...)
   835  	var resp *iampb.Policy
   836  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   837  		var err error
   838  		resp, err = c.client.SetIamPolicy(ctx, req, settings.GRPC...)
   839  		return err
   840  	}, opts...)
   841  	if err != nil {
   842  		return nil, err
   843  	}
   844  	return resp, nil
   845  }
   846  
   847  func (c *gRPCClient) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
   848  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "resource", url.QueryEscape(req.GetResource()))}
   849  
   850  	hds = append(c.xGoogHeaders, hds...)
   851  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   852  	opts = append((*c.CallOptions).GetIamPolicy[0:len((*c.CallOptions).GetIamPolicy):len((*c.CallOptions).GetIamPolicy)], opts...)
   853  	var resp *iampb.Policy
   854  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   855  		var err error
   856  		resp, err = c.client.GetIamPolicy(ctx, req, settings.GRPC...)
   857  		return err
   858  	}, opts...)
   859  	if err != nil {
   860  		return nil, err
   861  	}
   862  	return resp, nil
   863  }
   864  
   865  func (c *gRPCClient) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest, opts ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error) {
   866  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "resource", url.QueryEscape(req.GetResource()))}
   867  
   868  	hds = append(c.xGoogHeaders, hds...)
   869  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   870  	opts = append((*c.CallOptions).TestIamPermissions[0:len((*c.CallOptions).TestIamPermissions):len((*c.CallOptions).TestIamPermissions)], opts...)
   871  	var resp *iampb.TestIamPermissionsResponse
   872  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   873  		var err error
   874  		resp, err = c.client.TestIamPermissions(ctx, req, settings.GRPC...)
   875  		return err
   876  	}, opts...)
   877  	if err != nil {
   878  		return nil, err
   879  	}
   880  	return resp, nil
   881  }
   882  
   883  func (c *gRPCClient) GetLocation(ctx context.Context, req *locationpb.GetLocationRequest, opts ...gax.CallOption) (*locationpb.Location, error) {
   884  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   885  
   886  	hds = append(c.xGoogHeaders, hds...)
   887  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   888  	opts = append((*c.CallOptions).GetLocation[0:len((*c.CallOptions).GetLocation):len((*c.CallOptions).GetLocation)], opts...)
   889  	var resp *locationpb.Location
   890  	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   891  		var err error
   892  		resp, err = c.locationsClient.GetLocation(ctx, req, settings.GRPC...)
   893  		return err
   894  	}, opts...)
   895  	if err != nil {
   896  		return nil, err
   897  	}
   898  	return resp, nil
   899  }
   900  
   901  func (c *gRPCClient) ListLocations(ctx context.Context, req *locationpb.ListLocationsRequest, opts ...gax.CallOption) *LocationIterator {
   902  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
   903  
   904  	hds = append(c.xGoogHeaders, hds...)
   905  	ctx = gax.InsertMetadataIntoOutgoingContext(ctx, hds...)
   906  	opts = append((*c.CallOptions).ListLocations[0:len((*c.CallOptions).ListLocations):len((*c.CallOptions).ListLocations)], opts...)
   907  	it := &LocationIterator{}
   908  	req = proto.Clone(req).(*locationpb.ListLocationsRequest)
   909  	it.InternalFetch = func(pageSize int, pageToken string) ([]*locationpb.Location, string, error) {
   910  		resp := &locationpb.ListLocationsResponse{}
   911  		if pageToken != "" {
   912  			req.PageToken = pageToken
   913  		}
   914  		if pageSize > math.MaxInt32 {
   915  			req.PageSize = math.MaxInt32
   916  		} else if pageSize != 0 {
   917  			req.PageSize = int32(pageSize)
   918  		}
   919  		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   920  			var err error
   921  			resp, err = c.locationsClient.ListLocations(ctx, req, settings.GRPC...)
   922  			return err
   923  		}, opts...)
   924  		if err != nil {
   925  			return nil, "", err
   926  		}
   927  
   928  		it.Response = resp
   929  		return resp.GetLocations(), resp.GetNextPageToken(), nil
   930  	}
   931  	fetch := func(pageSize int, pageToken string) (string, error) {
   932  		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
   933  		if err != nil {
   934  			return "", err
   935  		}
   936  		it.items = append(it.items, items...)
   937  		return nextPageToken, nil
   938  	}
   939  
   940  	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
   941  	it.pageInfo.MaxSize = int(req.GetPageSize())
   942  	it.pageInfo.Token = req.GetPageToken()
   943  
   944  	return it
   945  }
   946  
   947  // ListSecrets lists Secrets.
   948  func (c *restClient) ListSecrets(ctx context.Context, req *secretmanagerpb.ListSecretsRequest, opts ...gax.CallOption) *SecretIterator {
   949  	it := &SecretIterator{}
   950  	req = proto.Clone(req).(*secretmanagerpb.ListSecretsRequest)
   951  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
   952  	it.InternalFetch = func(pageSize int, pageToken string) ([]*secretmanagerpb.Secret, string, error) {
   953  		resp := &secretmanagerpb.ListSecretsResponse{}
   954  		if pageToken != "" {
   955  			req.PageToken = pageToken
   956  		}
   957  		if pageSize > math.MaxInt32 {
   958  			req.PageSize = math.MaxInt32
   959  		} else if pageSize != 0 {
   960  			req.PageSize = int32(pageSize)
   961  		}
   962  		baseUrl, err := url.Parse(c.endpoint)
   963  		if err != nil {
   964  			return nil, "", err
   965  		}
   966  		baseUrl.Path += fmt.Sprintf("/v1beta2/%v/secrets", req.GetParent())
   967  
   968  		params := url.Values{}
   969  		params.Add("$alt", "json;enum-encoding=int")
   970  		if req.GetFilter() != "" {
   971  			params.Add("filter", fmt.Sprintf("%v", req.GetFilter()))
   972  		}
   973  		if req.GetPageSize() != 0 {
   974  			params.Add("pageSize", fmt.Sprintf("%v", req.GetPageSize()))
   975  		}
   976  		if req.GetPageToken() != "" {
   977  			params.Add("pageToken", fmt.Sprintf("%v", req.GetPageToken()))
   978  		}
   979  
   980  		baseUrl.RawQuery = params.Encode()
   981  
   982  		// Build HTTP headers from client and context metadata.
   983  		hds := append(c.xGoogHeaders, "Content-Type", "application/json")
   984  		headers := gax.BuildHeaders(ctx, hds...)
   985  		e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
   986  			if settings.Path != "" {
   987  				baseUrl.Path = settings.Path
   988  			}
   989  			httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
   990  			if err != nil {
   991  				return err
   992  			}
   993  			httpReq.Header = headers
   994  
   995  			httpRsp, err := c.httpClient.Do(httpReq)
   996  			if err != nil {
   997  				return err
   998  			}
   999  			defer httpRsp.Body.Close()
  1000  
  1001  			if err = googleapi.CheckResponse(httpRsp); err != nil {
  1002  				return err
  1003  			}
  1004  
  1005  			buf, err := io.ReadAll(httpRsp.Body)
  1006  			if err != nil {
  1007  				return err
  1008  			}
  1009  
  1010  			if err := unm.Unmarshal(buf, resp); err != nil {
  1011  				return err
  1012  			}
  1013  
  1014  			return nil
  1015  		}, opts...)
  1016  		if e != nil {
  1017  			return nil, "", e
  1018  		}
  1019  		it.Response = resp
  1020  		return resp.GetSecrets(), resp.GetNextPageToken(), nil
  1021  	}
  1022  
  1023  	fetch := func(pageSize int, pageToken string) (string, error) {
  1024  		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
  1025  		if err != nil {
  1026  			return "", err
  1027  		}
  1028  		it.items = append(it.items, items...)
  1029  		return nextPageToken, nil
  1030  	}
  1031  
  1032  	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
  1033  	it.pageInfo.MaxSize = int(req.GetPageSize())
  1034  	it.pageInfo.Token = req.GetPageToken()
  1035  
  1036  	return it
  1037  }
  1038  
  1039  // CreateSecret creates a new Secret
  1040  // containing no
  1041  // SecretVersions.
  1042  func (c *restClient) CreateSecret(ctx context.Context, req *secretmanagerpb.CreateSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
  1043  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1044  	body := req.GetSecret()
  1045  	jsonReq, err := m.Marshal(body)
  1046  	if err != nil {
  1047  		return nil, err
  1048  	}
  1049  
  1050  	baseUrl, err := url.Parse(c.endpoint)
  1051  	if err != nil {
  1052  		return nil, err
  1053  	}
  1054  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v/secrets", req.GetParent())
  1055  
  1056  	params := url.Values{}
  1057  	params.Add("$alt", "json;enum-encoding=int")
  1058  	params.Add("secretId", fmt.Sprintf("%v", req.GetSecretId()))
  1059  
  1060  	baseUrl.RawQuery = params.Encode()
  1061  
  1062  	// Build HTTP headers from client and context metadata.
  1063  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))}
  1064  
  1065  	hds = append(c.xGoogHeaders, hds...)
  1066  	hds = append(hds, "Content-Type", "application/json")
  1067  	headers := gax.BuildHeaders(ctx, hds...)
  1068  	opts = append((*c.CallOptions).CreateSecret[0:len((*c.CallOptions).CreateSecret):len((*c.CallOptions).CreateSecret)], opts...)
  1069  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1070  	resp := &secretmanagerpb.Secret{}
  1071  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1072  		if settings.Path != "" {
  1073  			baseUrl.Path = settings.Path
  1074  		}
  1075  		httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
  1076  		if err != nil {
  1077  			return err
  1078  		}
  1079  		httpReq = httpReq.WithContext(ctx)
  1080  		httpReq.Header = headers
  1081  
  1082  		httpRsp, err := c.httpClient.Do(httpReq)
  1083  		if err != nil {
  1084  			return err
  1085  		}
  1086  		defer httpRsp.Body.Close()
  1087  
  1088  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1089  			return err
  1090  		}
  1091  
  1092  		buf, err := io.ReadAll(httpRsp.Body)
  1093  		if err != nil {
  1094  			return err
  1095  		}
  1096  
  1097  		if err := unm.Unmarshal(buf, resp); err != nil {
  1098  			return err
  1099  		}
  1100  
  1101  		return nil
  1102  	}, opts...)
  1103  	if e != nil {
  1104  		return nil, e
  1105  	}
  1106  	return resp, nil
  1107  }
  1108  
  1109  // AddSecretVersion creates a new
  1110  // SecretVersion
  1111  // containing secret data and attaches it to an existing
  1112  // Secret.
  1113  func (c *restClient) AddSecretVersion(ctx context.Context, req *secretmanagerpb.AddSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
  1114  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1115  	jsonReq, err := m.Marshal(req)
  1116  	if err != nil {
  1117  		return nil, err
  1118  	}
  1119  
  1120  	baseUrl, err := url.Parse(c.endpoint)
  1121  	if err != nil {
  1122  		return nil, err
  1123  	}
  1124  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:addVersion", req.GetParent())
  1125  
  1126  	params := url.Values{}
  1127  	params.Add("$alt", "json;enum-encoding=int")
  1128  
  1129  	baseUrl.RawQuery = params.Encode()
  1130  
  1131  	// Build HTTP headers from client and context metadata.
  1132  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))}
  1133  
  1134  	hds = append(c.xGoogHeaders, hds...)
  1135  	hds = append(hds, "Content-Type", "application/json")
  1136  	headers := gax.BuildHeaders(ctx, hds...)
  1137  	opts = append((*c.CallOptions).AddSecretVersion[0:len((*c.CallOptions).AddSecretVersion):len((*c.CallOptions).AddSecretVersion)], opts...)
  1138  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1139  	resp := &secretmanagerpb.SecretVersion{}
  1140  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1141  		if settings.Path != "" {
  1142  			baseUrl.Path = settings.Path
  1143  		}
  1144  		httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
  1145  		if err != nil {
  1146  			return err
  1147  		}
  1148  		httpReq = httpReq.WithContext(ctx)
  1149  		httpReq.Header = headers
  1150  
  1151  		httpRsp, err := c.httpClient.Do(httpReq)
  1152  		if err != nil {
  1153  			return err
  1154  		}
  1155  		defer httpRsp.Body.Close()
  1156  
  1157  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1158  			return err
  1159  		}
  1160  
  1161  		buf, err := io.ReadAll(httpRsp.Body)
  1162  		if err != nil {
  1163  			return err
  1164  		}
  1165  
  1166  		if err := unm.Unmarshal(buf, resp); err != nil {
  1167  			return err
  1168  		}
  1169  
  1170  		return nil
  1171  	}, opts...)
  1172  	if e != nil {
  1173  		return nil, e
  1174  	}
  1175  	return resp, nil
  1176  }
  1177  
  1178  // GetSecret gets metadata for a given
  1179  // Secret.
  1180  func (c *restClient) GetSecret(ctx context.Context, req *secretmanagerpb.GetSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
  1181  	baseUrl, err := url.Parse(c.endpoint)
  1182  	if err != nil {
  1183  		return nil, err
  1184  	}
  1185  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v", req.GetName())
  1186  
  1187  	params := url.Values{}
  1188  	params.Add("$alt", "json;enum-encoding=int")
  1189  
  1190  	baseUrl.RawQuery = params.Encode()
  1191  
  1192  	// Build HTTP headers from client and context metadata.
  1193  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  1194  
  1195  	hds = append(c.xGoogHeaders, hds...)
  1196  	hds = append(hds, "Content-Type", "application/json")
  1197  	headers := gax.BuildHeaders(ctx, hds...)
  1198  	opts = append((*c.CallOptions).GetSecret[0:len((*c.CallOptions).GetSecret):len((*c.CallOptions).GetSecret)], opts...)
  1199  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1200  	resp := &secretmanagerpb.Secret{}
  1201  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1202  		if settings.Path != "" {
  1203  			baseUrl.Path = settings.Path
  1204  		}
  1205  		httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
  1206  		if err != nil {
  1207  			return err
  1208  		}
  1209  		httpReq = httpReq.WithContext(ctx)
  1210  		httpReq.Header = headers
  1211  
  1212  		httpRsp, err := c.httpClient.Do(httpReq)
  1213  		if err != nil {
  1214  			return err
  1215  		}
  1216  		defer httpRsp.Body.Close()
  1217  
  1218  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1219  			return err
  1220  		}
  1221  
  1222  		buf, err := io.ReadAll(httpRsp.Body)
  1223  		if err != nil {
  1224  			return err
  1225  		}
  1226  
  1227  		if err := unm.Unmarshal(buf, resp); err != nil {
  1228  			return err
  1229  		}
  1230  
  1231  		return nil
  1232  	}, opts...)
  1233  	if e != nil {
  1234  		return nil, e
  1235  	}
  1236  	return resp, nil
  1237  }
  1238  
  1239  // UpdateSecret updates metadata of an existing
  1240  // Secret.
  1241  func (c *restClient) UpdateSecret(ctx context.Context, req *secretmanagerpb.UpdateSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
  1242  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1243  	body := req.GetSecret()
  1244  	jsonReq, err := m.Marshal(body)
  1245  	if err != nil {
  1246  		return nil, err
  1247  	}
  1248  
  1249  	baseUrl, err := url.Parse(c.endpoint)
  1250  	if err != nil {
  1251  		return nil, err
  1252  	}
  1253  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v", req.GetSecret().GetName())
  1254  
  1255  	params := url.Values{}
  1256  	params.Add("$alt", "json;enum-encoding=int")
  1257  	if req.GetUpdateMask() != nil {
  1258  		updateMask, err := protojson.Marshal(req.GetUpdateMask())
  1259  		if err != nil {
  1260  			return nil, err
  1261  		}
  1262  		params.Add("updateMask", string(updateMask[1:len(updateMask)-1]))
  1263  	}
  1264  
  1265  	baseUrl.RawQuery = params.Encode()
  1266  
  1267  	// Build HTTP headers from client and context metadata.
  1268  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "secret.name", url.QueryEscape(req.GetSecret().GetName()))}
  1269  
  1270  	hds = append(c.xGoogHeaders, hds...)
  1271  	hds = append(hds, "Content-Type", "application/json")
  1272  	headers := gax.BuildHeaders(ctx, hds...)
  1273  	opts = append((*c.CallOptions).UpdateSecret[0:len((*c.CallOptions).UpdateSecret):len((*c.CallOptions).UpdateSecret)], opts...)
  1274  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1275  	resp := &secretmanagerpb.Secret{}
  1276  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1277  		if settings.Path != "" {
  1278  			baseUrl.Path = settings.Path
  1279  		}
  1280  		httpReq, err := http.NewRequest("PATCH", baseUrl.String(), bytes.NewReader(jsonReq))
  1281  		if err != nil {
  1282  			return err
  1283  		}
  1284  		httpReq = httpReq.WithContext(ctx)
  1285  		httpReq.Header = headers
  1286  
  1287  		httpRsp, err := c.httpClient.Do(httpReq)
  1288  		if err != nil {
  1289  			return err
  1290  		}
  1291  		defer httpRsp.Body.Close()
  1292  
  1293  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1294  			return err
  1295  		}
  1296  
  1297  		buf, err := io.ReadAll(httpRsp.Body)
  1298  		if err != nil {
  1299  			return err
  1300  		}
  1301  
  1302  		if err := unm.Unmarshal(buf, resp); err != nil {
  1303  			return err
  1304  		}
  1305  
  1306  		return nil
  1307  	}, opts...)
  1308  	if e != nil {
  1309  		return nil, e
  1310  	}
  1311  	return resp, nil
  1312  }
  1313  
  1314  // DeleteSecret deletes a Secret.
  1315  func (c *restClient) DeleteSecret(ctx context.Context, req *secretmanagerpb.DeleteSecretRequest, opts ...gax.CallOption) error {
  1316  	baseUrl, err := url.Parse(c.endpoint)
  1317  	if err != nil {
  1318  		return err
  1319  	}
  1320  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v", req.GetName())
  1321  
  1322  	params := url.Values{}
  1323  	params.Add("$alt", "json;enum-encoding=int")
  1324  	if req.GetEtag() != "" {
  1325  		params.Add("etag", fmt.Sprintf("%v", req.GetEtag()))
  1326  	}
  1327  
  1328  	baseUrl.RawQuery = params.Encode()
  1329  
  1330  	// Build HTTP headers from client and context metadata.
  1331  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  1332  
  1333  	hds = append(c.xGoogHeaders, hds...)
  1334  	hds = append(hds, "Content-Type", "application/json")
  1335  	headers := gax.BuildHeaders(ctx, hds...)
  1336  	return gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1337  		if settings.Path != "" {
  1338  			baseUrl.Path = settings.Path
  1339  		}
  1340  		httpReq, err := http.NewRequest("DELETE", baseUrl.String(), nil)
  1341  		if err != nil {
  1342  			return err
  1343  		}
  1344  		httpReq = httpReq.WithContext(ctx)
  1345  		httpReq.Header = headers
  1346  
  1347  		httpRsp, err := c.httpClient.Do(httpReq)
  1348  		if err != nil {
  1349  			return err
  1350  		}
  1351  		defer httpRsp.Body.Close()
  1352  
  1353  		// Returns nil if there is no error, otherwise wraps
  1354  		// the response code and body into a non-nil error
  1355  		return googleapi.CheckResponse(httpRsp)
  1356  	}, opts...)
  1357  }
  1358  
  1359  // ListSecretVersions lists SecretVersions.
  1360  // This call does not return secret data.
  1361  func (c *restClient) ListSecretVersions(ctx context.Context, req *secretmanagerpb.ListSecretVersionsRequest, opts ...gax.CallOption) *SecretVersionIterator {
  1362  	it := &SecretVersionIterator{}
  1363  	req = proto.Clone(req).(*secretmanagerpb.ListSecretVersionsRequest)
  1364  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1365  	it.InternalFetch = func(pageSize int, pageToken string) ([]*secretmanagerpb.SecretVersion, string, error) {
  1366  		resp := &secretmanagerpb.ListSecretVersionsResponse{}
  1367  		if pageToken != "" {
  1368  			req.PageToken = pageToken
  1369  		}
  1370  		if pageSize > math.MaxInt32 {
  1371  			req.PageSize = math.MaxInt32
  1372  		} else if pageSize != 0 {
  1373  			req.PageSize = int32(pageSize)
  1374  		}
  1375  		baseUrl, err := url.Parse(c.endpoint)
  1376  		if err != nil {
  1377  			return nil, "", err
  1378  		}
  1379  		baseUrl.Path += fmt.Sprintf("/v1beta2/%v/versions", req.GetParent())
  1380  
  1381  		params := url.Values{}
  1382  		params.Add("$alt", "json;enum-encoding=int")
  1383  		if req.GetFilter() != "" {
  1384  			params.Add("filter", fmt.Sprintf("%v", req.GetFilter()))
  1385  		}
  1386  		if req.GetPageSize() != 0 {
  1387  			params.Add("pageSize", fmt.Sprintf("%v", req.GetPageSize()))
  1388  		}
  1389  		if req.GetPageToken() != "" {
  1390  			params.Add("pageToken", fmt.Sprintf("%v", req.GetPageToken()))
  1391  		}
  1392  
  1393  		baseUrl.RawQuery = params.Encode()
  1394  
  1395  		// Build HTTP headers from client and context metadata.
  1396  		hds := append(c.xGoogHeaders, "Content-Type", "application/json")
  1397  		headers := gax.BuildHeaders(ctx, hds...)
  1398  		e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1399  			if settings.Path != "" {
  1400  				baseUrl.Path = settings.Path
  1401  			}
  1402  			httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
  1403  			if err != nil {
  1404  				return err
  1405  			}
  1406  			httpReq.Header = headers
  1407  
  1408  			httpRsp, err := c.httpClient.Do(httpReq)
  1409  			if err != nil {
  1410  				return err
  1411  			}
  1412  			defer httpRsp.Body.Close()
  1413  
  1414  			if err = googleapi.CheckResponse(httpRsp); err != nil {
  1415  				return err
  1416  			}
  1417  
  1418  			buf, err := io.ReadAll(httpRsp.Body)
  1419  			if err != nil {
  1420  				return err
  1421  			}
  1422  
  1423  			if err := unm.Unmarshal(buf, resp); err != nil {
  1424  				return err
  1425  			}
  1426  
  1427  			return nil
  1428  		}, opts...)
  1429  		if e != nil {
  1430  			return nil, "", e
  1431  		}
  1432  		it.Response = resp
  1433  		return resp.GetVersions(), resp.GetNextPageToken(), nil
  1434  	}
  1435  
  1436  	fetch := func(pageSize int, pageToken string) (string, error) {
  1437  		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
  1438  		if err != nil {
  1439  			return "", err
  1440  		}
  1441  		it.items = append(it.items, items...)
  1442  		return nextPageToken, nil
  1443  	}
  1444  
  1445  	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
  1446  	it.pageInfo.MaxSize = int(req.GetPageSize())
  1447  	it.pageInfo.Token = req.GetPageToken()
  1448  
  1449  	return it
  1450  }
  1451  
  1452  // GetSecretVersion gets metadata for a
  1453  // SecretVersion.
  1454  //
  1455  // projects/*/secrets/*/versions/latest is an alias to the most recently
  1456  // created SecretVersion.
  1457  func (c *restClient) GetSecretVersion(ctx context.Context, req *secretmanagerpb.GetSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
  1458  	baseUrl, err := url.Parse(c.endpoint)
  1459  	if err != nil {
  1460  		return nil, err
  1461  	}
  1462  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v", req.GetName())
  1463  
  1464  	params := url.Values{}
  1465  	params.Add("$alt", "json;enum-encoding=int")
  1466  
  1467  	baseUrl.RawQuery = params.Encode()
  1468  
  1469  	// Build HTTP headers from client and context metadata.
  1470  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  1471  
  1472  	hds = append(c.xGoogHeaders, hds...)
  1473  	hds = append(hds, "Content-Type", "application/json")
  1474  	headers := gax.BuildHeaders(ctx, hds...)
  1475  	opts = append((*c.CallOptions).GetSecretVersion[0:len((*c.CallOptions).GetSecretVersion):len((*c.CallOptions).GetSecretVersion)], opts...)
  1476  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1477  	resp := &secretmanagerpb.SecretVersion{}
  1478  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1479  		if settings.Path != "" {
  1480  			baseUrl.Path = settings.Path
  1481  		}
  1482  		httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
  1483  		if err != nil {
  1484  			return err
  1485  		}
  1486  		httpReq = httpReq.WithContext(ctx)
  1487  		httpReq.Header = headers
  1488  
  1489  		httpRsp, err := c.httpClient.Do(httpReq)
  1490  		if err != nil {
  1491  			return err
  1492  		}
  1493  		defer httpRsp.Body.Close()
  1494  
  1495  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1496  			return err
  1497  		}
  1498  
  1499  		buf, err := io.ReadAll(httpRsp.Body)
  1500  		if err != nil {
  1501  			return err
  1502  		}
  1503  
  1504  		if err := unm.Unmarshal(buf, resp); err != nil {
  1505  			return err
  1506  		}
  1507  
  1508  		return nil
  1509  	}, opts...)
  1510  	if e != nil {
  1511  		return nil, e
  1512  	}
  1513  	return resp, nil
  1514  }
  1515  
  1516  // AccessSecretVersion accesses a
  1517  // SecretVersion. This
  1518  // call returns the secret data.
  1519  //
  1520  // projects/*/secrets/*/versions/latest is an alias to the most recently
  1521  // created SecretVersion.
  1522  func (c *restClient) AccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error) {
  1523  	baseUrl, err := url.Parse(c.endpoint)
  1524  	if err != nil {
  1525  		return nil, err
  1526  	}
  1527  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:access", req.GetName())
  1528  
  1529  	params := url.Values{}
  1530  	params.Add("$alt", "json;enum-encoding=int")
  1531  
  1532  	baseUrl.RawQuery = params.Encode()
  1533  
  1534  	// Build HTTP headers from client and context metadata.
  1535  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  1536  
  1537  	hds = append(c.xGoogHeaders, hds...)
  1538  	hds = append(hds, "Content-Type", "application/json")
  1539  	headers := gax.BuildHeaders(ctx, hds...)
  1540  	opts = append((*c.CallOptions).AccessSecretVersion[0:len((*c.CallOptions).AccessSecretVersion):len((*c.CallOptions).AccessSecretVersion)], opts...)
  1541  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1542  	resp := &secretmanagerpb.AccessSecretVersionResponse{}
  1543  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1544  		if settings.Path != "" {
  1545  			baseUrl.Path = settings.Path
  1546  		}
  1547  		httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
  1548  		if err != nil {
  1549  			return err
  1550  		}
  1551  		httpReq = httpReq.WithContext(ctx)
  1552  		httpReq.Header = headers
  1553  
  1554  		httpRsp, err := c.httpClient.Do(httpReq)
  1555  		if err != nil {
  1556  			return err
  1557  		}
  1558  		defer httpRsp.Body.Close()
  1559  
  1560  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1561  			return err
  1562  		}
  1563  
  1564  		buf, err := io.ReadAll(httpRsp.Body)
  1565  		if err != nil {
  1566  			return err
  1567  		}
  1568  
  1569  		if err := unm.Unmarshal(buf, resp); err != nil {
  1570  			return err
  1571  		}
  1572  
  1573  		return nil
  1574  	}, opts...)
  1575  	if e != nil {
  1576  		return nil, e
  1577  	}
  1578  	return resp, nil
  1579  }
  1580  
  1581  // DisableSecretVersion disables a
  1582  // SecretVersion.
  1583  //
  1584  // Sets the state of
  1585  // the SecretVersion to
  1586  // DISABLED.
  1587  func (c *restClient) DisableSecretVersion(ctx context.Context, req *secretmanagerpb.DisableSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
  1588  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1589  	jsonReq, err := m.Marshal(req)
  1590  	if err != nil {
  1591  		return nil, err
  1592  	}
  1593  
  1594  	baseUrl, err := url.Parse(c.endpoint)
  1595  	if err != nil {
  1596  		return nil, err
  1597  	}
  1598  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:disable", req.GetName())
  1599  
  1600  	params := url.Values{}
  1601  	params.Add("$alt", "json;enum-encoding=int")
  1602  
  1603  	baseUrl.RawQuery = params.Encode()
  1604  
  1605  	// Build HTTP headers from client and context metadata.
  1606  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  1607  
  1608  	hds = append(c.xGoogHeaders, hds...)
  1609  	hds = append(hds, "Content-Type", "application/json")
  1610  	headers := gax.BuildHeaders(ctx, hds...)
  1611  	opts = append((*c.CallOptions).DisableSecretVersion[0:len((*c.CallOptions).DisableSecretVersion):len((*c.CallOptions).DisableSecretVersion)], opts...)
  1612  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1613  	resp := &secretmanagerpb.SecretVersion{}
  1614  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1615  		if settings.Path != "" {
  1616  			baseUrl.Path = settings.Path
  1617  		}
  1618  		httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
  1619  		if err != nil {
  1620  			return err
  1621  		}
  1622  		httpReq = httpReq.WithContext(ctx)
  1623  		httpReq.Header = headers
  1624  
  1625  		httpRsp, err := c.httpClient.Do(httpReq)
  1626  		if err != nil {
  1627  			return err
  1628  		}
  1629  		defer httpRsp.Body.Close()
  1630  
  1631  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1632  			return err
  1633  		}
  1634  
  1635  		buf, err := io.ReadAll(httpRsp.Body)
  1636  		if err != nil {
  1637  			return err
  1638  		}
  1639  
  1640  		if err := unm.Unmarshal(buf, resp); err != nil {
  1641  			return err
  1642  		}
  1643  
  1644  		return nil
  1645  	}, opts...)
  1646  	if e != nil {
  1647  		return nil, e
  1648  	}
  1649  	return resp, nil
  1650  }
  1651  
  1652  // EnableSecretVersion enables a
  1653  // SecretVersion.
  1654  //
  1655  // Sets the state of
  1656  // the SecretVersion to
  1657  // ENABLED.
  1658  func (c *restClient) EnableSecretVersion(ctx context.Context, req *secretmanagerpb.EnableSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
  1659  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1660  	jsonReq, err := m.Marshal(req)
  1661  	if err != nil {
  1662  		return nil, err
  1663  	}
  1664  
  1665  	baseUrl, err := url.Parse(c.endpoint)
  1666  	if err != nil {
  1667  		return nil, err
  1668  	}
  1669  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:enable", req.GetName())
  1670  
  1671  	params := url.Values{}
  1672  	params.Add("$alt", "json;enum-encoding=int")
  1673  
  1674  	baseUrl.RawQuery = params.Encode()
  1675  
  1676  	// Build HTTP headers from client and context metadata.
  1677  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  1678  
  1679  	hds = append(c.xGoogHeaders, hds...)
  1680  	hds = append(hds, "Content-Type", "application/json")
  1681  	headers := gax.BuildHeaders(ctx, hds...)
  1682  	opts = append((*c.CallOptions).EnableSecretVersion[0:len((*c.CallOptions).EnableSecretVersion):len((*c.CallOptions).EnableSecretVersion)], opts...)
  1683  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1684  	resp := &secretmanagerpb.SecretVersion{}
  1685  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1686  		if settings.Path != "" {
  1687  			baseUrl.Path = settings.Path
  1688  		}
  1689  		httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
  1690  		if err != nil {
  1691  			return err
  1692  		}
  1693  		httpReq = httpReq.WithContext(ctx)
  1694  		httpReq.Header = headers
  1695  
  1696  		httpRsp, err := c.httpClient.Do(httpReq)
  1697  		if err != nil {
  1698  			return err
  1699  		}
  1700  		defer httpRsp.Body.Close()
  1701  
  1702  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1703  			return err
  1704  		}
  1705  
  1706  		buf, err := io.ReadAll(httpRsp.Body)
  1707  		if err != nil {
  1708  			return err
  1709  		}
  1710  
  1711  		if err := unm.Unmarshal(buf, resp); err != nil {
  1712  			return err
  1713  		}
  1714  
  1715  		return nil
  1716  	}, opts...)
  1717  	if e != nil {
  1718  		return nil, e
  1719  	}
  1720  	return resp, nil
  1721  }
  1722  
  1723  // DestroySecretVersion destroys a
  1724  // SecretVersion.
  1725  //
  1726  // Sets the state of
  1727  // the SecretVersion to
  1728  // DESTROYED
  1729  // and irrevocably destroys the secret data.
  1730  func (c *restClient) DestroySecretVersion(ctx context.Context, req *secretmanagerpb.DestroySecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error) {
  1731  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1732  	jsonReq, err := m.Marshal(req)
  1733  	if err != nil {
  1734  		return nil, err
  1735  	}
  1736  
  1737  	baseUrl, err := url.Parse(c.endpoint)
  1738  	if err != nil {
  1739  		return nil, err
  1740  	}
  1741  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:destroy", req.GetName())
  1742  
  1743  	params := url.Values{}
  1744  	params.Add("$alt", "json;enum-encoding=int")
  1745  
  1746  	baseUrl.RawQuery = params.Encode()
  1747  
  1748  	// Build HTTP headers from client and context metadata.
  1749  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  1750  
  1751  	hds = append(c.xGoogHeaders, hds...)
  1752  	hds = append(hds, "Content-Type", "application/json")
  1753  	headers := gax.BuildHeaders(ctx, hds...)
  1754  	opts = append((*c.CallOptions).DestroySecretVersion[0:len((*c.CallOptions).DestroySecretVersion):len((*c.CallOptions).DestroySecretVersion)], opts...)
  1755  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1756  	resp := &secretmanagerpb.SecretVersion{}
  1757  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1758  		if settings.Path != "" {
  1759  			baseUrl.Path = settings.Path
  1760  		}
  1761  		httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
  1762  		if err != nil {
  1763  			return err
  1764  		}
  1765  		httpReq = httpReq.WithContext(ctx)
  1766  		httpReq.Header = headers
  1767  
  1768  		httpRsp, err := c.httpClient.Do(httpReq)
  1769  		if err != nil {
  1770  			return err
  1771  		}
  1772  		defer httpRsp.Body.Close()
  1773  
  1774  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1775  			return err
  1776  		}
  1777  
  1778  		buf, err := io.ReadAll(httpRsp.Body)
  1779  		if err != nil {
  1780  			return err
  1781  		}
  1782  
  1783  		if err := unm.Unmarshal(buf, resp); err != nil {
  1784  			return err
  1785  		}
  1786  
  1787  		return nil
  1788  	}, opts...)
  1789  	if e != nil {
  1790  		return nil, e
  1791  	}
  1792  	return resp, nil
  1793  }
  1794  
  1795  // SetIamPolicy sets the access control policy on the specified secret. Replaces any
  1796  // existing policy.
  1797  //
  1798  // Permissions on
  1799  // SecretVersions are
  1800  // enforced according to the policy set on the associated
  1801  // Secret.
  1802  func (c *restClient) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
  1803  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1804  	jsonReq, err := m.Marshal(req)
  1805  	if err != nil {
  1806  		return nil, err
  1807  	}
  1808  
  1809  	baseUrl, err := url.Parse(c.endpoint)
  1810  	if err != nil {
  1811  		return nil, err
  1812  	}
  1813  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:setIamPolicy", req.GetResource())
  1814  
  1815  	params := url.Values{}
  1816  	params.Add("$alt", "json;enum-encoding=int")
  1817  
  1818  	baseUrl.RawQuery = params.Encode()
  1819  
  1820  	// Build HTTP headers from client and context metadata.
  1821  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "resource", url.QueryEscape(req.GetResource()))}
  1822  
  1823  	hds = append(c.xGoogHeaders, hds...)
  1824  	hds = append(hds, "Content-Type", "application/json")
  1825  	headers := gax.BuildHeaders(ctx, hds...)
  1826  	opts = append((*c.CallOptions).SetIamPolicy[0:len((*c.CallOptions).SetIamPolicy):len((*c.CallOptions).SetIamPolicy)], opts...)
  1827  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1828  	resp := &iampb.Policy{}
  1829  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1830  		if settings.Path != "" {
  1831  			baseUrl.Path = settings.Path
  1832  		}
  1833  		httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
  1834  		if err != nil {
  1835  			return err
  1836  		}
  1837  		httpReq = httpReq.WithContext(ctx)
  1838  		httpReq.Header = headers
  1839  
  1840  		httpRsp, err := c.httpClient.Do(httpReq)
  1841  		if err != nil {
  1842  			return err
  1843  		}
  1844  		defer httpRsp.Body.Close()
  1845  
  1846  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1847  			return err
  1848  		}
  1849  
  1850  		buf, err := io.ReadAll(httpRsp.Body)
  1851  		if err != nil {
  1852  			return err
  1853  		}
  1854  
  1855  		if err := unm.Unmarshal(buf, resp); err != nil {
  1856  			return err
  1857  		}
  1858  
  1859  		return nil
  1860  	}, opts...)
  1861  	if e != nil {
  1862  		return nil, e
  1863  	}
  1864  	return resp, nil
  1865  }
  1866  
  1867  // GetIamPolicy gets the access control policy for a secret.
  1868  // Returns empty policy if the secret exists and does not have a policy set.
  1869  func (c *restClient) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
  1870  	baseUrl, err := url.Parse(c.endpoint)
  1871  	if err != nil {
  1872  		return nil, err
  1873  	}
  1874  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:getIamPolicy", req.GetResource())
  1875  
  1876  	params := url.Values{}
  1877  	params.Add("$alt", "json;enum-encoding=int")
  1878  	if req.GetOptions().GetRequestedPolicyVersion() != 0 {
  1879  		params.Add("options.requestedPolicyVersion", fmt.Sprintf("%v", req.GetOptions().GetRequestedPolicyVersion()))
  1880  	}
  1881  
  1882  	baseUrl.RawQuery = params.Encode()
  1883  
  1884  	// Build HTTP headers from client and context metadata.
  1885  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "resource", url.QueryEscape(req.GetResource()))}
  1886  
  1887  	hds = append(c.xGoogHeaders, hds...)
  1888  	hds = append(hds, "Content-Type", "application/json")
  1889  	headers := gax.BuildHeaders(ctx, hds...)
  1890  	opts = append((*c.CallOptions).GetIamPolicy[0:len((*c.CallOptions).GetIamPolicy):len((*c.CallOptions).GetIamPolicy)], opts...)
  1891  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1892  	resp := &iampb.Policy{}
  1893  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1894  		if settings.Path != "" {
  1895  			baseUrl.Path = settings.Path
  1896  		}
  1897  		httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
  1898  		if err != nil {
  1899  			return err
  1900  		}
  1901  		httpReq = httpReq.WithContext(ctx)
  1902  		httpReq.Header = headers
  1903  
  1904  		httpRsp, err := c.httpClient.Do(httpReq)
  1905  		if err != nil {
  1906  			return err
  1907  		}
  1908  		defer httpRsp.Body.Close()
  1909  
  1910  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1911  			return err
  1912  		}
  1913  
  1914  		buf, err := io.ReadAll(httpRsp.Body)
  1915  		if err != nil {
  1916  			return err
  1917  		}
  1918  
  1919  		if err := unm.Unmarshal(buf, resp); err != nil {
  1920  			return err
  1921  		}
  1922  
  1923  		return nil
  1924  	}, opts...)
  1925  	if e != nil {
  1926  		return nil, e
  1927  	}
  1928  	return resp, nil
  1929  }
  1930  
  1931  // TestIamPermissions returns permissions that a caller has for the specified secret.
  1932  // If the secret does not exist, this call returns an empty set of
  1933  // permissions, not a NOT_FOUND error.
  1934  //
  1935  // Note: This operation is designed to be used for building permission-aware
  1936  // UIs and command-line tools, not for authorization checking. This operation
  1937  // may “fail open” without warning.
  1938  func (c *restClient) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest, opts ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error) {
  1939  	m := protojson.MarshalOptions{AllowPartial: true, UseEnumNumbers: true}
  1940  	jsonReq, err := m.Marshal(req)
  1941  	if err != nil {
  1942  		return nil, err
  1943  	}
  1944  
  1945  	baseUrl, err := url.Parse(c.endpoint)
  1946  	if err != nil {
  1947  		return nil, err
  1948  	}
  1949  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v:testIamPermissions", req.GetResource())
  1950  
  1951  	params := url.Values{}
  1952  	params.Add("$alt", "json;enum-encoding=int")
  1953  
  1954  	baseUrl.RawQuery = params.Encode()
  1955  
  1956  	// Build HTTP headers from client and context metadata.
  1957  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "resource", url.QueryEscape(req.GetResource()))}
  1958  
  1959  	hds = append(c.xGoogHeaders, hds...)
  1960  	hds = append(hds, "Content-Type", "application/json")
  1961  	headers := gax.BuildHeaders(ctx, hds...)
  1962  	opts = append((*c.CallOptions).TestIamPermissions[0:len((*c.CallOptions).TestIamPermissions):len((*c.CallOptions).TestIamPermissions)], opts...)
  1963  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  1964  	resp := &iampb.TestIamPermissionsResponse{}
  1965  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  1966  		if settings.Path != "" {
  1967  			baseUrl.Path = settings.Path
  1968  		}
  1969  		httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
  1970  		if err != nil {
  1971  			return err
  1972  		}
  1973  		httpReq = httpReq.WithContext(ctx)
  1974  		httpReq.Header = headers
  1975  
  1976  		httpRsp, err := c.httpClient.Do(httpReq)
  1977  		if err != nil {
  1978  			return err
  1979  		}
  1980  		defer httpRsp.Body.Close()
  1981  
  1982  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  1983  			return err
  1984  		}
  1985  
  1986  		buf, err := io.ReadAll(httpRsp.Body)
  1987  		if err != nil {
  1988  			return err
  1989  		}
  1990  
  1991  		if err := unm.Unmarshal(buf, resp); err != nil {
  1992  			return err
  1993  		}
  1994  
  1995  		return nil
  1996  	}, opts...)
  1997  	if e != nil {
  1998  		return nil, e
  1999  	}
  2000  	return resp, nil
  2001  }
  2002  
  2003  // GetLocation gets information about a location.
  2004  func (c *restClient) GetLocation(ctx context.Context, req *locationpb.GetLocationRequest, opts ...gax.CallOption) (*locationpb.Location, error) {
  2005  	baseUrl, err := url.Parse(c.endpoint)
  2006  	if err != nil {
  2007  		return nil, err
  2008  	}
  2009  	baseUrl.Path += fmt.Sprintf("/v1beta2/%v", req.GetName())
  2010  
  2011  	params := url.Values{}
  2012  	params.Add("$alt", "json;enum-encoding=int")
  2013  
  2014  	baseUrl.RawQuery = params.Encode()
  2015  
  2016  	// Build HTTP headers from client and context metadata.
  2017  	hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))}
  2018  
  2019  	hds = append(c.xGoogHeaders, hds...)
  2020  	hds = append(hds, "Content-Type", "application/json")
  2021  	headers := gax.BuildHeaders(ctx, hds...)
  2022  	opts = append((*c.CallOptions).GetLocation[0:len((*c.CallOptions).GetLocation):len((*c.CallOptions).GetLocation)], opts...)
  2023  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  2024  	resp := &locationpb.Location{}
  2025  	e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  2026  		if settings.Path != "" {
  2027  			baseUrl.Path = settings.Path
  2028  		}
  2029  		httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
  2030  		if err != nil {
  2031  			return err
  2032  		}
  2033  		httpReq = httpReq.WithContext(ctx)
  2034  		httpReq.Header = headers
  2035  
  2036  		httpRsp, err := c.httpClient.Do(httpReq)
  2037  		if err != nil {
  2038  			return err
  2039  		}
  2040  		defer httpRsp.Body.Close()
  2041  
  2042  		if err = googleapi.CheckResponse(httpRsp); err != nil {
  2043  			return err
  2044  		}
  2045  
  2046  		buf, err := io.ReadAll(httpRsp.Body)
  2047  		if err != nil {
  2048  			return err
  2049  		}
  2050  
  2051  		if err := unm.Unmarshal(buf, resp); err != nil {
  2052  			return err
  2053  		}
  2054  
  2055  		return nil
  2056  	}, opts...)
  2057  	if e != nil {
  2058  		return nil, e
  2059  	}
  2060  	return resp, nil
  2061  }
  2062  
  2063  // ListLocations lists information about the supported locations for this service.
  2064  func (c *restClient) ListLocations(ctx context.Context, req *locationpb.ListLocationsRequest, opts ...gax.CallOption) *LocationIterator {
  2065  	it := &LocationIterator{}
  2066  	req = proto.Clone(req).(*locationpb.ListLocationsRequest)
  2067  	unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
  2068  	it.InternalFetch = func(pageSize int, pageToken string) ([]*locationpb.Location, string, error) {
  2069  		resp := &locationpb.ListLocationsResponse{}
  2070  		if pageToken != "" {
  2071  			req.PageToken = pageToken
  2072  		}
  2073  		if pageSize > math.MaxInt32 {
  2074  			req.PageSize = math.MaxInt32
  2075  		} else if pageSize != 0 {
  2076  			req.PageSize = int32(pageSize)
  2077  		}
  2078  		baseUrl, err := url.Parse(c.endpoint)
  2079  		if err != nil {
  2080  			return nil, "", err
  2081  		}
  2082  		baseUrl.Path += fmt.Sprintf("/v1beta2/%v/locations", req.GetName())
  2083  
  2084  		params := url.Values{}
  2085  		params.Add("$alt", "json;enum-encoding=int")
  2086  		if req.GetFilter() != "" {
  2087  			params.Add("filter", fmt.Sprintf("%v", req.GetFilter()))
  2088  		}
  2089  		if req.GetPageSize() != 0 {
  2090  			params.Add("pageSize", fmt.Sprintf("%v", req.GetPageSize()))
  2091  		}
  2092  		if req.GetPageToken() != "" {
  2093  			params.Add("pageToken", fmt.Sprintf("%v", req.GetPageToken()))
  2094  		}
  2095  
  2096  		baseUrl.RawQuery = params.Encode()
  2097  
  2098  		// Build HTTP headers from client and context metadata.
  2099  		hds := append(c.xGoogHeaders, "Content-Type", "application/json")
  2100  		headers := gax.BuildHeaders(ctx, hds...)
  2101  		e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  2102  			if settings.Path != "" {
  2103  				baseUrl.Path = settings.Path
  2104  			}
  2105  			httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
  2106  			if err != nil {
  2107  				return err
  2108  			}
  2109  			httpReq.Header = headers
  2110  
  2111  			httpRsp, err := c.httpClient.Do(httpReq)
  2112  			if err != nil {
  2113  				return err
  2114  			}
  2115  			defer httpRsp.Body.Close()
  2116  
  2117  			if err = googleapi.CheckResponse(httpRsp); err != nil {
  2118  				return err
  2119  			}
  2120  
  2121  			buf, err := io.ReadAll(httpRsp.Body)
  2122  			if err != nil {
  2123  				return err
  2124  			}
  2125  
  2126  			if err := unm.Unmarshal(buf, resp); err != nil {
  2127  				return err
  2128  			}
  2129  
  2130  			return nil
  2131  		}, opts...)
  2132  		if e != nil {
  2133  			return nil, "", e
  2134  		}
  2135  		it.Response = resp
  2136  		return resp.GetLocations(), resp.GetNextPageToken(), nil
  2137  	}
  2138  
  2139  	fetch := func(pageSize int, pageToken string) (string, error) {
  2140  		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
  2141  		if err != nil {
  2142  			return "", err
  2143  		}
  2144  		it.items = append(it.items, items...)
  2145  		return nextPageToken, nil
  2146  	}
  2147  
  2148  	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
  2149  	it.pageInfo.MaxSize = int(req.GetPageSize())
  2150  	it.pageInfo.Token = req.GetPageToken()
  2151  
  2152  	return it
  2153  }
  2154  

View as plain text