Documentation

Overview

Package dataproc is an auto-generated package for the Cloud Dataproc API.

Manages Hadoop-based clusters and jobs on Google Cloud Platform.

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 pkg.go.dev/cloud.google.com/go.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func DefaultAuthScopes

func DefaultAuthScopes() []string

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

    Types

    type AutoscalingPolicyCallOptions

    type AutoscalingPolicyCallOptions struct {
    	CreateAutoscalingPolicy []gax.CallOption
    	UpdateAutoscalingPolicy []gax.CallOption
    	GetAutoscalingPolicy    []gax.CallOption
    	ListAutoscalingPolicies []gax.CallOption
    	DeleteAutoscalingPolicy []gax.CallOption
    }

      AutoscalingPolicyCallOptions contains the retry settings for each method of AutoscalingPolicyClient.

      type AutoscalingPolicyClient

      type AutoscalingPolicyClient struct {
      
      	// The call options for this service.
      	CallOptions *AutoscalingPolicyCallOptions
      	// contains filtered or unexported fields
      }

        AutoscalingPolicyClient is a client for interacting with Cloud Dataproc API.

        Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

        func NewAutoscalingPolicyClient

        func NewAutoscalingPolicyClient(ctx context.Context, opts ...option.ClientOption) (*AutoscalingPolicyClient, error)

          NewAutoscalingPolicyClient creates a new autoscaling policy service client.

          The API interface for managing autoscaling policies in the Dataproc API.

          Example
          Output:
          
          

          func (*AutoscalingPolicyClient) Close

          func (c *AutoscalingPolicyClient) Close() error

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

            func (*AutoscalingPolicyClient) Connection

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

              Connection returns a connection to the API service.

              Deprecated.

              func (*AutoscalingPolicyClient) CreateAutoscalingPolicy

                CreateAutoscalingPolicy creates new autoscaling policy.

                Example
                Output:
                
                

                func (*AutoscalingPolicyClient) DeleteAutoscalingPolicy

                  DeleteAutoscalingPolicy deletes an autoscaling policy. It is an error to delete an autoscaling policy that is in use by one or more clusters.

                  Example
                  Output:
                  
                  

                  func (*AutoscalingPolicyClient) GetAutoscalingPolicy

                    GetAutoscalingPolicy retrieves autoscaling policy.

                    Example
                    Output:
                    
                    

                    func (*AutoscalingPolicyClient) ListAutoscalingPolicies

                      ListAutoscalingPolicies lists autoscaling policies in the project.

                      Example
                      Output:
                      
                      

                      func (*AutoscalingPolicyClient) UpdateAutoscalingPolicy

                        UpdateAutoscalingPolicy updates (replaces) autoscaling policy.

                        Disabled check for update_mask, because all updates will be full replacements.

                        Example
                        Output:
                        
                        

                        type AutoscalingPolicyIterator

                        type AutoscalingPolicyIterator struct {
                        
                        	// Response is the raw response for the current page.
                        	// It must be cast to the RPC response type.
                        	// Calling Next() or InternalFetch() updates this value.
                        	Response interface{}
                        
                        	// InternalFetch is for use by the Google Cloud Libraries only.
                        	// It is not part of the stable interface of this package.
                        	//
                        	// InternalFetch returns results from a single call to the underlying RPC.
                        	// The number of results is no greater than pageSize.
                        	// If there are no more results, nextPageToken is empty and err is nil.
                        	InternalFetch func(pageSize int, pageToken string) (results []*dataprocpb.AutoscalingPolicy, nextPageToken string, err error)
                        	// contains filtered or unexported fields
                        }

                          AutoscalingPolicyIterator manages a stream of *dataprocpb.AutoscalingPolicy.

                          func (*AutoscalingPolicyIterator) Next

                            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 (*AutoscalingPolicyIterator) PageInfo

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

                              type ClusterControllerCallOptions

                              type ClusterControllerCallOptions struct {
                              	CreateCluster   []gax.CallOption
                              	UpdateCluster   []gax.CallOption
                              	DeleteCluster   []gax.CallOption
                              	GetCluster      []gax.CallOption
                              	ListClusters    []gax.CallOption
                              	DiagnoseCluster []gax.CallOption
                              }

                                ClusterControllerCallOptions contains the retry settings for each method of ClusterControllerClient.

                                type ClusterControllerClient

                                type ClusterControllerClient struct {
                                
                                	// LROClient is used internally to handle longrunning operations.
                                	// It is exposed so that its CallOptions can be modified if required.
                                	// Users should not Close this client.
                                	LROClient *lroauto.OperationsClient
                                
                                	// The call options for this service.
                                	CallOptions *ClusterControllerCallOptions
                                	// contains filtered or unexported fields
                                }

                                  ClusterControllerClient is a client for interacting with Cloud Dataproc API.

                                  Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

                                  func NewClusterControllerClient

                                  func NewClusterControllerClient(ctx context.Context, opts ...option.ClientOption) (*ClusterControllerClient, error)

                                    NewClusterControllerClient creates a new cluster controller client.

                                    The ClusterControllerService provides methods to manage clusters of Compute Engine instances.

                                    Example
                                    Output:
                                    
                                    

                                    func (*ClusterControllerClient) Close

                                    func (c *ClusterControllerClient) Close() error

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

                                      func (*ClusterControllerClient) Connection

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

                                        Connection returns a connection to the API service.

                                        Deprecated.

                                        func (*ClusterControllerClient) CreateCluster

                                          CreateCluster creates a cluster in a project. The returned Operation.metadata will be ClusterOperationMetadata (at https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#clusteroperationmetadata).

                                          Example
                                          Output:
                                          
                                          

                                          func (*ClusterControllerClient) CreateClusterOperation

                                          func (c *ClusterControllerClient) CreateClusterOperation(name string) *CreateClusterOperation

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

                                            func (*ClusterControllerClient) DeleteCluster

                                              DeleteCluster deletes a cluster in a project. The returned Operation.metadata will be ClusterOperationMetadata (at https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#clusteroperationmetadata).

                                              Example
                                              Output:
                                              
                                              

                                              func (*ClusterControllerClient) DeleteClusterOperation

                                              func (c *ClusterControllerClient) DeleteClusterOperation(name string) *DeleteClusterOperation

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

                                                func (*ClusterControllerClient) DiagnoseCluster

                                                  DiagnoseCluster gets cluster diagnostic information. The returned Operation.metadata will be ClusterOperationMetadata (at https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#clusteroperationmetadata). After the operation completes, Operation.response contains DiagnoseClusterResults (at https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#diagnoseclusterresults).

                                                  Example
                                                  Output:
                                                  
                                                  

                                                  func (*ClusterControllerClient) DiagnoseClusterOperation

                                                  func (c *ClusterControllerClient) DiagnoseClusterOperation(name string) *DiagnoseClusterOperation

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

                                                    func (*ClusterControllerClient) GetCluster

                                                      GetCluster gets the resource representation for a cluster in a project.

                                                      Example
                                                      Output:
                                                      
                                                      

                                                      func (*ClusterControllerClient) ListClusters

                                                        ListClusters lists all regions/{region}/clusters in a project alphabetically.

                                                        Example
                                                        Output:
                                                        
                                                        

                                                        func (*ClusterControllerClient) UpdateCluster

                                                          UpdateCluster updates a cluster in a project. The returned Operation.metadata will be ClusterOperationMetadata (at https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#clusteroperationmetadata).

                                                          Example
                                                          Output:
                                                          
                                                          

                                                          func (*ClusterControllerClient) UpdateClusterOperation

                                                          func (c *ClusterControllerClient) UpdateClusterOperation(name string) *UpdateClusterOperation

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

                                                            type ClusterIterator

                                                            type ClusterIterator struct {
                                                            
                                                            	// Response is the raw response for the current page.
                                                            	// It must be cast to the RPC response type.
                                                            	// Calling Next() or InternalFetch() updates this value.
                                                            	Response interface{}
                                                            
                                                            	// InternalFetch is for use by the Google Cloud Libraries only.
                                                            	// It is not part of the stable interface of this package.
                                                            	//
                                                            	// InternalFetch returns results from a single call to the underlying RPC.
                                                            	// The number of results is no greater than pageSize.
                                                            	// If there are no more results, nextPageToken is empty and err is nil.
                                                            	InternalFetch func(pageSize int, pageToken string) (results []*dataprocpb.Cluster, nextPageToken string, err error)
                                                            	// contains filtered or unexported fields
                                                            }

                                                              ClusterIterator manages a stream of *dataprocpb.Cluster.

                                                              func (*ClusterIterator) Next

                                                              func (it *ClusterIterator) Next() (*dataprocpb.Cluster, error)

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

                                                                func (*ClusterIterator) PageInfo

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

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

                                                                  type CreateClusterOperation

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

                                                                    CreateClusterOperation manages a long-running operation from CreateCluster.

                                                                    func (*CreateClusterOperation) Delete

                                                                    func (op *CreateClusterOperation) Delete(ctx context.Context, opts ...gax.CallOption) error

                                                                      Delete deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation.

                                                                      func (*CreateClusterOperation) Done

                                                                      func (op *CreateClusterOperation) Done() bool

                                                                        Done reports whether the long-running operation has completed.

                                                                        func (*CreateClusterOperation) Metadata

                                                                          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 (*CreateClusterOperation) Name

                                                                          func (op *CreateClusterOperation) Name() string

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

                                                                            func (*CreateClusterOperation) Poll

                                                                              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 (*CreateClusterOperation) Wait

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

                                                                                See documentation of Poll for error-handling information.

                                                                                type DeleteClusterOperation

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

                                                                                  DeleteClusterOperation manages a long-running operation from DeleteCluster.

                                                                                  func (*DeleteClusterOperation) Delete

                                                                                  func (op *DeleteClusterOperation) Delete(ctx context.Context, opts ...gax.CallOption) error

                                                                                    Delete deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation.

                                                                                    func (*DeleteClusterOperation) Done

                                                                                    func (op *DeleteClusterOperation) Done() bool

                                                                                      Done reports whether the long-running operation has completed.

                                                                                      func (*DeleteClusterOperation) Metadata

                                                                                        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 (*DeleteClusterOperation) Name

                                                                                        func (op *DeleteClusterOperation) Name() string

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

                                                                                          func (*DeleteClusterOperation) Poll

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

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

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

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

                                                                                            func (*DeleteClusterOperation) Wait

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

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

                                                                                              See documentation of Poll for error-handling information.

                                                                                              type DiagnoseClusterOperation

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

                                                                                                DiagnoseClusterOperation manages a long-running operation from DiagnoseCluster.

                                                                                                func (*DiagnoseClusterOperation) Delete

                                                                                                func (op *DiagnoseClusterOperation) Delete(ctx context.Context, opts ...gax.CallOption) error

                                                                                                  Delete deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation.

                                                                                                  func (*DiagnoseClusterOperation) Done

                                                                                                  func (op *DiagnoseClusterOperation) Done() bool

                                                                                                    Done reports whether the long-running operation has completed.

                                                                                                    func (*DiagnoseClusterOperation) Metadata

                                                                                                      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 (*DiagnoseClusterOperation) Name

                                                                                                      func (op *DiagnoseClusterOperation) Name() string

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

                                                                                                        func (*DiagnoseClusterOperation) Poll

                                                                                                          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 (*DiagnoseClusterOperation) Wait

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

                                                                                                            See documentation of Poll for error-handling information.

                                                                                                            type InstantiateInlineWorkflowTemplateOperation

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

                                                                                                              InstantiateInlineWorkflowTemplateOperation manages a long-running operation from InstantiateInlineWorkflowTemplate.

                                                                                                              func (*InstantiateInlineWorkflowTemplateOperation) Cancel

                                                                                                                Cancel starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use Poll or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, op.Poll returns an error with code Canceled.

                                                                                                                func (*InstantiateInlineWorkflowTemplateOperation) Delete

                                                                                                                  Delete deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation.

                                                                                                                  func (*InstantiateInlineWorkflowTemplateOperation) Done

                                                                                                                    Done reports whether the long-running operation has completed.

                                                                                                                    func (*InstantiateInlineWorkflowTemplateOperation) Metadata

                                                                                                                      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 (*InstantiateInlineWorkflowTemplateOperation) Name

                                                                                                                        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 (*InstantiateInlineWorkflowTemplateOperation) Poll

                                                                                                                          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 (*InstantiateInlineWorkflowTemplateOperation) Wait

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

                                                                                                                            See documentation of Poll for error-handling information.

                                                                                                                            type InstantiateWorkflowTemplateOperation

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

                                                                                                                              InstantiateWorkflowTemplateOperation manages a long-running operation from InstantiateWorkflowTemplate.

                                                                                                                              func (*InstantiateWorkflowTemplateOperation) Cancel

                                                                                                                                Cancel starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use Poll or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, op.Poll returns an error with code Canceled.

                                                                                                                                func (*InstantiateWorkflowTemplateOperation) Delete

                                                                                                                                  Delete deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation.

                                                                                                                                  func (*InstantiateWorkflowTemplateOperation) Done

                                                                                                                                    Done reports whether the long-running operation has completed.

                                                                                                                                    func (*InstantiateWorkflowTemplateOperation) Metadata

                                                                                                                                      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 (*InstantiateWorkflowTemplateOperation) Name

                                                                                                                                        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 (*InstantiateWorkflowTemplateOperation) Poll

                                                                                                                                          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 (*InstantiateWorkflowTemplateOperation) Wait

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

                                                                                                                                            See documentation of Poll for error-handling information.

                                                                                                                                            type JobControllerCallOptions

                                                                                                                                            type JobControllerCallOptions struct {
                                                                                                                                            	SubmitJob            []gax.CallOption
                                                                                                                                            	SubmitJobAsOperation []gax.CallOption
                                                                                                                                            	GetJob               []gax.CallOption
                                                                                                                                            	ListJobs             []gax.CallOption
                                                                                                                                            	UpdateJob            []gax.CallOption
                                                                                                                                            	CancelJob            []gax.CallOption
                                                                                                                                            	DeleteJob            []gax.CallOption
                                                                                                                                            }

                                                                                                                                              JobControllerCallOptions contains the retry settings for each method of JobControllerClient.

                                                                                                                                              type JobControllerClient

                                                                                                                                              type JobControllerClient struct {
                                                                                                                                              
                                                                                                                                              	// LROClient is used internally to handle longrunning operations.
                                                                                                                                              	// It is exposed so that its CallOptions can be modified if required.
                                                                                                                                              	// Users should not Close this client.
                                                                                                                                              	LROClient *lroauto.OperationsClient
                                                                                                                                              
                                                                                                                                              	// The call options for this service.
                                                                                                                                              	CallOptions *JobControllerCallOptions
                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                              }

                                                                                                                                                JobControllerClient is a client for interacting with Cloud Dataproc API.

                                                                                                                                                Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

                                                                                                                                                func NewJobControllerClient

                                                                                                                                                func NewJobControllerClient(ctx context.Context, opts ...option.ClientOption) (*JobControllerClient, error)

                                                                                                                                                  NewJobControllerClient creates a new job controller client.

                                                                                                                                                  The JobController provides methods to manage jobs.

                                                                                                                                                  Example
                                                                                                                                                  Output:
                                                                                                                                                  
                                                                                                                                                  

                                                                                                                                                  func (*JobControllerClient) CancelJob

                                                                                                                                                    CancelJob starts a job cancellation request. To access the job resource after cancellation, call regions/{region}/jobs.list (at https://cloud.google.com/dataproc/docs/reference/rest/v1/projects.regions.jobs/list) or regions/{region}/jobs.get (at https://cloud.google.com/dataproc/docs/reference/rest/v1/projects.regions.jobs/get).

                                                                                                                                                    Example
                                                                                                                                                    Output:
                                                                                                                                                    
                                                                                                                                                    

                                                                                                                                                    func (*JobControllerClient) Close

                                                                                                                                                    func (c *JobControllerClient) Close() error

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

                                                                                                                                                      func (*JobControllerClient) Connection

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

                                                                                                                                                        Connection returns a connection to the API service.

                                                                                                                                                        Deprecated.

                                                                                                                                                        func (*JobControllerClient) DeleteJob

                                                                                                                                                          DeleteJob deletes the job from the project. If the job is active, the delete fails, and the response returns FAILED_PRECONDITION.

                                                                                                                                                          Example
                                                                                                                                                          Output:
                                                                                                                                                          
                                                                                                                                                          

                                                                                                                                                          func (*JobControllerClient) GetJob

                                                                                                                                                            GetJob gets the resource representation for a job in a project.

                                                                                                                                                            Example
                                                                                                                                                            Output:
                                                                                                                                                            
                                                                                                                                                            

                                                                                                                                                            func (*JobControllerClient) ListJobs

                                                                                                                                                              ListJobs lists regions/{region}/jobs in a project.

                                                                                                                                                              Example
                                                                                                                                                              Output:
                                                                                                                                                              
                                                                                                                                                              

                                                                                                                                                              func (*JobControllerClient) SubmitJob

                                                                                                                                                                SubmitJob submits a job to a cluster.

                                                                                                                                                                Example
                                                                                                                                                                Output:
                                                                                                                                                                
                                                                                                                                                                

                                                                                                                                                                func (*JobControllerClient) SubmitJobAsOperation

                                                                                                                                                                  SubmitJobAsOperation submits job to a cluster.

                                                                                                                                                                  Example
                                                                                                                                                                  Output:
                                                                                                                                                                  
                                                                                                                                                                  

                                                                                                                                                                  func (*JobControllerClient) SubmitJobAsOperationOperation

                                                                                                                                                                  func (c *JobControllerClient) SubmitJobAsOperationOperation(name string) *SubmitJobAsOperationOperation

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

                                                                                                                                                                    func (*JobControllerClient) UpdateJob

                                                                                                                                                                      UpdateJob updates a job in a project.

                                                                                                                                                                      Example
                                                                                                                                                                      Output:
                                                                                                                                                                      
                                                                                                                                                                      

                                                                                                                                                                      type JobIterator

                                                                                                                                                                      type JobIterator struct {
                                                                                                                                                                      
                                                                                                                                                                      	// Response is the raw response for the current page.
                                                                                                                                                                      	// It must be cast to the RPC response type.
                                                                                                                                                                      	// Calling Next() or InternalFetch() updates this value.
                                                                                                                                                                      	Response interface{}
                                                                                                                                                                      
                                                                                                                                                                      	// InternalFetch is for use by the Google Cloud Libraries only.
                                                                                                                                                                      	// It is not part of the stable interface of this package.
                                                                                                                                                                      	//
                                                                                                                                                                      	// InternalFetch returns results from a single call to the underlying RPC.
                                                                                                                                                                      	// The number of results is no greater than pageSize.
                                                                                                                                                                      	// If there are no more results, nextPageToken is empty and err is nil.
                                                                                                                                                                      	InternalFetch func(pageSize int, pageToken string) (results []*dataprocpb.Job, nextPageToken string, err error)
                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                      }

                                                                                                                                                                        JobIterator manages a stream of *dataprocpb.Job.

                                                                                                                                                                        func (*JobIterator) Next

                                                                                                                                                                        func (it *JobIterator) Next() (*dataprocpb.Job, error)

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

                                                                                                                                                                          func (*JobIterator) PageInfo

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

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

                                                                                                                                                                            type SubmitJobAsOperationOperation

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

                                                                                                                                                                              SubmitJobAsOperationOperation manages a long-running operation from SubmitJobAsOperation.

                                                                                                                                                                              func (*SubmitJobAsOperationOperation) Done

                                                                                                                                                                                Done reports whether the long-running operation has completed.

                                                                                                                                                                                func (*SubmitJobAsOperationOperation) Metadata

                                                                                                                                                                                  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 (*SubmitJobAsOperationOperation) Name

                                                                                                                                                                                    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 (*SubmitJobAsOperationOperation) Poll

                                                                                                                                                                                      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 (*SubmitJobAsOperationOperation) Wait

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

                                                                                                                                                                                        See documentation of Poll for error-handling information.

                                                                                                                                                                                        type UpdateClusterOperation

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

                                                                                                                                                                                          UpdateClusterOperation manages a long-running operation from UpdateCluster.

                                                                                                                                                                                          func (*UpdateClusterOperation) Delete

                                                                                                                                                                                          func (op *UpdateClusterOperation) Delete(ctx context.Context, opts ...gax.CallOption) error

                                                                                                                                                                                            Delete deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation.

                                                                                                                                                                                            func (*UpdateClusterOperation) Done

                                                                                                                                                                                            func (op *UpdateClusterOperation) Done() bool

                                                                                                                                                                                              Done reports whether the long-running operation has completed.

                                                                                                                                                                                              func (*UpdateClusterOperation) Metadata

                                                                                                                                                                                                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 (*UpdateClusterOperation) Name

                                                                                                                                                                                                func (op *UpdateClusterOperation) Name() string

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

                                                                                                                                                                                                  func (*UpdateClusterOperation) Poll

                                                                                                                                                                                                    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 (*UpdateClusterOperation) Wait

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

                                                                                                                                                                                                      See documentation of Poll for error-handling information.

                                                                                                                                                                                                      type WorkflowTemplateCallOptions

                                                                                                                                                                                                      type WorkflowTemplateCallOptions struct {
                                                                                                                                                                                                      	CreateWorkflowTemplate            []gax.CallOption
                                                                                                                                                                                                      	GetWorkflowTemplate               []gax.CallOption
                                                                                                                                                                                                      	InstantiateWorkflowTemplate       []gax.CallOption
                                                                                                                                                                                                      	InstantiateInlineWorkflowTemplate []gax.CallOption
                                                                                                                                                                                                      	UpdateWorkflowTemplate            []gax.CallOption
                                                                                                                                                                                                      	ListWorkflowTemplates             []gax.CallOption
                                                                                                                                                                                                      	DeleteWorkflowTemplate            []gax.CallOption
                                                                                                                                                                                                      }

                                                                                                                                                                                                        WorkflowTemplateCallOptions contains the retry settings for each method of WorkflowTemplateClient.

                                                                                                                                                                                                        type WorkflowTemplateClient

                                                                                                                                                                                                        type WorkflowTemplateClient struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// LROClient is used internally to handle longrunning operations.
                                                                                                                                                                                                        	// It is exposed so that its CallOptions can be modified if required.
                                                                                                                                                                                                        	// Users should not Close this client.
                                                                                                                                                                                                        	LROClient *lroauto.OperationsClient
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The call options for this service.
                                                                                                                                                                                                        	CallOptions *WorkflowTemplateCallOptions
                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                        }

                                                                                                                                                                                                          WorkflowTemplateClient is a client for interacting with Cloud Dataproc API.

                                                                                                                                                                                                          Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

                                                                                                                                                                                                          func NewWorkflowTemplateClient

                                                                                                                                                                                                          func NewWorkflowTemplateClient(ctx context.Context, opts ...option.ClientOption) (*WorkflowTemplateClient, error)

                                                                                                                                                                                                            NewWorkflowTemplateClient creates a new workflow template service client.

                                                                                                                                                                                                            The API interface for managing Workflow Templates in the Dataproc API.

                                                                                                                                                                                                            Example
                                                                                                                                                                                                            Output:
                                                                                                                                                                                                            
                                                                                                                                                                                                            

                                                                                                                                                                                                            func (*WorkflowTemplateClient) Close

                                                                                                                                                                                                            func (c *WorkflowTemplateClient) Close() error

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

                                                                                                                                                                                                              func (*WorkflowTemplateClient) Connection

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

                                                                                                                                                                                                                Connection returns a connection to the API service.

                                                                                                                                                                                                                Deprecated.

                                                                                                                                                                                                                func (*WorkflowTemplateClient) CreateWorkflowTemplate

                                                                                                                                                                                                                  CreateWorkflowTemplate creates new workflow template.

                                                                                                                                                                                                                  Example
                                                                                                                                                                                                                  Output:
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  func (*WorkflowTemplateClient) DeleteWorkflowTemplate

                                                                                                                                                                                                                  func (c *WorkflowTemplateClient) DeleteWorkflowTemplate(ctx context.Context, req *dataprocpb.DeleteWorkflowTemplateRequest, opts ...gax.CallOption) error

                                                                                                                                                                                                                    DeleteWorkflowTemplate deletes a workflow template. It does not cancel in-progress workflows.

                                                                                                                                                                                                                    Example
                                                                                                                                                                                                                    Output:
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    

                                                                                                                                                                                                                    func (*WorkflowTemplateClient) GetWorkflowTemplate

                                                                                                                                                                                                                      GetWorkflowTemplate retrieves the latest workflow template.

                                                                                                                                                                                                                      Can retrieve previously instantiated template by specifying optional version parameter.

                                                                                                                                                                                                                      Example
                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      

                                                                                                                                                                                                                      func (*WorkflowTemplateClient) InstantiateInlineWorkflowTemplate

                                                                                                                                                                                                                        InstantiateInlineWorkflowTemplate instantiates a template and begins execution.

                                                                                                                                                                                                                        This method is equivalent to executing the sequence CreateWorkflowTemplate, InstantiateWorkflowTemplate, DeleteWorkflowTemplate.

                                                                                                                                                                                                                        The returned Operation can be used to track execution of workflow by polling operations.get. The Operation will complete when entire workflow is finished.

                                                                                                                                                                                                                        The running workflow can be aborted via operations.cancel. This will cause any inflight jobs to be cancelled and workflow-owned clusters to be deleted.

                                                                                                                                                                                                                        The Operation.metadata will be WorkflowMetadata (at https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#workflowmetadata). Also see Using WorkflowMetadata (at https://cloud.google.com/dataproc/docs/concepts/workflows/debugging#using_workflowmetadata).

                                                                                                                                                                                                                        On successful completion, Operation.response will be Empty.

                                                                                                                                                                                                                        Example
                                                                                                                                                                                                                        Output:
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        

                                                                                                                                                                                                                        func (*WorkflowTemplateClient) InstantiateInlineWorkflowTemplateOperation

                                                                                                                                                                                                                        func (c *WorkflowTemplateClient) InstantiateInlineWorkflowTemplateOperation(name string) *InstantiateInlineWorkflowTemplateOperation

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

                                                                                                                                                                                                                          func (*WorkflowTemplateClient) InstantiateWorkflowTemplate

                                                                                                                                                                                                                            InstantiateWorkflowTemplate instantiates a template and begins execution.

                                                                                                                                                                                                                            The returned Operation can be used to track execution of workflow by polling operations.get. The Operation will complete when entire workflow is finished.

                                                                                                                                                                                                                            The running workflow can be aborted via operations.cancel. This will cause any inflight jobs to be cancelled and workflow-owned clusters to be deleted.

                                                                                                                                                                                                                            The Operation.metadata will be WorkflowMetadata (at https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#workflowmetadata). Also see Using WorkflowMetadata (at https://cloud.google.com/dataproc/docs/concepts/workflows/debugging#using_workflowmetadata).

                                                                                                                                                                                                                            On successful completion, Operation.response will be Empty.

                                                                                                                                                                                                                            Example
                                                                                                                                                                                                                            Output:
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            

                                                                                                                                                                                                                            func (*WorkflowTemplateClient) InstantiateWorkflowTemplateOperation

                                                                                                                                                                                                                            func (c *WorkflowTemplateClient) InstantiateWorkflowTemplateOperation(name string) *InstantiateWorkflowTemplateOperation

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

                                                                                                                                                                                                                              func (*WorkflowTemplateClient) ListWorkflowTemplates

                                                                                                                                                                                                                                ListWorkflowTemplates lists workflows that match the specified filter in the request.

                                                                                                                                                                                                                                Example
                                                                                                                                                                                                                                Output:
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                

                                                                                                                                                                                                                                func (*WorkflowTemplateClient) UpdateWorkflowTemplate

                                                                                                                                                                                                                                  UpdateWorkflowTemplate updates (replaces) workflow template. The updated template must contain version that matches the current server version.

                                                                                                                                                                                                                                  Example
                                                                                                                                                                                                                                  Output:
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  type WorkflowTemplateIterator

                                                                                                                                                                                                                                  type WorkflowTemplateIterator struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// Response is the raw response for the current page.
                                                                                                                                                                                                                                  	// It must be cast to the RPC response type.
                                                                                                                                                                                                                                  	// Calling Next() or InternalFetch() updates this value.
                                                                                                                                                                                                                                  	Response interface{}
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// InternalFetch is for use by the Google Cloud Libraries only.
                                                                                                                                                                                                                                  	// It is not part of the stable interface of this package.
                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                  	// InternalFetch returns results from a single call to the underlying RPC.
                                                                                                                                                                                                                                  	// The number of results is no greater than pageSize.
                                                                                                                                                                                                                                  	// If there are no more results, nextPageToken is empty and err is nil.
                                                                                                                                                                                                                                  	InternalFetch func(pageSize int, pageToken string) (results []*dataprocpb.WorkflowTemplate, nextPageToken string, err error)
                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    WorkflowTemplateIterator manages a stream of *dataprocpb.WorkflowTemplate.

                                                                                                                                                                                                                                    func (*WorkflowTemplateIterator) Next

                                                                                                                                                                                                                                      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 (*WorkflowTemplateIterator) PageInfo

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

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