Network Services API v1 - Package cloud.google.com/go/networkservices/apiv1 (v0.5.1)

Version latest

• 0.5.1 (latest)
• 0.5.0
• 0.4.0
• 0.3.0
• 0.2.5
• 0.1.6

Note: To get more information about this package, such as access to older versions, view this package on pkg.go.dev.

Package networkservices is an auto-generated package for the Network Services API.

General documentation

For information that is relevant for all client libraries please reference https://pkg.go.dev/cloud.google.com/go#pkg-overview. Some information on this page includes:

• Authentication and Authorization
• Timeouts and Cancellation
• Testing against Client Libraries
• Debugging Client Libraries
• Inspecting errors

Example usage

To get started with this package, create a client.

// go get cloud.google.com/go/networkservices/apiv1@latest
ctx := context.Background()
// This snippet has been automatically generated and should be regarded as a code template only.
// It will require modifications to work:
// - It may require correct/in-range values for request initialization.
// - It may require specifying regional endpoints when creating the service client as shown in:
//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
c, err := networkservices.NewDepClient(ctx)
if err != nil {
    // TODO: Handle error.
}
defer c.Close()

The client will use your default application credentials. Clients should be reused instead of created as needed. The methods of Client are safe for concurrent use by multiple goroutines. The returned client must be Closed when it is done being used.

Using the Client

The following is an example of making an API call with the newly created client, mentioned above.

req := &networkservicespb.CreateAuthzExtensionRequest{
    // TODO: Fill request struct fields.
    // See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateAuthzExtensionRequest.
}
op, err := c.CreateAuthzExtension(ctx, req)
if err != nil {
    // TODO: Handle error.
}

resp, err := op.Wait(ctx)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

Use of Context

The ctx passed to NewDepClient is used for authentication requests and for creating the underlying connection, but is not used for subsequent calls. Individual methods on the client use the ctx given to them.

To close the open connection, use the Close() method.

Functions

func DefaultAuthScopes

func DefaultAuthScopes() []string

DefaultAuthScopes reports the default set of authentication scopes to use with this package.

AuthzExtensionIterator

type AuthzExtensionIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.AuthzExtension, nextPageToken string, err error)
	// contains filtered or unexported fields
}

AuthzExtensionIterator manages a stream of *networkservicespb.AuthzExtension.

func (*AuthzExtensionIterator) All

func (it *AuthzExtensionIterator) All() iter.Seq2[*networkservicespb.AuthzExtension, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*AuthzExtensionIterator) Next

func (it *AuthzExtensionIterator) Next() (*networkservicespb.AuthzExtension, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*AuthzExtensionIterator) PageInfo

func (it *AuthzExtensionIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

CallOptions

type CallOptions struct {
	ListEndpointPolicies    []gax.CallOption
	GetEndpointPolicy       []gax.CallOption
	CreateEndpointPolicy    []gax.CallOption
	UpdateEndpointPolicy    []gax.CallOption
	DeleteEndpointPolicy    []gax.CallOption
	ListWasmPluginVersions  []gax.CallOption
	GetWasmPluginVersion    []gax.CallOption
	CreateWasmPluginVersion []gax.CallOption
	DeleteWasmPluginVersion []gax.CallOption
	ListWasmPlugins         []gax.CallOption
	GetWasmPlugin           []gax.CallOption
	CreateWasmPlugin        []gax.CallOption
	UpdateWasmPlugin        []gax.CallOption
	DeleteWasmPlugin        []gax.CallOption
	ListGateways            []gax.CallOption
	GetGateway              []gax.CallOption
	CreateGateway           []gax.CallOption
	UpdateGateway           []gax.CallOption
	DeleteGateway           []gax.CallOption
	ListGrpcRoutes          []gax.CallOption
	GetGrpcRoute            []gax.CallOption
	CreateGrpcRoute         []gax.CallOption
	UpdateGrpcRoute         []gax.CallOption
	DeleteGrpcRoute         []gax.CallOption
	ListHttpRoutes          []gax.CallOption
	GetHttpRoute            []gax.CallOption
	CreateHttpRoute         []gax.CallOption
	UpdateHttpRoute         []gax.CallOption
	DeleteHttpRoute         []gax.CallOption
	ListTcpRoutes           []gax.CallOption
	GetTcpRoute             []gax.CallOption
	CreateTcpRoute          []gax.CallOption
	UpdateTcpRoute          []gax.CallOption
	DeleteTcpRoute          []gax.CallOption
	ListTlsRoutes           []gax.CallOption
	GetTlsRoute             []gax.CallOption
	CreateTlsRoute          []gax.CallOption
	UpdateTlsRoute          []gax.CallOption
	DeleteTlsRoute          []gax.CallOption
	ListServiceBindings     []gax.CallOption
	GetServiceBinding       []gax.CallOption
	CreateServiceBinding    []gax.CallOption
	UpdateServiceBinding    []gax.CallOption
	DeleteServiceBinding    []gax.CallOption
	ListMeshes              []gax.CallOption
	GetMesh                 []gax.CallOption
	CreateMesh              []gax.CallOption
	UpdateMesh              []gax.CallOption
	DeleteMesh              []gax.CallOption
	ListServiceLbPolicies   []gax.CallOption
	GetServiceLbPolicy      []gax.CallOption
	CreateServiceLbPolicy   []gax.CallOption
	UpdateServiceLbPolicy   []gax.CallOption
	DeleteServiceLbPolicy   []gax.CallOption
	GetGatewayRouteView     []gax.CallOption
	GetMeshRouteView        []gax.CallOption
	ListGatewayRouteViews   []gax.CallOption
	ListMeshRouteViews      []gax.CallOption
	GetLocation             []gax.CallOption
	ListLocations           []gax.CallOption
	GetIamPolicy            []gax.CallOption
	SetIamPolicy            []gax.CallOption
	TestIamPermissions      []gax.CallOption
	CancelOperation         []gax.CallOption
	DeleteOperation         []gax.CallOption
	GetOperation            []gax.CallOption
	ListOperations          []gax.CallOption
}

CallOptions contains the retry settings for each method of Client.

Client

type Client struct {

	// The call options for this service.
	CallOptions *CallOptions

	// LROClient is used internally to handle long-running operations.
	// It is exposed so that its CallOptions can be modified if required.
	// Users should not Close this client.
	LROClient *lroauto.OperationsClient
	// contains filtered or unexported fields
}

Client is a client for interacting with Network Services API. Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

Service describing handlers for resources.

func NewClient

func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error)

NewClient creates a new network services client based on gRPC. The returned client must be Closed when it is done being used to clean up its underlying connections.

Service describing handlers for resources.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

func NewRESTClient

func NewRESTClient(ctx context.Context, opts ...option.ClientOption) (*Client, error)

NewRESTClient creates a new network services rest client.

Service describing handlers for resources.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewRESTClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

func (*Client) CancelOperation

func (c *Client) CancelOperation(ctx context.Context, req *longrunningpb.CancelOperationRequest, opts ...gax.CallOption) error

CancelOperation is a utility method from google.longrunning.Operations.

Example

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.CancelOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#CancelOperationRequest.
	}
	err = c.CancelOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) Close

func (c *Client) Close() error

Close closes the connection to the API service. The user should invoke this when the client is no longer required.

func (*Client) Connection (deprecated)

func (c *Client) Connection() *grpc.ClientConn

Connection returns a connection to the API service.

Deprecated: Connections are now pooled so this method does not always return the same resource.

func (*Client) CreateEndpointPolicy

func (c *Client) CreateEndpointPolicy(ctx context.Context, req *networkservicespb.CreateEndpointPolicyRequest, opts ...gax.CallOption) (*CreateEndpointPolicyOperation, error)

CreateEndpointPolicy creates a new EndpointPolicy in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateEndpointPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateEndpointPolicyRequest.
	}
	op, err := c.CreateEndpointPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateEndpointPolicyOperation

func (c *Client) CreateEndpointPolicyOperation(name string) *CreateEndpointPolicyOperation

CreateEndpointPolicyOperation returns a new CreateEndpointPolicyOperation from a given name. The name must be that of a previously created CreateEndpointPolicyOperation, possibly from a different process.

func (*Client) CreateGateway

func (c *Client) CreateGateway(ctx context.Context, req *networkservicespb.CreateGatewayRequest, opts ...gax.CallOption) (*CreateGatewayOperation, error)

CreateGateway creates a new Gateway in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateGatewayRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateGatewayRequest.
	}
	op, err := c.CreateGateway(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateGatewayOperation

func (c *Client) CreateGatewayOperation(name string) *CreateGatewayOperation

CreateGatewayOperation returns a new CreateGatewayOperation from a given name. The name must be that of a previously created CreateGatewayOperation, possibly from a different process.

func (*Client) CreateGrpcRoute

func (c *Client) CreateGrpcRoute(ctx context.Context, req *networkservicespb.CreateGrpcRouteRequest, opts ...gax.CallOption) (*CreateGrpcRouteOperation, error)

CreateGrpcRoute creates a new GrpcRoute in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateGrpcRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateGrpcRouteRequest.
	}
	op, err := c.CreateGrpcRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateGrpcRouteOperation

func (c *Client) CreateGrpcRouteOperation(name string) *CreateGrpcRouteOperation

CreateGrpcRouteOperation returns a new CreateGrpcRouteOperation from a given name. The name must be that of a previously created CreateGrpcRouteOperation, possibly from a different process.

func (*Client) CreateHttpRoute

func (c *Client) CreateHttpRoute(ctx context.Context, req *networkservicespb.CreateHttpRouteRequest, opts ...gax.CallOption) (*CreateHttpRouteOperation, error)

CreateHttpRoute creates a new HttpRoute in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateHttpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateHttpRouteRequest.
	}
	op, err := c.CreateHttpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateHttpRouteOperation

func (c *Client) CreateHttpRouteOperation(name string) *CreateHttpRouteOperation

CreateHttpRouteOperation returns a new CreateHttpRouteOperation from a given name. The name must be that of a previously created CreateHttpRouteOperation, possibly from a different process.

func (*Client) CreateMesh

func (c *Client) CreateMesh(ctx context.Context, req *networkservicespb.CreateMeshRequest, opts ...gax.CallOption) (*CreateMeshOperation, error)

CreateMesh creates a new Mesh in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateMeshRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateMeshRequest.
	}
	op, err := c.CreateMesh(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateMeshOperation

func (c *Client) CreateMeshOperation(name string) *CreateMeshOperation

CreateMeshOperation returns a new CreateMeshOperation from a given name. The name must be that of a previously created CreateMeshOperation, possibly from a different process.

func (*Client) CreateServiceBinding

func (c *Client) CreateServiceBinding(ctx context.Context, req *networkservicespb.CreateServiceBindingRequest, opts ...gax.CallOption) (*CreateServiceBindingOperation, error)

CreateServiceBinding creates a new ServiceBinding in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateServiceBindingRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateServiceBindingRequest.
	}
	op, err := c.CreateServiceBinding(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateServiceBindingOperation

func (c *Client) CreateServiceBindingOperation(name string) *CreateServiceBindingOperation

CreateServiceBindingOperation returns a new CreateServiceBindingOperation from a given name. The name must be that of a previously created CreateServiceBindingOperation, possibly from a different process.

func (*Client) CreateServiceLbPolicy

func (c *Client) CreateServiceLbPolicy(ctx context.Context, req *networkservicespb.CreateServiceLbPolicyRequest, opts ...gax.CallOption) (*CreateServiceLbPolicyOperation, error)

CreateServiceLbPolicy creates a new ServiceLbPolicy in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateServiceLbPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateServiceLbPolicyRequest.
	}
	op, err := c.CreateServiceLbPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateServiceLbPolicyOperation

func (c *Client) CreateServiceLbPolicyOperation(name string) *CreateServiceLbPolicyOperation

CreateServiceLbPolicyOperation returns a new CreateServiceLbPolicyOperation from a given name. The name must be that of a previously created CreateServiceLbPolicyOperation, possibly from a different process.

func (*Client) CreateTcpRoute

