1074 lines
36 KiB
Go
1074 lines
36 KiB
Go
// Copyright 2024 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// Code generated by protoc-gen-go_gapic. DO NOT EDIT.
|
|
|
|
package compute
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"net/http"
|
|
"net/url"
|
|
"sort"
|
|
"time"
|
|
|
|
computepb "cloud.google.com/go/compute/apiv1/computepb"
|
|
gax "github.com/googleapis/gax-go/v2"
|
|
"google.golang.org/api/googleapi"
|
|
"google.golang.org/api/iterator"
|
|
"google.golang.org/api/option"
|
|
"google.golang.org/api/option/internaloption"
|
|
httptransport "google.golang.org/api/transport/http"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/protobuf/encoding/protojson"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
var newReservationsClientHook clientHook
|
|
|
|
// ReservationsCallOptions contains the retry settings for each method of ReservationsClient.
|
|
type ReservationsCallOptions struct {
|
|
AggregatedList []gax.CallOption
|
|
Delete []gax.CallOption
|
|
Get []gax.CallOption
|
|
GetIamPolicy []gax.CallOption
|
|
Insert []gax.CallOption
|
|
List []gax.CallOption
|
|
Resize []gax.CallOption
|
|
SetIamPolicy []gax.CallOption
|
|
TestIamPermissions []gax.CallOption
|
|
Update []gax.CallOption
|
|
}
|
|
|
|
func defaultReservationsRESTCallOptions() *ReservationsCallOptions {
|
|
return &ReservationsCallOptions{
|
|
AggregatedList: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
gax.WithRetry(func() gax.Retryer {
|
|
return gax.OnHTTPCodes(gax.Backoff{
|
|
Initial: 100 * time.Millisecond,
|
|
Max: 60000 * time.Millisecond,
|
|
Multiplier: 1.30,
|
|
},
|
|
http.StatusGatewayTimeout,
|
|
http.StatusServiceUnavailable)
|
|
}),
|
|
},
|
|
Delete: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
},
|
|
Get: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
gax.WithRetry(func() gax.Retryer {
|
|
return gax.OnHTTPCodes(gax.Backoff{
|
|
Initial: 100 * time.Millisecond,
|
|
Max: 60000 * time.Millisecond,
|
|
Multiplier: 1.30,
|
|
},
|
|
http.StatusGatewayTimeout,
|
|
http.StatusServiceUnavailable)
|
|
}),
|
|
},
|
|
GetIamPolicy: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
gax.WithRetry(func() gax.Retryer {
|
|
return gax.OnHTTPCodes(gax.Backoff{
|
|
Initial: 100 * time.Millisecond,
|
|
Max: 60000 * time.Millisecond,
|
|
Multiplier: 1.30,
|
|
},
|
|
http.StatusGatewayTimeout,
|
|
http.StatusServiceUnavailable)
|
|
}),
|
|
},
|
|
Insert: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
},
|
|
List: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
gax.WithRetry(func() gax.Retryer {
|
|
return gax.OnHTTPCodes(gax.Backoff{
|
|
Initial: 100 * time.Millisecond,
|
|
Max: 60000 * time.Millisecond,
|
|
Multiplier: 1.30,
|
|
},
|
|
http.StatusGatewayTimeout,
|
|
http.StatusServiceUnavailable)
|
|
}),
|
|
},
|
|
Resize: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
},
|
|
SetIamPolicy: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
},
|
|
TestIamPermissions: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
},
|
|
Update: []gax.CallOption{
|
|
gax.WithTimeout(600000 * time.Millisecond),
|
|
},
|
|
}
|
|
}
|
|
|
|
// internalReservationsClient is an interface that defines the methods available from Google Compute Engine API.
|
|
type internalReservationsClient interface {
|
|
Close() error
|
|
setGoogleClientInfo(...string)
|
|
Connection() *grpc.ClientConn
|
|
AggregatedList(context.Context, *computepb.AggregatedListReservationsRequest, ...gax.CallOption) *ReservationsScopedListPairIterator
|
|
Delete(context.Context, *computepb.DeleteReservationRequest, ...gax.CallOption) (*Operation, error)
|
|
Get(context.Context, *computepb.GetReservationRequest, ...gax.CallOption) (*computepb.Reservation, error)
|
|
GetIamPolicy(context.Context, *computepb.GetIamPolicyReservationRequest, ...gax.CallOption) (*computepb.Policy, error)
|
|
Insert(context.Context, *computepb.InsertReservationRequest, ...gax.CallOption) (*Operation, error)
|
|
List(context.Context, *computepb.ListReservationsRequest, ...gax.CallOption) *ReservationIterator
|
|
Resize(context.Context, *computepb.ResizeReservationRequest, ...gax.CallOption) (*Operation, error)
|
|
SetIamPolicy(context.Context, *computepb.SetIamPolicyReservationRequest, ...gax.CallOption) (*computepb.Policy, error)
|
|
TestIamPermissions(context.Context, *computepb.TestIamPermissionsReservationRequest, ...gax.CallOption) (*computepb.TestPermissionsResponse, error)
|
|
Update(context.Context, *computepb.UpdateReservationRequest, ...gax.CallOption) (*Operation, error)
|
|
}
|
|
|
|
// ReservationsClient is a client for interacting with Google Compute Engine API.
|
|
// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.
|
|
//
|
|
// The Reservations API.
|
|
type ReservationsClient struct {
|
|
// The internal transport-dependent client.
|
|
internalClient internalReservationsClient
|
|
|
|
// The call options for this service.
|
|
CallOptions *ReservationsCallOptions
|
|
}
|
|
|
|
// 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 *ReservationsClient) 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 *ReservationsClient) 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 *ReservationsClient) Connection() *grpc.ClientConn {
|
|
return c.internalClient.Connection()
|
|
}
|
|
|
|
// AggregatedList retrieves an aggregated list of reservations. To prevent failure, Google recommends that you set the returnPartialSuccess parameter to true.
|
|
func (c *ReservationsClient) AggregatedList(ctx context.Context, req *computepb.AggregatedListReservationsRequest, opts ...gax.CallOption) *ReservationsScopedListPairIterator {
|
|
return c.internalClient.AggregatedList(ctx, req, opts...)
|
|
}
|
|
|
|
// Delete deletes the specified reservation.
|
|
func (c *ReservationsClient) Delete(ctx context.Context, req *computepb.DeleteReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
return c.internalClient.Delete(ctx, req, opts...)
|
|
}
|
|
|
|
// Get retrieves information about the specified reservation.
|
|
func (c *ReservationsClient) Get(ctx context.Context, req *computepb.GetReservationRequest, opts ...gax.CallOption) (*computepb.Reservation, error) {
|
|
return c.internalClient.Get(ctx, req, opts...)
|
|
}
|
|
|
|
// GetIamPolicy gets the access control policy for a resource. May be empty if no such policy or resource exists.
|
|
func (c *ReservationsClient) GetIamPolicy(ctx context.Context, req *computepb.GetIamPolicyReservationRequest, opts ...gax.CallOption) (*computepb.Policy, error) {
|
|
return c.internalClient.GetIamPolicy(ctx, req, opts...)
|
|
}
|
|
|
|
// Insert creates a new reservation. For more information, read Reserving zonal resources.
|
|
func (c *ReservationsClient) Insert(ctx context.Context, req *computepb.InsertReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
return c.internalClient.Insert(ctx, req, opts...)
|
|
}
|
|
|
|
// List a list of all the reservations that have been configured for the specified project in specified zone.
|
|
func (c *ReservationsClient) List(ctx context.Context, req *computepb.ListReservationsRequest, opts ...gax.CallOption) *ReservationIterator {
|
|
return c.internalClient.List(ctx, req, opts...)
|
|
}
|
|
|
|
// Resize resizes the reservation (applicable to standalone reservations only). For more information, read Modifying reservations.
|
|
func (c *ReservationsClient) Resize(ctx context.Context, req *computepb.ResizeReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
return c.internalClient.Resize(ctx, req, opts...)
|
|
}
|
|
|
|
// SetIamPolicy sets the access control policy on the specified resource. Replaces any existing policy.
|
|
func (c *ReservationsClient) SetIamPolicy(ctx context.Context, req *computepb.SetIamPolicyReservationRequest, opts ...gax.CallOption) (*computepb.Policy, error) {
|
|
return c.internalClient.SetIamPolicy(ctx, req, opts...)
|
|
}
|
|
|
|
// TestIamPermissions returns permissions that a caller has on the specified resource.
|
|
func (c *ReservationsClient) TestIamPermissions(ctx context.Context, req *computepb.TestIamPermissionsReservationRequest, opts ...gax.CallOption) (*computepb.TestPermissionsResponse, error) {
|
|
return c.internalClient.TestIamPermissions(ctx, req, opts...)
|
|
}
|
|
|
|
// Update update share settings of the reservation.
|
|
func (c *ReservationsClient) Update(ctx context.Context, req *computepb.UpdateReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
return c.internalClient.Update(ctx, req, opts...)
|
|
}
|
|
|
|
// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.
|
|
type reservationsRESTClient struct {
|
|
// The http endpoint to connect to.
|
|
endpoint string
|
|
|
|
// The http client.
|
|
httpClient *http.Client
|
|
|
|
// operationClient is used to call the operation-specific management service.
|
|
operationClient *ZoneOperationsClient
|
|
|
|
// The x-goog-* headers to be sent with each request.
|
|
xGoogHeaders []string
|
|
|
|
// Points back to the CallOptions field of the containing ReservationsClient
|
|
CallOptions **ReservationsCallOptions
|
|
}
|
|
|
|
// NewReservationsRESTClient creates a new reservations rest client.
|
|
//
|
|
// The Reservations API.
|
|
func NewReservationsRESTClient(ctx context.Context, opts ...option.ClientOption) (*ReservationsClient, error) {
|
|
clientOpts := append(defaultReservationsRESTClientOptions(), opts...)
|
|
httpClient, endpoint, err := httptransport.NewClient(ctx, clientOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
callOpts := defaultReservationsRESTCallOptions()
|
|
c := &reservationsRESTClient{
|
|
endpoint: endpoint,
|
|
httpClient: httpClient,
|
|
CallOptions: &callOpts,
|
|
}
|
|
c.setGoogleClientInfo()
|
|
|
|
o := []option.ClientOption{
|
|
option.WithHTTPClient(httpClient),
|
|
option.WithEndpoint(endpoint),
|
|
}
|
|
opC, err := NewZoneOperationsRESTClient(ctx, o...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
c.operationClient = opC
|
|
|
|
return &ReservationsClient{internalClient: c, CallOptions: callOpts}, nil
|
|
}
|
|
|
|
func defaultReservationsRESTClientOptions() []option.ClientOption {
|
|
return []option.ClientOption{
|
|
internaloption.WithDefaultEndpoint("https://compute.googleapis.com"),
|
|
internaloption.WithDefaultEndpointTemplate("https://compute.UNIVERSE_DOMAIN"),
|
|
internaloption.WithDefaultMTLSEndpoint("https://compute.mtls.googleapis.com"),
|
|
internaloption.WithDefaultUniverseDomain("googleapis.com"),
|
|
internaloption.WithDefaultAudience("https://compute.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 *reservationsRESTClient) 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 *reservationsRESTClient) Close() error {
|
|
// Replace httpClient with nil to force cleanup.
|
|
c.httpClient = nil
|
|
if err := c.operationClient.Close(); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Connection returns a connection to the API service.
|
|
//
|
|
// Deprecated: This method always returns nil.
|
|
func (c *reservationsRESTClient) Connection() *grpc.ClientConn {
|
|
return nil
|
|
}
|
|
|
|
// AggregatedList retrieves an aggregated list of reservations. To prevent failure, Google recommends that you set the returnPartialSuccess parameter to true.
|
|
func (c *reservationsRESTClient) AggregatedList(ctx context.Context, req *computepb.AggregatedListReservationsRequest, opts ...gax.CallOption) *ReservationsScopedListPairIterator {
|
|
it := &ReservationsScopedListPairIterator{}
|
|
req = proto.Clone(req).(*computepb.AggregatedListReservationsRequest)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
it.InternalFetch = func(pageSize int, pageToken string) ([]ReservationsScopedListPair, string, error) {
|
|
resp := &computepb.ReservationAggregatedList{}
|
|
if pageToken != "" {
|
|
req.PageToken = proto.String(pageToken)
|
|
}
|
|
if pageSize > math.MaxInt32 {
|
|
req.MaxResults = proto.Uint32(uint32(math.MaxInt32))
|
|
} else if pageSize != 0 {
|
|
req.MaxResults = proto.Uint32(uint32(pageSize))
|
|
}
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/aggregated/reservations", req.GetProject())
|
|
|
|
params := url.Values{}
|
|
if req != nil && req.Filter != nil {
|
|
params.Add("filter", fmt.Sprintf("%v", req.GetFilter()))
|
|
}
|
|
if req != nil && req.IncludeAllScopes != nil {
|
|
params.Add("includeAllScopes", fmt.Sprintf("%v", req.GetIncludeAllScopes()))
|
|
}
|
|
if req != nil && req.MaxResults != nil {
|
|
params.Add("maxResults", fmt.Sprintf("%v", req.GetMaxResults()))
|
|
}
|
|
if req != nil && req.OrderBy != nil {
|
|
params.Add("orderBy", fmt.Sprintf("%v", req.GetOrderBy()))
|
|
}
|
|
if req != nil && req.PageToken != nil {
|
|
params.Add("pageToken", fmt.Sprintf("%v", req.GetPageToken()))
|
|
}
|
|
if req != nil && req.ReturnPartialSuccess != nil {
|
|
params.Add("returnPartialSuccess", fmt.Sprintf("%v", req.GetReturnPartialSuccess()))
|
|
}
|
|
if req != nil && req.ServiceProjectNumber != nil {
|
|
params.Add("serviceProjectNumber", fmt.Sprintf("%v", req.GetServiceProjectNumber()))
|
|
}
|
|
|
|
baseUrl.RawQuery = params.Encode()
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := append(c.xGoogHeaders, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, "", e
|
|
}
|
|
it.Response = resp
|
|
|
|
elems := make([]ReservationsScopedListPair, 0, len(resp.GetItems()))
|
|
for k, v := range resp.GetItems() {
|
|
elems = append(elems, ReservationsScopedListPair{k, v})
|
|
}
|
|
sort.Slice(elems, func(i, j int) bool { return elems[i].Key < elems[j].Key })
|
|
|
|
return elems, 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.GetMaxResults())
|
|
it.pageInfo.Token = req.GetPageToken()
|
|
|
|
return it
|
|
}
|
|
|
|
// Delete deletes the specified reservation.
|
|
func (c *reservationsRESTClient) Delete(ctx context.Context, req *computepb.DeleteReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations/%v", req.GetProject(), req.GetZone(), req.GetReservation())
|
|
|
|
params := url.Values{}
|
|
if req != nil && req.RequestId != nil {
|
|
params.Add("requestId", fmt.Sprintf("%v", req.GetRequestId()))
|
|
}
|
|
|
|
baseUrl.RawQuery = params.Encode()
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()), "reservation", url.QueryEscape(req.GetReservation()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).Delete[0:len((*c.CallOptions).Delete):len((*c.CallOptions).Delete)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.Operation{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("DELETE", baseUrl.String(), nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
op := &Operation{
|
|
&zoneOperationsHandle{
|
|
c: c.operationClient,
|
|
proto: resp,
|
|
project: req.GetProject(),
|
|
zone: req.GetZone(),
|
|
},
|
|
}
|
|
return op, nil
|
|
}
|
|
|
|
// Get retrieves information about the specified reservation.
|
|
func (c *reservationsRESTClient) Get(ctx context.Context, req *computepb.GetReservationRequest, opts ...gax.CallOption) (*computepb.Reservation, error) {
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations/%v", req.GetProject(), req.GetZone(), req.GetReservation())
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()), "reservation", url.QueryEscape(req.GetReservation()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).Get[0:len((*c.CallOptions).Get):len((*c.CallOptions).Get)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.Reservation{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
// GetIamPolicy gets the access control policy for a resource. May be empty if no such policy or resource exists.
|
|
func (c *reservationsRESTClient) GetIamPolicy(ctx context.Context, req *computepb.GetIamPolicyReservationRequest, opts ...gax.CallOption) (*computepb.Policy, error) {
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations/%v/getIamPolicy", req.GetProject(), req.GetZone(), req.GetResource())
|
|
|
|
params := url.Values{}
|
|
if req != nil && req.OptionsRequestedPolicyVersion != nil {
|
|
params.Add("optionsRequestedPolicyVersion", fmt.Sprintf("%v", req.GetOptionsRequestedPolicyVersion()))
|
|
}
|
|
|
|
baseUrl.RawQuery = params.Encode()
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()), "resource", url.QueryEscape(req.GetResource()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).GetIamPolicy[0:len((*c.CallOptions).GetIamPolicy):len((*c.CallOptions).GetIamPolicy)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.Policy{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
// Insert creates a new reservation. For more information, read Reserving zonal resources.
|
|
func (c *reservationsRESTClient) Insert(ctx context.Context, req *computepb.InsertReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
m := protojson.MarshalOptions{AllowPartial: true}
|
|
body := req.GetReservationResource()
|
|
jsonReq, err := m.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations", req.GetProject(), req.GetZone())
|
|
|
|
params := url.Values{}
|
|
if req != nil && req.RequestId != nil {
|
|
params.Add("requestId", fmt.Sprintf("%v", req.GetRequestId()))
|
|
}
|
|
|
|
baseUrl.RawQuery = params.Encode()
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).Insert[0:len((*c.CallOptions).Insert):len((*c.CallOptions).Insert)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.Operation{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
op := &Operation{
|
|
&zoneOperationsHandle{
|
|
c: c.operationClient,
|
|
proto: resp,
|
|
project: req.GetProject(),
|
|
zone: req.GetZone(),
|
|
},
|
|
}
|
|
return op, nil
|
|
}
|
|
|
|
// List a list of all the reservations that have been configured for the specified project in specified zone.
|
|
func (c *reservationsRESTClient) List(ctx context.Context, req *computepb.ListReservationsRequest, opts ...gax.CallOption) *ReservationIterator {
|
|
it := &ReservationIterator{}
|
|
req = proto.Clone(req).(*computepb.ListReservationsRequest)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
it.InternalFetch = func(pageSize int, pageToken string) ([]*computepb.Reservation, string, error) {
|
|
resp := &computepb.ReservationList{}
|
|
if pageToken != "" {
|
|
req.PageToken = proto.String(pageToken)
|
|
}
|
|
if pageSize > math.MaxInt32 {
|
|
req.MaxResults = proto.Uint32(uint32(math.MaxInt32))
|
|
} else if pageSize != 0 {
|
|
req.MaxResults = proto.Uint32(uint32(pageSize))
|
|
}
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations", req.GetProject(), req.GetZone())
|
|
|
|
params := url.Values{}
|
|
if req != nil && req.Filter != nil {
|
|
params.Add("filter", fmt.Sprintf("%v", req.GetFilter()))
|
|
}
|
|
if req != nil && req.MaxResults != nil {
|
|
params.Add("maxResults", fmt.Sprintf("%v", req.GetMaxResults()))
|
|
}
|
|
if req != nil && req.OrderBy != nil {
|
|
params.Add("orderBy", fmt.Sprintf("%v", req.GetOrderBy()))
|
|
}
|
|
if req != nil && req.PageToken != nil {
|
|
params.Add("pageToken", fmt.Sprintf("%v", req.GetPageToken()))
|
|
}
|
|
if req != nil && req.ReturnPartialSuccess != nil {
|
|
params.Add("returnPartialSuccess", fmt.Sprintf("%v", req.GetReturnPartialSuccess()))
|
|
}
|
|
|
|
baseUrl.RawQuery = params.Encode()
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := append(c.xGoogHeaders, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("GET", baseUrl.String(), nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, "", e
|
|
}
|
|
it.Response = resp
|
|
return resp.GetItems(), 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.GetMaxResults())
|
|
it.pageInfo.Token = req.GetPageToken()
|
|
|
|
return it
|
|
}
|
|
|
|
// Resize resizes the reservation (applicable to standalone reservations only). For more information, read Modifying reservations.
|
|
func (c *reservationsRESTClient) Resize(ctx context.Context, req *computepb.ResizeReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
m := protojson.MarshalOptions{AllowPartial: true}
|
|
body := req.GetReservationsResizeRequestResource()
|
|
jsonReq, err := m.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations/%v/resize", req.GetProject(), req.GetZone(), req.GetReservation())
|
|
|
|
params := url.Values{}
|
|
if req != nil && req.RequestId != nil {
|
|
params.Add("requestId", fmt.Sprintf("%v", req.GetRequestId()))
|
|
}
|
|
|
|
baseUrl.RawQuery = params.Encode()
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()), "reservation", url.QueryEscape(req.GetReservation()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).Resize[0:len((*c.CallOptions).Resize):len((*c.CallOptions).Resize)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.Operation{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
op := &Operation{
|
|
&zoneOperationsHandle{
|
|
c: c.operationClient,
|
|
proto: resp,
|
|
project: req.GetProject(),
|
|
zone: req.GetZone(),
|
|
},
|
|
}
|
|
return op, nil
|
|
}
|
|
|
|
// SetIamPolicy sets the access control policy on the specified resource. Replaces any existing policy.
|
|
func (c *reservationsRESTClient) SetIamPolicy(ctx context.Context, req *computepb.SetIamPolicyReservationRequest, opts ...gax.CallOption) (*computepb.Policy, error) {
|
|
m := protojson.MarshalOptions{AllowPartial: true}
|
|
body := req.GetZoneSetPolicyRequestResource()
|
|
jsonReq, err := m.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations/%v/setIamPolicy", req.GetProject(), req.GetZone(), req.GetResource())
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()), "resource", url.QueryEscape(req.GetResource()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).SetIamPolicy[0:len((*c.CallOptions).SetIamPolicy):len((*c.CallOptions).SetIamPolicy)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.Policy{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
// TestIamPermissions returns permissions that a caller has on the specified resource.
|
|
func (c *reservationsRESTClient) TestIamPermissions(ctx context.Context, req *computepb.TestIamPermissionsReservationRequest, opts ...gax.CallOption) (*computepb.TestPermissionsResponse, error) {
|
|
m := protojson.MarshalOptions{AllowPartial: true}
|
|
body := req.GetTestPermissionsRequestResource()
|
|
jsonReq, err := m.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations/%v/testIamPermissions", req.GetProject(), req.GetZone(), req.GetResource())
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()), "resource", url.QueryEscape(req.GetResource()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).TestIamPermissions[0:len((*c.CallOptions).TestIamPermissions):len((*c.CallOptions).TestIamPermissions)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.TestPermissionsResponse{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("POST", baseUrl.String(), bytes.NewReader(jsonReq))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
// Update update share settings of the reservation.
|
|
func (c *reservationsRESTClient) Update(ctx context.Context, req *computepb.UpdateReservationRequest, opts ...gax.CallOption) (*Operation, error) {
|
|
m := protojson.MarshalOptions{AllowPartial: true}
|
|
body := req.GetReservationResource()
|
|
jsonReq, err := m.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
baseUrl, err := url.Parse(c.endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseUrl.Path += fmt.Sprintf("/compute/v1/projects/%v/zones/%v/reservations/%v", req.GetProject(), req.GetZone(), req.GetReservation())
|
|
|
|
params := url.Values{}
|
|
if req != nil && req.Paths != nil {
|
|
params.Add("paths", fmt.Sprintf("%v", req.GetPaths()))
|
|
}
|
|
if req != nil && req.RequestId != nil {
|
|
params.Add("requestId", fmt.Sprintf("%v", req.GetRequestId()))
|
|
}
|
|
if req != nil && req.UpdateMask != nil {
|
|
params.Add("updateMask", fmt.Sprintf("%v", req.GetUpdateMask()))
|
|
}
|
|
|
|
baseUrl.RawQuery = params.Encode()
|
|
|
|
// Build HTTP headers from client and context metadata.
|
|
hds := []string{"x-goog-request-params", fmt.Sprintf("%s=%v&%s=%v&%s=%v", "project", url.QueryEscape(req.GetProject()), "zone", url.QueryEscape(req.GetZone()), "reservation", url.QueryEscape(req.GetReservation()))}
|
|
|
|
hds = append(c.xGoogHeaders, hds...)
|
|
hds = append(hds, "Content-Type", "application/json")
|
|
headers := gax.BuildHeaders(ctx, hds...)
|
|
opts = append((*c.CallOptions).Update[0:len((*c.CallOptions).Update):len((*c.CallOptions).Update)], opts...)
|
|
unm := protojson.UnmarshalOptions{AllowPartial: true, DiscardUnknown: true}
|
|
resp := &computepb.Operation{}
|
|
e := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
|
|
if settings.Path != "" {
|
|
baseUrl.Path = settings.Path
|
|
}
|
|
httpReq, err := http.NewRequest("PATCH", baseUrl.String(), bytes.NewReader(jsonReq))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
httpReq = httpReq.WithContext(ctx)
|
|
httpReq.Header = headers
|
|
|
|
httpRsp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer httpRsp.Body.Close()
|
|
|
|
if err = googleapi.CheckResponse(httpRsp); err != nil {
|
|
return err
|
|
}
|
|
|
|
buf, err := io.ReadAll(httpRsp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := unm.Unmarshal(buf, resp); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, opts...)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
op := &Operation{
|
|
&zoneOperationsHandle{
|
|
c: c.operationClient,
|
|
proto: resp,
|
|
project: req.GetProject(),
|
|
zone: req.GetZone(),
|
|
},
|
|
}
|
|
return op, nil
|
|
}
|