diff --git a/internal/.repo-metadata-full.json b/internal/.repo-metadata-full.json index 4c5c57c4a88..ef65fcb062f 100644 --- a/internal/.repo-metadata-full.json +++ b/internal/.repo-metadata-full.json @@ -989,6 +989,15 @@ "release_level": "beta", "library_type": "" }, + "cloud.google.com/go/notebooks/apiv1": { + "distribution_name": "cloud.google.com/go/notebooks/apiv1", + "description": "Notebooks API", + "language": "Go", + "client_library_type": "generated", + "docs_url": "https://cloud.google.com/go/docs/reference/cloud.google.com/go/notebooks/latest/apiv1", + "release_level": "beta", + "library_type": "" + }, "cloud.google.com/go/notebooks/apiv1beta1": { "distribution_name": "cloud.google.com/go/notebooks/apiv1beta1", "description": "Notebooks API", diff --git a/internal/gapicgen/generator/config.go b/internal/gapicgen/generator/config.go index 7d2a55fbdfd..ba97152f083 100644 --- a/internal/gapicgen/generator/config.go +++ b/internal/gapicgen/generator/config.go @@ -1436,6 +1436,15 @@ var MicrogenGapicConfigs = []*MicrogenConfig{ // GA after 2022/06/05 ReleaseLevel: "beta", }, + { + InputDirectoryPath: "google/cloud/notebooks/v1", + Pkg: "notebooks", + ImportPath: "cloud.google.com/go/notebooks/apiv1", + GRPCServiceConfigPath: "notebooks_grpc_service_config.json", + ApiServiceConfigPath: "notebooks_v1.yaml", + // GA after 2022/06/05 + ReleaseLevel: "beta", + }, // Non-Cloud APIs { diff --git a/notebooks/apiv1/doc.go b/notebooks/apiv1/doc.go new file mode 100644 index 00000000000..12a894de038 --- /dev/null +++ b/notebooks/apiv1/doc.go @@ -0,0 +1,167 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +// Package notebooks is an auto-generated package for the +// Notebooks API. +// +// Notebooks API is used to manage notebook resources in Google Cloud. +// +// NOTE: This package is in beta. It is not stable, and may be subject to changes. +// +// Example usage +// +// To get started with this package, create a client. +// ctx := context.Background() +// c, err := notebooks.NewManagedNotebookClient(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. +// +// ctx := context.Background() +// c, err := notebooks.NewManagedNotebookClient(ctx) +// if err != nil { +// // TODO: Handle error. +// } +// defer c.Close() +// +// req := ¬ebookspb.ListRuntimesRequest{ +// // TODO: Fill request struct fields. +// // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ListRuntimesRequest. +// } +// it := c.ListRuntimes(ctx, req) +// for { +// resp, err := it.Next() +// if err == iterator.Done { +// break +// } +// if err != nil { +// // TODO: Handle error. +// } +// // TODO: Use resp. +// _ = resp +// } +// +// 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. +package notebooks // import "cloud.google.com/go/notebooks/apiv1" + +import ( + "context" + "os" + "runtime" + "strconv" + "strings" + "unicode" + + "google.golang.org/api/option" + "google.golang.org/grpc/metadata" +) + +// For more information on implementing a client constructor hook, see +// https://github.com/googleapis/google-cloud-go/wiki/Customizing-constructors. +type clientHookParams struct{} +type clientHook func(context.Context, clientHookParams) ([]option.ClientOption, error) + +var versionClient string + +func getVersionClient() string { + if versionClient == "" { + return "UNKNOWN" + } + return versionClient +} + +func insertMetadata(ctx context.Context, mds ...metadata.MD) context.Context { + out, _ := metadata.FromOutgoingContext(ctx) + out = out.Copy() + for _, md := range mds { + for k, v := range md { + out[k] = append(out[k], v...) + } + } + return metadata.NewOutgoingContext(ctx, out) +} + +func checkDisableDeadlines() (bool, error) { + raw, ok := os.LookupEnv("GOOGLE_API_GO_EXPERIMENTAL_DISABLE_DEFAULT_DEADLINE") + if !ok { + return false, nil + } + + b, err := strconv.ParseBool(raw) + return b, err +} + +// DefaultAuthScopes reports the default set of authentication scopes to use with this package. +func DefaultAuthScopes() []string { + return []string{ + "https://www.googleapis.com/auth/cloud-platform", + } +} + +// versionGo returns the Go runtime version. The returned string +// has no whitespace, suitable for reporting in header. +func versionGo() string { + const develPrefix = "devel +" + + s := runtime.Version() + if strings.HasPrefix(s, develPrefix) { + s = s[len(develPrefix):] + if p := strings.IndexFunc(s, unicode.IsSpace); p >= 0 { + s = s[:p] + } + return s + } + + notSemverRune := func(r rune) bool { + return !strings.ContainsRune("0123456789.", r) + } + + if strings.HasPrefix(s, "go1") { + s = s[2:] + var prerelease string + if p := strings.IndexFunc(s, notSemverRune); p >= 0 { + s, prerelease = s[:p], s[p:] + } + if strings.HasSuffix(s, ".") { + s += "0" + } else if strings.Count(s, ".") < 2 { + s += ".0" + } + if prerelease != "" { + s += "-" + prerelease + } + return s + } + return "UNKNOWN" +} diff --git a/notebooks/apiv1/gapic_metadata.json b/notebooks/apiv1/gapic_metadata.json new file mode 100644 index 00000000000..1369fbe5495 --- /dev/null +++ b/notebooks/apiv1/gapic_metadata.json @@ -0,0 +1,242 @@ +{ + "schema": "1.0", + "comment": "This file maps proto services/RPCs to the corresponding library clients/methods.", + "language": "go", + "protoPackage": "google.cloud.notebooks.v1", + "libraryPackage": "cloud.google.com/go/notebooks/apiv1", + "services": { + "ManagedNotebookService": { + "clients": { + "grpc": { + "libraryClient": "ManagedNotebookClient", + "rpcs": { + "CreateRuntime": { + "methods": [ + "CreateRuntime" + ] + }, + "DeleteRuntime": { + "methods": [ + "DeleteRuntime" + ] + }, + "GetRuntime": { + "methods": [ + "GetRuntime" + ] + }, + "ListRuntimes": { + "methods": [ + "ListRuntimes" + ] + }, + "RefreshRuntimeTokenInternal": { + "methods": [ + "RefreshRuntimeTokenInternal" + ] + }, + "ReportRuntimeEvent": { + "methods": [ + "ReportRuntimeEvent" + ] + }, + "ResetRuntime": { + "methods": [ + "ResetRuntime" + ] + }, + "StartRuntime": { + "methods": [ + "StartRuntime" + ] + }, + "StopRuntime": { + "methods": [ + "StopRuntime" + ] + }, + "SwitchRuntime": { + "methods": [ + "SwitchRuntime" + ] + } + } + } + } + }, + "NotebookService": { + "clients": { + "grpc": { + "libraryClient": "NotebookClient", + "rpcs": { + "CreateEnvironment": { + "methods": [ + "CreateEnvironment" + ] + }, + "CreateExecution": { + "methods": [ + "CreateExecution" + ] + }, + "CreateInstance": { + "methods": [ + "CreateInstance" + ] + }, + "CreateSchedule": { + "methods": [ + "CreateSchedule" + ] + }, + "DeleteEnvironment": { + "methods": [ + "DeleteEnvironment" + ] + }, + "DeleteExecution": { + "methods": [ + "DeleteExecution" + ] + }, + "DeleteInstance": { + "methods": [ + "DeleteInstance" + ] + }, + "DeleteSchedule": { + "methods": [ + "DeleteSchedule" + ] + }, + "GetEnvironment": { + "methods": [ + "GetEnvironment" + ] + }, + "GetExecution": { + "methods": [ + "GetExecution" + ] + }, + "GetInstance": { + "methods": [ + "GetInstance" + ] + }, + "GetInstanceHealth": { + "methods": [ + "GetInstanceHealth" + ] + }, + "GetSchedule": { + "methods": [ + "GetSchedule" + ] + }, + "IsInstanceUpgradeable": { + "methods": [ + "IsInstanceUpgradeable" + ] + }, + "ListEnvironments": { + "methods": [ + "ListEnvironments" + ] + }, + "ListExecutions": { + "methods": [ + "ListExecutions" + ] + }, + "ListInstances": { + "methods": [ + "ListInstances" + ] + }, + "ListSchedules": { + "methods": [ + "ListSchedules" + ] + }, + "RegisterInstance": { + "methods": [ + "RegisterInstance" + ] + }, + "ReportInstanceInfo": { + "methods": [ + "ReportInstanceInfo" + ] + }, + "ResetInstance": { + "methods": [ + "ResetInstance" + ] + }, + "RollbackInstance": { + "methods": [ + "RollbackInstance" + ] + }, + "SetInstanceAccelerator": { + "methods": [ + "SetInstanceAccelerator" + ] + }, + "SetInstanceLabels": { + "methods": [ + "SetInstanceLabels" + ] + }, + "SetInstanceMachineType": { + "methods": [ + "SetInstanceMachineType" + ] + }, + "StartInstance": { + "methods": [ + "StartInstance" + ] + }, + "StopInstance": { + "methods": [ + "StopInstance" + ] + }, + "TriggerSchedule": { + "methods": [ + "TriggerSchedule" + ] + }, + "UpdateInstanceConfig": { + "methods": [ + "UpdateInstanceConfig" + ] + }, + "UpdateInstanceMetadataItems": { + "methods": [ + "UpdateInstanceMetadataItems" + ] + }, + "UpdateShieldedInstanceConfig": { + "methods": [ + "UpdateShieldedInstanceConfig" + ] + }, + "UpgradeInstance": { + "methods": [ + "UpgradeInstance" + ] + }, + "UpgradeInstanceInternal": { + "methods": [ + "UpgradeInstanceInternal" + ] + } + } + } + } + } + } +} diff --git a/notebooks/apiv1/managed_notebook_client.go b/notebooks/apiv1/managed_notebook_client.go new file mode 100644 index 00000000000..27db5f46fb3 --- /dev/null +++ b/notebooks/apiv1/managed_notebook_client.go @@ -0,0 +1,1139 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +package notebooks + +import ( + "context" + "fmt" + "math" + "net/url" + "time" + + "cloud.google.com/go/longrunning" + lroauto "cloud.google.com/go/longrunning/autogen" + gax "github.com/googleapis/gax-go/v2" + "google.golang.org/api/iterator" + "google.golang.org/api/option" + "google.golang.org/api/option/internaloption" + gtransport "google.golang.org/api/transport/grpc" + notebookspb "google.golang.org/genproto/googleapis/cloud/notebooks/v1" + longrunningpb "google.golang.org/genproto/googleapis/longrunning" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/protobuf/proto" +) + +var newManagedNotebookClientHook clientHook + +// ManagedNotebookCallOptions contains the retry settings for each method of ManagedNotebookClient. +type ManagedNotebookCallOptions struct { + ListRuntimes []gax.CallOption + GetRuntime []gax.CallOption + CreateRuntime []gax.CallOption + DeleteRuntime []gax.CallOption + StartRuntime []gax.CallOption + StopRuntime []gax.CallOption + SwitchRuntime []gax.CallOption + ResetRuntime []gax.CallOption + ReportRuntimeEvent []gax.CallOption + RefreshRuntimeTokenInternal []gax.CallOption +} + +func defaultManagedNotebookGRPCClientOptions() []option.ClientOption { + return []option.ClientOption{ + internaloption.WithDefaultEndpoint("notebooks.googleapis.com:443"), + internaloption.WithDefaultMTLSEndpoint("notebooks.mtls.googleapis.com:443"), + internaloption.WithDefaultAudience("https://notebooks.googleapis.com/"), + internaloption.WithDefaultScopes(DefaultAuthScopes()...), + internaloption.EnableJwtWithScope(), + option.WithGRPCDialOption(grpc.WithDefaultCallOptions( + grpc.MaxCallRecvMsgSize(math.MaxInt32))), + } +} + +func defaultManagedNotebookCallOptions() *ManagedNotebookCallOptions { + return &ManagedNotebookCallOptions{ + ListRuntimes: []gax.CallOption{}, + GetRuntime: []gax.CallOption{}, + CreateRuntime: []gax.CallOption{}, + DeleteRuntime: []gax.CallOption{}, + StartRuntime: []gax.CallOption{}, + StopRuntime: []gax.CallOption{}, + SwitchRuntime: []gax.CallOption{}, + ResetRuntime: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 60000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ReportRuntimeEvent: []gax.CallOption{}, + RefreshRuntimeTokenInternal: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 60000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + } +} + +// internalManagedNotebookClient is an interface that defines the methods availaible from Notebooks API. +type internalManagedNotebookClient interface { + Close() error + setGoogleClientInfo(...string) + Connection() *grpc.ClientConn + ListRuntimes(context.Context, *notebookspb.ListRuntimesRequest, ...gax.CallOption) *RuntimeIterator + GetRuntime(context.Context, *notebookspb.GetRuntimeRequest, ...gax.CallOption) (*notebookspb.Runtime, error) + CreateRuntime(context.Context, *notebookspb.CreateRuntimeRequest, ...gax.CallOption) (*CreateRuntimeOperation, error) + CreateRuntimeOperation(name string) *CreateRuntimeOperation + DeleteRuntime(context.Context, *notebookspb.DeleteRuntimeRequest, ...gax.CallOption) (*DeleteRuntimeOperation, error) + DeleteRuntimeOperation(name string) *DeleteRuntimeOperation + StartRuntime(context.Context, *notebookspb.StartRuntimeRequest, ...gax.CallOption) (*StartRuntimeOperation, error) + StartRuntimeOperation(name string) *StartRuntimeOperation + StopRuntime(context.Context, *notebookspb.StopRuntimeRequest, ...gax.CallOption) (*StopRuntimeOperation, error) + StopRuntimeOperation(name string) *StopRuntimeOperation + SwitchRuntime(context.Context, *notebookspb.SwitchRuntimeRequest, ...gax.CallOption) (*SwitchRuntimeOperation, error) + SwitchRuntimeOperation(name string) *SwitchRuntimeOperation + ResetRuntime(context.Context, *notebookspb.ResetRuntimeRequest, ...gax.CallOption) (*ResetRuntimeOperation, error) + ResetRuntimeOperation(name string) *ResetRuntimeOperation + ReportRuntimeEvent(context.Context, *notebookspb.ReportRuntimeEventRequest, ...gax.CallOption) (*ReportRuntimeEventOperation, error) + ReportRuntimeEventOperation(name string) *ReportRuntimeEventOperation + RefreshRuntimeTokenInternal(context.Context, *notebookspb.RefreshRuntimeTokenInternalRequest, ...gax.CallOption) (*notebookspb.RefreshRuntimeTokenInternalResponse, error) +} + +// ManagedNotebookClient is a client for interacting with Notebooks API. +// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. +// +// API v1 service for Managed Notebooks. +type ManagedNotebookClient struct { + // The internal transport-dependent client. + internalClient internalManagedNotebookClient + + // The call options for this service. + CallOptions *ManagedNotebookCallOptions + + // 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 +} + +// Wrapper methods routed to the internal client. + +// Close closes the connection to the API service. The user should invoke this when +// the client is no longer required. +func (c *ManagedNotebookClient) Close() error { + return c.internalClient.Close() +} + +// setGoogleClientInfo sets the name and version of the application in +// the `x-goog-api-client` header passed on each request. Intended for +// use by Google-written clients. +func (c *ManagedNotebookClient) setGoogleClientInfo(keyval ...string) { + c.internalClient.setGoogleClientInfo(keyval...) +} + +// Connection returns a connection to the API service. +// +// Deprecated. +func (c *ManagedNotebookClient) Connection() *grpc.ClientConn { + return c.internalClient.Connection() +} + +// ListRuntimes lists Runtimes in a given project and location. +func (c *ManagedNotebookClient) ListRuntimes(ctx context.Context, req *notebookspb.ListRuntimesRequest, opts ...gax.CallOption) *RuntimeIterator { + return c.internalClient.ListRuntimes(ctx, req, opts...) +} + +// GetRuntime gets details of a single Runtime. The location must be a regional endpoint +// rather than zonal. +func (c *ManagedNotebookClient) GetRuntime(ctx context.Context, req *notebookspb.GetRuntimeRequest, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + return c.internalClient.GetRuntime(ctx, req, opts...) +} + +// CreateRuntime creates a new Runtime in a given project and location. +func (c *ManagedNotebookClient) CreateRuntime(ctx context.Context, req *notebookspb.CreateRuntimeRequest, opts ...gax.CallOption) (*CreateRuntimeOperation, error) { + return c.internalClient.CreateRuntime(ctx, req, opts...) +} + +// CreateRuntimeOperation returns a new CreateRuntimeOperation from a given name. +// The name must be that of a previously created CreateRuntimeOperation, possibly from a different process. +func (c *ManagedNotebookClient) CreateRuntimeOperation(name string) *CreateRuntimeOperation { + return c.internalClient.CreateRuntimeOperation(name) +} + +// DeleteRuntime deletes a single Runtime. +func (c *ManagedNotebookClient) DeleteRuntime(ctx context.Context, req *notebookspb.DeleteRuntimeRequest, opts ...gax.CallOption) (*DeleteRuntimeOperation, error) { + return c.internalClient.DeleteRuntime(ctx, req, opts...) +} + +// DeleteRuntimeOperation returns a new DeleteRuntimeOperation from a given name. +// The name must be that of a previously created DeleteRuntimeOperation, possibly from a different process. +func (c *ManagedNotebookClient) DeleteRuntimeOperation(name string) *DeleteRuntimeOperation { + return c.internalClient.DeleteRuntimeOperation(name) +} + +// StartRuntime starts a Managed Notebook Runtime. +// Perform “Start” on GPU instances; “Resume” on CPU instances +// See: +// https://cloud.google.com/compute/docs/instances/stop-start-instance (at https://cloud.google.com/compute/docs/instances/stop-start-instance) +// https://cloud.google.com/compute/docs/instances/suspend-resume-instance (at https://cloud.google.com/compute/docs/instances/suspend-resume-instance) +func (c *ManagedNotebookClient) StartRuntime(ctx context.Context, req *notebookspb.StartRuntimeRequest, opts ...gax.CallOption) (*StartRuntimeOperation, error) { + return c.internalClient.StartRuntime(ctx, req, opts...) +} + +// StartRuntimeOperation returns a new StartRuntimeOperation from a given name. +// The name must be that of a previously created StartRuntimeOperation, possibly from a different process. +func (c *ManagedNotebookClient) StartRuntimeOperation(name string) *StartRuntimeOperation { + return c.internalClient.StartRuntimeOperation(name) +} + +// StopRuntime stops a Managed Notebook Runtime. +// Perform “Stop” on GPU instances; “Suspend” on CPU instances +// See: +// https://cloud.google.com/compute/docs/instances/stop-start-instance (at https://cloud.google.com/compute/docs/instances/stop-start-instance) +// https://cloud.google.com/compute/docs/instances/suspend-resume-instance (at https://cloud.google.com/compute/docs/instances/suspend-resume-instance) +func (c *ManagedNotebookClient) StopRuntime(ctx context.Context, req *notebookspb.StopRuntimeRequest, opts ...gax.CallOption) (*StopRuntimeOperation, error) { + return c.internalClient.StopRuntime(ctx, req, opts...) +} + +// StopRuntimeOperation returns a new StopRuntimeOperation from a given name. +// The name must be that of a previously created StopRuntimeOperation, possibly from a different process. +func (c *ManagedNotebookClient) StopRuntimeOperation(name string) *StopRuntimeOperation { + return c.internalClient.StopRuntimeOperation(name) +} + +// SwitchRuntime switch a Managed Notebook Runtime. +func (c *ManagedNotebookClient) SwitchRuntime(ctx context.Context, req *notebookspb.SwitchRuntimeRequest, opts ...gax.CallOption) (*SwitchRuntimeOperation, error) { + return c.internalClient.SwitchRuntime(ctx, req, opts...) +} + +// SwitchRuntimeOperation returns a new SwitchRuntimeOperation from a given name. +// The name must be that of a previously created SwitchRuntimeOperation, possibly from a different process. +func (c *ManagedNotebookClient) SwitchRuntimeOperation(name string) *SwitchRuntimeOperation { + return c.internalClient.SwitchRuntimeOperation(name) +} + +// ResetRuntime resets a Managed Notebook Runtime. +func (c *ManagedNotebookClient) ResetRuntime(ctx context.Context, req *notebookspb.ResetRuntimeRequest, opts ...gax.CallOption) (*ResetRuntimeOperation, error) { + return c.internalClient.ResetRuntime(ctx, req, opts...) +} + +// ResetRuntimeOperation returns a new ResetRuntimeOperation from a given name. +// The name must be that of a previously created ResetRuntimeOperation, possibly from a different process. +func (c *ManagedNotebookClient) ResetRuntimeOperation(name string) *ResetRuntimeOperation { + return c.internalClient.ResetRuntimeOperation(name) +} + +// ReportRuntimeEvent report and process a runtime event. +func (c *ManagedNotebookClient) ReportRuntimeEvent(ctx context.Context, req *notebookspb.ReportRuntimeEventRequest, opts ...gax.CallOption) (*ReportRuntimeEventOperation, error) { + return c.internalClient.ReportRuntimeEvent(ctx, req, opts...) +} + +// ReportRuntimeEventOperation returns a new ReportRuntimeEventOperation from a given name. +// The name must be that of a previously created ReportRuntimeEventOperation, possibly from a different process. +func (c *ManagedNotebookClient) ReportRuntimeEventOperation(name string) *ReportRuntimeEventOperation { + return c.internalClient.ReportRuntimeEventOperation(name) +} + +// RefreshRuntimeTokenInternal gets an access token for the consumer service account that the customer +// attached to the runtime. Only accessible from the tenant instance. +func (c *ManagedNotebookClient) RefreshRuntimeTokenInternal(ctx context.Context, req *notebookspb.RefreshRuntimeTokenInternalRequest, opts ...gax.CallOption) (*notebookspb.RefreshRuntimeTokenInternalResponse, error) { + return c.internalClient.RefreshRuntimeTokenInternal(ctx, req, opts...) +} + +// managedNotebookGRPCClient is a client for interacting with Notebooks API over gRPC transport. +// +// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. +type managedNotebookGRPCClient struct { + // Connection pool of gRPC connections to the service. + connPool gtransport.ConnPool + + // flag to opt out of default deadlines via GOOGLE_API_GO_EXPERIMENTAL_DISABLE_DEFAULT_DEADLINE + disableDeadlines bool + + // Points back to the CallOptions field of the containing ManagedNotebookClient + CallOptions **ManagedNotebookCallOptions + + // The gRPC API client. + managedNotebookClient notebookspb.ManagedNotebookServiceClient + + // 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 + + // The x-goog-* metadata to be sent with each request. + xGoogMetadata metadata.MD +} + +// NewManagedNotebookClient creates a new managed notebook service client based on gRPC. +// The returned client must be Closed when it is done being used to clean up its underlying connections. +// +// API v1 service for Managed Notebooks. +func NewManagedNotebookClient(ctx context.Context, opts ...option.ClientOption) (*ManagedNotebookClient, error) { + clientOpts := defaultManagedNotebookGRPCClientOptions() + if newManagedNotebookClientHook != nil { + hookOpts, err := newManagedNotebookClientHook(ctx, clientHookParams{}) + if err != nil { + return nil, err + } + clientOpts = append(clientOpts, hookOpts...) + } + + disableDeadlines, err := checkDisableDeadlines() + if err != nil { + return nil, err + } + + connPool, err := gtransport.DialPool(ctx, append(clientOpts, opts...)...) + if err != nil { + return nil, err + } + client := ManagedNotebookClient{CallOptions: defaultManagedNotebookCallOptions()} + + c := &managedNotebookGRPCClient{ + connPool: connPool, + disableDeadlines: disableDeadlines, + managedNotebookClient: notebookspb.NewManagedNotebookServiceClient(connPool), + CallOptions: &client.CallOptions, + } + c.setGoogleClientInfo() + + client.internalClient = c + + client.LROClient, err = lroauto.NewOperationsClient(ctx, gtransport.WithConnPool(connPool)) + if err != nil { + // This error "should not happen", since we are just reusing old connection pool + // and never actually need to dial. + // If this does happen, we could leak connp. However, we cannot close conn: + // If the user invoked the constructor with option.WithGRPCConn, + // we would close a connection that's still in use. + // TODO: investigate error conditions. + return nil, err + } + c.LROClient = &client.LROClient + return &client, nil +} + +// Connection returns a connection to the API service. +// +// Deprecated. +func (c *managedNotebookGRPCClient) Connection() *grpc.ClientConn { + return c.connPool.Conn() +} + +// setGoogleClientInfo sets the name and version of the application in +// the `x-goog-api-client` header passed on each request. Intended for +// use by Google-written clients. +func (c *managedNotebookGRPCClient) setGoogleClientInfo(keyval ...string) { + kv := append([]string{"gl-go", versionGo()}, keyval...) + kv = append(kv, "gapic", getVersionClient(), "gax", gax.Version, "grpc", grpc.Version) + c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...)) +} + +// Close closes the connection to the API service. The user should invoke this when +// the client is no longer required. +func (c *managedNotebookGRPCClient) Close() error { + return c.connPool.Close() +} + +func (c *managedNotebookGRPCClient) ListRuntimes(ctx context.Context, req *notebookspb.ListRuntimesRequest, opts ...gax.CallOption) *RuntimeIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ListRuntimes[0:len((*c.CallOptions).ListRuntimes):len((*c.CallOptions).ListRuntimes)], opts...) + it := &RuntimeIterator{} + req = proto.Clone(req).(*notebookspb.ListRuntimesRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*notebookspb.Runtime, string, error) { + resp := ¬ebookspb.ListRuntimesResponse{} + if pageToken != "" { + req.PageToken = pageToken + } + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else if pageSize != 0 { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.ListRuntimes(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetRuntimes(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + + return it +} + +func (c *managedNotebookGRPCClient) GetRuntime(ctx context.Context, req *notebookspb.GetRuntimeRequest, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).GetRuntime[0:len((*c.CallOptions).GetRuntime):len((*c.CallOptions).GetRuntime)], opts...) + var resp *notebookspb.Runtime + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.GetRuntime(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *managedNotebookGRPCClient) CreateRuntime(ctx context.Context, req *notebookspb.CreateRuntimeRequest, opts ...gax.CallOption) (*CreateRuntimeOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).CreateRuntime[0:len((*c.CallOptions).CreateRuntime):len((*c.CallOptions).CreateRuntime)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.CreateRuntime(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &CreateRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *managedNotebookGRPCClient) DeleteRuntime(ctx context.Context, req *notebookspb.DeleteRuntimeRequest, opts ...gax.CallOption) (*DeleteRuntimeOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).DeleteRuntime[0:len((*c.CallOptions).DeleteRuntime):len((*c.CallOptions).DeleteRuntime)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.DeleteRuntime(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &DeleteRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *managedNotebookGRPCClient) StartRuntime(ctx context.Context, req *notebookspb.StartRuntimeRequest, opts ...gax.CallOption) (*StartRuntimeOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).StartRuntime[0:len((*c.CallOptions).StartRuntime):len((*c.CallOptions).StartRuntime)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.StartRuntime(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &StartRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *managedNotebookGRPCClient) StopRuntime(ctx context.Context, req *notebookspb.StopRuntimeRequest, opts ...gax.CallOption) (*StopRuntimeOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).StopRuntime[0:len((*c.CallOptions).StopRuntime):len((*c.CallOptions).StopRuntime)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.StopRuntime(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &StopRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *managedNotebookGRPCClient) SwitchRuntime(ctx context.Context, req *notebookspb.SwitchRuntimeRequest, opts ...gax.CallOption) (*SwitchRuntimeOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).SwitchRuntime[0:len((*c.CallOptions).SwitchRuntime):len((*c.CallOptions).SwitchRuntime)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.SwitchRuntime(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &SwitchRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *managedNotebookGRPCClient) ResetRuntime(ctx context.Context, req *notebookspb.ResetRuntimeRequest, opts ...gax.CallOption) (*ResetRuntimeOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ResetRuntime[0:len((*c.CallOptions).ResetRuntime):len((*c.CallOptions).ResetRuntime)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.ResetRuntime(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &ResetRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *managedNotebookGRPCClient) ReportRuntimeEvent(ctx context.Context, req *notebookspb.ReportRuntimeEventRequest, opts ...gax.CallOption) (*ReportRuntimeEventOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ReportRuntimeEvent[0:len((*c.CallOptions).ReportRuntimeEvent):len((*c.CallOptions).ReportRuntimeEvent)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.ReportRuntimeEvent(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &ReportRuntimeEventOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *managedNotebookGRPCClient) RefreshRuntimeTokenInternal(ctx context.Context, req *notebookspb.RefreshRuntimeTokenInternalRequest, opts ...gax.CallOption) (*notebookspb.RefreshRuntimeTokenInternalResponse, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).RefreshRuntimeTokenInternal[0:len((*c.CallOptions).RefreshRuntimeTokenInternal):len((*c.CallOptions).RefreshRuntimeTokenInternal)], opts...) + var resp *notebookspb.RefreshRuntimeTokenInternalResponse + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.managedNotebookClient.RefreshRuntimeTokenInternal(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// CreateRuntimeOperation manages a long-running operation from CreateRuntime. +type CreateRuntimeOperation struct { + lro *longrunning.Operation +} + +// CreateRuntimeOperation returns a new CreateRuntimeOperation from a given name. +// The name must be that of a previously created CreateRuntimeOperation, possibly from a different process. +func (c *managedNotebookGRPCClient) CreateRuntimeOperation(name string) *CreateRuntimeOperation { + return &CreateRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *CreateRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *CreateRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *CreateRuntimeOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *CreateRuntimeOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *CreateRuntimeOperation) Name() string { + return op.lro.Name() +} + +// DeleteRuntimeOperation manages a long-running operation from DeleteRuntime. +type DeleteRuntimeOperation struct { + lro *longrunning.Operation +} + +// DeleteRuntimeOperation returns a new DeleteRuntimeOperation from a given name. +// The name must be that of a previously created DeleteRuntimeOperation, possibly from a different process. +func (c *managedNotebookGRPCClient) DeleteRuntimeOperation(name string) *DeleteRuntimeOperation { + return &DeleteRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *DeleteRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...) +} + +// 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 (op *DeleteRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.Poll(ctx, nil, opts...) +} + +// 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 (op *DeleteRuntimeOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *DeleteRuntimeOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *DeleteRuntimeOperation) Name() string { + return op.lro.Name() +} + +// ReportRuntimeEventOperation manages a long-running operation from ReportRuntimeEvent. +type ReportRuntimeEventOperation struct { + lro *longrunning.Operation +} + +// ReportRuntimeEventOperation returns a new ReportRuntimeEventOperation from a given name. +// The name must be that of a previously created ReportRuntimeEventOperation, possibly from a different process. +func (c *managedNotebookGRPCClient) ReportRuntimeEventOperation(name string) *ReportRuntimeEventOperation { + return &ReportRuntimeEventOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *ReportRuntimeEventOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *ReportRuntimeEventOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *ReportRuntimeEventOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *ReportRuntimeEventOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *ReportRuntimeEventOperation) Name() string { + return op.lro.Name() +} + +// ResetRuntimeOperation manages a long-running operation from ResetRuntime. +type ResetRuntimeOperation struct { + lro *longrunning.Operation +} + +// ResetRuntimeOperation returns a new ResetRuntimeOperation from a given name. +// The name must be that of a previously created ResetRuntimeOperation, possibly from a different process. +func (c *managedNotebookGRPCClient) ResetRuntimeOperation(name string) *ResetRuntimeOperation { + return &ResetRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *ResetRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *ResetRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *ResetRuntimeOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *ResetRuntimeOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *ResetRuntimeOperation) Name() string { + return op.lro.Name() +} + +// StartRuntimeOperation manages a long-running operation from StartRuntime. +type StartRuntimeOperation struct { + lro *longrunning.Operation +} + +// StartRuntimeOperation returns a new StartRuntimeOperation from a given name. +// The name must be that of a previously created StartRuntimeOperation, possibly from a different process. +func (c *managedNotebookGRPCClient) StartRuntimeOperation(name string) *StartRuntimeOperation { + return &StartRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *StartRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *StartRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *StartRuntimeOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *StartRuntimeOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *StartRuntimeOperation) Name() string { + return op.lro.Name() +} + +// StopRuntimeOperation manages a long-running operation from StopRuntime. +type StopRuntimeOperation struct { + lro *longrunning.Operation +} + +// StopRuntimeOperation returns a new StopRuntimeOperation from a given name. +// The name must be that of a previously created StopRuntimeOperation, possibly from a different process. +func (c *managedNotebookGRPCClient) StopRuntimeOperation(name string) *StopRuntimeOperation { + return &StopRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *StopRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *StopRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *StopRuntimeOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *StopRuntimeOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *StopRuntimeOperation) Name() string { + return op.lro.Name() +} + +// SwitchRuntimeOperation manages a long-running operation from SwitchRuntime. +type SwitchRuntimeOperation struct { + lro *longrunning.Operation +} + +// SwitchRuntimeOperation returns a new SwitchRuntimeOperation from a given name. +// The name must be that of a previously created SwitchRuntimeOperation, possibly from a different process. +func (c *managedNotebookGRPCClient) SwitchRuntimeOperation(name string) *SwitchRuntimeOperation { + return &SwitchRuntimeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *SwitchRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *SwitchRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Runtime, error) { + var resp notebookspb.Runtime + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *SwitchRuntimeOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *SwitchRuntimeOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *SwitchRuntimeOperation) Name() string { + return op.lro.Name() +} + +// RuntimeIterator manages a stream of *notebookspb.Runtime. +type RuntimeIterator struct { + items []*notebookspb.Runtime + pageInfo *iterator.PageInfo + nextFunc func() error + + // 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 []*notebookspb.Runtime, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *RuntimeIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// 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 (it *RuntimeIterator) Next() (*notebookspb.Runtime, error) { + var item *notebookspb.Runtime + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *RuntimeIterator) bufLen() int { + return len(it.items) +} + +func (it *RuntimeIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} diff --git a/notebooks/apiv1/managed_notebook_client_example_test.go b/notebooks/apiv1/managed_notebook_client_example_test.go new file mode 100644 index 00000000000..a48393c2431 --- /dev/null +++ b/notebooks/apiv1/managed_notebook_client_example_test.go @@ -0,0 +1,276 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +package notebooks_test + +import ( + "context" + + notebooks "cloud.google.com/go/notebooks/apiv1" + "google.golang.org/api/iterator" + notebookspb "google.golang.org/genproto/googleapis/cloud/notebooks/v1" +) + +func ExampleNewManagedNotebookClient() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + // TODO: Use client. + _ = c +} + +func ExampleManagedNotebookClient_ListRuntimes() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ListRuntimesRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ListRuntimesRequest. + } + it := c.ListRuntimes(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleManagedNotebookClient_GetRuntime() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.GetRuntimeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#GetRuntimeRequest. + } + resp, err := c.GetRuntime(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleManagedNotebookClient_CreateRuntime() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.CreateRuntimeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#CreateRuntimeRequest. + } + op, err := c.CreateRuntime(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleManagedNotebookClient_DeleteRuntime() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.DeleteRuntimeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#DeleteRuntimeRequest. + } + op, err := c.DeleteRuntime(ctx, req) + if err != nil { + // TODO: Handle error. + } + + err = op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleManagedNotebookClient_StartRuntime() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.StartRuntimeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#StartRuntimeRequest. + } + op, err := c.StartRuntime(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleManagedNotebookClient_StopRuntime() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.StopRuntimeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#StopRuntimeRequest. + } + op, err := c.StopRuntime(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleManagedNotebookClient_SwitchRuntime() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.SwitchRuntimeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#SwitchRuntimeRequest. + } + op, err := c.SwitchRuntime(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleManagedNotebookClient_ResetRuntime() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ResetRuntimeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ResetRuntimeRequest. + } + op, err := c.ResetRuntime(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleManagedNotebookClient_ReportRuntimeEvent() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ReportRuntimeEventRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ReportRuntimeEventRequest. + } + op, err := c.ReportRuntimeEvent(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleManagedNotebookClient_RefreshRuntimeTokenInternal() { + ctx := context.Background() + c, err := notebooks.NewManagedNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.RefreshRuntimeTokenInternalRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#RefreshRuntimeTokenInternalRequest. + } + resp, err := c.RefreshRuntimeTokenInternal(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} diff --git a/notebooks/apiv1/notebook_client.go b/notebooks/apiv1/notebook_client.go new file mode 100644 index 00000000000..eb8350d0eae --- /dev/null +++ b/notebooks/apiv1/notebook_client.go @@ -0,0 +1,3173 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +package notebooks + +import ( + "context" + "fmt" + "math" + "net/url" + "time" + + "cloud.google.com/go/longrunning" + lroauto "cloud.google.com/go/longrunning/autogen" + gax "github.com/googleapis/gax-go/v2" + "google.golang.org/api/iterator" + "google.golang.org/api/option" + "google.golang.org/api/option/internaloption" + gtransport "google.golang.org/api/transport/grpc" + notebookspb "google.golang.org/genproto/googleapis/cloud/notebooks/v1" + longrunningpb "google.golang.org/genproto/googleapis/longrunning" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/protobuf/proto" +) + +var newNotebookClientHook clientHook + +// NotebookCallOptions contains the retry settings for each method of NotebookClient. +type NotebookCallOptions struct { + ListInstances []gax.CallOption + GetInstance []gax.CallOption + CreateInstance []gax.CallOption + RegisterInstance []gax.CallOption + SetInstanceAccelerator []gax.CallOption + SetInstanceMachineType []gax.CallOption + UpdateInstanceConfig []gax.CallOption + UpdateShieldedInstanceConfig []gax.CallOption + SetInstanceLabels []gax.CallOption + UpdateInstanceMetadataItems []gax.CallOption + DeleteInstance []gax.CallOption + StartInstance []gax.CallOption + StopInstance []gax.CallOption + ResetInstance []gax.CallOption + ReportInstanceInfo []gax.CallOption + IsInstanceUpgradeable []gax.CallOption + GetInstanceHealth []gax.CallOption + UpgradeInstance []gax.CallOption + RollbackInstance []gax.CallOption + UpgradeInstanceInternal []gax.CallOption + ListEnvironments []gax.CallOption + GetEnvironment []gax.CallOption + CreateEnvironment []gax.CallOption + DeleteEnvironment []gax.CallOption + ListSchedules []gax.CallOption + GetSchedule []gax.CallOption + DeleteSchedule []gax.CallOption + CreateSchedule []gax.CallOption + TriggerSchedule []gax.CallOption + ListExecutions []gax.CallOption + GetExecution []gax.CallOption + DeleteExecution []gax.CallOption + CreateExecution []gax.CallOption +} + +func defaultNotebookGRPCClientOptions() []option.ClientOption { + return []option.ClientOption{ + internaloption.WithDefaultEndpoint("notebooks.googleapis.com:443"), + internaloption.WithDefaultMTLSEndpoint("notebooks.mtls.googleapis.com:443"), + internaloption.WithDefaultAudience("https://notebooks.googleapis.com/"), + internaloption.WithDefaultScopes(DefaultAuthScopes()...), + internaloption.EnableJwtWithScope(), + option.WithGRPCDialOption(grpc.WithDefaultCallOptions( + grpc.MaxCallRecvMsgSize(math.MaxInt32))), + } +} + +func defaultNotebookCallOptions() *NotebookCallOptions { + return &NotebookCallOptions{ + ListInstances: []gax.CallOption{}, + GetInstance: []gax.CallOption{}, + CreateInstance: []gax.CallOption{}, + RegisterInstance: []gax.CallOption{}, + SetInstanceAccelerator: []gax.CallOption{}, + SetInstanceMachineType: []gax.CallOption{}, + UpdateInstanceConfig: []gax.CallOption{}, + UpdateShieldedInstanceConfig: []gax.CallOption{}, + SetInstanceLabels: []gax.CallOption{}, + UpdateInstanceMetadataItems: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 60000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + DeleteInstance: []gax.CallOption{}, + StartInstance: []gax.CallOption{}, + StopInstance: []gax.CallOption{}, + ResetInstance: []gax.CallOption{}, + ReportInstanceInfo: []gax.CallOption{}, + IsInstanceUpgradeable: []gax.CallOption{}, + GetInstanceHealth: []gax.CallOption{}, + UpgradeInstance: []gax.CallOption{}, + RollbackInstance: []gax.CallOption{}, + UpgradeInstanceInternal: []gax.CallOption{}, + ListEnvironments: []gax.CallOption{}, + GetEnvironment: []gax.CallOption{}, + CreateEnvironment: []gax.CallOption{}, + DeleteEnvironment: []gax.CallOption{}, + ListSchedules: []gax.CallOption{}, + GetSchedule: []gax.CallOption{}, + DeleteSchedule: []gax.CallOption{}, + CreateSchedule: []gax.CallOption{}, + TriggerSchedule: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 60000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListExecutions: []gax.CallOption{}, + GetExecution: []gax.CallOption{}, + DeleteExecution: []gax.CallOption{}, + CreateExecution: []gax.CallOption{}, + } +} + +// internalNotebookClient is an interface that defines the methods availaible from Notebooks API. +type internalNotebookClient interface { + Close() error + setGoogleClientInfo(...string) + Connection() *grpc.ClientConn + ListInstances(context.Context, *notebookspb.ListInstancesRequest, ...gax.CallOption) *InstanceIterator + GetInstance(context.Context, *notebookspb.GetInstanceRequest, ...gax.CallOption) (*notebookspb.Instance, error) + CreateInstance(context.Context, *notebookspb.CreateInstanceRequest, ...gax.CallOption) (*CreateInstanceOperation, error) + CreateInstanceOperation(name string) *CreateInstanceOperation + RegisterInstance(context.Context, *notebookspb.RegisterInstanceRequest, ...gax.CallOption) (*RegisterInstanceOperation, error) + RegisterInstanceOperation(name string) *RegisterInstanceOperation + SetInstanceAccelerator(context.Context, *notebookspb.SetInstanceAcceleratorRequest, ...gax.CallOption) (*SetInstanceAcceleratorOperation, error) + SetInstanceAcceleratorOperation(name string) *SetInstanceAcceleratorOperation + SetInstanceMachineType(context.Context, *notebookspb.SetInstanceMachineTypeRequest, ...gax.CallOption) (*SetInstanceMachineTypeOperation, error) + SetInstanceMachineTypeOperation(name string) *SetInstanceMachineTypeOperation + UpdateInstanceConfig(context.Context, *notebookspb.UpdateInstanceConfigRequest, ...gax.CallOption) (*UpdateInstanceConfigOperation, error) + UpdateInstanceConfigOperation(name string) *UpdateInstanceConfigOperation + UpdateShieldedInstanceConfig(context.Context, *notebookspb.UpdateShieldedInstanceConfigRequest, ...gax.CallOption) (*UpdateShieldedInstanceConfigOperation, error) + UpdateShieldedInstanceConfigOperation(name string) *UpdateShieldedInstanceConfigOperation + SetInstanceLabels(context.Context, *notebookspb.SetInstanceLabelsRequest, ...gax.CallOption) (*SetInstanceLabelsOperation, error) + SetInstanceLabelsOperation(name string) *SetInstanceLabelsOperation + UpdateInstanceMetadataItems(context.Context, *notebookspb.UpdateInstanceMetadataItemsRequest, ...gax.CallOption) (*notebookspb.UpdateInstanceMetadataItemsResponse, error) + DeleteInstance(context.Context, *notebookspb.DeleteInstanceRequest, ...gax.CallOption) (*DeleteInstanceOperation, error) + DeleteInstanceOperation(name string) *DeleteInstanceOperation + StartInstance(context.Context, *notebookspb.StartInstanceRequest, ...gax.CallOption) (*StartInstanceOperation, error) + StartInstanceOperation(name string) *StartInstanceOperation + StopInstance(context.Context, *notebookspb.StopInstanceRequest, ...gax.CallOption) (*StopInstanceOperation, error) + StopInstanceOperation(name string) *StopInstanceOperation + ResetInstance(context.Context, *notebookspb.ResetInstanceRequest, ...gax.CallOption) (*ResetInstanceOperation, error) + ResetInstanceOperation(name string) *ResetInstanceOperation + ReportInstanceInfo(context.Context, *notebookspb.ReportInstanceInfoRequest, ...gax.CallOption) (*ReportInstanceInfoOperation, error) + ReportInstanceInfoOperation(name string) *ReportInstanceInfoOperation + IsInstanceUpgradeable(context.Context, *notebookspb.IsInstanceUpgradeableRequest, ...gax.CallOption) (*notebookspb.IsInstanceUpgradeableResponse, error) + GetInstanceHealth(context.Context, *notebookspb.GetInstanceHealthRequest, ...gax.CallOption) (*notebookspb.GetInstanceHealthResponse, error) + UpgradeInstance(context.Context, *notebookspb.UpgradeInstanceRequest, ...gax.CallOption) (*UpgradeInstanceOperation, error) + UpgradeInstanceOperation(name string) *UpgradeInstanceOperation + RollbackInstance(context.Context, *notebookspb.RollbackInstanceRequest, ...gax.CallOption) (*RollbackInstanceOperation, error) + RollbackInstanceOperation(name string) *RollbackInstanceOperation + UpgradeInstanceInternal(context.Context, *notebookspb.UpgradeInstanceInternalRequest, ...gax.CallOption) (*UpgradeInstanceInternalOperation, error) + UpgradeInstanceInternalOperation(name string) *UpgradeInstanceInternalOperation + ListEnvironments(context.Context, *notebookspb.ListEnvironmentsRequest, ...gax.CallOption) *EnvironmentIterator + GetEnvironment(context.Context, *notebookspb.GetEnvironmentRequest, ...gax.CallOption) (*notebookspb.Environment, error) + CreateEnvironment(context.Context, *notebookspb.CreateEnvironmentRequest, ...gax.CallOption) (*CreateEnvironmentOperation, error) + CreateEnvironmentOperation(name string) *CreateEnvironmentOperation + DeleteEnvironment(context.Context, *notebookspb.DeleteEnvironmentRequest, ...gax.CallOption) (*DeleteEnvironmentOperation, error) + DeleteEnvironmentOperation(name string) *DeleteEnvironmentOperation + ListSchedules(context.Context, *notebookspb.ListSchedulesRequest, ...gax.CallOption) *ScheduleIterator + GetSchedule(context.Context, *notebookspb.GetScheduleRequest, ...gax.CallOption) (*notebookspb.Schedule, error) + DeleteSchedule(context.Context, *notebookspb.DeleteScheduleRequest, ...gax.CallOption) (*DeleteScheduleOperation, error) + DeleteScheduleOperation(name string) *DeleteScheduleOperation + CreateSchedule(context.Context, *notebookspb.CreateScheduleRequest, ...gax.CallOption) (*CreateScheduleOperation, error) + CreateScheduleOperation(name string) *CreateScheduleOperation + TriggerSchedule(context.Context, *notebookspb.TriggerScheduleRequest, ...gax.CallOption) (*TriggerScheduleOperation, error) + TriggerScheduleOperation(name string) *TriggerScheduleOperation + ListExecutions(context.Context, *notebookspb.ListExecutionsRequest, ...gax.CallOption) *ExecutionIterator + GetExecution(context.Context, *notebookspb.GetExecutionRequest, ...gax.CallOption) (*notebookspb.Execution, error) + DeleteExecution(context.Context, *notebookspb.DeleteExecutionRequest, ...gax.CallOption) (*DeleteExecutionOperation, error) + DeleteExecutionOperation(name string) *DeleteExecutionOperation + CreateExecution(context.Context, *notebookspb.CreateExecutionRequest, ...gax.CallOption) (*CreateExecutionOperation, error) + CreateExecutionOperation(name string) *CreateExecutionOperation +} + +// NotebookClient is a client for interacting with Notebooks API. +// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. +// +// API v1 service for Cloud AI Platform Notebooks. +type NotebookClient struct { + // The internal transport-dependent client. + internalClient internalNotebookClient + + // The call options for this service. + CallOptions *NotebookCallOptions + + // 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 +} + +// Wrapper methods routed to the internal client. + +// Close closes the connection to the API service. The user should invoke this when +// the client is no longer required. +func (c *NotebookClient) Close() error { + return c.internalClient.Close() +} + +// setGoogleClientInfo sets the name and version of the application in +// the `x-goog-api-client` header passed on each request. Intended for +// use by Google-written clients. +func (c *NotebookClient) setGoogleClientInfo(keyval ...string) { + c.internalClient.setGoogleClientInfo(keyval...) +} + +// Connection returns a connection to the API service. +// +// Deprecated. +func (c *NotebookClient) Connection() *grpc.ClientConn { + return c.internalClient.Connection() +} + +// ListInstances lists instances in a given project and location. +func (c *NotebookClient) ListInstances(ctx context.Context, req *notebookspb.ListInstancesRequest, opts ...gax.CallOption) *InstanceIterator { + return c.internalClient.ListInstances(ctx, req, opts...) +} + +// GetInstance gets details of a single Instance. +func (c *NotebookClient) GetInstance(ctx context.Context, req *notebookspb.GetInstanceRequest, opts ...gax.CallOption) (*notebookspb.Instance, error) { + return c.internalClient.GetInstance(ctx, req, opts...) +} + +// CreateInstance creates a new Instance in a given project and location. +func (c *NotebookClient) CreateInstance(ctx context.Context, req *notebookspb.CreateInstanceRequest, opts ...gax.CallOption) (*CreateInstanceOperation, error) { + return c.internalClient.CreateInstance(ctx, req, opts...) +} + +// CreateInstanceOperation returns a new CreateInstanceOperation from a given name. +// The name must be that of a previously created CreateInstanceOperation, possibly from a different process. +func (c *NotebookClient) CreateInstanceOperation(name string) *CreateInstanceOperation { + return c.internalClient.CreateInstanceOperation(name) +} + +// RegisterInstance registers an existing legacy notebook instance to the Notebooks API server. +// Legacy instances are instances created with the legacy Compute Engine +// calls. They are not manageable by the Notebooks API out of the box. This +// call makes these instances manageable by the Notebooks API. +func (c *NotebookClient) RegisterInstance(ctx context.Context, req *notebookspb.RegisterInstanceRequest, opts ...gax.CallOption) (*RegisterInstanceOperation, error) { + return c.internalClient.RegisterInstance(ctx, req, opts...) +} + +// RegisterInstanceOperation returns a new RegisterInstanceOperation from a given name. +// The name must be that of a previously created RegisterInstanceOperation, possibly from a different process. +func (c *NotebookClient) RegisterInstanceOperation(name string) *RegisterInstanceOperation { + return c.internalClient.RegisterInstanceOperation(name) +} + +// SetInstanceAccelerator updates the guest accelerators of a single Instance. +func (c *NotebookClient) SetInstanceAccelerator(ctx context.Context, req *notebookspb.SetInstanceAcceleratorRequest, opts ...gax.CallOption) (*SetInstanceAcceleratorOperation, error) { + return c.internalClient.SetInstanceAccelerator(ctx, req, opts...) +} + +// SetInstanceAcceleratorOperation returns a new SetInstanceAcceleratorOperation from a given name. +// The name must be that of a previously created SetInstanceAcceleratorOperation, possibly from a different process. +func (c *NotebookClient) SetInstanceAcceleratorOperation(name string) *SetInstanceAcceleratorOperation { + return c.internalClient.SetInstanceAcceleratorOperation(name) +} + +// SetInstanceMachineType updates the machine type of a single Instance. +func (c *NotebookClient) SetInstanceMachineType(ctx context.Context, req *notebookspb.SetInstanceMachineTypeRequest, opts ...gax.CallOption) (*SetInstanceMachineTypeOperation, error) { + return c.internalClient.SetInstanceMachineType(ctx, req, opts...) +} + +// SetInstanceMachineTypeOperation returns a new SetInstanceMachineTypeOperation from a given name. +// The name must be that of a previously created SetInstanceMachineTypeOperation, possibly from a different process. +func (c *NotebookClient) SetInstanceMachineTypeOperation(name string) *SetInstanceMachineTypeOperation { + return c.internalClient.SetInstanceMachineTypeOperation(name) +} + +// UpdateInstanceConfig update Notebook Instance configurations. +func (c *NotebookClient) UpdateInstanceConfig(ctx context.Context, req *notebookspb.UpdateInstanceConfigRequest, opts ...gax.CallOption) (*UpdateInstanceConfigOperation, error) { + return c.internalClient.UpdateInstanceConfig(ctx, req, opts...) +} + +// UpdateInstanceConfigOperation returns a new UpdateInstanceConfigOperation from a given name. +// The name must be that of a previously created UpdateInstanceConfigOperation, possibly from a different process. +func (c *NotebookClient) UpdateInstanceConfigOperation(name string) *UpdateInstanceConfigOperation { + return c.internalClient.UpdateInstanceConfigOperation(name) +} + +// UpdateShieldedInstanceConfig updates the Shielded instance configuration of a single Instance. +func (c *NotebookClient) UpdateShieldedInstanceConfig(ctx context.Context, req *notebookspb.UpdateShieldedInstanceConfigRequest, opts ...gax.CallOption) (*UpdateShieldedInstanceConfigOperation, error) { + return c.internalClient.UpdateShieldedInstanceConfig(ctx, req, opts...) +} + +// UpdateShieldedInstanceConfigOperation returns a new UpdateShieldedInstanceConfigOperation from a given name. +// The name must be that of a previously created UpdateShieldedInstanceConfigOperation, possibly from a different process. +func (c *NotebookClient) UpdateShieldedInstanceConfigOperation(name string) *UpdateShieldedInstanceConfigOperation { + return c.internalClient.UpdateShieldedInstanceConfigOperation(name) +} + +// SetInstanceLabels replaces all the labels of an Instance. +func (c *NotebookClient) SetInstanceLabels(ctx context.Context, req *notebookspb.SetInstanceLabelsRequest, opts ...gax.CallOption) (*SetInstanceLabelsOperation, error) { + return c.internalClient.SetInstanceLabels(ctx, req, opts...) +} + +// SetInstanceLabelsOperation returns a new SetInstanceLabelsOperation from a given name. +// The name must be that of a previously created SetInstanceLabelsOperation, possibly from a different process. +func (c *NotebookClient) SetInstanceLabelsOperation(name string) *SetInstanceLabelsOperation { + return c.internalClient.SetInstanceLabelsOperation(name) +} + +// UpdateInstanceMetadataItems add/update metadata items for an instance. +func (c *NotebookClient) UpdateInstanceMetadataItems(ctx context.Context, req *notebookspb.UpdateInstanceMetadataItemsRequest, opts ...gax.CallOption) (*notebookspb.UpdateInstanceMetadataItemsResponse, error) { + return c.internalClient.UpdateInstanceMetadataItems(ctx, req, opts...) +} + +// DeleteInstance deletes a single Instance. +func (c *NotebookClient) DeleteInstance(ctx context.Context, req *notebookspb.DeleteInstanceRequest, opts ...gax.CallOption) (*DeleteInstanceOperation, error) { + return c.internalClient.DeleteInstance(ctx, req, opts...) +} + +// DeleteInstanceOperation returns a new DeleteInstanceOperation from a given name. +// The name must be that of a previously created DeleteInstanceOperation, possibly from a different process. +func (c *NotebookClient) DeleteInstanceOperation(name string) *DeleteInstanceOperation { + return c.internalClient.DeleteInstanceOperation(name) +} + +// StartInstance starts a notebook instance. +func (c *NotebookClient) StartInstance(ctx context.Context, req *notebookspb.StartInstanceRequest, opts ...gax.CallOption) (*StartInstanceOperation, error) { + return c.internalClient.StartInstance(ctx, req, opts...) +} + +// StartInstanceOperation returns a new StartInstanceOperation from a given name. +// The name must be that of a previously created StartInstanceOperation, possibly from a different process. +func (c *NotebookClient) StartInstanceOperation(name string) *StartInstanceOperation { + return c.internalClient.StartInstanceOperation(name) +} + +// StopInstance stops a notebook instance. +func (c *NotebookClient) StopInstance(ctx context.Context, req *notebookspb.StopInstanceRequest, opts ...gax.CallOption) (*StopInstanceOperation, error) { + return c.internalClient.StopInstance(ctx, req, opts...) +} + +// StopInstanceOperation returns a new StopInstanceOperation from a given name. +// The name must be that of a previously created StopInstanceOperation, possibly from a different process. +func (c *NotebookClient) StopInstanceOperation(name string) *StopInstanceOperation { + return c.internalClient.StopInstanceOperation(name) +} + +// ResetInstance resets a notebook instance. +func (c *NotebookClient) ResetInstance(ctx context.Context, req *notebookspb.ResetInstanceRequest, opts ...gax.CallOption) (*ResetInstanceOperation, error) { + return c.internalClient.ResetInstance(ctx, req, opts...) +} + +// ResetInstanceOperation returns a new ResetInstanceOperation from a given name. +// The name must be that of a previously created ResetInstanceOperation, possibly from a different process. +func (c *NotebookClient) ResetInstanceOperation(name string) *ResetInstanceOperation { + return c.internalClient.ResetInstanceOperation(name) +} + +// ReportInstanceInfo allows notebook instances to +// report their latest instance information to the Notebooks +// API server. The server will merge the reported information to +// the instance metadata store. Do not use this method directly. +func (c *NotebookClient) ReportInstanceInfo(ctx context.Context, req *notebookspb.ReportInstanceInfoRequest, opts ...gax.CallOption) (*ReportInstanceInfoOperation, error) { + return c.internalClient.ReportInstanceInfo(ctx, req, opts...) +} + +// ReportInstanceInfoOperation returns a new ReportInstanceInfoOperation from a given name. +// The name must be that of a previously created ReportInstanceInfoOperation, possibly from a different process. +func (c *NotebookClient) ReportInstanceInfoOperation(name string) *ReportInstanceInfoOperation { + return c.internalClient.ReportInstanceInfoOperation(name) +} + +// IsInstanceUpgradeable check if a notebook instance is upgradable. +func (c *NotebookClient) IsInstanceUpgradeable(ctx context.Context, req *notebookspb.IsInstanceUpgradeableRequest, opts ...gax.CallOption) (*notebookspb.IsInstanceUpgradeableResponse, error) { + return c.internalClient.IsInstanceUpgradeable(ctx, req, opts...) +} + +// GetInstanceHealth check if a notebook instance is healthy. +func (c *NotebookClient) GetInstanceHealth(ctx context.Context, req *notebookspb.GetInstanceHealthRequest, opts ...gax.CallOption) (*notebookspb.GetInstanceHealthResponse, error) { + return c.internalClient.GetInstanceHealth(ctx, req, opts...) +} + +// UpgradeInstance upgrades a notebook instance to the latest version. +func (c *NotebookClient) UpgradeInstance(ctx context.Context, req *notebookspb.UpgradeInstanceRequest, opts ...gax.CallOption) (*UpgradeInstanceOperation, error) { + return c.internalClient.UpgradeInstance(ctx, req, opts...) +} + +// UpgradeInstanceOperation returns a new UpgradeInstanceOperation from a given name. +// The name must be that of a previously created UpgradeInstanceOperation, possibly from a different process. +func (c *NotebookClient) UpgradeInstanceOperation(name string) *UpgradeInstanceOperation { + return c.internalClient.UpgradeInstanceOperation(name) +} + +// RollbackInstance rollbacks a notebook instance to the previous version. +func (c *NotebookClient) RollbackInstance(ctx context.Context, req *notebookspb.RollbackInstanceRequest, opts ...gax.CallOption) (*RollbackInstanceOperation, error) { + return c.internalClient.RollbackInstance(ctx, req, opts...) +} + +// RollbackInstanceOperation returns a new RollbackInstanceOperation from a given name. +// The name must be that of a previously created RollbackInstanceOperation, possibly from a different process. +func (c *NotebookClient) RollbackInstanceOperation(name string) *RollbackInstanceOperation { + return c.internalClient.RollbackInstanceOperation(name) +} + +// UpgradeInstanceInternal allows notebook instances to +// call this endpoint to upgrade themselves. Do not use this method directly. +func (c *NotebookClient) UpgradeInstanceInternal(ctx context.Context, req *notebookspb.UpgradeInstanceInternalRequest, opts ...gax.CallOption) (*UpgradeInstanceInternalOperation, error) { + return c.internalClient.UpgradeInstanceInternal(ctx, req, opts...) +} + +// UpgradeInstanceInternalOperation returns a new UpgradeInstanceInternalOperation from a given name. +// The name must be that of a previously created UpgradeInstanceInternalOperation, possibly from a different process. +func (c *NotebookClient) UpgradeInstanceInternalOperation(name string) *UpgradeInstanceInternalOperation { + return c.internalClient.UpgradeInstanceInternalOperation(name) +} + +// ListEnvironments lists environments in a project. +func (c *NotebookClient) ListEnvironments(ctx context.Context, req *notebookspb.ListEnvironmentsRequest, opts ...gax.CallOption) *EnvironmentIterator { + return c.internalClient.ListEnvironments(ctx, req, opts...) +} + +// GetEnvironment gets details of a single Environment. +func (c *NotebookClient) GetEnvironment(ctx context.Context, req *notebookspb.GetEnvironmentRequest, opts ...gax.CallOption) (*notebookspb.Environment, error) { + return c.internalClient.GetEnvironment(ctx, req, opts...) +} + +// CreateEnvironment creates a new Environment. +func (c *NotebookClient) CreateEnvironment(ctx context.Context, req *notebookspb.CreateEnvironmentRequest, opts ...gax.CallOption) (*CreateEnvironmentOperation, error) { + return c.internalClient.CreateEnvironment(ctx, req, opts...) +} + +// CreateEnvironmentOperation returns a new CreateEnvironmentOperation from a given name. +// The name must be that of a previously created CreateEnvironmentOperation, possibly from a different process. +func (c *NotebookClient) CreateEnvironmentOperation(name string) *CreateEnvironmentOperation { + return c.internalClient.CreateEnvironmentOperation(name) +} + +// DeleteEnvironment deletes a single Environment. +func (c *NotebookClient) DeleteEnvironment(ctx context.Context, req *notebookspb.DeleteEnvironmentRequest, opts ...gax.CallOption) (*DeleteEnvironmentOperation, error) { + return c.internalClient.DeleteEnvironment(ctx, req, opts...) +} + +// DeleteEnvironmentOperation returns a new DeleteEnvironmentOperation from a given name. +// The name must be that of a previously created DeleteEnvironmentOperation, possibly from a different process. +func (c *NotebookClient) DeleteEnvironmentOperation(name string) *DeleteEnvironmentOperation { + return c.internalClient.DeleteEnvironmentOperation(name) +} + +// ListSchedules lists schedules in a given project and location. +func (c *NotebookClient) ListSchedules(ctx context.Context, req *notebookspb.ListSchedulesRequest, opts ...gax.CallOption) *ScheduleIterator { + return c.internalClient.ListSchedules(ctx, req, opts...) +} + +// GetSchedule gets details of schedule +func (c *NotebookClient) GetSchedule(ctx context.Context, req *notebookspb.GetScheduleRequest, opts ...gax.CallOption) (*notebookspb.Schedule, error) { + return c.internalClient.GetSchedule(ctx, req, opts...) +} + +// DeleteSchedule deletes schedule and all underlying jobs +func (c *NotebookClient) DeleteSchedule(ctx context.Context, req *notebookspb.DeleteScheduleRequest, opts ...gax.CallOption) (*DeleteScheduleOperation, error) { + return c.internalClient.DeleteSchedule(ctx, req, opts...) +} + +// DeleteScheduleOperation returns a new DeleteScheduleOperation from a given name. +// The name must be that of a previously created DeleteScheduleOperation, possibly from a different process. +func (c *NotebookClient) DeleteScheduleOperation(name string) *DeleteScheduleOperation { + return c.internalClient.DeleteScheduleOperation(name) +} + +// CreateSchedule creates a new Scheduled Notebook in a given project and location. +func (c *NotebookClient) CreateSchedule(ctx context.Context, req *notebookspb.CreateScheduleRequest, opts ...gax.CallOption) (*CreateScheduleOperation, error) { + return c.internalClient.CreateSchedule(ctx, req, opts...) +} + +// CreateScheduleOperation returns a new CreateScheduleOperation from a given name. +// The name must be that of a previously created CreateScheduleOperation, possibly from a different process. +func (c *NotebookClient) CreateScheduleOperation(name string) *CreateScheduleOperation { + return c.internalClient.CreateScheduleOperation(name) +} + +// TriggerSchedule triggers execution of an existing schedule. +func (c *NotebookClient) TriggerSchedule(ctx context.Context, req *notebookspb.TriggerScheduleRequest, opts ...gax.CallOption) (*TriggerScheduleOperation, error) { + return c.internalClient.TriggerSchedule(ctx, req, opts...) +} + +// TriggerScheduleOperation returns a new TriggerScheduleOperation from a given name. +// The name must be that of a previously created TriggerScheduleOperation, possibly from a different process. +func (c *NotebookClient) TriggerScheduleOperation(name string) *TriggerScheduleOperation { + return c.internalClient.TriggerScheduleOperation(name) +} + +// ListExecutions lists executions in a given project and location +func (c *NotebookClient) ListExecutions(ctx context.Context, req *notebookspb.ListExecutionsRequest, opts ...gax.CallOption) *ExecutionIterator { + return c.internalClient.ListExecutions(ctx, req, opts...) +} + +// GetExecution gets details of executions +func (c *NotebookClient) GetExecution(ctx context.Context, req *notebookspb.GetExecutionRequest, opts ...gax.CallOption) (*notebookspb.Execution, error) { + return c.internalClient.GetExecution(ctx, req, opts...) +} + +// DeleteExecution deletes execution +func (c *NotebookClient) DeleteExecution(ctx context.Context, req *notebookspb.DeleteExecutionRequest, opts ...gax.CallOption) (*DeleteExecutionOperation, error) { + return c.internalClient.DeleteExecution(ctx, req, opts...) +} + +// DeleteExecutionOperation returns a new DeleteExecutionOperation from a given name. +// The name must be that of a previously created DeleteExecutionOperation, possibly from a different process. +func (c *NotebookClient) DeleteExecutionOperation(name string) *DeleteExecutionOperation { + return c.internalClient.DeleteExecutionOperation(name) +} + +// CreateExecution creates a new Execution in a given project and location. +func (c *NotebookClient) CreateExecution(ctx context.Context, req *notebookspb.CreateExecutionRequest, opts ...gax.CallOption) (*CreateExecutionOperation, error) { + return c.internalClient.CreateExecution(ctx, req, opts...) +} + +// CreateExecutionOperation returns a new CreateExecutionOperation from a given name. +// The name must be that of a previously created CreateExecutionOperation, possibly from a different process. +func (c *NotebookClient) CreateExecutionOperation(name string) *CreateExecutionOperation { + return c.internalClient.CreateExecutionOperation(name) +} + +// notebookGRPCClient is a client for interacting with Notebooks API over gRPC transport. +// +// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. +type notebookGRPCClient struct { + // Connection pool of gRPC connections to the service. + connPool gtransport.ConnPool + + // flag to opt out of default deadlines via GOOGLE_API_GO_EXPERIMENTAL_DISABLE_DEFAULT_DEADLINE + disableDeadlines bool + + // Points back to the CallOptions field of the containing NotebookClient + CallOptions **NotebookCallOptions + + // The gRPC API client. + notebookClient notebookspb.NotebookServiceClient + + // 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 + + // The x-goog-* metadata to be sent with each request. + xGoogMetadata metadata.MD +} + +// NewNotebookClient creates a new notebook service client based on gRPC. +// The returned client must be Closed when it is done being used to clean up its underlying connections. +// +// API v1 service for Cloud AI Platform Notebooks. +func NewNotebookClient(ctx context.Context, opts ...option.ClientOption) (*NotebookClient, error) { + clientOpts := defaultNotebookGRPCClientOptions() + if newNotebookClientHook != nil { + hookOpts, err := newNotebookClientHook(ctx, clientHookParams{}) + if err != nil { + return nil, err + } + clientOpts = append(clientOpts, hookOpts...) + } + + disableDeadlines, err := checkDisableDeadlines() + if err != nil { + return nil, err + } + + connPool, err := gtransport.DialPool(ctx, append(clientOpts, opts...)...) + if err != nil { + return nil, err + } + client := NotebookClient{CallOptions: defaultNotebookCallOptions()} + + c := ¬ebookGRPCClient{ + connPool: connPool, + disableDeadlines: disableDeadlines, + notebookClient: notebookspb.NewNotebookServiceClient(connPool), + CallOptions: &client.CallOptions, + } + c.setGoogleClientInfo() + + client.internalClient = c + + client.LROClient, err = lroauto.NewOperationsClient(ctx, gtransport.WithConnPool(connPool)) + if err != nil { + // This error "should not happen", since we are just reusing old connection pool + // and never actually need to dial. + // If this does happen, we could leak connp. However, we cannot close conn: + // If the user invoked the constructor with option.WithGRPCConn, + // we would close a connection that's still in use. + // TODO: investigate error conditions. + return nil, err + } + c.LROClient = &client.LROClient + return &client, nil +} + +// Connection returns a connection to the API service. +// +// Deprecated. +func (c *notebookGRPCClient) Connection() *grpc.ClientConn { + return c.connPool.Conn() +} + +// setGoogleClientInfo sets the name and version of the application in +// the `x-goog-api-client` header passed on each request. Intended for +// use by Google-written clients. +func (c *notebookGRPCClient) setGoogleClientInfo(keyval ...string) { + kv := append([]string{"gl-go", versionGo()}, keyval...) + kv = append(kv, "gapic", getVersionClient(), "gax", gax.Version, "grpc", grpc.Version) + c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...)) +} + +// Close closes the connection to the API service. The user should invoke this when +// the client is no longer required. +func (c *notebookGRPCClient) Close() error { + return c.connPool.Close() +} + +func (c *notebookGRPCClient) ListInstances(ctx context.Context, req *notebookspb.ListInstancesRequest, opts ...gax.CallOption) *InstanceIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ListInstances[0:len((*c.CallOptions).ListInstances):len((*c.CallOptions).ListInstances)], opts...) + it := &InstanceIterator{} + req = proto.Clone(req).(*notebookspb.ListInstancesRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*notebookspb.Instance, string, error) { + resp := ¬ebookspb.ListInstancesResponse{} + if pageToken != "" { + req.PageToken = pageToken + } + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else if pageSize != 0 { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.ListInstances(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetInstances(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + + return it +} + +func (c *notebookGRPCClient) GetInstance(ctx context.Context, req *notebookspb.GetInstanceRequest, opts ...gax.CallOption) (*notebookspb.Instance, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).GetInstance[0:len((*c.CallOptions).GetInstance):len((*c.CallOptions).GetInstance)], opts...) + var resp *notebookspb.Instance + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.GetInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *notebookGRPCClient) CreateInstance(ctx context.Context, req *notebookspb.CreateInstanceRequest, opts ...gax.CallOption) (*CreateInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).CreateInstance[0:len((*c.CallOptions).CreateInstance):len((*c.CallOptions).CreateInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.CreateInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &CreateInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) RegisterInstance(ctx context.Context, req *notebookspb.RegisterInstanceRequest, opts ...gax.CallOption) (*RegisterInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).RegisterInstance[0:len((*c.CallOptions).RegisterInstance):len((*c.CallOptions).RegisterInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.RegisterInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &RegisterInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) SetInstanceAccelerator(ctx context.Context, req *notebookspb.SetInstanceAcceleratorRequest, opts ...gax.CallOption) (*SetInstanceAcceleratorOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).SetInstanceAccelerator[0:len((*c.CallOptions).SetInstanceAccelerator):len((*c.CallOptions).SetInstanceAccelerator)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.SetInstanceAccelerator(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &SetInstanceAcceleratorOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) SetInstanceMachineType(ctx context.Context, req *notebookspb.SetInstanceMachineTypeRequest, opts ...gax.CallOption) (*SetInstanceMachineTypeOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).SetInstanceMachineType[0:len((*c.CallOptions).SetInstanceMachineType):len((*c.CallOptions).SetInstanceMachineType)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.SetInstanceMachineType(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &SetInstanceMachineTypeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) UpdateInstanceConfig(ctx context.Context, req *notebookspb.UpdateInstanceConfigRequest, opts ...gax.CallOption) (*UpdateInstanceConfigOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).UpdateInstanceConfig[0:len((*c.CallOptions).UpdateInstanceConfig):len((*c.CallOptions).UpdateInstanceConfig)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.UpdateInstanceConfig(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &UpdateInstanceConfigOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) UpdateShieldedInstanceConfig(ctx context.Context, req *notebookspb.UpdateShieldedInstanceConfigRequest, opts ...gax.CallOption) (*UpdateShieldedInstanceConfigOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).UpdateShieldedInstanceConfig[0:len((*c.CallOptions).UpdateShieldedInstanceConfig):len((*c.CallOptions).UpdateShieldedInstanceConfig)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.UpdateShieldedInstanceConfig(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &UpdateShieldedInstanceConfigOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) SetInstanceLabels(ctx context.Context, req *notebookspb.SetInstanceLabelsRequest, opts ...gax.CallOption) (*SetInstanceLabelsOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).SetInstanceLabels[0:len((*c.CallOptions).SetInstanceLabels):len((*c.CallOptions).SetInstanceLabels)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.SetInstanceLabels(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &SetInstanceLabelsOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) UpdateInstanceMetadataItems(ctx context.Context, req *notebookspb.UpdateInstanceMetadataItemsRequest, opts ...gax.CallOption) (*notebookspb.UpdateInstanceMetadataItemsResponse, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).UpdateInstanceMetadataItems[0:len((*c.CallOptions).UpdateInstanceMetadataItems):len((*c.CallOptions).UpdateInstanceMetadataItems)], opts...) + var resp *notebookspb.UpdateInstanceMetadataItemsResponse + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.UpdateInstanceMetadataItems(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *notebookGRPCClient) DeleteInstance(ctx context.Context, req *notebookspb.DeleteInstanceRequest, opts ...gax.CallOption) (*DeleteInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).DeleteInstance[0:len((*c.CallOptions).DeleteInstance):len((*c.CallOptions).DeleteInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.DeleteInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &DeleteInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) StartInstance(ctx context.Context, req *notebookspb.StartInstanceRequest, opts ...gax.CallOption) (*StartInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).StartInstance[0:len((*c.CallOptions).StartInstance):len((*c.CallOptions).StartInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.StartInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &StartInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) StopInstance(ctx context.Context, req *notebookspb.StopInstanceRequest, opts ...gax.CallOption) (*StopInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).StopInstance[0:len((*c.CallOptions).StopInstance):len((*c.CallOptions).StopInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.StopInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &StopInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) ResetInstance(ctx context.Context, req *notebookspb.ResetInstanceRequest, opts ...gax.CallOption) (*ResetInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ResetInstance[0:len((*c.CallOptions).ResetInstance):len((*c.CallOptions).ResetInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.ResetInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &ResetInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) ReportInstanceInfo(ctx context.Context, req *notebookspb.ReportInstanceInfoRequest, opts ...gax.CallOption) (*ReportInstanceInfoOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ReportInstanceInfo[0:len((*c.CallOptions).ReportInstanceInfo):len((*c.CallOptions).ReportInstanceInfo)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.ReportInstanceInfo(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &ReportInstanceInfoOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) IsInstanceUpgradeable(ctx context.Context, req *notebookspb.IsInstanceUpgradeableRequest, opts ...gax.CallOption) (*notebookspb.IsInstanceUpgradeableResponse, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "notebook_instance", url.QueryEscape(req.GetNotebookInstance()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).IsInstanceUpgradeable[0:len((*c.CallOptions).IsInstanceUpgradeable):len((*c.CallOptions).IsInstanceUpgradeable)], opts...) + var resp *notebookspb.IsInstanceUpgradeableResponse + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.IsInstanceUpgradeable(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *notebookGRPCClient) GetInstanceHealth(ctx context.Context, req *notebookspb.GetInstanceHealthRequest, opts ...gax.CallOption) (*notebookspb.GetInstanceHealthResponse, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).GetInstanceHealth[0:len((*c.CallOptions).GetInstanceHealth):len((*c.CallOptions).GetInstanceHealth)], opts...) + var resp *notebookspb.GetInstanceHealthResponse + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.GetInstanceHealth(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *notebookGRPCClient) UpgradeInstance(ctx context.Context, req *notebookspb.UpgradeInstanceRequest, opts ...gax.CallOption) (*UpgradeInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).UpgradeInstance[0:len((*c.CallOptions).UpgradeInstance):len((*c.CallOptions).UpgradeInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.UpgradeInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &UpgradeInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) RollbackInstance(ctx context.Context, req *notebookspb.RollbackInstanceRequest, opts ...gax.CallOption) (*RollbackInstanceOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).RollbackInstance[0:len((*c.CallOptions).RollbackInstance):len((*c.CallOptions).RollbackInstance)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.RollbackInstance(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &RollbackInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) UpgradeInstanceInternal(ctx context.Context, req *notebookspb.UpgradeInstanceInternalRequest, opts ...gax.CallOption) (*UpgradeInstanceInternalOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).UpgradeInstanceInternal[0:len((*c.CallOptions).UpgradeInstanceInternal):len((*c.CallOptions).UpgradeInstanceInternal)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.UpgradeInstanceInternal(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &UpgradeInstanceInternalOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) ListEnvironments(ctx context.Context, req *notebookspb.ListEnvironmentsRequest, opts ...gax.CallOption) *EnvironmentIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ListEnvironments[0:len((*c.CallOptions).ListEnvironments):len((*c.CallOptions).ListEnvironments)], opts...) + it := &EnvironmentIterator{} + req = proto.Clone(req).(*notebookspb.ListEnvironmentsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*notebookspb.Environment, string, error) { + resp := ¬ebookspb.ListEnvironmentsResponse{} + if pageToken != "" { + req.PageToken = pageToken + } + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else if pageSize != 0 { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.ListEnvironments(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetEnvironments(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + + return it +} + +func (c *notebookGRPCClient) GetEnvironment(ctx context.Context, req *notebookspb.GetEnvironmentRequest, opts ...gax.CallOption) (*notebookspb.Environment, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).GetEnvironment[0:len((*c.CallOptions).GetEnvironment):len((*c.CallOptions).GetEnvironment)], opts...) + var resp *notebookspb.Environment + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.GetEnvironment(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *notebookGRPCClient) CreateEnvironment(ctx context.Context, req *notebookspb.CreateEnvironmentRequest, opts ...gax.CallOption) (*CreateEnvironmentOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).CreateEnvironment[0:len((*c.CallOptions).CreateEnvironment):len((*c.CallOptions).CreateEnvironment)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.CreateEnvironment(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &CreateEnvironmentOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) DeleteEnvironment(ctx context.Context, req *notebookspb.DeleteEnvironmentRequest, opts ...gax.CallOption) (*DeleteEnvironmentOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).DeleteEnvironment[0:len((*c.CallOptions).DeleteEnvironment):len((*c.CallOptions).DeleteEnvironment)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.DeleteEnvironment(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &DeleteEnvironmentOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) ListSchedules(ctx context.Context, req *notebookspb.ListSchedulesRequest, opts ...gax.CallOption) *ScheduleIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ListSchedules[0:len((*c.CallOptions).ListSchedules):len((*c.CallOptions).ListSchedules)], opts...) + it := &ScheduleIterator{} + req = proto.Clone(req).(*notebookspb.ListSchedulesRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*notebookspb.Schedule, string, error) { + resp := ¬ebookspb.ListSchedulesResponse{} + if pageToken != "" { + req.PageToken = pageToken + } + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else if pageSize != 0 { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.ListSchedules(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetSchedules(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + + return it +} + +func (c *notebookGRPCClient) GetSchedule(ctx context.Context, req *notebookspb.GetScheduleRequest, opts ...gax.CallOption) (*notebookspb.Schedule, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).GetSchedule[0:len((*c.CallOptions).GetSchedule):len((*c.CallOptions).GetSchedule)], opts...) + var resp *notebookspb.Schedule + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.GetSchedule(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *notebookGRPCClient) DeleteSchedule(ctx context.Context, req *notebookspb.DeleteScheduleRequest, opts ...gax.CallOption) (*DeleteScheduleOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).DeleteSchedule[0:len((*c.CallOptions).DeleteSchedule):len((*c.CallOptions).DeleteSchedule)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.DeleteSchedule(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &DeleteScheduleOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) CreateSchedule(ctx context.Context, req *notebookspb.CreateScheduleRequest, opts ...gax.CallOption) (*CreateScheduleOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).CreateSchedule[0:len((*c.CallOptions).CreateSchedule):len((*c.CallOptions).CreateSchedule)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.CreateSchedule(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &CreateScheduleOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) TriggerSchedule(ctx context.Context, req *notebookspb.TriggerScheduleRequest, opts ...gax.CallOption) (*TriggerScheduleOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).TriggerSchedule[0:len((*c.CallOptions).TriggerSchedule):len((*c.CallOptions).TriggerSchedule)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.TriggerSchedule(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &TriggerScheduleOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) ListExecutions(ctx context.Context, req *notebookspb.ListExecutionsRequest, opts ...gax.CallOption) *ExecutionIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).ListExecutions[0:len((*c.CallOptions).ListExecutions):len((*c.CallOptions).ListExecutions)], opts...) + it := &ExecutionIterator{} + req = proto.Clone(req).(*notebookspb.ListExecutionsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*notebookspb.Execution, string, error) { + resp := ¬ebookspb.ListExecutionsResponse{} + if pageToken != "" { + req.PageToken = pageToken + } + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else if pageSize != 0 { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.ListExecutions(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetExecutions(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + + return it +} + +func (c *notebookGRPCClient) GetExecution(ctx context.Context, req *notebookspb.GetExecutionRequest, opts ...gax.CallOption) (*notebookspb.Execution, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).GetExecution[0:len((*c.CallOptions).GetExecution):len((*c.CallOptions).GetExecution)], opts...) + var resp *notebookspb.Execution + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.GetExecution(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +func (c *notebookGRPCClient) DeleteExecution(ctx context.Context, req *notebookspb.DeleteExecutionRequest, opts ...gax.CallOption) (*DeleteExecutionOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).DeleteExecution[0:len((*c.CallOptions).DeleteExecution):len((*c.CallOptions).DeleteExecution)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.DeleteExecution(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &DeleteExecutionOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +func (c *notebookGRPCClient) CreateExecution(ctx context.Context, req *notebookspb.CreateExecutionRequest, opts ...gax.CallOption) (*CreateExecutionOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 60000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append((*c.CallOptions).CreateExecution[0:len((*c.CallOptions).CreateExecution):len((*c.CallOptions).CreateExecution)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.notebookClient.CreateExecution(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &CreateExecutionOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, resp), + }, nil +} + +// CreateEnvironmentOperation manages a long-running operation from CreateEnvironment. +type CreateEnvironmentOperation struct { + lro *longrunning.Operation +} + +// CreateEnvironmentOperation returns a new CreateEnvironmentOperation from a given name. +// The name must be that of a previously created CreateEnvironmentOperation, possibly from a different process. +func (c *notebookGRPCClient) CreateEnvironmentOperation(name string) *CreateEnvironmentOperation { + return &CreateEnvironmentOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *CreateEnvironmentOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Environment, error) { + var resp notebookspb.Environment + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *CreateEnvironmentOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Environment, error) { + var resp notebookspb.Environment + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *CreateEnvironmentOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *CreateEnvironmentOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *CreateEnvironmentOperation) Name() string { + return op.lro.Name() +} + +// CreateExecutionOperation manages a long-running operation from CreateExecution. +type CreateExecutionOperation struct { + lro *longrunning.Operation +} + +// CreateExecutionOperation returns a new CreateExecutionOperation from a given name. +// The name must be that of a previously created CreateExecutionOperation, possibly from a different process. +func (c *notebookGRPCClient) CreateExecutionOperation(name string) *CreateExecutionOperation { + return &CreateExecutionOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *CreateExecutionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Execution, error) { + var resp notebookspb.Execution + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *CreateExecutionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Execution, error) { + var resp notebookspb.Execution + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *CreateExecutionOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *CreateExecutionOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *CreateExecutionOperation) Name() string { + return op.lro.Name() +} + +// CreateInstanceOperation manages a long-running operation from CreateInstance. +type CreateInstanceOperation struct { + lro *longrunning.Operation +} + +// CreateInstanceOperation returns a new CreateInstanceOperation from a given name. +// The name must be that of a previously created CreateInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) CreateInstanceOperation(name string) *CreateInstanceOperation { + return &CreateInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *CreateInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *CreateInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *CreateInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *CreateInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *CreateInstanceOperation) Name() string { + return op.lro.Name() +} + +// CreateScheduleOperation manages a long-running operation from CreateSchedule. +type CreateScheduleOperation struct { + lro *longrunning.Operation +} + +// CreateScheduleOperation returns a new CreateScheduleOperation from a given name. +// The name must be that of a previously created CreateScheduleOperation, possibly from a different process. +func (c *notebookGRPCClient) CreateScheduleOperation(name string) *CreateScheduleOperation { + return &CreateScheduleOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *CreateScheduleOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Schedule, error) { + var resp notebookspb.Schedule + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *CreateScheduleOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Schedule, error) { + var resp notebookspb.Schedule + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *CreateScheduleOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *CreateScheduleOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *CreateScheduleOperation) Name() string { + return op.lro.Name() +} + +// DeleteEnvironmentOperation manages a long-running operation from DeleteEnvironment. +type DeleteEnvironmentOperation struct { + lro *longrunning.Operation +} + +// DeleteEnvironmentOperation returns a new DeleteEnvironmentOperation from a given name. +// The name must be that of a previously created DeleteEnvironmentOperation, possibly from a different process. +func (c *notebookGRPCClient) DeleteEnvironmentOperation(name string) *DeleteEnvironmentOperation { + return &DeleteEnvironmentOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *DeleteEnvironmentOperation) Wait(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...) +} + +// 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 (op *DeleteEnvironmentOperation) Poll(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.Poll(ctx, nil, opts...) +} + +// 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 (op *DeleteEnvironmentOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *DeleteEnvironmentOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *DeleteEnvironmentOperation) Name() string { + return op.lro.Name() +} + +// DeleteExecutionOperation manages a long-running operation from DeleteExecution. +type DeleteExecutionOperation struct { + lro *longrunning.Operation +} + +// DeleteExecutionOperation returns a new DeleteExecutionOperation from a given name. +// The name must be that of a previously created DeleteExecutionOperation, possibly from a different process. +func (c *notebookGRPCClient) DeleteExecutionOperation(name string) *DeleteExecutionOperation { + return &DeleteExecutionOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *DeleteExecutionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...) +} + +// 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 (op *DeleteExecutionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.Poll(ctx, nil, opts...) +} + +// 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 (op *DeleteExecutionOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *DeleteExecutionOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *DeleteExecutionOperation) Name() string { + return op.lro.Name() +} + +// DeleteInstanceOperation manages a long-running operation from DeleteInstance. +type DeleteInstanceOperation struct { + lro *longrunning.Operation +} + +// DeleteInstanceOperation returns a new DeleteInstanceOperation from a given name. +// The name must be that of a previously created DeleteInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) DeleteInstanceOperation(name string) *DeleteInstanceOperation { + return &DeleteInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *DeleteInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...) +} + +// 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 (op *DeleteInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.Poll(ctx, nil, opts...) +} + +// 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 (op *DeleteInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *DeleteInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *DeleteInstanceOperation) Name() string { + return op.lro.Name() +} + +// DeleteScheduleOperation manages a long-running operation from DeleteSchedule. +type DeleteScheduleOperation struct { + lro *longrunning.Operation +} + +// DeleteScheduleOperation returns a new DeleteScheduleOperation from a given name. +// The name must be that of a previously created DeleteScheduleOperation, possibly from a different process. +func (c *notebookGRPCClient) DeleteScheduleOperation(name string) *DeleteScheduleOperation { + return &DeleteScheduleOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *DeleteScheduleOperation) Wait(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...) +} + +// 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 (op *DeleteScheduleOperation) Poll(ctx context.Context, opts ...gax.CallOption) error { + return op.lro.Poll(ctx, nil, opts...) +} + +// 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 (op *DeleteScheduleOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *DeleteScheduleOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *DeleteScheduleOperation) Name() string { + return op.lro.Name() +} + +// RegisterInstanceOperation manages a long-running operation from RegisterInstance. +type RegisterInstanceOperation struct { + lro *longrunning.Operation +} + +// RegisterInstanceOperation returns a new RegisterInstanceOperation from a given name. +// The name must be that of a previously created RegisterInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) RegisterInstanceOperation(name string) *RegisterInstanceOperation { + return &RegisterInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *RegisterInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *RegisterInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *RegisterInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *RegisterInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *RegisterInstanceOperation) Name() string { + return op.lro.Name() +} + +// ReportInstanceInfoOperation manages a long-running operation from ReportInstanceInfo. +type ReportInstanceInfoOperation struct { + lro *longrunning.Operation +} + +// ReportInstanceInfoOperation returns a new ReportInstanceInfoOperation from a given name. +// The name must be that of a previously created ReportInstanceInfoOperation, possibly from a different process. +func (c *notebookGRPCClient) ReportInstanceInfoOperation(name string) *ReportInstanceInfoOperation { + return &ReportInstanceInfoOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *ReportInstanceInfoOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *ReportInstanceInfoOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *ReportInstanceInfoOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *ReportInstanceInfoOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *ReportInstanceInfoOperation) Name() string { + return op.lro.Name() +} + +// ResetInstanceOperation manages a long-running operation from ResetInstance. +type ResetInstanceOperation struct { + lro *longrunning.Operation +} + +// ResetInstanceOperation returns a new ResetInstanceOperation from a given name. +// The name must be that of a previously created ResetInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) ResetInstanceOperation(name string) *ResetInstanceOperation { + return &ResetInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *ResetInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *ResetInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *ResetInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *ResetInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *ResetInstanceOperation) Name() string { + return op.lro.Name() +} + +// RollbackInstanceOperation manages a long-running operation from RollbackInstance. +type RollbackInstanceOperation struct { + lro *longrunning.Operation +} + +// RollbackInstanceOperation returns a new RollbackInstanceOperation from a given name. +// The name must be that of a previously created RollbackInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) RollbackInstanceOperation(name string) *RollbackInstanceOperation { + return &RollbackInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *RollbackInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *RollbackInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *RollbackInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *RollbackInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *RollbackInstanceOperation) Name() string { + return op.lro.Name() +} + +// SetInstanceAcceleratorOperation manages a long-running operation from SetInstanceAccelerator. +type SetInstanceAcceleratorOperation struct { + lro *longrunning.Operation +} + +// SetInstanceAcceleratorOperation returns a new SetInstanceAcceleratorOperation from a given name. +// The name must be that of a previously created SetInstanceAcceleratorOperation, possibly from a different process. +func (c *notebookGRPCClient) SetInstanceAcceleratorOperation(name string) *SetInstanceAcceleratorOperation { + return &SetInstanceAcceleratorOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *SetInstanceAcceleratorOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *SetInstanceAcceleratorOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *SetInstanceAcceleratorOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *SetInstanceAcceleratorOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *SetInstanceAcceleratorOperation) Name() string { + return op.lro.Name() +} + +// SetInstanceLabelsOperation manages a long-running operation from SetInstanceLabels. +type SetInstanceLabelsOperation struct { + lro *longrunning.Operation +} + +// SetInstanceLabelsOperation returns a new SetInstanceLabelsOperation from a given name. +// The name must be that of a previously created SetInstanceLabelsOperation, possibly from a different process. +func (c *notebookGRPCClient) SetInstanceLabelsOperation(name string) *SetInstanceLabelsOperation { + return &SetInstanceLabelsOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *SetInstanceLabelsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *SetInstanceLabelsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *SetInstanceLabelsOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *SetInstanceLabelsOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *SetInstanceLabelsOperation) Name() string { + return op.lro.Name() +} + +// SetInstanceMachineTypeOperation manages a long-running operation from SetInstanceMachineType. +type SetInstanceMachineTypeOperation struct { + lro *longrunning.Operation +} + +// SetInstanceMachineTypeOperation returns a new SetInstanceMachineTypeOperation from a given name. +// The name must be that of a previously created SetInstanceMachineTypeOperation, possibly from a different process. +func (c *notebookGRPCClient) SetInstanceMachineTypeOperation(name string) *SetInstanceMachineTypeOperation { + return &SetInstanceMachineTypeOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *SetInstanceMachineTypeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *SetInstanceMachineTypeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *SetInstanceMachineTypeOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *SetInstanceMachineTypeOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *SetInstanceMachineTypeOperation) Name() string { + return op.lro.Name() +} + +// StartInstanceOperation manages a long-running operation from StartInstance. +type StartInstanceOperation struct { + lro *longrunning.Operation +} + +// StartInstanceOperation returns a new StartInstanceOperation from a given name. +// The name must be that of a previously created StartInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) StartInstanceOperation(name string) *StartInstanceOperation { + return &StartInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *StartInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *StartInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *StartInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *StartInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *StartInstanceOperation) Name() string { + return op.lro.Name() +} + +// StopInstanceOperation manages a long-running operation from StopInstance. +type StopInstanceOperation struct { + lro *longrunning.Operation +} + +// StopInstanceOperation returns a new StopInstanceOperation from a given name. +// The name must be that of a previously created StopInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) StopInstanceOperation(name string) *StopInstanceOperation { + return &StopInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *StopInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *StopInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *StopInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *StopInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *StopInstanceOperation) Name() string { + return op.lro.Name() +} + +// TriggerScheduleOperation manages a long-running operation from TriggerSchedule. +type TriggerScheduleOperation struct { + lro *longrunning.Operation +} + +// TriggerScheduleOperation returns a new TriggerScheduleOperation from a given name. +// The name must be that of a previously created TriggerScheduleOperation, possibly from a different process. +func (c *notebookGRPCClient) TriggerScheduleOperation(name string) *TriggerScheduleOperation { + return &TriggerScheduleOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *TriggerScheduleOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Schedule, error) { + var resp notebookspb.Schedule + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *TriggerScheduleOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Schedule, error) { + var resp notebookspb.Schedule + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *TriggerScheduleOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *TriggerScheduleOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *TriggerScheduleOperation) Name() string { + return op.lro.Name() +} + +// UpdateInstanceConfigOperation manages a long-running operation from UpdateInstanceConfig. +type UpdateInstanceConfigOperation struct { + lro *longrunning.Operation +} + +// UpdateInstanceConfigOperation returns a new UpdateInstanceConfigOperation from a given name. +// The name must be that of a previously created UpdateInstanceConfigOperation, possibly from a different process. +func (c *notebookGRPCClient) UpdateInstanceConfigOperation(name string) *UpdateInstanceConfigOperation { + return &UpdateInstanceConfigOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *UpdateInstanceConfigOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *UpdateInstanceConfigOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *UpdateInstanceConfigOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *UpdateInstanceConfigOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *UpdateInstanceConfigOperation) Name() string { + return op.lro.Name() +} + +// UpdateShieldedInstanceConfigOperation manages a long-running operation from UpdateShieldedInstanceConfig. +type UpdateShieldedInstanceConfigOperation struct { + lro *longrunning.Operation +} + +// UpdateShieldedInstanceConfigOperation returns a new UpdateShieldedInstanceConfigOperation from a given name. +// The name must be that of a previously created UpdateShieldedInstanceConfigOperation, possibly from a different process. +func (c *notebookGRPCClient) UpdateShieldedInstanceConfigOperation(name string) *UpdateShieldedInstanceConfigOperation { + return &UpdateShieldedInstanceConfigOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *UpdateShieldedInstanceConfigOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *UpdateShieldedInstanceConfigOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *UpdateShieldedInstanceConfigOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *UpdateShieldedInstanceConfigOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *UpdateShieldedInstanceConfigOperation) Name() string { + return op.lro.Name() +} + +// UpgradeInstanceOperation manages a long-running operation from UpgradeInstance. +type UpgradeInstanceOperation struct { + lro *longrunning.Operation +} + +// UpgradeInstanceOperation returns a new UpgradeInstanceOperation from a given name. +// The name must be that of a previously created UpgradeInstanceOperation, possibly from a different process. +func (c *notebookGRPCClient) UpgradeInstanceOperation(name string) *UpgradeInstanceOperation { + return &UpgradeInstanceOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *UpgradeInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *UpgradeInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *UpgradeInstanceOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *UpgradeInstanceOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *UpgradeInstanceOperation) Name() string { + return op.lro.Name() +} + +// UpgradeInstanceInternalOperation manages a long-running operation from UpgradeInstanceInternal. +type UpgradeInstanceInternalOperation struct { + lro *longrunning.Operation +} + +// UpgradeInstanceInternalOperation returns a new UpgradeInstanceInternalOperation from a given name. +// The name must be that of a previously created UpgradeInstanceInternalOperation, possibly from a different process. +func (c *notebookGRPCClient) UpgradeInstanceInternalOperation(name string) *UpgradeInstanceInternalOperation { + return &UpgradeInstanceInternalOperation{ + lro: longrunning.InternalNewOperation(*c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *UpgradeInstanceInternalOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// 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 (op *UpgradeInstanceInternalOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*notebookspb.Instance, error) { + var resp notebookspb.Instance + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// 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 (op *UpgradeInstanceInternalOperation) Metadata() (*notebookspb.OperationMetadata, error) { + var meta notebookspb.OperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *UpgradeInstanceInternalOperation) Done() bool { + return op.lro.Done() +} + +// 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 (op *UpgradeInstanceInternalOperation) Name() string { + return op.lro.Name() +} + +// EnvironmentIterator manages a stream of *notebookspb.Environment. +type EnvironmentIterator struct { + items []*notebookspb.Environment + pageInfo *iterator.PageInfo + nextFunc func() error + + // 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 []*notebookspb.Environment, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *EnvironmentIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// 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 (it *EnvironmentIterator) Next() (*notebookspb.Environment, error) { + var item *notebookspb.Environment + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *EnvironmentIterator) bufLen() int { + return len(it.items) +} + +func (it *EnvironmentIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// ExecutionIterator manages a stream of *notebookspb.Execution. +type ExecutionIterator struct { + items []*notebookspb.Execution + pageInfo *iterator.PageInfo + nextFunc func() error + + // 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 []*notebookspb.Execution, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *ExecutionIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// 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 (it *ExecutionIterator) Next() (*notebookspb.Execution, error) { + var item *notebookspb.Execution + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *ExecutionIterator) bufLen() int { + return len(it.items) +} + +func (it *ExecutionIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// InstanceIterator manages a stream of *notebookspb.Instance. +type InstanceIterator struct { + items []*notebookspb.Instance + pageInfo *iterator.PageInfo + nextFunc func() error + + // 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 []*notebookspb.Instance, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *InstanceIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// 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 (it *InstanceIterator) Next() (*notebookspb.Instance, error) { + var item *notebookspb.Instance + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *InstanceIterator) bufLen() int { + return len(it.items) +} + +func (it *InstanceIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// ScheduleIterator manages a stream of *notebookspb.Schedule. +type ScheduleIterator struct { + items []*notebookspb.Schedule + pageInfo *iterator.PageInfo + nextFunc func() error + + // 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 []*notebookspb.Schedule, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *ScheduleIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// 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 (it *ScheduleIterator) Next() (*notebookspb.Schedule, error) { + var item *notebookspb.Schedule + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *ScheduleIterator) bufLen() int { + return len(it.items) +} + +func (it *ScheduleIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} diff --git a/notebooks/apiv1/notebook_client_example_test.go b/notebooks/apiv1/notebook_client_example_test.go new file mode 100644 index 00000000000..4ce464ffe53 --- /dev/null +++ b/notebooks/apiv1/notebook_client_example_test.go @@ -0,0 +1,823 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +package notebooks_test + +import ( + "context" + + notebooks "cloud.google.com/go/notebooks/apiv1" + "google.golang.org/api/iterator" + notebookspb "google.golang.org/genproto/googleapis/cloud/notebooks/v1" +) + +func ExampleNewNotebookClient() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + // TODO: Use client. + _ = c +} + +func ExampleNotebookClient_ListInstances() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ListInstancesRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ListInstancesRequest. + } + it := c.ListInstances(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleNotebookClient_GetInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.GetInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#GetInstanceRequest. + } + resp, err := c.GetInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_CreateInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.CreateInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#CreateInstanceRequest. + } + op, err := c.CreateInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_RegisterInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.RegisterInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#RegisterInstanceRequest. + } + op, err := c.RegisterInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_SetInstanceAccelerator() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.SetInstanceAcceleratorRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#SetInstanceAcceleratorRequest. + } + op, err := c.SetInstanceAccelerator(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_SetInstanceMachineType() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.SetInstanceMachineTypeRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#SetInstanceMachineTypeRequest. + } + op, err := c.SetInstanceMachineType(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_UpdateInstanceConfig() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.UpdateInstanceConfigRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#UpdateInstanceConfigRequest. + } + op, err := c.UpdateInstanceConfig(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_UpdateShieldedInstanceConfig() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.UpdateShieldedInstanceConfigRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#UpdateShieldedInstanceConfigRequest. + } + op, err := c.UpdateShieldedInstanceConfig(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_SetInstanceLabels() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.SetInstanceLabelsRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#SetInstanceLabelsRequest. + } + op, err := c.SetInstanceLabels(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_UpdateInstanceMetadataItems() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.UpdateInstanceMetadataItemsRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#UpdateInstanceMetadataItemsRequest. + } + resp, err := c.UpdateInstanceMetadataItems(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_DeleteInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.DeleteInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#DeleteInstanceRequest. + } + op, err := c.DeleteInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + err = op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleNotebookClient_StartInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.StartInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#StartInstanceRequest. + } + op, err := c.StartInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_StopInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.StopInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#StopInstanceRequest. + } + op, err := c.StopInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_ResetInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ResetInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ResetInstanceRequest. + } + op, err := c.ResetInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_ReportInstanceInfo() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ReportInstanceInfoRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ReportInstanceInfoRequest. + } + op, err := c.ReportInstanceInfo(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_IsInstanceUpgradeable() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.IsInstanceUpgradeableRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#IsInstanceUpgradeableRequest. + } + resp, err := c.IsInstanceUpgradeable(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_GetInstanceHealth() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.GetInstanceHealthRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#GetInstanceHealthRequest. + } + resp, err := c.GetInstanceHealth(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_UpgradeInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.UpgradeInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#UpgradeInstanceRequest. + } + op, err := c.UpgradeInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_RollbackInstance() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.RollbackInstanceRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#RollbackInstanceRequest. + } + op, err := c.RollbackInstance(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_UpgradeInstanceInternal() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.UpgradeInstanceInternalRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#UpgradeInstanceInternalRequest. + } + op, err := c.UpgradeInstanceInternal(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_ListEnvironments() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ListEnvironmentsRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ListEnvironmentsRequest. + } + it := c.ListEnvironments(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleNotebookClient_GetEnvironment() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.GetEnvironmentRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#GetEnvironmentRequest. + } + resp, err := c.GetEnvironment(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_CreateEnvironment() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.CreateEnvironmentRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#CreateEnvironmentRequest. + } + op, err := c.CreateEnvironment(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_DeleteEnvironment() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.DeleteEnvironmentRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#DeleteEnvironmentRequest. + } + op, err := c.DeleteEnvironment(ctx, req) + if err != nil { + // TODO: Handle error. + } + + err = op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleNotebookClient_ListSchedules() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ListSchedulesRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ListSchedulesRequest. + } + it := c.ListSchedules(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleNotebookClient_GetSchedule() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.GetScheduleRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#GetScheduleRequest. + } + resp, err := c.GetSchedule(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_DeleteSchedule() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.DeleteScheduleRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#DeleteScheduleRequest. + } + op, err := c.DeleteSchedule(ctx, req) + if err != nil { + // TODO: Handle error. + } + + err = op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleNotebookClient_CreateSchedule() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.CreateScheduleRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#CreateScheduleRequest. + } + op, err := c.CreateSchedule(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_TriggerSchedule() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.TriggerScheduleRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#TriggerScheduleRequest. + } + op, err := c.TriggerSchedule(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_ListExecutions() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.ListExecutionsRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#ListExecutionsRequest. + } + it := c.ListExecutions(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleNotebookClient_GetExecution() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.GetExecutionRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#GetExecutionRequest. + } + resp, err := c.GetExecution(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleNotebookClient_DeleteExecution() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.DeleteExecutionRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#DeleteExecutionRequest. + } + op, err := c.DeleteExecution(ctx, req) + if err != nil { + // TODO: Handle error. + } + + err = op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleNotebookClient_CreateExecution() { + ctx := context.Background() + c, err := notebooks.NewNotebookClient(ctx) + if err != nil { + // TODO: Handle error. + } + defer c.Close() + + req := ¬ebookspb.CreateExecutionRequest{ + // TODO: Fill request struct fields. + // See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/notebooks/v1#CreateExecutionRequest. + } + op, err := c.CreateExecution(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} diff --git a/notebooks/apiv1/version.go b/notebooks/apiv1/version.go new file mode 100644 index 00000000000..3363e38b7da --- /dev/null +++ b/notebooks/apiv1/version.go @@ -0,0 +1,23 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by gapicgen. DO NOT EDIT. + +package notebooks + +import "cloud.google.com/go/notebooks/internal" + +func init() { + versionClient = internal.Version +} diff --git a/notebooks/go.mod b/notebooks/go.mod index 01215350830..5e612d4129f 100644 --- a/notebooks/go.mod +++ b/notebooks/go.mod @@ -6,7 +6,7 @@ require ( cloud.google.com/go v0.100.2 github.com/googleapis/gax-go/v2 v2.3.0 google.golang.org/api v0.74.0 - google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac - google.golang.org/grpc v1.45.0 + google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3 + google.golang.org/grpc v1.46.0 google.golang.org/protobuf v1.28.0 ) diff --git a/notebooks/go.sum b/notebooks/go.sum index 3ef386f55ae..a385b788f2e 100644 --- a/notebooks/go.sum +++ b/notebooks/go.sum @@ -68,6 +68,7 @@ github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XP github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= @@ -78,6 +79,7 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= @@ -539,8 +541,9 @@ google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2 google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= -google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac h1:qSNTkEN+L2mvWcLgJOR+8bdHX9rN/IdU3A1Ghpfb1Rg= google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3 h1:q1kiSVscqoDeqTF27eQ2NnLLDmqF0I373qQNXYMy0fo= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= @@ -568,8 +571,9 @@ google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnD google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc v1.45.0 h1:NEpgUqV3Z+ZjkqMsxMg11IaDrXY4RY6CQukSGK0uI1M= google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0 h1:oCjezcn6g6A75TGoKYBPgKmVBLexhYLM6MebdrPApP8= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=