func (c *Client) CreateTcpRoute(ctx context.Context, req *networkservicespb.CreateTcpRouteRequest, opts ...gax.CallOption) (*CreateTcpRouteOperation, error)

CreateTcpRoute creates a new TcpRoute in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateTcpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateTcpRouteRequest.
	}
	op, err := c.CreateTcpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateTcpRouteOperation

func (c *Client) CreateTcpRouteOperation(name string) *CreateTcpRouteOperation

CreateTcpRouteOperation returns a new CreateTcpRouteOperation from a given name. The name must be that of a previously created CreateTcpRouteOperation, possibly from a different process.

func (*Client) CreateTlsRoute

func (c *Client) CreateTlsRoute(ctx context.Context, req *networkservicespb.CreateTlsRouteRequest, opts ...gax.CallOption) (*CreateTlsRouteOperation, error)

CreateTlsRoute creates a new TlsRoute in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateTlsRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateTlsRouteRequest.
	}
	op, err := c.CreateTlsRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateTlsRouteOperation

func (c *Client) CreateTlsRouteOperation(name string) *CreateTlsRouteOperation

CreateTlsRouteOperation returns a new CreateTlsRouteOperation from a given name. The name must be that of a previously created CreateTlsRouteOperation, possibly from a different process.

func (*Client) CreateWasmPlugin

func (c *Client) CreateWasmPlugin(ctx context.Context, req *networkservicespb.CreateWasmPluginRequest, opts ...gax.CallOption) (*CreateWasmPluginOperation, error)

CreateWasmPlugin creates a new WasmPlugin resource in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateWasmPluginRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateWasmPluginRequest.
	}
	op, err := c.CreateWasmPlugin(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateWasmPluginOperation

func (c *Client) CreateWasmPluginOperation(name string) *CreateWasmPluginOperation

CreateWasmPluginOperation returns a new CreateWasmPluginOperation from a given name. The name must be that of a previously created CreateWasmPluginOperation, possibly from a different process.

func (*Client) CreateWasmPluginVersion

func (c *Client) CreateWasmPluginVersion(ctx context.Context, req *networkservicespb.CreateWasmPluginVersionRequest, opts ...gax.CallOption) (*CreateWasmPluginVersionOperation, error)

CreateWasmPluginVersion creates a new WasmPluginVersion resource in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateWasmPluginVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateWasmPluginVersionRequest.
	}
	op, err := c.CreateWasmPluginVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) CreateWasmPluginVersionOperation

func (c *Client) CreateWasmPluginVersionOperation(name string) *CreateWasmPluginVersionOperation

CreateWasmPluginVersionOperation returns a new CreateWasmPluginVersionOperation from a given name. The name must be that of a previously created CreateWasmPluginVersionOperation, possibly from a different process.

func (*Client) DeleteEndpointPolicy

func (c *Client) DeleteEndpointPolicy(ctx context.Context, req *networkservicespb.DeleteEndpointPolicyRequest, opts ...gax.CallOption) (*DeleteEndpointPolicyOperation, error)

DeleteEndpointPolicy deletes a single EndpointPolicy.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteEndpointPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteEndpointPolicyRequest.
	}
	op, err := c.DeleteEndpointPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteEndpointPolicyOperation

func (c *Client) DeleteEndpointPolicyOperation(name string) *DeleteEndpointPolicyOperation

DeleteEndpointPolicyOperation returns a new DeleteEndpointPolicyOperation from a given name. The name must be that of a previously created DeleteEndpointPolicyOperation, possibly from a different process.

func (*Client) DeleteGateway

func (c *Client) DeleteGateway(ctx context.Context, req *networkservicespb.DeleteGatewayRequest, opts ...gax.CallOption) (*DeleteGatewayOperation, error)

DeleteGateway deletes a single Gateway.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteGatewayRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteGatewayRequest.
	}
	op, err := c.DeleteGateway(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteGatewayOperation

func (c *Client) DeleteGatewayOperation(name string) *DeleteGatewayOperation

DeleteGatewayOperation returns a new DeleteGatewayOperation from a given name. The name must be that of a previously created DeleteGatewayOperation, possibly from a different process.

func (*Client) DeleteGrpcRoute

func (c *Client) DeleteGrpcRoute(ctx context.Context, req *networkservicespb.DeleteGrpcRouteRequest, opts ...gax.CallOption) (*DeleteGrpcRouteOperation, error)

DeleteGrpcRoute deletes a single GrpcRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteGrpcRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteGrpcRouteRequest.
	}
	op, err := c.DeleteGrpcRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteGrpcRouteOperation

func (c *Client) DeleteGrpcRouteOperation(name string) *DeleteGrpcRouteOperation

DeleteGrpcRouteOperation returns a new DeleteGrpcRouteOperation from a given name. The name must be that of a previously created DeleteGrpcRouteOperation, possibly from a different process.

func (*Client) DeleteHttpRoute

func (c *Client) DeleteHttpRoute(ctx context.Context, req *networkservicespb.DeleteHttpRouteRequest, opts ...gax.CallOption) (*DeleteHttpRouteOperation, error)

DeleteHttpRoute deletes a single HttpRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteHttpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteHttpRouteRequest.
	}
	op, err := c.DeleteHttpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteHttpRouteOperation

func (c *Client) DeleteHttpRouteOperation(name string) *DeleteHttpRouteOperation

DeleteHttpRouteOperation returns a new DeleteHttpRouteOperation from a given name. The name must be that of a previously created DeleteHttpRouteOperation, possibly from a different process.

func (*Client) DeleteMesh

func (c *Client) DeleteMesh(ctx context.Context, req *networkservicespb.DeleteMeshRequest, opts ...gax.CallOption) (*DeleteMeshOperation, error)

DeleteMesh deletes a single Mesh.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteMeshRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteMeshRequest.
	}
	op, err := c.DeleteMesh(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteMeshOperation

func (c *Client) DeleteMeshOperation(name string) *DeleteMeshOperation

DeleteMeshOperation returns a new DeleteMeshOperation from a given name. The name must be that of a previously created DeleteMeshOperation, possibly from a different process.

func (*Client) DeleteOperation

func (c *Client) DeleteOperation(ctx context.Context, req *longrunningpb.DeleteOperationRequest, opts ...gax.CallOption) error

DeleteOperation is a utility method from google.longrunning.Operations.

Example

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.DeleteOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#DeleteOperationRequest.
	}
	err = c.DeleteOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteServiceBinding

func (c *Client) DeleteServiceBinding(ctx context.Context, req *networkservicespb.DeleteServiceBindingRequest, opts ...gax.CallOption) (*DeleteServiceBindingOperation, error)

DeleteServiceBinding deletes a single ServiceBinding.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteServiceBindingRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteServiceBindingRequest.
	}
	op, err := c.DeleteServiceBinding(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteServiceBindingOperation

func (c *Client) DeleteServiceBindingOperation(name string) *DeleteServiceBindingOperation

DeleteServiceBindingOperation returns a new DeleteServiceBindingOperation from a given name. The name must be that of a previously created DeleteServiceBindingOperation, possibly from a different process.

func (*Client) DeleteServiceLbPolicy

func (c *Client) DeleteServiceLbPolicy(ctx context.Context, req *networkservicespb.DeleteServiceLbPolicyRequest, opts ...gax.CallOption) (*DeleteServiceLbPolicyOperation, error)

DeleteServiceLbPolicy deletes a single ServiceLbPolicy.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteServiceLbPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteServiceLbPolicyRequest.
	}
	op, err := c.DeleteServiceLbPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteServiceLbPolicyOperation

func (c *Client) DeleteServiceLbPolicyOperation(name string) *DeleteServiceLbPolicyOperation

DeleteServiceLbPolicyOperation returns a new DeleteServiceLbPolicyOperation from a given name. The name must be that of a previously created DeleteServiceLbPolicyOperation, possibly from a different process.

func (*Client) DeleteTcpRoute

func (c *Client) DeleteTcpRoute(ctx context.Context, req *networkservicespb.DeleteTcpRouteRequest, opts ...gax.CallOption) (*DeleteTcpRouteOperation, error)

DeleteTcpRoute deletes a single TcpRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteTcpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteTcpRouteRequest.
	}
	op, err := c.DeleteTcpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteTcpRouteOperation

func (c *Client) DeleteTcpRouteOperation(name string) *DeleteTcpRouteOperation

DeleteTcpRouteOperation returns a new DeleteTcpRouteOperation from a given name. The name must be that of a previously created DeleteTcpRouteOperation, possibly from a different process.

func (*Client) DeleteTlsRoute

func (c *Client) DeleteTlsRoute(ctx context.Context, req *networkservicespb.DeleteTlsRouteRequest, opts ...gax.CallOption) (*DeleteTlsRouteOperation, error)

DeleteTlsRoute deletes a single TlsRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteTlsRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteTlsRouteRequest.
	}
	op, err := c.DeleteTlsRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteTlsRouteOperation

func (c *Client) DeleteTlsRouteOperation(name string) *DeleteTlsRouteOperation

DeleteTlsRouteOperation returns a new DeleteTlsRouteOperation from a given name. The name must be that of a previously created DeleteTlsRouteOperation, possibly from a different process.

func (*Client) DeleteWasmPlugin

func (c *Client) DeleteWasmPlugin(ctx context.Context, req *networkservicespb.DeleteWasmPluginRequest, opts ...gax.CallOption) (*DeleteWasmPluginOperation, error)

DeleteWasmPlugin deletes the specified WasmPlugin resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteWasmPluginRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteWasmPluginRequest.
	}
	op, err := c.DeleteWasmPlugin(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteWasmPluginOperation

func (c *Client) DeleteWasmPluginOperation(name string) *DeleteWasmPluginOperation

DeleteWasmPluginOperation returns a new DeleteWasmPluginOperation from a given name. The name must be that of a previously created DeleteWasmPluginOperation, possibly from a different process.

func (*Client) DeleteWasmPluginVersion

func (c *Client) DeleteWasmPluginVersion(ctx context.Context, req *networkservicespb.DeleteWasmPluginVersionRequest, opts ...gax.CallOption) (*DeleteWasmPluginVersionOperation, error)

DeleteWasmPluginVersion deletes the specified WasmPluginVersion resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteWasmPluginVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteWasmPluginVersionRequest.
	}
	op, err := c.DeleteWasmPluginVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*Client) DeleteWasmPluginVersionOperation

func (c *Client) DeleteWasmPluginVersionOperation(name string) *DeleteWasmPluginVersionOperation

DeleteWasmPluginVersionOperation returns a new DeleteWasmPluginVersionOperation from a given name. The name must be that of a previously created DeleteWasmPluginVersionOperation, possibly from a different process.

func (*Client) GetEndpointPolicy

func (c *Client) GetEndpointPolicy(ctx context.Context, req *networkservicespb.GetEndpointPolicyRequest, opts ...gax.CallOption) (*networkservicespb.EndpointPolicy, error)

GetEndpointPolicy gets details of a single EndpointPolicy.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetEndpointPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetEndpointPolicyRequest.
	}
	resp, err := c.GetEndpointPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetGateway

func (c *Client) GetGateway(ctx context.Context, req *networkservicespb.GetGatewayRequest, opts ...gax.CallOption) (*networkservicespb.Gateway, error)

GetGateway gets details of a single Gateway.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetGatewayRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetGatewayRequest.
	}
	resp, err := c.GetGateway(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetGatewayRouteView

func (c *Client) GetGatewayRouteView(ctx context.Context, req *networkservicespb.GetGatewayRouteViewRequest, opts ...gax.CallOption) (*networkservicespb.GatewayRouteView, error)

GetGatewayRouteView get a single RouteView of a Gateway.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetGatewayRouteViewRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetGatewayRouteViewRequest.
	}
	resp, err := c.GetGatewayRouteView(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetGrpcRoute

func (c *Client) GetGrpcRoute(ctx context.Context, req *networkservicespb.GetGrpcRouteRequest, opts ...gax.CallOption) (*networkservicespb.GrpcRoute, error)

GetGrpcRoute gets details of a single GrpcRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetGrpcRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetGrpcRouteRequest.
	}
	resp, err := c.GetGrpcRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetHttpRoute

