gaming

package
v0.88.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 22, 2021 License: Apache-2.0 Imports: 23 Imported by: 0

Documentation

Overview

Package gaming is an auto-generated package for the Game Services API.

Deploy and manage infrastructure for global multiplayer gaming experiences. 

NOTE: This package is in beta. It is not stable, and may be subject to changes.

Use of Context

The ctx passed to NewClient 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.

For information about setting deadlines, reusing contexts, and more please visit https://pkg.go.dev/cloud.google.com/go.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func DefaultAuthScopes 

func DefaultAuthScopes() []string

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

Types

type CreateGameServerClusterOperation 

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

CreateGameServerClusterOperation manages a long-running operation from CreateGameServerCluster.

func (*CreateGameServerClusterOperation) Done 

func (op *CreateGameServerClusterOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateGameServerClusterOperation) Metadata 

func (op *CreateGameServerClusterOperation) Metadata() (*gamingpb.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 (*CreateGameServerClusterOperation) Name 

func (op *CreateGameServerClusterOperation) 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 (*CreateGameServerClusterOperation) Poll 

func (op *CreateGameServerClusterOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerCluster, 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 (*CreateGameServerClusterOperation) Wait 

func (op *CreateGameServerClusterOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerCluster, 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.

type CreateGameServerConfigOperation 

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

CreateGameServerConfigOperation manages a long-running operation from CreateGameServerConfig.

func (*CreateGameServerConfigOperation) Done 

func (op *CreateGameServerConfigOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateGameServerConfigOperation) Metadata 

func (op *CreateGameServerConfigOperation) Metadata() (*gamingpb.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 (*CreateGameServerConfigOperation) Name 

func (op *CreateGameServerConfigOperation) 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 (*CreateGameServerConfigOperation) Poll 

func (op *CreateGameServerConfigOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerConfig, 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 (*CreateGameServerConfigOperation) Wait 

func (op *CreateGameServerConfigOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerConfig, 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.

type CreateGameServerDeploymentOperation 

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

CreateGameServerDeploymentOperation manages a long-running operation from CreateGameServerDeployment.

func (*CreateGameServerDeploymentOperation) Done 

func (op *CreateGameServerDeploymentOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateGameServerDeploymentOperation) Metadata 

func (op *CreateGameServerDeploymentOperation) Metadata() (*gamingpb.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 (*CreateGameServerDeploymentOperation) Name 

func (op *CreateGameServerDeploymentOperation) 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 (*CreateGameServerDeploymentOperation) Poll 

func (op *CreateGameServerDeploymentOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerDeployment, 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 (*CreateGameServerDeploymentOperation) Wait 

func (op *CreateGameServerDeploymentOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerDeployment, 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.

type CreateRealmOperation 

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

CreateRealmOperation manages a long-running operation from CreateRealm.

func (*CreateRealmOperation) Done 

func (op *CreateRealmOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateRealmOperation) Metadata 

func (op *CreateRealmOperation) Metadata() (*gamingpb.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 (*CreateRealmOperation) Name 

func (op *CreateRealmOperation) 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 (*CreateRealmOperation) Poll 

func (op *CreateRealmOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.Realm, 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 (*CreateRealmOperation) Wait 

func (op *CreateRealmOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.Realm, 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.

type DeleteGameServerClusterOperation 

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

DeleteGameServerClusterOperation manages a long-running operation from DeleteGameServerCluster.

func (*DeleteGameServerClusterOperation) Done 

func (op *DeleteGameServerClusterOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteGameServerClusterOperation) Metadata 

func (op *DeleteGameServerClusterOperation) Metadata() (*gamingpb.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 (*DeleteGameServerClusterOperation) Name 

func (op *DeleteGameServerClusterOperation) 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 (*DeleteGameServerClusterOperation) Poll 

func (op *DeleteGameServerClusterOperation) 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 (*DeleteGameServerClusterOperation) Wait 

func (op *DeleteGameServerClusterOperation) 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.

type DeleteGameServerConfigOperation 

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

DeleteGameServerConfigOperation manages a long-running operation from DeleteGameServerConfig.

func (*DeleteGameServerConfigOperation) Done 

func (op *DeleteGameServerConfigOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteGameServerConfigOperation) Metadata 

func (op *DeleteGameServerConfigOperation) Metadata() (*gamingpb.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 (*DeleteGameServerConfigOperation) Name 

func (op *DeleteGameServerConfigOperation) 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 (*DeleteGameServerConfigOperation) Poll 

func (op *DeleteGameServerConfigOperation) 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 (*DeleteGameServerConfigOperation) Wait 

func (op *DeleteGameServerConfigOperation) 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.

type DeleteGameServerDeploymentOperation 

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

DeleteGameServerDeploymentOperation manages a long-running operation from DeleteGameServerDeployment.

func (*DeleteGameServerDeploymentOperation) Done 

func (op *DeleteGameServerDeploymentOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteGameServerDeploymentOperation) Metadata 

func (op *DeleteGameServerDeploymentOperation) Metadata() (*gamingpb.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 (*DeleteGameServerDeploymentOperation) Name 

func (op *DeleteGameServerDeploymentOperation) 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 (*DeleteGameServerDeploymentOperation) Poll 

func (op *DeleteGameServerDeploymentOperation) 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 (*DeleteGameServerDeploymentOperation) Wait 

func (op *DeleteGameServerDeploymentOperation) 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.

type DeleteRealmOperation 

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

DeleteRealmOperation manages a long-running operation from DeleteRealm.

func (*DeleteRealmOperation) Done 

func (op *DeleteRealmOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteRealmOperation) Metadata 

func (op *DeleteRealmOperation) Metadata() (*gamingpb.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 (*DeleteRealmOperation) Name 

func (op *DeleteRealmOperation) 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 (*DeleteRealmOperation) Poll 

func (op *DeleteRealmOperation) 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 (*DeleteRealmOperation) Wait 

func (op *DeleteRealmOperation) 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.

type GameServerClusterIterator 

type GameServerClusterIterator 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 []*gamingpb.GameServerCluster, nextPageToken string, err error)
	// contains filtered or unexported fields
}

GameServerClusterIterator manages a stream of *gamingpb.GameServerCluster.

func (*GameServerClusterIterator) Next 

func (it *GameServerClusterIterator) Next() (*gamingpb.GameServerCluster, 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 (*GameServerClusterIterator) PageInfo 

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

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

type GameServerClustersCallOptions 

type GameServerClustersCallOptions struct {
	ListGameServerClusters         []gax.CallOption
	GetGameServerCluster           []gax.CallOption
	CreateGameServerCluster        []gax.CallOption
	PreviewCreateGameServerCluster []gax.CallOption
	DeleteGameServerCluster        []gax.CallOption
	PreviewDeleteGameServerCluster []gax.CallOption
	UpdateGameServerCluster        []gax.CallOption
	PreviewUpdateGameServerCluster []gax.CallOption
}

GameServerClustersCallOptions contains the retry settings for each method of GameServerClustersClient.

type GameServerClustersClient 

type GameServerClustersClient struct {

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

	// 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
}

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

The game server cluster maps to Kubernetes clusters running Agones and is used to manage fleets within clusters.

func NewGameServerClustersClient 

func NewGameServerClustersClient(ctx context.Context, opts ...option.ClientOption) (*GameServerClustersClient, error)

NewGameServerClustersClient creates a new game server clusters service client based on gRPC. The returned client must be Closed when it is done being used to clean up its underlying connections.

The game server cluster maps to Kubernetes clusters running Agones and is used to manage fleets within clusters.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

Output:

func (*GameServerClustersClient) Close 

func (c *GameServerClustersClient) Close() error

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

func (*GameServerClustersClient) Connection 

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

Connection returns a connection to the API service.

Deprecated.

func (*GameServerClustersClient) CreateGameServerCluster 

func (c *GameServerClustersClient) CreateGameServerCluster(ctx context.Context, req *gamingpb.CreateGameServerClusterRequest, opts ...gax.CallOption) (*CreateGameServerClusterOperation, error)

CreateGameServerCluster creates a new game server cluster in a given project and location.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.CreateGameServerClusterRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.CreateGameServerCluster(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerClustersClient) CreateGameServerClusterOperation 

func (c *GameServerClustersClient) CreateGameServerClusterOperation(name string) *CreateGameServerClusterOperation

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

func (*GameServerClustersClient) DeleteGameServerCluster 

func (c *GameServerClustersClient) DeleteGameServerCluster(ctx context.Context, req *gamingpb.DeleteGameServerClusterRequest, opts ...gax.CallOption) (*DeleteGameServerClusterOperation, error)

DeleteGameServerCluster deletes a single game server cluster.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.DeleteGameServerClusterRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.DeleteGameServerCluster(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerClustersClient) DeleteGameServerClusterOperation 

func (c *GameServerClustersClient) DeleteGameServerClusterOperation(name string) *DeleteGameServerClusterOperation

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

func (*GameServerClustersClient) GetGameServerCluster 

func (c *GameServerClustersClient) GetGameServerCluster(ctx context.Context, req *gamingpb.GetGameServerClusterRequest, opts ...gax.CallOption) (*gamingpb.GameServerCluster, error)

GetGameServerCluster gets details of a single game server cluster.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.GetGameServerClusterRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.GetGameServerCluster(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerClustersClient) ListGameServerClusters 

func (c *GameServerClustersClient) ListGameServerClusters(ctx context.Context, req *gamingpb.ListGameServerClustersRequest, opts ...gax.CallOption) *GameServerClusterIterator

ListGameServerClusters lists game server clusters in a given project and location.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
	"google.golang.org/api/iterator"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.ListGameServerClustersRequest{
		// TODO: Fill request struct fields.
	}
	it := c.ListGameServerClusters(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

Output:

func (*GameServerClustersClient) PreviewCreateGameServerCluster 

func (c *GameServerClustersClient) PreviewCreateGameServerCluster(ctx context.Context, req *gamingpb.PreviewCreateGameServerClusterRequest, opts ...gax.CallOption) (*gamingpb.PreviewCreateGameServerClusterResponse, error)

PreviewCreateGameServerCluster previews creation of a new game server cluster in a given project and location.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.PreviewCreateGameServerClusterRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.PreviewCreateGameServerCluster(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerClustersClient) PreviewDeleteGameServerCluster 

func (c *GameServerClustersClient) PreviewDeleteGameServerCluster(ctx context.Context, req *gamingpb.PreviewDeleteGameServerClusterRequest, opts ...gax.CallOption) (*gamingpb.PreviewDeleteGameServerClusterResponse, error)

PreviewDeleteGameServerCluster previews deletion of a single game server cluster.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.PreviewDeleteGameServerClusterRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.PreviewDeleteGameServerCluster(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerClustersClient) PreviewUpdateGameServerCluster 

func (c *GameServerClustersClient) PreviewUpdateGameServerCluster(ctx context.Context, req *gamingpb.PreviewUpdateGameServerClusterRequest, opts ...gax.CallOption) (*gamingpb.PreviewUpdateGameServerClusterResponse, error)

PreviewUpdateGameServerCluster previews updating a GameServerCluster.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.PreviewUpdateGameServerClusterRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.PreviewUpdateGameServerCluster(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerClustersClient) UpdateGameServerCluster 

func (c *GameServerClustersClient) UpdateGameServerCluster(ctx context.Context, req *gamingpb.UpdateGameServerClusterRequest, opts ...gax.CallOption) (*UpdateGameServerClusterOperation, error)

UpdateGameServerCluster patches a single game server cluster.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.UpdateGameServerClusterRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.UpdateGameServerCluster(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerClustersClient) UpdateGameServerClusterOperation 

func (c *GameServerClustersClient) UpdateGameServerClusterOperation(name string) *UpdateGameServerClusterOperation

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

type GameServerConfigIterator 

type GameServerConfigIterator 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 []*gamingpb.GameServerConfig, nextPageToken string, err error)
	// contains filtered or unexported fields
}

GameServerConfigIterator manages a stream of *gamingpb.GameServerConfig.

func (*GameServerConfigIterator) Next 

func (it *GameServerConfigIterator) Next() (*gamingpb.GameServerConfig, 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 (*GameServerConfigIterator) PageInfo 

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

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

type GameServerConfigsCallOptions 

type GameServerConfigsCallOptions struct {
	ListGameServerConfigs  []gax.CallOption
	GetGameServerConfig    []gax.CallOption
	CreateGameServerConfig []gax.CallOption
	DeleteGameServerConfig []gax.CallOption
}

GameServerConfigsCallOptions contains the retry settings for each method of GameServerConfigsClient.

type GameServerConfigsClient 

type GameServerConfigsClient struct {

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

	// 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
}

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

The game server config configures the game servers in an Agones fleet.

func NewGameServerConfigsClient 

func NewGameServerConfigsClient(ctx context.Context, opts ...option.ClientOption) (*GameServerConfigsClient, error)

NewGameServerConfigsClient creates a new game server configs service client based on gRPC. The returned client must be Closed when it is done being used to clean up its underlying connections.

The game server config configures the game servers in an Agones fleet.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

Output:

func (*GameServerConfigsClient) Close 

func (c *GameServerConfigsClient) Close() error

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

func (*GameServerConfigsClient) Connection 

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

Connection returns a connection to the API service.

Deprecated.

func (*GameServerConfigsClient) CreateGameServerConfig 

func (c *GameServerConfigsClient) CreateGameServerConfig(ctx context.Context, req *gamingpb.CreateGameServerConfigRequest, opts ...gax.CallOption) (*CreateGameServerConfigOperation, error)

CreateGameServerConfig creates a new game server config in a given project, location, and game server deployment. Game server configs are immutable, and are not applied until referenced in the game server deployment rollout resource.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.CreateGameServerConfigRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.CreateGameServerConfig(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerConfigsClient) CreateGameServerConfigOperation 

func (c *GameServerConfigsClient) CreateGameServerConfigOperation(name string) *CreateGameServerConfigOperation

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

func (*GameServerConfigsClient) DeleteGameServerConfig 

func (c *GameServerConfigsClient) DeleteGameServerConfig(ctx context.Context, req *gamingpb.DeleteGameServerConfigRequest, opts ...gax.CallOption) (*DeleteGameServerConfigOperation, error)

DeleteGameServerConfig deletes a single game server config. The deletion will fail if the game server config is referenced in a game server deployment rollout.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.DeleteGameServerConfigRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.DeleteGameServerConfig(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerConfigsClient) DeleteGameServerConfigOperation 

func (c *GameServerConfigsClient) DeleteGameServerConfigOperation(name string) *DeleteGameServerConfigOperation

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

func (*GameServerConfigsClient) GetGameServerConfig 

func (c *GameServerConfigsClient) GetGameServerConfig(ctx context.Context, req *gamingpb.GetGameServerConfigRequest, opts ...gax.CallOption) (*gamingpb.GameServerConfig, error)

GetGameServerConfig gets details of a single game server config.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.GetGameServerConfigRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.GetGameServerConfig(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerConfigsClient) ListGameServerConfigs 

func (c *GameServerConfigsClient) ListGameServerConfigs(ctx context.Context, req *gamingpb.ListGameServerConfigsRequest, opts ...gax.CallOption) *GameServerConfigIterator

ListGameServerConfigs lists game server configs in a given project, location, and game server deployment.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
	"google.golang.org/api/iterator"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerConfigsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.ListGameServerConfigsRequest{
		// TODO: Fill request struct fields.
	}
	it := c.ListGameServerConfigs(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

Output:

type GameServerDeploymentIterator 

type GameServerDeploymentIterator 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 []*gamingpb.GameServerDeployment, nextPageToken string, err error)
	// contains filtered or unexported fields
}

GameServerDeploymentIterator manages a stream of *gamingpb.GameServerDeployment.

func (*GameServerDeploymentIterator) Next 

func (it *GameServerDeploymentIterator) Next() (*gamingpb.GameServerDeployment, 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 (*GameServerDeploymentIterator) PageInfo 

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

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

type GameServerDeploymentsCallOptions 

type GameServerDeploymentsCallOptions struct {
	ListGameServerDeployments          []gax.CallOption
	GetGameServerDeployment            []gax.CallOption
	CreateGameServerDeployment         []gax.CallOption
	DeleteGameServerDeployment         []gax.CallOption
	UpdateGameServerDeployment         []gax.CallOption
	GetGameServerDeploymentRollout     []gax.CallOption
	UpdateGameServerDeploymentRollout  []gax.CallOption
	PreviewGameServerDeploymentRollout []gax.CallOption
	FetchDeploymentState               []gax.CallOption
}

GameServerDeploymentsCallOptions contains the retry settings for each method of GameServerDeploymentsClient.

type GameServerDeploymentsClient 

type GameServerDeploymentsClient struct {

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

	// 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
}

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

The game server deployment is used to control the deployment of Agones fleets.

func NewGameServerDeploymentsClient 

func NewGameServerDeploymentsClient(ctx context.Context, opts ...option.ClientOption) (*GameServerDeploymentsClient, error)

NewGameServerDeploymentsClient creates a new game server deployments service client based on gRPC. The returned client must be Closed when it is done being used to clean up its underlying connections.

The game server deployment is used to control the deployment of Agones fleets.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

Output:

func (*GameServerDeploymentsClient) Close 

func (c *GameServerDeploymentsClient) Close() error

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

func (*GameServerDeploymentsClient) Connection 

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

Connection returns a connection to the API service.

Deprecated.

func (*GameServerDeploymentsClient) CreateGameServerDeployment 

func (c *GameServerDeploymentsClient) CreateGameServerDeployment(ctx context.Context, req *gamingpb.CreateGameServerDeploymentRequest, opts ...gax.CallOption) (*CreateGameServerDeploymentOperation, error)

CreateGameServerDeployment creates a new game server deployment in a given project and location.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.CreateGameServerDeploymentRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.CreateGameServerDeployment(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerDeploymentsClient) CreateGameServerDeploymentOperation 

func (c *GameServerDeploymentsClient) CreateGameServerDeploymentOperation(name string) *CreateGameServerDeploymentOperation

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

func (*GameServerDeploymentsClient) DeleteGameServerDeployment 

func (c *GameServerDeploymentsClient) DeleteGameServerDeployment(ctx context.Context, req *gamingpb.DeleteGameServerDeploymentRequest, opts ...gax.CallOption) (*DeleteGameServerDeploymentOperation, error)

DeleteGameServerDeployment deletes a single game server deployment.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.DeleteGameServerDeploymentRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.DeleteGameServerDeployment(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerDeploymentsClient) DeleteGameServerDeploymentOperation 

func (c *GameServerDeploymentsClient) DeleteGameServerDeploymentOperation(name string) *DeleteGameServerDeploymentOperation

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

func (*GameServerDeploymentsClient) FetchDeploymentState 

func (c *GameServerDeploymentsClient) FetchDeploymentState(ctx context.Context, req *gamingpb.FetchDeploymentStateRequest, opts ...gax.CallOption) (*gamingpb.FetchDeploymentStateResponse, error)

FetchDeploymentState retrieves information about the current state of the game server deployment. Gathers all the Agones fleets and Agones autoscalers, including fleets running an older version of the game server deployment.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.FetchDeploymentStateRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.FetchDeploymentState(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerDeploymentsClient) GetGameServerDeployment 

func (c *GameServerDeploymentsClient) GetGameServerDeployment(ctx context.Context, req *gamingpb.GetGameServerDeploymentRequest, opts ...gax.CallOption) (*gamingpb.GameServerDeployment, error)

GetGameServerDeployment gets details of a single game server deployment.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.GetGameServerDeploymentRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.GetGameServerDeployment(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerDeploymentsClient) GetGameServerDeploymentRollout 

func (c *GameServerDeploymentsClient) GetGameServerDeploymentRollout(ctx context.Context, req *gamingpb.GetGameServerDeploymentRolloutRequest, opts ...gax.CallOption) (*gamingpb.GameServerDeploymentRollout, error)

GetGameServerDeploymentRollout gets details a single game server deployment rollout.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.GetGameServerDeploymentRolloutRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.GetGameServerDeploymentRollout(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerDeploymentsClient) ListGameServerDeployments 

func (c *GameServerDeploymentsClient) ListGameServerDeployments(ctx context.Context, req *gamingpb.ListGameServerDeploymentsRequest, opts ...gax.CallOption) *GameServerDeploymentIterator

ListGameServerDeployments lists game server deployments in a given project and location.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
	"google.golang.org/api/iterator"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.ListGameServerDeploymentsRequest{
		// TODO: Fill request struct fields.
	}
	it := c.ListGameServerDeployments(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

Output:

func (*GameServerDeploymentsClient) PreviewGameServerDeploymentRollout 

func (c *GameServerDeploymentsClient) PreviewGameServerDeploymentRollout(ctx context.Context, req *gamingpb.PreviewGameServerDeploymentRolloutRequest, opts ...gax.CallOption) (*gamingpb.PreviewGameServerDeploymentRolloutResponse, error)

PreviewGameServerDeploymentRollout previews the game server deployment rollout. This API does not mutate the rollout resource.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.PreviewGameServerDeploymentRolloutRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.PreviewGameServerDeploymentRollout(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*GameServerDeploymentsClient) UpdateGameServerDeployment 

func (c *GameServerDeploymentsClient) UpdateGameServerDeployment(ctx context.Context, req *gamingpb.UpdateGameServerDeploymentRequest, opts ...gax.CallOption) (*UpdateGameServerDeploymentOperation, error)

UpdateGameServerDeployment patches a game server deployment.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.UpdateGameServerDeploymentRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.UpdateGameServerDeployment(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerDeploymentsClient) UpdateGameServerDeploymentOperation 

func (c *GameServerDeploymentsClient) UpdateGameServerDeploymentOperation(name string) *UpdateGameServerDeploymentOperation

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

func (*GameServerDeploymentsClient) UpdateGameServerDeploymentRollout 

func (c *GameServerDeploymentsClient) UpdateGameServerDeploymentRollout(ctx context.Context, req *gamingpb.UpdateGameServerDeploymentRolloutRequest, opts ...gax.CallOption) (*UpdateGameServerDeploymentRolloutOperation, error)

UpdateGameServerDeploymentRollout patches a single game server deployment rollout. The method will not return an error if the update does not affect any existing realms. For example - if the default_game_server_config is changed but all existing realms use the override, that is valid. Similarly, if a non existing realm is explicitly called out in game_server_config_overrides field, that will also not result in an error.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.UpdateGameServerDeploymentRolloutRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.UpdateGameServerDeploymentRollout(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*GameServerDeploymentsClient) UpdateGameServerDeploymentRolloutOperation 

func (c *GameServerDeploymentsClient) UpdateGameServerDeploymentRolloutOperation(name string) *UpdateGameServerDeploymentRolloutOperation

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

type RealmIterator 

type RealmIterator 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 []*gamingpb.Realm, nextPageToken string, err error)
	// contains filtered or unexported fields
}

RealmIterator manages a stream of *gamingpb.Realm.

func (*RealmIterator) Next 

func (it *RealmIterator) Next() (*gamingpb.Realm, 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 (*RealmIterator) PageInfo 

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

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

type RealmsCallOptions 

type RealmsCallOptions struct {
	ListRealms         []gax.CallOption
	GetRealm           []gax.CallOption
	CreateRealm        []gax.CallOption
	DeleteRealm        []gax.CallOption
	UpdateRealm        []gax.CallOption
	PreviewRealmUpdate []gax.CallOption
}

RealmsCallOptions contains the retry settings for each method of RealmsClient.

type RealmsClient 

type RealmsClient struct {

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

	// 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
}

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

A realm is a grouping of game server clusters that are considered interchangeable.

func NewRealmsClient 

func NewRealmsClient(ctx context.Context, opts ...option.ClientOption) (*RealmsClient, error)

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

A realm is a grouping of game server clusters that are considered interchangeable.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

Output:

func (*RealmsClient) Close 

func (c *RealmsClient) Close() error

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

func (*RealmsClient) Connection 

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

Connection returns a connection to the API service.

Deprecated.

func (*RealmsClient) CreateRealm 

func (c *RealmsClient) CreateRealm(ctx context.Context, req *gamingpb.CreateRealmRequest, opts ...gax.CallOption) (*CreateRealmOperation, error)

CreateRealm creates a new realm in a given project and location.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.CreateRealmRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.CreateRealm(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*RealmsClient) CreateRealmOperation 

func (c *RealmsClient) CreateRealmOperation(name string) *CreateRealmOperation

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

func (*RealmsClient) DeleteRealm 

func (c *RealmsClient) DeleteRealm(ctx context.Context, req *gamingpb.DeleteRealmRequest, opts ...gax.CallOption) (*DeleteRealmOperation, error)

DeleteRealm deletes a single realm.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.DeleteRealmRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.DeleteRealm(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*RealmsClient) DeleteRealmOperation 

func (c *RealmsClient) DeleteRealmOperation(name string) *DeleteRealmOperation

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

func (*RealmsClient) GetRealm 

func (c *RealmsClient) GetRealm(ctx context.Context, req *gamingpb.GetRealmRequest, opts ...gax.CallOption) (*gamingpb.Realm, error)

GetRealm gets details of a single realm.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.GetRealmRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.GetRealm(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*RealmsClient) ListRealms 

func (c *RealmsClient) ListRealms(ctx context.Context, req *gamingpb.ListRealmsRequest, opts ...gax.CallOption) *RealmIterator

ListRealms lists realms in a given project and location.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"
	"google.golang.org/api/iterator"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.ListRealmsRequest{
		// TODO: Fill request struct fields.
	}
	it := c.ListRealms(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

Output:

func (*RealmsClient) PreviewRealmUpdate 

func (c *RealmsClient) PreviewRealmUpdate(ctx context.Context, req *gamingpb.PreviewRealmUpdateRequest, opts ...gax.CallOption) (*gamingpb.PreviewRealmUpdateResponse, error)

PreviewRealmUpdate previews patches to a single realm.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.PreviewRealmUpdateRequest{
		// TODO: Fill request struct fields.
	}
	resp, err := c.PreviewRealmUpdate(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Output:

func (*RealmsClient) UpdateRealm 

func (c *RealmsClient) UpdateRealm(ctx context.Context, req *gamingpb.UpdateRealmRequest, opts ...gax.CallOption) (*UpdateRealmOperation, error)

UpdateRealm patches a single realm.

Example 
package main

import (
	"context"

	gaming "cloud.google.com/go/gaming/apiv1beta"

	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1beta"
)

func main() {
	ctx := context.Background()
	c, err := gaming.NewRealmsClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &gamingpb.UpdateRealmRequest{
		// TODO: Fill request struct fields.
	}
	op, err := c.UpdateRealm(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Output:

func (*RealmsClient) UpdateRealmOperation 

func (c *RealmsClient) UpdateRealmOperation(name string) *UpdateRealmOperation

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

type UpdateGameServerClusterOperation 

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

UpdateGameServerClusterOperation manages a long-running operation from UpdateGameServerCluster.

func (*UpdateGameServerClusterOperation) Done 

func (op *UpdateGameServerClusterOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateGameServerClusterOperation) Metadata 

func (op *UpdateGameServerClusterOperation) Metadata() (*gamingpb.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 (*UpdateGameServerClusterOperation) Name 

func (op *UpdateGameServerClusterOperation) 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 (*UpdateGameServerClusterOperation) Poll 

func (op *UpdateGameServerClusterOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerCluster, 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 (*UpdateGameServerClusterOperation) Wait 

func (op *UpdateGameServerClusterOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerCluster, 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.

type UpdateGameServerDeploymentOperation 

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

UpdateGameServerDeploymentOperation manages a long-running operation from UpdateGameServerDeployment.

func (*UpdateGameServerDeploymentOperation) Done 

func (op *UpdateGameServerDeploymentOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateGameServerDeploymentOperation) Metadata 

func (op *UpdateGameServerDeploymentOperation) Metadata() (*gamingpb.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 (*UpdateGameServerDeploymentOperation) Name 

func (op *UpdateGameServerDeploymentOperation) 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 (*UpdateGameServerDeploymentOperation) Poll 

func (op *UpdateGameServerDeploymentOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerDeployment, 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 (*UpdateGameServerDeploymentOperation) Wait 

func (op *UpdateGameServerDeploymentOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerDeployment, 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.

type UpdateGameServerDeploymentRolloutOperation 

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

UpdateGameServerDeploymentRolloutOperation manages a long-running operation from UpdateGameServerDeploymentRollout.

func (*UpdateGameServerDeploymentRolloutOperation) Done 

func (op *UpdateGameServerDeploymentRolloutOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateGameServerDeploymentRolloutOperation) Metadata 

func (op *UpdateGameServerDeploymentRolloutOperation) Metadata() (*gamingpb.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 (*UpdateGameServerDeploymentRolloutOperation) Name 

func (op *UpdateGameServerDeploymentRolloutOperation) 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 (*UpdateGameServerDeploymentRolloutOperation) Poll 

func (op *UpdateGameServerDeploymentRolloutOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerDeployment, 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 (*UpdateGameServerDeploymentRolloutOperation) Wait 

func (op *UpdateGameServerDeploymentRolloutOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.GameServerDeployment, 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.

type UpdateRealmOperation 

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

UpdateRealmOperation manages a long-running operation from UpdateRealm.

func (*UpdateRealmOperation) Done 

func (op *UpdateRealmOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateRealmOperation) Metadata 

func (op *UpdateRealmOperation) Metadata() (*gamingpb.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 (*UpdateRealmOperation) Name 

func (op *UpdateRealmOperation) 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 (*UpdateRealmOperation) Poll 

func (op *UpdateRealmOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*gamingpb.Realm, 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 (*UpdateRealmOperation) Wait 

func (op *UpdateRealmOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*gamingpb.Realm, 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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.