func (c *Client) GetHttpRoute(ctx context.Context, req *networkservicespb.GetHttpRouteRequest, opts ...gax.CallOption) (*networkservicespb.HttpRoute, error)

GetHttpRoute gets details of a single HttpRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetHttpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetHttpRouteRequest.
	}
	resp, err := c.GetHttpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetIamPolicy

func (c *Client) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error)

GetIamPolicy gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.

Example

package main

import (
	"context"

	iampb "cloud.google.com/go/iam/apiv1/iampb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &iampb.GetIamPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/iam/apiv1/iampb#GetIamPolicyRequest.
	}
	resp, err := c.GetIamPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetLocation

func (c *Client) GetLocation(ctx context.Context, req *locationpb.GetLocationRequest, opts ...gax.CallOption) (*locationpb.Location, error)

GetLocation gets information about a location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.GetLocationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#GetLocationRequest.
	}
	resp, err := c.GetLocation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetMesh

func (c *Client) GetMesh(ctx context.Context, req *networkservicespb.GetMeshRequest, opts ...gax.CallOption) (*networkservicespb.Mesh, error)

GetMesh gets details of a single Mesh.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetMeshRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetMeshRequest.
	}
	resp, err := c.GetMesh(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetMeshRouteView

func (c *Client) GetMeshRouteView(ctx context.Context, req *networkservicespb.GetMeshRouteViewRequest, opts ...gax.CallOption) (*networkservicespb.MeshRouteView, error)

GetMeshRouteView get a single RouteView of a Mesh.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetMeshRouteViewRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetMeshRouteViewRequest.
	}
	resp, err := c.GetMeshRouteView(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetOperation

func (c *Client) GetOperation(ctx context.Context, req *longrunningpb.GetOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error)

GetOperation is a utility method from google.longrunning.Operations.

Example

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.GetOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#GetOperationRequest.
	}
	resp, err := c.GetOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetServiceBinding

func (c *Client) GetServiceBinding(ctx context.Context, req *networkservicespb.GetServiceBindingRequest, opts ...gax.CallOption) (*networkservicespb.ServiceBinding, error)

GetServiceBinding gets details of a single ServiceBinding.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetServiceBindingRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetServiceBindingRequest.
	}
	resp, err := c.GetServiceBinding(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetServiceLbPolicy

func (c *Client) GetServiceLbPolicy(ctx context.Context, req *networkservicespb.GetServiceLbPolicyRequest, opts ...gax.CallOption) (*networkservicespb.ServiceLbPolicy, error)

GetServiceLbPolicy gets details of a single ServiceLbPolicy.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetServiceLbPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetServiceLbPolicyRequest.
	}
	resp, err := c.GetServiceLbPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetTcpRoute

func (c *Client) GetTcpRoute(ctx context.Context, req *networkservicespb.GetTcpRouteRequest, opts ...gax.CallOption) (*networkservicespb.TcpRoute, error)

GetTcpRoute gets details of a single TcpRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetTcpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetTcpRouteRequest.
	}
	resp, err := c.GetTcpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetTlsRoute

func (c *Client) GetTlsRoute(ctx context.Context, req *networkservicespb.GetTlsRouteRequest, opts ...gax.CallOption) (*networkservicespb.TlsRoute, error)

GetTlsRoute gets details of a single TlsRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetTlsRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetTlsRouteRequest.
	}
	resp, err := c.GetTlsRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetWasmPlugin

func (c *Client) GetWasmPlugin(ctx context.Context, req *networkservicespb.GetWasmPluginRequest, opts ...gax.CallOption) (*networkservicespb.WasmPlugin, error)

GetWasmPlugin gets details of the specified WasmPlugin resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetWasmPluginRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetWasmPluginRequest.
	}
	resp, err := c.GetWasmPlugin(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) GetWasmPluginVersion

func (c *Client) GetWasmPluginVersion(ctx context.Context, req *networkservicespb.GetWasmPluginVersionRequest, opts ...gax.CallOption) (*networkservicespb.WasmPluginVersion, error)

GetWasmPluginVersion gets details of the specified WasmPluginVersion resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetWasmPluginVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetWasmPluginVersionRequest.
	}
	resp, err := c.GetWasmPluginVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) ListEndpointPolicies

func (c *Client) ListEndpointPolicies(ctx context.Context, req *networkservicespb.ListEndpointPoliciesRequest, opts ...gax.CallOption) *EndpointPolicyIterator

ListEndpointPolicies lists EndpointPolicies in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListEndpointPoliciesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListEndpointPoliciesRequest.
	}
	it := c.ListEndpointPolicies(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListEndpointPoliciesResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListEndpointPoliciesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListEndpointPoliciesRequest.
	}
	for resp, err := range c.ListEndpointPolicies(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListGatewayRouteViews

func (c *Client) ListGatewayRouteViews(ctx context.Context, req *networkservicespb.ListGatewayRouteViewsRequest, opts ...gax.CallOption) *GatewayRouteViewIterator

ListGatewayRouteViews lists RouteViews

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListGatewayRouteViewsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListGatewayRouteViewsRequest.
	}
	it := c.ListGatewayRouteViews(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListGatewayRouteViewsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListGatewayRouteViewsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListGatewayRouteViewsRequest.
	}
	for resp, err := range c.ListGatewayRouteViews(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListGateways

func (c *Client) ListGateways(ctx context.Context, req *networkservicespb.ListGatewaysRequest, opts ...gax.CallOption) *GatewayIterator

ListGateways lists Gateways in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListGatewaysRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListGatewaysRequest.
	}
	it := c.ListGateways(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListGatewaysResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListGatewaysRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListGatewaysRequest.
	}
	for resp, err := range c.ListGateways(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListGrpcRoutes

func (c *Client) ListGrpcRoutes(ctx context.Context, req *networkservicespb.ListGrpcRoutesRequest, opts ...gax.CallOption) *GrpcRouteIterator

ListGrpcRoutes lists GrpcRoutes in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListGrpcRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListGrpcRoutesRequest.
	}
	it := c.ListGrpcRoutes(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListGrpcRoutesResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListGrpcRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListGrpcRoutesRequest.
	}
	for resp, err := range c.ListGrpcRoutes(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListHttpRoutes

func (c *Client) ListHttpRoutes(ctx context.Context, req *networkservicespb.ListHttpRoutesRequest, opts ...gax.CallOption) *HttpRouteIterator

ListHttpRoutes lists HttpRoute in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListHttpRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListHttpRoutesRequest.
	}
	it := c.ListHttpRoutes(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListHttpRoutesResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListHttpRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListHttpRoutesRequest.
	}
	for resp, err := range c.ListHttpRoutes(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListLocations

func (c *Client) ListLocations(ctx context.Context, req *locationpb.ListLocationsRequest, opts ...gax.CallOption) *LocationIterator

ListLocations lists information about the supported locations for this service.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"
	"google.golang.org/api/iterator"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.ListLocationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#ListLocationsRequest.
	}
	it := c.ListLocations(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*locationpb.ListLocationsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.ListLocationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#ListLocationsRequest.
	}
	for resp, err := range c.ListLocations(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListMeshRouteViews

func (c *Client) ListMeshRouteViews(ctx context.Context, req *networkservicespb.ListMeshRouteViewsRequest, opts ...gax.CallOption) *MeshRouteViewIterator

ListMeshRouteViews lists RouteViews

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListMeshRouteViewsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListMeshRouteViewsRequest.
	}
	it := c.ListMeshRouteViews(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListMeshRouteViewsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListMeshRouteViewsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListMeshRouteViewsRequest.
	}
	for resp, err := range c.ListMeshRouteViews(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListMeshes

func (c *Client) ListMeshes(ctx context.Context, req *networkservicespb.ListMeshesRequest, opts ...gax.CallOption) *MeshIterator

ListMeshes lists Meshes in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListMeshesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListMeshesRequest.
	}
	it := c.ListMeshes(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListMeshesResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListMeshesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListMeshesRequest.
	}
	for resp, err := range c.ListMeshes(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListOperations

func (c *Client) ListOperations(ctx context.Context, req *longrunningpb.ListOperationsRequest, opts ...gax.CallOption) *OperationIterator

ListOperations is a utility method from google.longrunning.Operations.

Examples

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.ListOperationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#ListOperationsRequest.
	}
	it := c.ListOperations(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*longrunningpb.ListOperationsResponse)
	}
}

all

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.ListOperationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#ListOperationsRequest.
	}
	for resp, err := range c.ListOperations(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListServiceBindings

func (c *Client) ListServiceBindings(ctx context.Context, req *networkservicespb.ListServiceBindingsRequest, opts ...gax.CallOption) *ServiceBindingIterator

ListServiceBindings lists ServiceBinding in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListServiceBindingsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListServiceBindingsRequest.
	}
	it := c.ListServiceBindings(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListServiceBindingsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListServiceBindingsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListServiceBindingsRequest.
	}
	for resp, err := range c.ListServiceBindings(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListServiceLbPolicies

func (c *Client) ListServiceLbPolicies(ctx context.Context, req *networkservicespb.ListServiceLbPoliciesRequest, opts ...gax.CallOption) *ServiceLbPolicyIterator

ListServiceLbPolicies lists ServiceLbPolicies in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListServiceLbPoliciesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListServiceLbPoliciesRequest.
	}
	it := c.ListServiceLbPolicies(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListServiceLbPoliciesResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListServiceLbPoliciesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListServiceLbPoliciesRequest.
	}
	for resp, err := range c.ListServiceLbPolicies(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListTcpRoutes

func (c *Client) ListTcpRoutes(ctx context.Context, req *networkservicespb.ListTcpRoutesRequest, opts ...gax.CallOption) *TcpRouteIterator

ListTcpRoutes lists TcpRoute in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListTcpRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListTcpRoutesRequest.
	}
	it := c.ListTcpRoutes(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListTcpRoutesResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListTcpRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListTcpRoutesRequest.
	}
	for resp, err := range c.ListTcpRoutes(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListTlsRoutes

func (c *Client) ListTlsRoutes(ctx context.Context, req *networkservicespb.ListTlsRoutesRequest, opts ...gax.CallOption) *TlsRouteIterator

ListTlsRoutes lists TlsRoute in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListTlsRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListTlsRoutesRequest.
	}
	it := c.ListTlsRoutes(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListTlsRoutesResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListTlsRoutesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListTlsRoutesRequest.
	}
	for resp, err := range c.ListTlsRoutes(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListWasmPluginVersions

func (c *Client) ListWasmPluginVersions(ctx context.Context, req *networkservicespb.ListWasmPluginVersionsRequest, opts ...gax.CallOption) *WasmPluginVersionIterator

ListWasmPluginVersions lists WasmPluginVersion resources in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListWasmPluginVersionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListWasmPluginVersionsRequest.
	}
	it := c.ListWasmPluginVersions(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListWasmPluginVersionsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListWasmPluginVersionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListWasmPluginVersionsRequest.
	}
	for resp, err := range c.ListWasmPluginVersions(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) ListWasmPlugins

func (c *Client) ListWasmPlugins(ctx context.Context, req *networkservicespb.ListWasmPluginsRequest, opts ...gax.CallOption) *WasmPluginIterator

ListWasmPlugins lists WasmPlugin resources in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListWasmPluginsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListWasmPluginsRequest.
	}
	it := c.ListWasmPlugins(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListWasmPluginsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListWasmPluginsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListWasmPluginsRequest.
	}
	for resp, err := range c.ListWasmPlugins(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*Client) SetIamPolicy

func (c *Client) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error)

SetIamPolicy sets the access control policy on the specified resource. Replaces any existing policy.

Can return NOT_FOUND, INVALID_ARGUMENT, and PERMISSION_DENIED errors.

Example

package main

import (
	"context"

	iampb "cloud.google.com/go/iam/apiv1/iampb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &iampb.SetIamPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/iam/apiv1/iampb#SetIamPolicyRequest.
	}
	resp, err := c.SetIamPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) TestIamPermissions

func (c *Client) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest, opts ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error)

TestIamPermissions returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a NOT_FOUND error.

Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may “fail open” without warning.

Example

package main

import (
	"context"

	iampb "cloud.google.com/go/iam/apiv1/iampb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &iampb.TestIamPermissionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/iam/apiv1/iampb#TestIamPermissionsRequest.
	}
	resp, err := c.TestIamPermissions(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateEndpointPolicy

func (c *Client) UpdateEndpointPolicy(ctx context.Context, req *networkservicespb.UpdateEndpointPolicyRequest, opts ...gax.CallOption) (*UpdateEndpointPolicyOperation, error)

UpdateEndpointPolicy updates the parameters of a single EndpointPolicy.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateEndpointPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateEndpointPolicyRequest.
	}
	op, err := c.UpdateEndpointPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateEndpointPolicyOperation

func (c *Client) UpdateEndpointPolicyOperation(name string) *UpdateEndpointPolicyOperation

UpdateEndpointPolicyOperation returns a new UpdateEndpointPolicyOperation from a given name. The name must be that of a previously created UpdateEndpointPolicyOperation, possibly from a different process.

func (*Client) UpdateGateway

func (c *Client) UpdateGateway(ctx context.Context, req *networkservicespb.UpdateGatewayRequest, opts ...gax.CallOption) (*UpdateGatewayOperation, error)

UpdateGateway updates the parameters of a single Gateway.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateGatewayRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateGatewayRequest.
	}
	op, err := c.UpdateGateway(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateGatewayOperation

func (c *Client) UpdateGatewayOperation(name string) *UpdateGatewayOperation

UpdateGatewayOperation returns a new UpdateGatewayOperation from a given name. The name must be that of a previously created UpdateGatewayOperation, possibly from a different process.

func (*Client) UpdateGrpcRoute

func (c *Client) UpdateGrpcRoute(ctx context.Context, req *networkservicespb.UpdateGrpcRouteRequest, opts ...gax.CallOption) (*UpdateGrpcRouteOperation, error)

UpdateGrpcRoute updates the parameters of a single GrpcRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateGrpcRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateGrpcRouteRequest.
	}
	op, err := c.UpdateGrpcRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateGrpcRouteOperation

func (c *Client) UpdateGrpcRouteOperation(name string) *UpdateGrpcRouteOperation

UpdateGrpcRouteOperation returns a new UpdateGrpcRouteOperation from a given name. The name must be that of a previously created UpdateGrpcRouteOperation, possibly from a different process.

func (*Client) UpdateHttpRoute

func (c *Client) UpdateHttpRoute(ctx context.Context, req *networkservicespb.UpdateHttpRouteRequest, opts ...gax.CallOption) (*UpdateHttpRouteOperation, error)

UpdateHttpRoute updates the parameters of a single HttpRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateHttpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateHttpRouteRequest.
	}
	op, err := c.UpdateHttpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateHttpRouteOperation

func (c *Client) UpdateHttpRouteOperation(name string) *UpdateHttpRouteOperation

UpdateHttpRouteOperation returns a new UpdateHttpRouteOperation from a given name. The name must be that of a previously created UpdateHttpRouteOperation, possibly from a different process.

func (*Client) UpdateMesh

func (c *Client) UpdateMesh(ctx context.Context, req *networkservicespb.UpdateMeshRequest, opts ...gax.CallOption) (*UpdateMeshOperation, error)

UpdateMesh updates the parameters of a single Mesh.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateMeshRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateMeshRequest.
	}
	op, err := c.UpdateMesh(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateMeshOperation

func (c *Client) UpdateMeshOperation(name string) *UpdateMeshOperation

UpdateMeshOperation returns a new UpdateMeshOperation from a given name. The name must be that of a previously created UpdateMeshOperation, possibly from a different process.

func (*Client) UpdateServiceBinding

func (c *Client) UpdateServiceBinding(ctx context.Context, req *networkservicespb.UpdateServiceBindingRequest, opts ...gax.CallOption) (*UpdateServiceBindingOperation, error)

UpdateServiceBinding updates the parameters of a single ServiceBinding.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateServiceBindingRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateServiceBindingRequest.
	}
	op, err := c.UpdateServiceBinding(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateServiceBindingOperation

func (c *Client) UpdateServiceBindingOperation(name string) *UpdateServiceBindingOperation

UpdateServiceBindingOperation returns a new UpdateServiceBindingOperation from a given name. The name must be that of a previously created UpdateServiceBindingOperation, possibly from a different process.

func (*Client) UpdateServiceLbPolicy

func (c *Client) UpdateServiceLbPolicy(ctx context.Context, req *networkservicespb.UpdateServiceLbPolicyRequest, opts ...gax.CallOption) (*UpdateServiceLbPolicyOperation, error)

UpdateServiceLbPolicy updates the parameters of a single ServiceLbPolicy.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateServiceLbPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateServiceLbPolicyRequest.
	}
	op, err := c.UpdateServiceLbPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateServiceLbPolicyOperation

func (c *Client) UpdateServiceLbPolicyOperation(name string) *UpdateServiceLbPolicyOperation

UpdateServiceLbPolicyOperation returns a new UpdateServiceLbPolicyOperation from a given name. The name must be that of a previously created UpdateServiceLbPolicyOperation, possibly from a different process.

func (*Client) UpdateTcpRoute

func (c *Client) UpdateTcpRoute(ctx context.Context, req *networkservicespb.UpdateTcpRouteRequest, opts ...gax.CallOption) (*UpdateTcpRouteOperation, error)

UpdateTcpRoute updates the parameters of a single TcpRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateTcpRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateTcpRouteRequest.
	}
	op, err := c.UpdateTcpRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateTcpRouteOperation

func (c *Client) UpdateTcpRouteOperation(name string) *UpdateTcpRouteOperation

UpdateTcpRouteOperation returns a new UpdateTcpRouteOperation from a given name. The name must be that of a previously created UpdateTcpRouteOperation, possibly from a different process.

func (*Client) UpdateTlsRoute

func (c *Client) UpdateTlsRoute(ctx context.Context, req *networkservicespb.UpdateTlsRouteRequest, opts ...gax.CallOption) (*UpdateTlsRouteOperation, error)

UpdateTlsRoute updates the parameters of a single TlsRoute.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateTlsRouteRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateTlsRouteRequest.
	}
	op, err := c.UpdateTlsRoute(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateTlsRouteOperation

func (c *Client) UpdateTlsRouteOperation(name string) *UpdateTlsRouteOperation

UpdateTlsRouteOperation returns a new UpdateTlsRouteOperation from a given name. The name must be that of a previously created UpdateTlsRouteOperation, possibly from a different process.

func (*Client) UpdateWasmPlugin

func (c *Client) UpdateWasmPlugin(ctx context.Context, req *networkservicespb.UpdateWasmPluginRequest, opts ...gax.CallOption) (*UpdateWasmPluginOperation, error)

UpdateWasmPlugin updates the parameters of the specified WasmPlugin resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateWasmPluginRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateWasmPluginRequest.
	}
	op, err := c.UpdateWasmPlugin(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*Client) UpdateWasmPluginOperation

func (c *Client) UpdateWasmPluginOperation(name string) *UpdateWasmPluginOperation

UpdateWasmPluginOperation returns a new UpdateWasmPluginOperation from a given name. The name must be that of a previously created UpdateWasmPluginOperation, possibly from a different process.

CreateAuthzExtensionOperation

type CreateAuthzExtensionOperation struct {
	// contains filtered or unexported fields
}

CreateAuthzExtensionOperation manages a long-running operation from CreateAuthzExtension.

func (*CreateAuthzExtensionOperation) Done

func (op *CreateAuthzExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateAuthzExtensionOperation) Metadata

func (op *CreateAuthzExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateAuthzExtensionOperation) Name

func (op *CreateAuthzExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateAuthzExtensionOperation) Poll

func (op *CreateAuthzExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.AuthzExtension, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateAuthzExtensionOperation) Wait

func (op *CreateAuthzExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.AuthzExtension, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateEndpointPolicyOperation

type CreateEndpointPolicyOperation struct {
	// contains filtered or unexported fields
}

CreateEndpointPolicyOperation manages a long-running operation from CreateEndpointPolicy.

func (*CreateEndpointPolicyOperation) Done

func (op *CreateEndpointPolicyOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateEndpointPolicyOperation) Metadata

func (op *CreateEndpointPolicyOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateEndpointPolicyOperation) Name

func (op *CreateEndpointPolicyOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateEndpointPolicyOperation) Poll

func (op *CreateEndpointPolicyOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.EndpointPolicy, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateEndpointPolicyOperation) Wait

func (op *CreateEndpointPolicyOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.EndpointPolicy, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateGatewayOperation

type CreateGatewayOperation struct {
	// contains filtered or unexported fields
}

CreateGatewayOperation manages a long-running operation from CreateGateway.

func (*CreateGatewayOperation) Done

func (op *CreateGatewayOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateGatewayOperation) Metadata

func (op *CreateGatewayOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateGatewayOperation) Name

func (op *CreateGatewayOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateGatewayOperation) Poll

func (op *CreateGatewayOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Gateway, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateGatewayOperation) Wait

func (op *CreateGatewayOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Gateway, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateGrpcRouteOperation

type CreateGrpcRouteOperation struct {
	// contains filtered or unexported fields
}

CreateGrpcRouteOperation manages a long-running operation from CreateGrpcRoute.

func (*CreateGrpcRouteOperation) Done

func (op *CreateGrpcRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateGrpcRouteOperation) Metadata

func (op *CreateGrpcRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateGrpcRouteOperation) Name

func (op *CreateGrpcRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateGrpcRouteOperation) Poll

func (op *CreateGrpcRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.GrpcRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateGrpcRouteOperation) Wait

func (op *CreateGrpcRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.GrpcRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateHttpRouteOperation

type CreateHttpRouteOperation struct {
	// contains filtered or unexported fields
}

CreateHttpRouteOperation manages a long-running operation from CreateHttpRoute.

func (*CreateHttpRouteOperation) Done

func (op *CreateHttpRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateHttpRouteOperation) Metadata

func (op *CreateHttpRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateHttpRouteOperation) Name

func (op *CreateHttpRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateHttpRouteOperation) Poll

func (op *CreateHttpRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.HttpRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateHttpRouteOperation) Wait

func (op *CreateHttpRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.HttpRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateLbRouteExtensionOperation

type CreateLbRouteExtensionOperation struct {
	// contains filtered or unexported fields
}

CreateLbRouteExtensionOperation manages a long-running operation from CreateLbRouteExtension.

func (*CreateLbRouteExtensionOperation) Done

func (op *CreateLbRouteExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateLbRouteExtensionOperation) Metadata

func (op *CreateLbRouteExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateLbRouteExtensionOperation) Name

func (op *CreateLbRouteExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateLbRouteExtensionOperation) Poll

func (op *CreateLbRouteExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbRouteExtension, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateLbRouteExtensionOperation) Wait

func (op *CreateLbRouteExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbRouteExtension, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateLbTrafficExtensionOperation

type CreateLbTrafficExtensionOperation struct {
	// contains filtered or unexported fields
}

CreateLbTrafficExtensionOperation manages a long-running operation from CreateLbTrafficExtension.

func (*CreateLbTrafficExtensionOperation) Done

func (op *CreateLbTrafficExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateLbTrafficExtensionOperation) Metadata

func (op *CreateLbTrafficExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateLbTrafficExtensionOperation) Name

func (op *CreateLbTrafficExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateLbTrafficExtensionOperation) Poll

func (op *CreateLbTrafficExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbTrafficExtension, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateLbTrafficExtensionOperation) Wait

func (op *CreateLbTrafficExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbTrafficExtension, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateMeshOperation

type CreateMeshOperation struct {
	// contains filtered or unexported fields
}

CreateMeshOperation manages a long-running operation from CreateMesh.

func (*CreateMeshOperation) Done

func (op *CreateMeshOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateMeshOperation) Metadata

func (op *CreateMeshOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateMeshOperation) Name

func (op *CreateMeshOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateMeshOperation) Poll

func (op *CreateMeshOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Mesh, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateMeshOperation) Wait

func (op *CreateMeshOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Mesh, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateServiceBindingOperation

type CreateServiceBindingOperation struct {
	// contains filtered or unexported fields
}

CreateServiceBindingOperation manages a long-running operation from CreateServiceBinding.

func (*CreateServiceBindingOperation) Done

func (op *CreateServiceBindingOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateServiceBindingOperation) Metadata

func (op *CreateServiceBindingOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateServiceBindingOperation) Name

func (op *CreateServiceBindingOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateServiceBindingOperation) Poll

func (op *CreateServiceBindingOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceBinding, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateServiceBindingOperation) Wait

func (op *CreateServiceBindingOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceBinding, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateServiceLbPolicyOperation

type CreateServiceLbPolicyOperation struct {
	// contains filtered or unexported fields
}

CreateServiceLbPolicyOperation manages a long-running operation from CreateServiceLbPolicy.

func (*CreateServiceLbPolicyOperation) Done

func (op *CreateServiceLbPolicyOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateServiceLbPolicyOperation) Metadata

func (op *CreateServiceLbPolicyOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateServiceLbPolicyOperation) Name

func (op *CreateServiceLbPolicyOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateServiceLbPolicyOperation) Poll

func (op *CreateServiceLbPolicyOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceLbPolicy, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateServiceLbPolicyOperation) Wait

func (op *CreateServiceLbPolicyOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceLbPolicy, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateTcpRouteOperation

type CreateTcpRouteOperation struct {
	// contains filtered or unexported fields
}

CreateTcpRouteOperation manages a long-running operation from CreateTcpRoute.

func (*CreateTcpRouteOperation) Done

func (op *CreateTcpRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateTcpRouteOperation) Metadata

func (op *CreateTcpRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateTcpRouteOperation) Name

func (op *CreateTcpRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateTcpRouteOperation) Poll

func (op *CreateTcpRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TcpRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateTcpRouteOperation) Wait

func (op *CreateTcpRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TcpRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateTlsRouteOperation

type CreateTlsRouteOperation struct {
	// contains filtered or unexported fields
}

CreateTlsRouteOperation manages a long-running operation from CreateTlsRoute.

func (*CreateTlsRouteOperation) Done

func (op *CreateTlsRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateTlsRouteOperation) Metadata

func (op *CreateTlsRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateTlsRouteOperation) Name

func (op *CreateTlsRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateTlsRouteOperation) Poll

func (op *CreateTlsRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TlsRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateTlsRouteOperation) Wait

func (op *CreateTlsRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TlsRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateWasmPluginOperation

type CreateWasmPluginOperation struct {
	// contains filtered or unexported fields
}

CreateWasmPluginOperation manages a long-running operation from CreateWasmPlugin.

func (*CreateWasmPluginOperation) Done

func (op *CreateWasmPluginOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateWasmPluginOperation) Metadata

func (op *CreateWasmPluginOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateWasmPluginOperation) Name

func (op *CreateWasmPluginOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateWasmPluginOperation) Poll

func (op *CreateWasmPluginOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.WasmPlugin, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateWasmPluginOperation) Wait

func (op *CreateWasmPluginOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.WasmPlugin, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

CreateWasmPluginVersionOperation

type CreateWasmPluginVersionOperation struct {
	// contains filtered or unexported fields
}

CreateWasmPluginVersionOperation manages a long-running operation from CreateWasmPluginVersion.

func (*CreateWasmPluginVersionOperation) Done

func (op *CreateWasmPluginVersionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateWasmPluginVersionOperation) Metadata

func (op *CreateWasmPluginVersionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*CreateWasmPluginVersionOperation) Name

func (op *CreateWasmPluginVersionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*CreateWasmPluginVersionOperation) Poll

func (op *CreateWasmPluginVersionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.WasmPluginVersion, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*CreateWasmPluginVersionOperation) Wait

func (op *CreateWasmPluginVersionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.WasmPluginVersion, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteAuthzExtensionOperation

type DeleteAuthzExtensionOperation struct {
	// contains filtered or unexported fields
}

DeleteAuthzExtensionOperation manages a long-running operation from DeleteAuthzExtension.

func (*DeleteAuthzExtensionOperation) Done

func (op *DeleteAuthzExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteAuthzExtensionOperation) Metadata

func (op *DeleteAuthzExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteAuthzExtensionOperation) Name

func (op *DeleteAuthzExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteAuthzExtensionOperation) Poll

func (op *DeleteAuthzExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteAuthzExtensionOperation) Wait

func (op *DeleteAuthzExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteEndpointPolicyOperation

type DeleteEndpointPolicyOperation struct {
	// contains filtered or unexported fields
}

DeleteEndpointPolicyOperation manages a long-running operation from DeleteEndpointPolicy.

func (*DeleteEndpointPolicyOperation) Done

func (op *DeleteEndpointPolicyOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteEndpointPolicyOperation) Metadata

func (op *DeleteEndpointPolicyOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteEndpointPolicyOperation) Name

func (op *DeleteEndpointPolicyOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteEndpointPolicyOperation) Poll

func (op *DeleteEndpointPolicyOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteEndpointPolicyOperation) Wait

func (op *DeleteEndpointPolicyOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteGatewayOperation

type DeleteGatewayOperation struct {
	// contains filtered or unexported fields
}

DeleteGatewayOperation manages a long-running operation from DeleteGateway.

func (*DeleteGatewayOperation) Done

func (op *DeleteGatewayOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteGatewayOperation) Metadata

func (op *DeleteGatewayOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteGatewayOperation) Name

func (op *DeleteGatewayOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteGatewayOperation) Poll

func (op *DeleteGatewayOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteGatewayOperation) Wait

func (op *DeleteGatewayOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteGrpcRouteOperation

type DeleteGrpcRouteOperation struct {
	// contains filtered or unexported fields
}

DeleteGrpcRouteOperation manages a long-running operation from DeleteGrpcRoute.

func (*DeleteGrpcRouteOperation) Done

func (op *DeleteGrpcRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteGrpcRouteOperation) Metadata

func (op *DeleteGrpcRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteGrpcRouteOperation) Name

func (op *DeleteGrpcRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteGrpcRouteOperation) Poll

func (op *DeleteGrpcRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteGrpcRouteOperation) Wait

func (op *DeleteGrpcRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteHttpRouteOperation

type DeleteHttpRouteOperation struct {
	// contains filtered or unexported fields
}

DeleteHttpRouteOperation manages a long-running operation from DeleteHttpRoute.

func (*DeleteHttpRouteOperation) Done

func (op *DeleteHttpRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteHttpRouteOperation) Metadata

func (op *DeleteHttpRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteHttpRouteOperation) Name

func (op *DeleteHttpRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteHttpRouteOperation) Poll

func (op *DeleteHttpRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteHttpRouteOperation) Wait

func (op *DeleteHttpRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteLbRouteExtensionOperation

type DeleteLbRouteExtensionOperation struct {
	// contains filtered or unexported fields
}

DeleteLbRouteExtensionOperation manages a long-running operation from DeleteLbRouteExtension.

func (*DeleteLbRouteExtensionOperation) Done

func (op *DeleteLbRouteExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteLbRouteExtensionOperation) Metadata

func (op *DeleteLbRouteExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteLbRouteExtensionOperation) Name

func (op *DeleteLbRouteExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteLbRouteExtensionOperation) Poll

func (op *DeleteLbRouteExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteLbRouteExtensionOperation) Wait

func (op *DeleteLbRouteExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteLbTrafficExtensionOperation

type DeleteLbTrafficExtensionOperation struct {
	// contains filtered or unexported fields
}

DeleteLbTrafficExtensionOperation manages a long-running operation from DeleteLbTrafficExtension.

func (*DeleteLbTrafficExtensionOperation) Done

func (op *DeleteLbTrafficExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteLbTrafficExtensionOperation) Metadata

func (op *DeleteLbTrafficExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteLbTrafficExtensionOperation) Name

func (op *DeleteLbTrafficExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteLbTrafficExtensionOperation) Poll

func (op *DeleteLbTrafficExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteLbTrafficExtensionOperation) Wait

func (op *DeleteLbTrafficExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteMeshOperation

type DeleteMeshOperation struct {
	// contains filtered or unexported fields
}

DeleteMeshOperation manages a long-running operation from DeleteMesh.

func (*DeleteMeshOperation) Done

func (op *DeleteMeshOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteMeshOperation) Metadata

func (op *DeleteMeshOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteMeshOperation) Name

func (op *DeleteMeshOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteMeshOperation) Poll

func (op *DeleteMeshOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteMeshOperation) Wait

func (op *DeleteMeshOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteServiceBindingOperation

type DeleteServiceBindingOperation struct {
	// contains filtered or unexported fields
}

DeleteServiceBindingOperation manages a long-running operation from DeleteServiceBinding.

func (*DeleteServiceBindingOperation) Done

func (op *DeleteServiceBindingOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteServiceBindingOperation) Metadata

func (op *DeleteServiceBindingOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteServiceBindingOperation) Name

func (op *DeleteServiceBindingOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteServiceBindingOperation) Poll

func (op *DeleteServiceBindingOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteServiceBindingOperation) Wait

func (op *DeleteServiceBindingOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteServiceLbPolicyOperation

type DeleteServiceLbPolicyOperation struct {
	// contains filtered or unexported fields
}

DeleteServiceLbPolicyOperation manages a long-running operation from DeleteServiceLbPolicy.

func (*DeleteServiceLbPolicyOperation) Done

func (op *DeleteServiceLbPolicyOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteServiceLbPolicyOperation) Metadata

func (op *DeleteServiceLbPolicyOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteServiceLbPolicyOperation) Name

func (op *DeleteServiceLbPolicyOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteServiceLbPolicyOperation) Poll

func (op *DeleteServiceLbPolicyOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteServiceLbPolicyOperation) Wait

func (op *DeleteServiceLbPolicyOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteTcpRouteOperation

type DeleteTcpRouteOperation struct {
	// contains filtered or unexported fields
}

DeleteTcpRouteOperation manages a long-running operation from DeleteTcpRoute.

func (*DeleteTcpRouteOperation) Done

func (op *DeleteTcpRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteTcpRouteOperation) Metadata

func (op *DeleteTcpRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteTcpRouteOperation) Name

func (op *DeleteTcpRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteTcpRouteOperation) Poll

func (op *DeleteTcpRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteTcpRouteOperation) Wait

func (op *DeleteTcpRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteTlsRouteOperation

type DeleteTlsRouteOperation struct {
	// contains filtered or unexported fields
}

DeleteTlsRouteOperation manages a long-running operation from DeleteTlsRoute.

func (*DeleteTlsRouteOperation) Done

func (op *DeleteTlsRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteTlsRouteOperation) Metadata

func (op *DeleteTlsRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteTlsRouteOperation) Name

func (op *DeleteTlsRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteTlsRouteOperation) Poll

func (op *DeleteTlsRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteTlsRouteOperation) Wait

func (op *DeleteTlsRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteWasmPluginOperation

type DeleteWasmPluginOperation struct {
	// contains filtered or unexported fields
}

DeleteWasmPluginOperation manages a long-running operation from DeleteWasmPlugin.

func (*DeleteWasmPluginOperation) Done

func (op *DeleteWasmPluginOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteWasmPluginOperation) Metadata

func (op *DeleteWasmPluginOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteWasmPluginOperation) Name

func (op *DeleteWasmPluginOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteWasmPluginOperation) Poll

func (op *DeleteWasmPluginOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteWasmPluginOperation) Wait

func (op *DeleteWasmPluginOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DeleteWasmPluginVersionOperation

type DeleteWasmPluginVersionOperation struct {
	// contains filtered or unexported fields
}

DeleteWasmPluginVersionOperation manages a long-running operation from DeleteWasmPluginVersion.

func (*DeleteWasmPluginVersionOperation) Done

func (op *DeleteWasmPluginVersionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteWasmPluginVersionOperation) Metadata

func (op *DeleteWasmPluginVersionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*DeleteWasmPluginVersionOperation) Name

func (op *DeleteWasmPluginVersionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*DeleteWasmPluginVersionOperation) Poll

func (op *DeleteWasmPluginVersionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*DeleteWasmPluginVersionOperation) Wait

func (op *DeleteWasmPluginVersionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

DepCallOptions

type DepCallOptions struct {
	ListLbTrafficExtensions  []gax.CallOption
	GetLbTrafficExtension    []gax.CallOption
	CreateLbTrafficExtension []gax.CallOption
	UpdateLbTrafficExtension []gax.CallOption
	DeleteLbTrafficExtension []gax.CallOption
	ListLbRouteExtensions    []gax.CallOption
	GetLbRouteExtension      []gax.CallOption
	CreateLbRouteExtension   []gax.CallOption
	UpdateLbRouteExtension   []gax.CallOption
	DeleteLbRouteExtension   []gax.CallOption
	ListAuthzExtensions      []gax.CallOption
	GetAuthzExtension        []gax.CallOption
	CreateAuthzExtension     []gax.CallOption
	UpdateAuthzExtension     []gax.CallOption
	DeleteAuthzExtension     []gax.CallOption
	GetLocation              []gax.CallOption
	ListLocations            []gax.CallOption
	GetIamPolicy             []gax.CallOption
	SetIamPolicy             []gax.CallOption
	TestIamPermissions       []gax.CallOption
	CancelOperation          []gax.CallOption
	DeleteOperation          []gax.CallOption
	GetOperation             []gax.CallOption
	ListOperations           []gax.CallOption
}

DepCallOptions contains the retry settings for each method of DepClient.

DepClient

type DepClient struct {

	// The call options for this service.
	CallOptions *DepCallOptions

	// LROClient is used internally to handle long-running operations.
	// It is exposed so that its CallOptions can be modified if required.
	// Users should not Close this client.
	LROClient *lroauto.OperationsClient
	// contains filtered or unexported fields
}

DepClient is a client for interacting with Network Services API. Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

Service describing handlers for resources.

func NewDepClient

func NewDepClient(ctx context.Context, opts ...option.ClientOption) (*DepClient, error)

NewDepClient creates a new dep service client based on gRPC. The returned client must be Closed when it is done being used to clean up its underlying connections.

Service describing handlers for resources.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

func NewDepRESTClient

func NewDepRESTClient(ctx context.Context, opts ...option.ClientOption) (*DepClient, error)

NewDepRESTClient creates a new dep service rest client.

Service describing handlers for resources.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepRESTClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

func (*DepClient) CancelOperation

func (c *DepClient) CancelOperation(ctx context.Context, req *longrunningpb.CancelOperationRequest, opts ...gax.CallOption) error

CancelOperation is a utility method from google.longrunning.Operations.

Example

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.CancelOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#CancelOperationRequest.
	}
	err = c.CancelOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*DepClient) Close

func (c *DepClient) Close() error

Close closes the connection to the API service. The user should invoke this when the client is no longer required.

func (*DepClient) Connection (deprecated)

func (c *DepClient) Connection() *grpc.ClientConn

Connection returns a connection to the API service.

Deprecated: Connections are now pooled so this method does not always return the same resource.

func (*DepClient) CreateAuthzExtension

func (c *DepClient) CreateAuthzExtension(ctx context.Context, req *networkservicespb.CreateAuthzExtensionRequest, opts ...gax.CallOption) (*CreateAuthzExtensionOperation, error)

CreateAuthzExtension creates a new AuthzExtension resource in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateAuthzExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateAuthzExtensionRequest.
	}
	op, err := c.CreateAuthzExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) CreateAuthzExtensionOperation

func (c *DepClient) CreateAuthzExtensionOperation(name string) *CreateAuthzExtensionOperation

CreateAuthzExtensionOperation returns a new CreateAuthzExtensionOperation from a given name. The name must be that of a previously created CreateAuthzExtensionOperation, possibly from a different process.

func (*DepClient) CreateLbRouteExtension

func (c *DepClient) CreateLbRouteExtension(ctx context.Context, req *networkservicespb.CreateLbRouteExtensionRequest, opts ...gax.CallOption) (*CreateLbRouteExtensionOperation, error)

CreateLbRouteExtension creates a new LbRouteExtension resource in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateLbRouteExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateLbRouteExtensionRequest.
	}
	op, err := c.CreateLbRouteExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) CreateLbRouteExtensionOperation

func (c *DepClient) CreateLbRouteExtensionOperation(name string) *CreateLbRouteExtensionOperation

CreateLbRouteExtensionOperation returns a new CreateLbRouteExtensionOperation from a given name. The name must be that of a previously created CreateLbRouteExtensionOperation, possibly from a different process.

func (*DepClient) CreateLbTrafficExtension

func (c *DepClient) CreateLbTrafficExtension(ctx context.Context, req *networkservicespb.CreateLbTrafficExtensionRequest, opts ...gax.CallOption) (*CreateLbTrafficExtensionOperation, error)

CreateLbTrafficExtension creates a new LbTrafficExtension resource in a given project and location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.CreateLbTrafficExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#CreateLbTrafficExtensionRequest.
	}
	op, err := c.CreateLbTrafficExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) CreateLbTrafficExtensionOperation

func (c *DepClient) CreateLbTrafficExtensionOperation(name string) *CreateLbTrafficExtensionOperation

CreateLbTrafficExtensionOperation returns a new CreateLbTrafficExtensionOperation from a given name. The name must be that of a previously created CreateLbTrafficExtensionOperation, possibly from a different process.

func (*DepClient) DeleteAuthzExtension

func (c *DepClient) DeleteAuthzExtension(ctx context.Context, req *networkservicespb.DeleteAuthzExtensionRequest, opts ...gax.CallOption) (*DeleteAuthzExtensionOperation, error)

DeleteAuthzExtension deletes the specified AuthzExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteAuthzExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteAuthzExtensionRequest.
	}
	op, err := c.DeleteAuthzExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*DepClient) DeleteAuthzExtensionOperation

func (c *DepClient) DeleteAuthzExtensionOperation(name string) *DeleteAuthzExtensionOperation

DeleteAuthzExtensionOperation returns a new DeleteAuthzExtensionOperation from a given name. The name must be that of a previously created DeleteAuthzExtensionOperation, possibly from a different process.

func (*DepClient) DeleteLbRouteExtension

func (c *DepClient) DeleteLbRouteExtension(ctx context.Context, req *networkservicespb.DeleteLbRouteExtensionRequest, opts ...gax.CallOption) (*DeleteLbRouteExtensionOperation, error)

DeleteLbRouteExtension deletes the specified LbRouteExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteLbRouteExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteLbRouteExtensionRequest.
	}
	op, err := c.DeleteLbRouteExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*DepClient) DeleteLbRouteExtensionOperation

func (c *DepClient) DeleteLbRouteExtensionOperation(name string) *DeleteLbRouteExtensionOperation

DeleteLbRouteExtensionOperation returns a new DeleteLbRouteExtensionOperation from a given name. The name must be that of a previously created DeleteLbRouteExtensionOperation, possibly from a different process.

func (*DepClient) DeleteLbTrafficExtension

func (c *DepClient) DeleteLbTrafficExtension(ctx context.Context, req *networkservicespb.DeleteLbTrafficExtensionRequest, opts ...gax.CallOption) (*DeleteLbTrafficExtensionOperation, error)

DeleteLbTrafficExtension deletes the specified LbTrafficExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.DeleteLbTrafficExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#DeleteLbTrafficExtensionRequest.
	}
	op, err := c.DeleteLbTrafficExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*DepClient) DeleteLbTrafficExtensionOperation

func (c *DepClient) DeleteLbTrafficExtensionOperation(name string) *DeleteLbTrafficExtensionOperation

DeleteLbTrafficExtensionOperation returns a new DeleteLbTrafficExtensionOperation from a given name. The name must be that of a previously created DeleteLbTrafficExtensionOperation, possibly from a different process.

func (*DepClient) DeleteOperation

func (c *DepClient) DeleteOperation(ctx context.Context, req *longrunningpb.DeleteOperationRequest, opts ...gax.CallOption) error

DeleteOperation is a utility method from google.longrunning.Operations.

Example

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.DeleteOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#DeleteOperationRequest.
	}
	err = c.DeleteOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*DepClient) GetAuthzExtension

func (c *DepClient) GetAuthzExtension(ctx context.Context, req *networkservicespb.GetAuthzExtensionRequest, opts ...gax.CallOption) (*networkservicespb.AuthzExtension, error)

GetAuthzExtension gets details of the specified AuthzExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetAuthzExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetAuthzExtensionRequest.
	}
	resp, err := c.GetAuthzExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) GetIamPolicy

func (c *DepClient) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error)

GetIamPolicy gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.

Example

package main

import (
	"context"

	iampb "cloud.google.com/go/iam/apiv1/iampb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &iampb.GetIamPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/iam/apiv1/iampb#GetIamPolicyRequest.
	}
	resp, err := c.GetIamPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) GetLbRouteExtension

func (c *DepClient) GetLbRouteExtension(ctx context.Context, req *networkservicespb.GetLbRouteExtensionRequest, opts ...gax.CallOption) (*networkservicespb.LbRouteExtension, error)

GetLbRouteExtension gets details of the specified LbRouteExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetLbRouteExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetLbRouteExtensionRequest.
	}
	resp, err := c.GetLbRouteExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) GetLbTrafficExtension

func (c *DepClient) GetLbTrafficExtension(ctx context.Context, req *networkservicespb.GetLbTrafficExtensionRequest, opts ...gax.CallOption) (*networkservicespb.LbTrafficExtension, error)

GetLbTrafficExtension gets details of the specified LbTrafficExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.GetLbTrafficExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#GetLbTrafficExtensionRequest.
	}
	resp, err := c.GetLbTrafficExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) GetLocation

func (c *DepClient) GetLocation(ctx context.Context, req *locationpb.GetLocationRequest, opts ...gax.CallOption) (*locationpb.Location, error)

GetLocation gets information about a location.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.GetLocationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#GetLocationRequest.
	}
	resp, err := c.GetLocation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) GetOperation

func (c *DepClient) GetOperation(ctx context.Context, req *longrunningpb.GetOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error)

GetOperation is a utility method from google.longrunning.Operations.

Example

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.GetOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#GetOperationRequest.
	}
	resp, err := c.GetOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) ListAuthzExtensions

func (c *DepClient) ListAuthzExtensions(ctx context.Context, req *networkservicespb.ListAuthzExtensionsRequest, opts ...gax.CallOption) *AuthzExtensionIterator

ListAuthzExtensions lists AuthzExtension resources in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListAuthzExtensionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListAuthzExtensionsRequest.
	}
	it := c.ListAuthzExtensions(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListAuthzExtensionsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListAuthzExtensionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListAuthzExtensionsRequest.
	}
	for resp, err := range c.ListAuthzExtensions(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*DepClient) ListLbRouteExtensions

func (c *DepClient) ListLbRouteExtensions(ctx context.Context, req *networkservicespb.ListLbRouteExtensionsRequest, opts ...gax.CallOption) *LbRouteExtensionIterator

ListLbRouteExtensions lists LbRouteExtension resources in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListLbRouteExtensionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListLbRouteExtensionsRequest.
	}
	it := c.ListLbRouteExtensions(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListLbRouteExtensionsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListLbRouteExtensionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListLbRouteExtensionsRequest.
	}
	for resp, err := range c.ListLbRouteExtensions(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*DepClient) ListLbTrafficExtensions

func (c *DepClient) ListLbTrafficExtensions(ctx context.Context, req *networkservicespb.ListLbTrafficExtensionsRequest, opts ...gax.CallOption) *LbTrafficExtensionIterator

ListLbTrafficExtensions lists LbTrafficExtension resources in a given project and location.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListLbTrafficExtensionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListLbTrafficExtensionsRequest.
	}
	it := c.ListLbTrafficExtensions(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*networkservicespb.ListLbTrafficExtensionsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.ListLbTrafficExtensionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#ListLbTrafficExtensionsRequest.
	}
	for resp, err := range c.ListLbTrafficExtensions(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*DepClient) ListLocations

func (c *DepClient) ListLocations(ctx context.Context, req *locationpb.ListLocationsRequest, opts ...gax.CallOption) *LocationIterator

ListLocations lists information about the supported locations for this service.

Examples

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"
	"google.golang.org/api/iterator"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.ListLocationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#ListLocationsRequest.
	}
	it := c.ListLocations(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*locationpb.ListLocationsResponse)
	}
}

all

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.ListLocationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#ListLocationsRequest.
	}
	for resp, err := range c.ListLocations(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*DepClient) ListOperations

func (c *DepClient) ListOperations(ctx context.Context, req *longrunningpb.ListOperationsRequest, opts ...gax.CallOption) *OperationIterator

ListOperations is a utility method from google.longrunning.Operations.

Examples

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.ListOperationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#ListOperationsRequest.
	}
	it := c.ListOperations(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*longrunningpb.ListOperationsResponse)
	}
}

all

package main

import (
	"context"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.ListOperationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#ListOperationsRequest.
	}
	for resp, err := range c.ListOperations(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*DepClient) SetIamPolicy

func (c *DepClient) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error)

SetIamPolicy sets the access control policy on the specified resource. Replaces any existing policy.

Can return NOT_FOUND, INVALID_ARGUMENT, and PERMISSION_DENIED errors.

Example

package main

import (
	"context"

	iampb "cloud.google.com/go/iam/apiv1/iampb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &iampb.SetIamPolicyRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/iam/apiv1/iampb#SetIamPolicyRequest.
	}
	resp, err := c.SetIamPolicy(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) TestIamPermissions

func (c *DepClient) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest, opts ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error)

TestIamPermissions returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a NOT_FOUND error.

Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may “fail open” without warning.

Example

package main

import (
	"context"

	iampb "cloud.google.com/go/iam/apiv1/iampb"

	networkservices "cloud.google.com/go/networkservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &iampb.TestIamPermissionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/iam/apiv1/iampb#TestIamPermissionsRequest.
	}
	resp, err := c.TestIamPermissions(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) UpdateAuthzExtension

func (c *DepClient) UpdateAuthzExtension(ctx context.Context, req *networkservicespb.UpdateAuthzExtensionRequest, opts ...gax.CallOption) (*UpdateAuthzExtensionOperation, error)

UpdateAuthzExtension updates the parameters of the specified AuthzExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateAuthzExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateAuthzExtensionRequest.
	}
	op, err := c.UpdateAuthzExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) UpdateAuthzExtensionOperation

func (c *DepClient) UpdateAuthzExtensionOperation(name string) *UpdateAuthzExtensionOperation

UpdateAuthzExtensionOperation returns a new UpdateAuthzExtensionOperation from a given name. The name must be that of a previously created UpdateAuthzExtensionOperation, possibly from a different process.

func (*DepClient) UpdateLbRouteExtension

func (c *DepClient) UpdateLbRouteExtension(ctx context.Context, req *networkservicespb.UpdateLbRouteExtensionRequest, opts ...gax.CallOption) (*UpdateLbRouteExtensionOperation, error)

UpdateLbRouteExtension updates the parameters of the specified LbRouteExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateLbRouteExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateLbRouteExtensionRequest.
	}
	op, err := c.UpdateLbRouteExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) UpdateLbRouteExtensionOperation

func (c *DepClient) UpdateLbRouteExtensionOperation(name string) *UpdateLbRouteExtensionOperation

UpdateLbRouteExtensionOperation returns a new UpdateLbRouteExtensionOperation from a given name. The name must be that of a previously created UpdateLbRouteExtensionOperation, possibly from a different process.

func (*DepClient) UpdateLbTrafficExtension

func (c *DepClient) UpdateLbTrafficExtension(ctx context.Context, req *networkservicespb.UpdateLbTrafficExtensionRequest, opts ...gax.CallOption) (*UpdateLbTrafficExtensionOperation, error)

UpdateLbTrafficExtension updates the parameters of the specified LbTrafficExtension resource.

Example

package main

import (
	"context"

	networkservices "cloud.google.com/go/networkservices/apiv1"

	networkservicespb "cloud.google.com/go/networkservices/apiv1/networkservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := networkservices.NewDepClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &networkservicespb.UpdateLbTrafficExtensionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/networkservices/apiv1/networkservicespb#UpdateLbTrafficExtensionRequest.
	}
	op, err := c.UpdateLbTrafficExtension(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*DepClient) UpdateLbTrafficExtensionOperation

func (c *DepClient) UpdateLbTrafficExtensionOperation(name string) *UpdateLbTrafficExtensionOperation

UpdateLbTrafficExtensionOperation returns a new UpdateLbTrafficExtensionOperation from a given name. The name must be that of a previously created UpdateLbTrafficExtensionOperation, possibly from a different process.

EndpointPolicyIterator

type EndpointPolicyIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.EndpointPolicy, nextPageToken string, err error)
	// contains filtered or unexported fields
}

EndpointPolicyIterator manages a stream of *networkservicespb.EndpointPolicy.

func (*EndpointPolicyIterator) All

func (it *EndpointPolicyIterator) All() iter.Seq2[*networkservicespb.EndpointPolicy, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*EndpointPolicyIterator) Next

func (it *EndpointPolicyIterator) Next() (*networkservicespb.EndpointPolicy, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*EndpointPolicyIterator) PageInfo

func (it *EndpointPolicyIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

GatewayIterator

type GatewayIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.Gateway, nextPageToken string, err error)
	// contains filtered or unexported fields
}

GatewayIterator manages a stream of *networkservicespb.Gateway.

func (*GatewayIterator) All

func (it *GatewayIterator) All() iter.Seq2[*networkservicespb.Gateway, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*GatewayIterator) Next

func (it *GatewayIterator) Next() (*networkservicespb.Gateway, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*GatewayIterator) PageInfo

func (it *GatewayIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

GatewayRouteViewIterator

type GatewayRouteViewIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.GatewayRouteView, nextPageToken string, err error)
	// contains filtered or unexported fields
}

GatewayRouteViewIterator manages a stream of *networkservicespb.GatewayRouteView.

func (*GatewayRouteViewIterator) All

func (it *GatewayRouteViewIterator) All() iter.Seq2[*networkservicespb.GatewayRouteView, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*GatewayRouteViewIterator) Next

func (it *GatewayRouteViewIterator) Next() (*networkservicespb.GatewayRouteView, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*GatewayRouteViewIterator) PageInfo

func (it *GatewayRouteViewIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

GrpcRouteIterator

type GrpcRouteIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.GrpcRoute, nextPageToken string, err error)
	// contains filtered or unexported fields
}

GrpcRouteIterator manages a stream of *networkservicespb.GrpcRoute.

func (*GrpcRouteIterator) All

func (it *GrpcRouteIterator) All() iter.Seq2[*networkservicespb.GrpcRoute, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*GrpcRouteIterator) Next

func (it *GrpcRouteIterator) Next() (*networkservicespb.GrpcRoute, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*GrpcRouteIterator) PageInfo

func (it *GrpcRouteIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

HttpRouteIterator

type HttpRouteIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.HttpRoute, nextPageToken string, err error)
	// contains filtered or unexported fields
}

HttpRouteIterator manages a stream of *networkservicespb.HttpRoute.

func (*HttpRouteIterator) All

func (it *HttpRouteIterator) All() iter.Seq2[*networkservicespb.HttpRoute, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*HttpRouteIterator) Next

func (it *HttpRouteIterator) Next() (*networkservicespb.HttpRoute, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*HttpRouteIterator) PageInfo

func (it *HttpRouteIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

LbRouteExtensionIterator

type LbRouteExtensionIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.LbRouteExtension, nextPageToken string, err error)
	// contains filtered or unexported fields
}

LbRouteExtensionIterator manages a stream of *networkservicespb.LbRouteExtension.

func (*LbRouteExtensionIterator) All

func (it *LbRouteExtensionIterator) All() iter.Seq2[*networkservicespb.LbRouteExtension, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*LbRouteExtensionIterator) Next

func (it *LbRouteExtensionIterator) Next() (*networkservicespb.LbRouteExtension, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*LbRouteExtensionIterator) PageInfo

func (it *LbRouteExtensionIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

LbTrafficExtensionIterator

type LbTrafficExtensionIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.LbTrafficExtension, nextPageToken string, err error)
	// contains filtered or unexported fields
}

LbTrafficExtensionIterator manages a stream of *networkservicespb.LbTrafficExtension.

func (*LbTrafficExtensionIterator) All

func (it *LbTrafficExtensionIterator) All() iter.Seq2[*networkservicespb.LbTrafficExtension, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*LbTrafficExtensionIterator) Next

func (it *LbTrafficExtensionIterator) Next() (*networkservicespb.LbTrafficExtension, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*LbTrafficExtensionIterator) PageInfo

func (it *LbTrafficExtensionIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

LocationIterator

type LocationIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*locationpb.Location, nextPageToken string, err error)
	// contains filtered or unexported fields
}

LocationIterator manages a stream of *locationpb.Location.

func (*LocationIterator) All

func (it *LocationIterator) All() iter.Seq2[*locationpb.Location, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*LocationIterator) Next

func (it *LocationIterator) Next() (*locationpb.Location, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*LocationIterator) PageInfo

func (it *LocationIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

MeshIterator

type MeshIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.Mesh, nextPageToken string, err error)
	// contains filtered or unexported fields
}

MeshIterator manages a stream of *networkservicespb.Mesh.

func (*MeshIterator) All

func (it *MeshIterator) All() iter.Seq2[*networkservicespb.Mesh, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*MeshIterator) Next

func (it *MeshIterator) Next() (*networkservicespb.Mesh, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*MeshIterator) PageInfo

func (it *MeshIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

MeshRouteViewIterator

type MeshRouteViewIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.MeshRouteView, nextPageToken string, err error)
	// contains filtered or unexported fields
}

MeshRouteViewIterator manages a stream of *networkservicespb.MeshRouteView.

func (*MeshRouteViewIterator) All

func (it *MeshRouteViewIterator) All() iter.Seq2[*networkservicespb.MeshRouteView, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*MeshRouteViewIterator) Next

func (it *MeshRouteViewIterator) Next() (*networkservicespb.MeshRouteView, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*MeshRouteViewIterator) PageInfo

func (it *MeshRouteViewIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

OperationIterator

type OperationIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*longrunningpb.Operation, nextPageToken string, err error)
	// contains filtered or unexported fields
}

OperationIterator manages a stream of *longrunningpb.Operation.

func (*OperationIterator) All

func (it *OperationIterator) All() iter.Seq2[*longrunningpb.Operation, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*OperationIterator) Next

func (it *OperationIterator) Next() (*longrunningpb.Operation, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*OperationIterator) PageInfo

func (it *OperationIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

ServiceBindingIterator

type ServiceBindingIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.ServiceBinding, nextPageToken string, err error)
	// contains filtered or unexported fields
}

ServiceBindingIterator manages a stream of *networkservicespb.ServiceBinding.

func (*ServiceBindingIterator) All

func (it *ServiceBindingIterator) All() iter.Seq2[*networkservicespb.ServiceBinding, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*ServiceBindingIterator) Next

func (it *ServiceBindingIterator) Next() (*networkservicespb.ServiceBinding, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*ServiceBindingIterator) PageInfo

func (it *ServiceBindingIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

ServiceLbPolicyIterator

type ServiceLbPolicyIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.ServiceLbPolicy, nextPageToken string, err error)
	// contains filtered or unexported fields
}

ServiceLbPolicyIterator manages a stream of *networkservicespb.ServiceLbPolicy.

func (*ServiceLbPolicyIterator) All

func (it *ServiceLbPolicyIterator) All() iter.Seq2[*networkservicespb.ServiceLbPolicy, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*ServiceLbPolicyIterator) Next

func (it *ServiceLbPolicyIterator) Next() (*networkservicespb.ServiceLbPolicy, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*ServiceLbPolicyIterator) PageInfo

func (it *ServiceLbPolicyIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

TcpRouteIterator

type TcpRouteIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.TcpRoute, nextPageToken string, err error)
	// contains filtered or unexported fields
}

TcpRouteIterator manages a stream of *networkservicespb.TcpRoute.

func (*TcpRouteIterator) All

func (it *TcpRouteIterator) All() iter.Seq2[*networkservicespb.TcpRoute, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*TcpRouteIterator) Next

func (it *TcpRouteIterator) Next() (*networkservicespb.TcpRoute, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*TcpRouteIterator) PageInfo

func (it *TcpRouteIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

TlsRouteIterator

type TlsRouteIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.TlsRoute, nextPageToken string, err error)
	// contains filtered or unexported fields
}

TlsRouteIterator manages a stream of *networkservicespb.TlsRoute.

func (*TlsRouteIterator) All

func (it *TlsRouteIterator) All() iter.Seq2[*networkservicespb.TlsRoute, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*TlsRouteIterator) Next

func (it *TlsRouteIterator) Next() (*networkservicespb.TlsRoute, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*TlsRouteIterator) PageInfo

func (it *TlsRouteIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

UpdateAuthzExtensionOperation

type UpdateAuthzExtensionOperation struct {
	// contains filtered or unexported fields
}

UpdateAuthzExtensionOperation manages a long-running operation from UpdateAuthzExtension.

func (*UpdateAuthzExtensionOperation) Done

func (op *UpdateAuthzExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateAuthzExtensionOperation) Metadata

func (op *UpdateAuthzExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateAuthzExtensionOperation) Name

func (op *UpdateAuthzExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateAuthzExtensionOperation) Poll

func (op *UpdateAuthzExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.AuthzExtension, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateAuthzExtensionOperation) Wait

func (op *UpdateAuthzExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.AuthzExtension, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateEndpointPolicyOperation

type UpdateEndpointPolicyOperation struct {
	// contains filtered or unexported fields
}

UpdateEndpointPolicyOperation manages a long-running operation from UpdateEndpointPolicy.

func (*UpdateEndpointPolicyOperation) Done

func (op *UpdateEndpointPolicyOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateEndpointPolicyOperation) Metadata

func (op *UpdateEndpointPolicyOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateEndpointPolicyOperation) Name

func (op *UpdateEndpointPolicyOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateEndpointPolicyOperation) Poll

func (op *UpdateEndpointPolicyOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.EndpointPolicy, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateEndpointPolicyOperation) Wait

func (op *UpdateEndpointPolicyOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.EndpointPolicy, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateGatewayOperation

type UpdateGatewayOperation struct {
	// contains filtered or unexported fields
}

UpdateGatewayOperation manages a long-running operation from UpdateGateway.

func (*UpdateGatewayOperation) Done

func (op *UpdateGatewayOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateGatewayOperation) Metadata

func (op *UpdateGatewayOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateGatewayOperation) Name

func (op *UpdateGatewayOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateGatewayOperation) Poll

func (op *UpdateGatewayOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Gateway, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateGatewayOperation) Wait

func (op *UpdateGatewayOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Gateway, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateGrpcRouteOperation

type UpdateGrpcRouteOperation struct {
	// contains filtered or unexported fields
}

UpdateGrpcRouteOperation manages a long-running operation from UpdateGrpcRoute.

func (*UpdateGrpcRouteOperation) Done

func (op *UpdateGrpcRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateGrpcRouteOperation) Metadata

func (op *UpdateGrpcRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateGrpcRouteOperation) Name

func (op *UpdateGrpcRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateGrpcRouteOperation) Poll

func (op *UpdateGrpcRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.GrpcRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateGrpcRouteOperation) Wait

func (op *UpdateGrpcRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.GrpcRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateHttpRouteOperation

type UpdateHttpRouteOperation struct {
	// contains filtered or unexported fields
}

UpdateHttpRouteOperation manages a long-running operation from UpdateHttpRoute.

func (*UpdateHttpRouteOperation) Done

func (op *UpdateHttpRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateHttpRouteOperation) Metadata

func (op *UpdateHttpRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateHttpRouteOperation) Name

func (op *UpdateHttpRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateHttpRouteOperation) Poll

func (op *UpdateHttpRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.HttpRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateHttpRouteOperation) Wait

func (op *UpdateHttpRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.HttpRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateLbRouteExtensionOperation

type UpdateLbRouteExtensionOperation struct {
	// contains filtered or unexported fields
}

UpdateLbRouteExtensionOperation manages a long-running operation from UpdateLbRouteExtension.

func (*UpdateLbRouteExtensionOperation) Done

func (op *UpdateLbRouteExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateLbRouteExtensionOperation) Metadata

func (op *UpdateLbRouteExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateLbRouteExtensionOperation) Name

func (op *UpdateLbRouteExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateLbRouteExtensionOperation) Poll

func (op *UpdateLbRouteExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbRouteExtension, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateLbRouteExtensionOperation) Wait

func (op *UpdateLbRouteExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbRouteExtension, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateLbTrafficExtensionOperation

type UpdateLbTrafficExtensionOperation struct {
	// contains filtered or unexported fields
}

UpdateLbTrafficExtensionOperation manages a long-running operation from UpdateLbTrafficExtension.

func (*UpdateLbTrafficExtensionOperation) Done

func (op *UpdateLbTrafficExtensionOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateLbTrafficExtensionOperation) Metadata

func (op *UpdateLbTrafficExtensionOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateLbTrafficExtensionOperation) Name

func (op *UpdateLbTrafficExtensionOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateLbTrafficExtensionOperation) Poll

func (op *UpdateLbTrafficExtensionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbTrafficExtension, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateLbTrafficExtensionOperation) Wait

func (op *UpdateLbTrafficExtensionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.LbTrafficExtension, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateMeshOperation

type UpdateMeshOperation struct {
	// contains filtered or unexported fields
}

UpdateMeshOperation manages a long-running operation from UpdateMesh.

func (*UpdateMeshOperation) Done

func (op *UpdateMeshOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateMeshOperation) Metadata

func (op *UpdateMeshOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateMeshOperation) Name

func (op *UpdateMeshOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateMeshOperation) Poll

func (op *UpdateMeshOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Mesh, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateMeshOperation) Wait

func (op *UpdateMeshOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.Mesh, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateServiceBindingOperation

type UpdateServiceBindingOperation struct {
	// contains filtered or unexported fields
}

UpdateServiceBindingOperation manages a long-running operation from UpdateServiceBinding.

func (*UpdateServiceBindingOperation) Done

func (op *UpdateServiceBindingOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateServiceBindingOperation) Metadata

func (op *UpdateServiceBindingOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateServiceBindingOperation) Name

func (op *UpdateServiceBindingOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateServiceBindingOperation) Poll

func (op *UpdateServiceBindingOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceBinding, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateServiceBindingOperation) Wait

func (op *UpdateServiceBindingOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceBinding, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateServiceLbPolicyOperation

type UpdateServiceLbPolicyOperation struct {
	// contains filtered or unexported fields
}

UpdateServiceLbPolicyOperation manages a long-running operation from UpdateServiceLbPolicy.

func (*UpdateServiceLbPolicyOperation) Done

func (op *UpdateServiceLbPolicyOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateServiceLbPolicyOperation) Metadata

func (op *UpdateServiceLbPolicyOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateServiceLbPolicyOperation) Name

func (op *UpdateServiceLbPolicyOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateServiceLbPolicyOperation) Poll

func (op *UpdateServiceLbPolicyOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceLbPolicy, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateServiceLbPolicyOperation) Wait

func (op *UpdateServiceLbPolicyOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.ServiceLbPolicy, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateTcpRouteOperation

type UpdateTcpRouteOperation struct {
	// contains filtered or unexported fields
}

UpdateTcpRouteOperation manages a long-running operation from UpdateTcpRoute.

func (*UpdateTcpRouteOperation) Done

func (op *UpdateTcpRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateTcpRouteOperation) Metadata

func (op *UpdateTcpRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateTcpRouteOperation) Name

func (op *UpdateTcpRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateTcpRouteOperation) Poll

func (op *UpdateTcpRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TcpRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateTcpRouteOperation) Wait

func (op *UpdateTcpRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TcpRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateTlsRouteOperation

type UpdateTlsRouteOperation struct {
	// contains filtered or unexported fields
}

UpdateTlsRouteOperation manages a long-running operation from UpdateTlsRoute.

func (*UpdateTlsRouteOperation) Done

func (op *UpdateTlsRouteOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateTlsRouteOperation) Metadata

func (op *UpdateTlsRouteOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateTlsRouteOperation) Name

func (op *UpdateTlsRouteOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateTlsRouteOperation) Poll

func (op *UpdateTlsRouteOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TlsRoute, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateTlsRouteOperation) Wait

func (op *UpdateTlsRouteOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.TlsRoute, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

UpdateWasmPluginOperation

type UpdateWasmPluginOperation struct {
	// contains filtered or unexported fields
}

UpdateWasmPluginOperation manages a long-running operation from UpdateWasmPlugin.

func (*UpdateWasmPluginOperation) Done

func (op *UpdateWasmPluginOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateWasmPluginOperation) Metadata

func (op *UpdateWasmPluginOperation) Metadata() (*networkservicespb.OperationMetadata, error)

Metadata returns metadata associated with the long-running operation. Metadata itself does not contact the server, but Poll does. To get the latest metadata, call this method after a successful call to Poll. If the metadata is not available, the returned metadata and error are both nil.

func (*UpdateWasmPluginOperation) Name

func (op *UpdateWasmPluginOperation) Name() string

Name returns the name of the long-running operation. The name is assigned by the server and is unique within the service from which the operation is created.

func (*UpdateWasmPluginOperation) Poll

func (op *UpdateWasmPluginOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.WasmPlugin, error)

Poll fetches the latest state of the long-running operation.

Poll also fetches the latest metadata, which can be retrieved by Metadata.

If Poll fails, the error is returned and op is unmodified. If Poll succeeds and the operation has completed with failure, the error is returned and op.Done will return true. If Poll succeeds and the operation has completed successfully, op.Done will return true, and the response of the operation is returned. If Poll succeeds and the operation has not completed, the returned response and error are both nil.

func (*UpdateWasmPluginOperation) Wait

func (op *UpdateWasmPluginOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*networkservicespb.WasmPlugin, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

WasmPluginIterator

type WasmPluginIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.WasmPlugin, nextPageToken string, err error)
	// contains filtered or unexported fields
}

WasmPluginIterator manages a stream of *networkservicespb.WasmPlugin.

func (*WasmPluginIterator) All

func (it *WasmPluginIterator) All() iter.Seq2[*networkservicespb.WasmPlugin, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*WasmPluginIterator) Next

func (it *WasmPluginIterator) Next() (*networkservicespb.WasmPlugin, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*WasmPluginIterator) PageInfo

func (it *WasmPluginIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.

WasmPluginVersionIterator

type WasmPluginVersionIterator struct {

	// Response is the raw response for the current page.
	// It must be cast to the RPC response type.
	// Calling Next() or InternalFetch() updates this value.
	Response interface{}

	// InternalFetch is for use by the Google Cloud Libraries only.
	// It is not part of the stable interface of this package.
	//
	// InternalFetch returns results from a single call to the underlying RPC.
	// The number of results is no greater than pageSize.
	// If there are no more results, nextPageToken is empty and err is nil.
	InternalFetch func(pageSize int, pageToken string) (results []*networkservicespb.WasmPluginVersion, nextPageToken string, err error)
	// contains filtered or unexported fields
}

WasmPluginVersionIterator manages a stream of *networkservicespb.WasmPluginVersion.

func (*WasmPluginVersionIterator) All

func (it *WasmPluginVersionIterator) All() iter.Seq2[*networkservicespb.WasmPluginVersion, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*WasmPluginVersionIterator) Next

func (it *WasmPluginVersionIterator) Next() (*networkservicespb.WasmPluginVersion, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*WasmPluginVersionIterator) PageInfo

func (it *WasmPluginVersionIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the [google.golang.org/api/iterator] package for details.