# Copyright 2015 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'date' require 'google/apis/core/base_service' require 'google/apis/core/json_representation' require 'google/apis/core/hashable' require 'google/apis/errors' module Google module Apis module GenomicsV1alpha2 # The request message for Operations.CancelOperation. class CancelOperationRequest include Google::Apis::Core::Hashable def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) end end # Describes a Compute Engine resource that is being managed by a running # pipeline. class ComputeEngine include Google::Apis::Core::Hashable # The names of the disks that were created for this pipeline. # Corresponds to the JSON property `diskNames` # @return [Array] attr_accessor :disk_names # The instance on which the operation is running. # Corresponds to the JSON property `instanceName` # @return [String] attr_accessor :instance_name # The machine type of the instance. # Corresponds to the JSON property `machineType` # @return [String] attr_accessor :machine_type # The availability zone in which the instance resides. # Corresponds to the JSON property `zone` # @return [String] attr_accessor :zone def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @disk_names = args[:disk_names] if args.key?(:disk_names) @instance_name = args[:instance_name] if args.key?(:instance_name) @machine_type = args[:machine_type] if args.key?(:machine_type) @zone = args[:zone] if args.key?(:zone) end end # This event is generated when a container starts. class ContainerStartedEvent include Google::Apis::Core::Hashable # The numeric ID of the action that started this container. # Corresponds to the JSON property `actionId` # @return [Fixnum] attr_accessor :action_id # The public IP address that can be used to connect to the container. This # field is only populated when at least one port mapping is present. If the # instance was created with a private address this field will be empty even # if port mappings exist. # Corresponds to the JSON property `ipAddress` # @return [String] attr_accessor :ip_address # The container to host port mappings installed for this container. This # set will contain any ports exposed using the PUBLISH_EXPOSED_PORTS flag as # well as any specified in the Action definition. # Corresponds to the JSON property `portMappings` # @return [Hash] attr_accessor :port_mappings def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @action_id = args[:action_id] if args.key?(:action_id) @ip_address = args[:ip_address] if args.key?(:ip_address) @port_mappings = args[:port_mappings] if args.key?(:port_mappings) end end # This event is generated when a container exits. class ContainerStoppedEvent include Google::Apis::Core::Hashable # The numeric ID of the action that started this container. # Corresponds to the JSON property `actionId` # @return [Fixnum] attr_accessor :action_id # The exit status of the container. # Corresponds to the JSON property `exitStatus` # @return [Fixnum] attr_accessor :exit_status # The tail end of any content written to standard error by the container. # To prevent this from being recorded if the action is known to emit # large amounts of debugging noise or sensitive information, set the # DISABLE_STANDARD_ERROR_CAPTURE flag. # Note that only a small amount of the end of the stream is captured here. # The entire stream is stored in the /google/logs directory mounted into # each action, and may be copied off the machine as described elsewhere. # Corresponds to the JSON property `stderr` # @return [String] attr_accessor :stderr def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @action_id = args[:action_id] if args.key?(:action_id) @exit_status = args[:exit_status] if args.key?(:exit_status) @stderr = args[:stderr] if args.key?(:stderr) end end # Stores the information that the controller will fetch from the # server in order to run. Should only be used by VMs created by the # Pipelines Service and not by end users. class ControllerConfig include Google::Apis::Core::Hashable # # Corresponds to the JSON property `cmd` # @return [String] attr_accessor :cmd # # Corresponds to the JSON property `disks` # @return [Hash] attr_accessor :disks # # Corresponds to the JSON property `gcsLogPath` # @return [String] attr_accessor :gcs_log_path # # Corresponds to the JSON property `gcsSinks` # @return [Hash] attr_accessor :gcs_sinks # # Corresponds to the JSON property `gcsSources` # @return [Hash] attr_accessor :gcs_sources # # Corresponds to the JSON property `image` # @return [String] attr_accessor :image # # Corresponds to the JSON property `machineType` # @return [String] attr_accessor :machine_type # # Corresponds to the JSON property `vars` # @return [Hash] attr_accessor :vars def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @cmd = args[:cmd] if args.key?(:cmd) @disks = args[:disks] if args.key?(:disks) @gcs_log_path = args[:gcs_log_path] if args.key?(:gcs_log_path) @gcs_sinks = args[:gcs_sinks] if args.key?(:gcs_sinks) @gcs_sources = args[:gcs_sources] if args.key?(:gcs_sources) @image = args[:image] if args.key?(:image) @machine_type = args[:machine_type] if args.key?(:machine_type) @vars = args[:vars] if args.key?(:vars) end end # This event is generated whenever a resource limitation or transient error # delays execution of a pipeline that was otherwise ready to run. class DelayedEvent include Google::Apis::Core::Hashable # A textual description of the cause of the delay. The string may change # without notice since it is often generated by another service (such as # Compute Engine). # Corresponds to the JSON property `cause` # @return [String] attr_accessor :cause # If the delay was caused by a resource shortage, this field lists the # Compute Engine metrics that are preventing this operation from running # (for example, CPUS or INSTANCES). If the particular metric is not known, # a single UNKNOWN metric will be present. # Corresponds to the JSON property `metrics` # @return [Array] attr_accessor :metrics def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @cause = args[:cause] if args.key?(:cause) @metrics = args[:metrics] if args.key?(:metrics) end end # A Google Compute Engine disk resource specification. class Disk include Google::Apis::Core::Hashable # Deprecated. Disks created by the Pipelines API will be deleted at the end # of the pipeline run, regardless of what this field is set to. # Corresponds to the JSON property `autoDelete` # @return [Boolean] attr_accessor :auto_delete alias_method :auto_delete?, :auto_delete # Required at create time and cannot be overridden at run time. # Specifies the path in the docker container where files on # this disk should be located. For example, if `mountPoint` # is `/mnt/disk`, and the parameter has `localPath` # `inputs/file.txt`, the docker container can access the data at # `/mnt/disk/inputs/file.txt`. # Corresponds to the JSON property `mountPoint` # @return [String] attr_accessor :mount_point # Required. The name of the disk that can be used in the pipeline # parameters. Must be 1 - 63 characters. # The name "boot" is reserved for system use. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # Specifies how a sourced-base persistent disk will be mounted. See # https://cloud.google.com/compute/docs/disks/persistent-disks# # use_multi_instances # for more details. # Can only be set at create time. # Corresponds to the JSON property `readOnly` # @return [Boolean] attr_accessor :read_only alias_method :read_only?, :read_only # The size of the disk. Defaults to 500 (GB). # This field is not applicable for local SSD. # Corresponds to the JSON property `sizeGb` # @return [Fixnum] attr_accessor :size_gb # The full or partial URL of the persistent disk to attach. See # https://cloud.google.com/compute/docs/reference/latest/instances#resource # and # https://cloud.google.com/compute/docs/disks/persistent-disks#snapshots # for more details. # Corresponds to the JSON property `source` # @return [String] attr_accessor :source # Required. The type of the disk to create. # Corresponds to the JSON property `type` # @return [String] attr_accessor :type def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @auto_delete = args[:auto_delete] if args.key?(:auto_delete) @mount_point = args[:mount_point] if args.key?(:mount_point) @name = args[:name] if args.key?(:name) @read_only = args[:read_only] if args.key?(:read_only) @size_gb = args[:size_gb] if args.key?(:size_gb) @source = args[:source] if args.key?(:source) @type = args[:type] if args.key?(:type) end end # The Docker execuctor specification. class DockerExecutor include Google::Apis::Core::Hashable # Required. The command or newline delimited script to run. The command # string will be executed within a bash shell. # If the command exits with a non-zero exit code, output parameter # de-localization will be skipped and the pipeline operation's # `error` field will be populated. # Maximum command string length is 16384. # Corresponds to the JSON property `cmd` # @return [String] attr_accessor :cmd # Required. Image name from either Docker Hub or Google Container Registry. # Users that run pipelines must have READ access to the image. # Corresponds to the JSON property `imageName` # @return [String] attr_accessor :image_name def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @cmd = args[:cmd] if args.key?(:cmd) @image_name = args[:image_name] if args.key?(:image_name) end end # A generic empty message that you can re-use to avoid defining duplicated # empty messages in your APIs. A typical example is to use it as the request # or the response type of an API method. For instance: # service Foo ` # rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); # ` # The JSON representation for `Empty` is empty JSON object ````. class Empty include Google::Apis::Core::Hashable def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) end end # Event carries information about events that occur during pipeline execution. class Event include Google::Apis::Core::Hashable # A human readable description of the event. Note that these strings may # change at any time without notice. Any application logic must use the # information in the details field. # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # Machine readable details about the event. # Corresponds to the JSON property `details` # @return [Hash] attr_accessor :details # The time that the event occurred. # Corresponds to the JSON property `timestamp` # @return [String] attr_accessor :timestamp def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @description = args[:description] if args.key?(:description) @details = args[:details] if args.key?(:details) @timestamp = args[:timestamp] if args.key?(:timestamp) end end # This event is generated when the execution of a pipeline has failed. Note # that other events may continue to occur after this event. class FailedEvent include Google::Apis::Core::Hashable # The human readable description of the cause of the failure. # Corresponds to the JSON property `cause` # @return [String] attr_accessor :cause # The Google standard error code that best describes this failure. # Corresponds to the JSON property `code` # @return [String] attr_accessor :code def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @cause = args[:cause] if args.key?(:cause) @code = args[:code] if args.key?(:code) end end # The read group set import response. class ImportReadGroupSetsResponse include Google::Apis::Core::Hashable # IDs of the read group sets that were created. # Corresponds to the JSON property `readGroupSetIds` # @return [Array] attr_accessor :read_group_set_ids def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @read_group_set_ids = args[:read_group_set_ids] if args.key?(:read_group_set_ids) end end # The variant data import response. class ImportVariantsResponse include Google::Apis::Core::Hashable # IDs of the call sets created during the import. # Corresponds to the JSON property `callSetIds` # @return [Array] attr_accessor :call_set_ids def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @call_set_ids = args[:call_set_ids] if args.key?(:call_set_ids) end end # The response message for Operations.ListOperations. class ListOperationsResponse include Google::Apis::Core::Hashable # The standard List next-page token. # Corresponds to the JSON property `nextPageToken` # @return [String] attr_accessor :next_page_token # A list of operations that matches the specified filter in the request. # Corresponds to the JSON property `operations` # @return [Array] attr_accessor :operations def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @next_page_token = args[:next_page_token] if args.key?(:next_page_token) @operations = args[:operations] if args.key?(:operations) end end # The response of ListPipelines. Contains at most `pageSize` # pipelines. If it contains `pageSize` pipelines, and more pipelines # exist, then `nextPageToken` will be populated and should be # used as the `pageToken` argument to a subsequent ListPipelines # request. class ListPipelinesResponse include Google::Apis::Core::Hashable # The token to use to get the next page of results. # Corresponds to the JSON property `nextPageToken` # @return [String] attr_accessor :next_page_token # The matched pipelines. # Corresponds to the JSON property `pipelines` # @return [Array] attr_accessor :pipelines def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @next_page_token = args[:next_page_token] if args.key?(:next_page_token) @pipelines = args[:pipelines] if args.key?(:pipelines) end end # LocalCopy defines how a remote file should be copied to and from the VM. class LocalCopy include Google::Apis::Core::Hashable # Required. The name of the disk where this parameter is # located. Can be the name of one of the disks specified in the # Resources field, or "boot", which represents the Docker # instance's boot disk and has a mount point of `/`. # Corresponds to the JSON property `disk` # @return [String] attr_accessor :disk # Required. The path within the user's docker container where # this input should be localized to and from, relative to the specified # disk's mount point. For example: file.txt, # Corresponds to the JSON property `path` # @return [String] attr_accessor :path def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @disk = args[:disk] if args.key?(:disk) @path = args[:path] if args.key?(:path) end end # The logging options for the pipeline run. class LoggingOptions include Google::Apis::Core::Hashable # The location in Google Cloud Storage to which the pipeline logs # will be copied. Can be specified as a fully qualified directory # path, in which case logs will be output with a unique identifier # as the filename in that directory, or as a fully specified path, # which must end in `.log`, in which case that path will be # used, and the user must ensure that logs are not # overwritten. Stdout and stderr logs from the run are also # generated and output as `-stdout.log` and `-stderr.log`. # Corresponds to the JSON property `gcsPath` # @return [String] attr_accessor :gcs_path def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @gcs_path = args[:gcs_path] if args.key?(:gcs_path) end end # This resource represents a long-running operation that is the result of a # network API call. class Operation include Google::Apis::Core::Hashable # If the value is `false`, it means the operation is still in progress. # If `true`, the operation is completed, and either `error` or `response` is # available. # Corresponds to the JSON property `done` # @return [Boolean] attr_accessor :done alias_method :done?, :done # The `Status` type defines a logical error model that is suitable for different # programming environments, including REST APIs and RPC APIs. It is used by # [gRPC](https://github.com/grpc). The error model is designed to be: # - Simple to use and understand for most users # - Flexible enough to meet unexpected needs # # Overview # The `Status` message contains three pieces of data: error code, error message, # and error details. The error code should be an enum value of # google.rpc.Code, but it may accept additional error codes if needed. The # error message should be a developer-facing English message that helps # developers *understand* and *resolve* the error. If a localized user-facing # error message is needed, put the localized message in the error details or # localize it in the client. The optional error details may contain arbitrary # information about the error. There is a predefined set of error detail types # in the package `google.rpc` that can be used for common error conditions. # # Language mapping # The `Status` message is the logical representation of the error model, but it # is not necessarily the actual wire format. When the `Status` message is # exposed in different client libraries and different wire protocols, it can be # mapped differently. For example, it will likely be mapped to some exceptions # in Java, but more likely mapped to some error codes in C. # # Other uses # The error model and the `Status` message can be used in a variety of # environments, either with or without APIs, to provide a # consistent developer experience across different environments. # Example uses of this error model include: # - Partial errors. If a service needs to return partial errors to the client, # it may embed the `Status` in the normal response to indicate the partial # errors. # - Workflow errors. A typical workflow has multiple steps. Each step may # have a `Status` message for error reporting. # - Batch operations. If a client uses batch request and batch response, the # `Status` message should be used directly inside batch response, one for # each error sub-response. # - Asynchronous operations. If an API call embeds asynchronous operation # results in its response, the status of those operations should be # represented directly using the `Status` message. # - Logging. If some API errors are stored in logs, the message `Status` could # be used directly after any stripping needed for security/privacy reasons. # Corresponds to the JSON property `error` # @return [Google::Apis::GenomicsV1alpha2::Status] attr_accessor :error # An OperationMetadata or Metadata object. This will always be returned with the # Operation. # Corresponds to the JSON property `metadata` # @return [Hash] attr_accessor :metadata # The server-assigned name, which is only unique within the same service that # originally returns it. For example: `operations/CJHU7Oi_ChDrveSpBRjfuL- # qzoWAgEw` # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # If importing ReadGroupSets, an ImportReadGroupSetsResponse is returned. If # importing Variants, an ImportVariantsResponse is returned. For pipelines and # exports, an Empty response is returned. # Corresponds to the JSON property `response` # @return [Hash] attr_accessor :response def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @done = args[:done] if args.key?(:done) @error = args[:error] if args.key?(:error) @metadata = args[:metadata] if args.key?(:metadata) @name = args[:name] if args.key?(:name) @response = args[:response] if args.key?(:response) end end # An event that occurred during an Operation. class OperationEvent include Google::Apis::Core::Hashable # Required description of event. # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # Optional time of when event finished. An event can have a start time and no # finish time. If an event has a finish time, there must be a start time. # Corresponds to the JSON property `endTime` # @return [String] attr_accessor :end_time # Optional time of when event started. # Corresponds to the JSON property `startTime` # @return [String] attr_accessor :start_time def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @description = args[:description] if args.key?(:description) @end_time = args[:end_time] if args.key?(:end_time) @start_time = args[:start_time] if args.key?(:start_time) end end # Metadata describing an Operation. class OperationMetadata include Google::Apis::Core::Hashable # This field is deprecated. Use `labels` instead. Optionally provided by the # caller when submitting the request that creates the operation. # Corresponds to the JSON property `clientId` # @return [String] attr_accessor :client_id # The time at which the job was submitted to the Genomics service. # Corresponds to the JSON property `createTime` # @return [String] attr_accessor :create_time # The time at which the job stopped running. # Corresponds to the JSON property `endTime` # @return [String] attr_accessor :end_time # Optional event messages that were generated during the job's execution. # This also contains any warnings that were generated during import # or export. # Corresponds to the JSON property `events` # @return [Array] attr_accessor :events # Optionally provided by the caller when submitting the request that creates # the operation. # Corresponds to the JSON property `labels` # @return [Hash] attr_accessor :labels # The Google Cloud Project in which the job is scoped. # Corresponds to the JSON property `projectId` # @return [String] attr_accessor :project_id # The original request that started the operation. Note that this will be in # current version of the API. If the operation was started with v1beta2 API # and a GetOperation is performed on v1 API, a v1 request will be returned. # Corresponds to the JSON property `request` # @return [Hash] attr_accessor :request # Runtime metadata on this Operation. # Corresponds to the JSON property `runtimeMetadata` # @return [Hash] attr_accessor :runtime_metadata # The time at which the job began to run. # Corresponds to the JSON property `startTime` # @return [String] attr_accessor :start_time def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @client_id = args[:client_id] if args.key?(:client_id) @create_time = args[:create_time] if args.key?(:create_time) @end_time = args[:end_time] if args.key?(:end_time) @events = args[:events] if args.key?(:events) @labels = args[:labels] if args.key?(:labels) @project_id = args[:project_id] if args.key?(:project_id) @request = args[:request] if args.key?(:request) @runtime_metadata = args[:runtime_metadata] if args.key?(:runtime_metadata) @start_time = args[:start_time] if args.key?(:start_time) end end # The pipeline object. Represents a transformation from a set of input # parameters to a set of output parameters. The transformation is defined # as a docker image and command to run within that image. Each pipeline # is run on a Google Compute Engine VM. A pipeline can be created with the # `create` method and then later run with the `run` method, or a pipeline can # be defined and run all at once with the `run` method. class Pipeline include Google::Apis::Core::Hashable # User-specified description. # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # The Docker execuctor specification. # Corresponds to the JSON property `docker` # @return [Google::Apis::GenomicsV1alpha2::DockerExecutor] attr_accessor :docker # Input parameters of the pipeline. # Corresponds to the JSON property `inputParameters` # @return [Array] attr_accessor :input_parameters # Required. A user specified pipeline name that does not have to be unique. # This name can be used for filtering Pipelines in ListPipelines. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # Output parameters of the pipeline. # Corresponds to the JSON property `outputParameters` # @return [Array] attr_accessor :output_parameters # Unique pipeline id that is generated by the service when CreatePipeline # is called. Cannot be specified in the Pipeline used in the # CreatePipelineRequest, and will be populated in the response to # CreatePipeline and all subsequent Get and List calls. Indicates that the # service has registered this pipeline. # Corresponds to the JSON property `pipelineId` # @return [String] attr_accessor :pipeline_id # Required. The project in which to create the pipeline. The caller must have # WRITE access. # Corresponds to the JSON property `projectId` # @return [String] attr_accessor :project_id # The system resources for the pipeline run. # Corresponds to the JSON property `resources` # @return [Google::Apis::GenomicsV1alpha2::PipelineResources] attr_accessor :resources def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @description = args[:description] if args.key?(:description) @docker = args[:docker] if args.key?(:docker) @input_parameters = args[:input_parameters] if args.key?(:input_parameters) @name = args[:name] if args.key?(:name) @output_parameters = args[:output_parameters] if args.key?(:output_parameters) @pipeline_id = args[:pipeline_id] if args.key?(:pipeline_id) @project_id = args[:project_id] if args.key?(:project_id) @resources = args[:resources] if args.key?(:resources) end end # Parameters facilitate setting and delivering data into the # pipeline's execution environment. They are defined at create time, # with optional defaults, and can be overridden at run time. # If `localCopy` is unset, then the parameter specifies a string that # is passed as-is into the pipeline, as the value of the environment # variable with the given name. A default value can be optionally # specified at create time. The default can be overridden at run time # using the inputs map. If no default is given, a value must be # supplied at runtime. # If `localCopy` is defined, then the parameter specifies a data # source or sink, both in Google Cloud Storage and on the Docker container # where the pipeline computation is run. The service account associated with # the Pipeline (by # default the project's Compute Engine service account) must have access to the # Google Cloud Storage paths. # At run time, the Google Cloud Storage paths can be overridden if a default # was provided at create time, or must be set otherwise. The pipeline runner # should add a key/value pair to either the inputs or outputs map. The # indicated data copies will be carried out before/after pipeline execution, # just as if the corresponding arguments were provided to `gsutil cp`. # For example: Given the following `PipelineParameter`, specified # in the `inputParameters` list: # ``` # `name: "input_file", localCopy: `path: "file.txt", disk: "pd1"`` # ``` # where `disk` is defined in the `PipelineResources` object as: # ``` # `name: "pd1", mountPoint: "/mnt/disk/"` # ``` # We create a disk named `pd1`, mount it on the host VM, and map # `/mnt/pd1` to `/mnt/disk` in the docker container. At # runtime, an entry for `input_file` would be required in the inputs # map, such as: # ``` # inputs["input_file"] = "gs://my-bucket/bar.txt" # ``` # This would generate the following gsutil call: # ``` # gsutil cp gs://my-bucket/bar.txt /mnt/pd1/file.txt # ``` # The file `/mnt/pd1/file.txt` maps to `/mnt/disk/file.txt` in the # Docker container. Acceptable paths are: # # # # # # # # #
Google Cloud storage pathLocal path
filefile
globdirectory
# For outputs, the direction of the copy is reversed: # ``` # gsutil cp /mnt/disk/file.txt gs://my-bucket/bar.txt # ``` # Acceptable paths are: # # # # # # # # # # # # # # #
Local pathGoogle Cloud Storage path
filefile
filedirectory - directory must already exist
globdirectory - directory will be created if it doesn't exist
# One restriction due to docker limitations, is that for outputs that are found # on the boot disk, the local path cannot be a glob and must be a file. class PipelineParameter include Google::Apis::Core::Hashable # The default value for this parameter. Can be overridden at runtime. # If `localCopy` is present, then this must be a Google Cloud Storage path # beginning with `gs://`. # Corresponds to the JSON property `defaultValue` # @return [String] attr_accessor :default_value # Human-readable description. # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # LocalCopy defines how a remote file should be copied to and from the VM. # Corresponds to the JSON property `localCopy` # @return [Google::Apis::GenomicsV1alpha2::LocalCopy] attr_accessor :local_copy # Required. Name of the parameter - the pipeline runner uses this string # as the key to the input and output maps in RunPipeline. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @default_value = args[:default_value] if args.key?(:default_value) @description = args[:description] if args.key?(:description) @local_copy = args[:local_copy] if args.key?(:local_copy) @name = args[:name] if args.key?(:name) end end # The system resources for the pipeline run. class PipelineResources include Google::Apis::Core::Hashable # Optional. The number of accelerators of the specified type to attach. # By specifying this parameter, you will download and install the following # third-party software onto your managed Compute Engine instances: # NVIDIA® Tesla® drivers and NVIDIA® CUDA toolkit. # Corresponds to the JSON property `acceleratorCount` # @return [Fixnum] attr_accessor :accelerator_count # Optional. The Compute Engine defined accelerator type. # By specifying this parameter, you will download and install the following # third-party software onto your managed Compute Engine instances: NVIDIA® # Tesla® drivers and NVIDIA® CUDA toolkit. # Please see https://cloud.google.com/compute/docs/gpus/ for a list of # available accelerator types. # Corresponds to the JSON property `acceleratorType` # @return [String] attr_accessor :accelerator_type # The size of the boot disk. Defaults to 10 (GB). # Corresponds to the JSON property `bootDiskSizeGb` # @return [Fixnum] attr_accessor :boot_disk_size_gb # Disks to attach. # Corresponds to the JSON property `disks` # @return [Array] attr_accessor :disks # The minimum number of cores to use. Defaults to 1. # Corresponds to the JSON property `minimumCpuCores` # @return [Fixnum] attr_accessor :minimum_cpu_cores # The minimum amount of RAM to use. Defaults to 3.75 (GB) # Corresponds to the JSON property `minimumRamGb` # @return [Float] attr_accessor :minimum_ram_gb # Whether to assign an external IP to the instance. This is an experimental # feature that may go away. Defaults to false. # Corresponds to `--no_address` flag for [gcloud compute instances create] # (https://cloud.google.com/sdk/gcloud/reference/compute/instances/create). # In order to use this, must be true for both create time and run time. # Cannot be true at run time if false at create time. If you need to ssh into # a private IP VM for debugging, you can ssh to a public VM and then ssh into # the private VM's Internal IP. If noAddress is set, this pipeline run may # only load docker images from Google Container Registry and not Docker Hub. # Before using this, you must # [configure access to Google services from internal IPs](https://cloud.google. # com/compute/docs/configure-private-google-access# # configuring_access_to_google_services_from_internal_ips). # Corresponds to the JSON property `noAddress` # @return [Boolean] attr_accessor :no_address alias_method :no_address?, :no_address # Whether to use preemptible VMs. Defaults to `false`. In order to use this, # must be true for both create time and run time. Cannot be true at run time # if false at create time. # Corresponds to the JSON property `preemptible` # @return [Boolean] attr_accessor :preemptible alias_method :preemptible?, :preemptible # List of Google Compute Engine availability zones to which resource # creation will restricted. If empty, any zone may be chosen. # Corresponds to the JSON property `zones` # @return [Array] attr_accessor :zones def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @accelerator_count = args[:accelerator_count] if args.key?(:accelerator_count) @accelerator_type = args[:accelerator_type] if args.key?(:accelerator_type) @boot_disk_size_gb = args[:boot_disk_size_gb] if args.key?(:boot_disk_size_gb) @disks = args[:disks] if args.key?(:disks) @minimum_cpu_cores = args[:minimum_cpu_cores] if args.key?(:minimum_cpu_cores) @minimum_ram_gb = args[:minimum_ram_gb] if args.key?(:minimum_ram_gb) @no_address = args[:no_address] if args.key?(:no_address) @preemptible = args[:preemptible] if args.key?(:preemptible) @zones = args[:zones] if args.key?(:zones) end end # This event is generated when the worker starts pulling an image. class PullStartedEvent include Google::Apis::Core::Hashable # The URI of the image that was pulled. # Corresponds to the JSON property `imageUri` # @return [String] attr_accessor :image_uri def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @image_uri = args[:image_uri] if args.key?(:image_uri) end end # This event is generated when the worker stops pulling an image. class PullStoppedEvent include Google::Apis::Core::Hashable # The URI of the image that was pulled. # Corresponds to the JSON property `imageUri` # @return [String] attr_accessor :image_uri def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @image_uri = args[:image_uri] if args.key?(:image_uri) end end # class RepeatedString include Google::Apis::Core::Hashable # # Corresponds to the JSON property `values` # @return [Array] attr_accessor :values def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @values = args[:values] if args.key?(:values) end end # The pipeline run arguments. class RunPipelineArgs include Google::Apis::Core::Hashable # This field is deprecated. Use `labels` instead. Client-specified pipeline # operation identifier. # Corresponds to the JSON property `clientId` # @return [String] attr_accessor :client_id # Pipeline input arguments; keys are defined in the pipeline documentation. # All input parameters that do not have default values must be specified. # If parameters with defaults are specified here, the defaults will be # overridden. # Corresponds to the JSON property `inputs` # @return [Hash] attr_accessor :inputs # How long to keep the VM up after a failure (for example docker command # failed, copying input or output files failed, etc). While the VM is up, one # can ssh into the VM to debug. Default is 0; maximum allowed value is 1 day. # Corresponds to the JSON property `keepVmAliveOnFailureDuration` # @return [String] attr_accessor :keep_vm_alive_on_failure_duration # Labels to apply to this pipeline run. Labels will also be applied to # compute resources (VM, disks) created by this pipeline run. When listing # operations, operations can filtered by labels. # Label keys may not be empty; label values may be empty. Non-empty labels # must be 1-63 characters long, and comply with [RFC1035] # (https://www.ietf.org/rfc/rfc1035.txt). # Specifically, the name must be 1-63 characters long and match the regular # expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first # character must be a lowercase letter, and all following characters must be # a dash, lowercase letter, or digit, except the last character, which cannot # be a dash. # Corresponds to the JSON property `labels` # @return [Hash] attr_accessor :labels # The logging options for the pipeline run. # Corresponds to the JSON property `logging` # @return [Google::Apis::GenomicsV1alpha2::LoggingOptions] attr_accessor :logging # Pipeline output arguments; keys are defined in the pipeline # documentation. All output parameters of without default values # must be specified. If parameters with defaults are specified # here, the defaults will be overridden. # Corresponds to the JSON property `outputs` # @return [Hash] attr_accessor :outputs # Required. The project in which to run the pipeline. The caller must have # WRITER access to all Google Cloud services and resources (e.g. Google # Compute Engine) will be used. # Corresponds to the JSON property `projectId` # @return [String] attr_accessor :project_id # The system resources for the pipeline run. # Corresponds to the JSON property `resources` # @return [Google::Apis::GenomicsV1alpha2::PipelineResources] attr_accessor :resources # A Google Cloud Service Account. # Corresponds to the JSON property `serviceAccount` # @return [Google::Apis::GenomicsV1alpha2::ServiceAccount] attr_accessor :service_account def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @client_id = args[:client_id] if args.key?(:client_id) @inputs = args[:inputs] if args.key?(:inputs) @keep_vm_alive_on_failure_duration = args[:keep_vm_alive_on_failure_duration] if args.key?(:keep_vm_alive_on_failure_duration) @labels = args[:labels] if args.key?(:labels) @logging = args[:logging] if args.key?(:logging) @outputs = args[:outputs] if args.key?(:outputs) @project_id = args[:project_id] if args.key?(:project_id) @resources = args[:resources] if args.key?(:resources) @service_account = args[:service_account] if args.key?(:service_account) end end # The request to run a pipeline. If `pipelineId` is specified, it # refers to a saved pipeline created with CreatePipeline and set as # the `pipelineId` of the returned Pipeline object. If # `ephemeralPipeline` is specified, that pipeline is run once # with the given args and not saved. It is an error to specify both # `pipelineId` and `ephemeralPipeline`. `pipelineArgs` # must be specified. class RunPipelineRequest include Google::Apis::Core::Hashable # The pipeline object. Represents a transformation from a set of input # parameters to a set of output parameters. The transformation is defined # as a docker image and command to run within that image. Each pipeline # is run on a Google Compute Engine VM. A pipeline can be created with the # `create` method and then later run with the `run` method, or a pipeline can # be defined and run all at once with the `run` method. # Corresponds to the JSON property `ephemeralPipeline` # @return [Google::Apis::GenomicsV1alpha2::Pipeline] attr_accessor :ephemeral_pipeline # The pipeline run arguments. # Corresponds to the JSON property `pipelineArgs` # @return [Google::Apis::GenomicsV1alpha2::RunPipelineArgs] attr_accessor :pipeline_args # The already created pipeline to run. # Corresponds to the JSON property `pipelineId` # @return [String] attr_accessor :pipeline_id def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @ephemeral_pipeline = args[:ephemeral_pipeline] if args.key?(:ephemeral_pipeline) @pipeline_args = args[:pipeline_args] if args.key?(:pipeline_args) @pipeline_id = args[:pipeline_id] if args.key?(:pipeline_id) end end # Runtime metadata that will be populated in the # runtimeMetadata # field of the Operation associated with a RunPipeline execution. class RuntimeMetadata include Google::Apis::Core::Hashable # Describes a Compute Engine resource that is being managed by a running # pipeline. # Corresponds to the JSON property `computeEngine` # @return [Google::Apis::GenomicsV1alpha2::ComputeEngine] attr_accessor :compute_engine def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @compute_engine = args[:compute_engine] if args.key?(:compute_engine) end end # A Google Cloud Service Account. class ServiceAccount include Google::Apis::Core::Hashable # Email address of the service account. Defaults to `default`, # which uses the compute service account associated with the project. # Corresponds to the JSON property `email` # @return [String] attr_accessor :email # List of scopes to be enabled for this service account on the VM. # The following scopes are automatically included: # * https://www.googleapis.com/auth/compute # * https://www.googleapis.com/auth/devstorage.full_control # * https://www.googleapis.com/auth/genomics # * https://www.googleapis.com/auth/logging.write # * https://www.googleapis.com/auth/monitoring.write # Corresponds to the JSON property `scopes` # @return [Array] attr_accessor :scopes def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @email = args[:email] if args.key?(:email) @scopes = args[:scopes] if args.key?(:scopes) end end # Request to set operation status. Should only be used by VMs # created by the Pipelines Service and not by end users. class SetOperationStatusRequest include Google::Apis::Core::Hashable # # Corresponds to the JSON property `errorCode` # @return [String] attr_accessor :error_code # # Corresponds to the JSON property `errorMessage` # @return [String] attr_accessor :error_message # # Corresponds to the JSON property `operationId` # @return [String] attr_accessor :operation_id # # Corresponds to the JSON property `timestampEvents` # @return [Array] attr_accessor :timestamp_events # # Corresponds to the JSON property `validationToken` # @return [Fixnum] attr_accessor :validation_token def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @error_code = args[:error_code] if args.key?(:error_code) @error_message = args[:error_message] if args.key?(:error_message) @operation_id = args[:operation_id] if args.key?(:operation_id) @timestamp_events = args[:timestamp_events] if args.key?(:timestamp_events) @validation_token = args[:validation_token] if args.key?(:validation_token) end end # The `Status` type defines a logical error model that is suitable for different # programming environments, including REST APIs and RPC APIs. It is used by # [gRPC](https://github.com/grpc). The error model is designed to be: # - Simple to use and understand for most users # - Flexible enough to meet unexpected needs # # Overview # The `Status` message contains three pieces of data: error code, error message, # and error details. The error code should be an enum value of # google.rpc.Code, but it may accept additional error codes if needed. The # error message should be a developer-facing English message that helps # developers *understand* and *resolve* the error. If a localized user-facing # error message is needed, put the localized message in the error details or # localize it in the client. The optional error details may contain arbitrary # information about the error. There is a predefined set of error detail types # in the package `google.rpc` that can be used for common error conditions. # # Language mapping # The `Status` message is the logical representation of the error model, but it # is not necessarily the actual wire format. When the `Status` message is # exposed in different client libraries and different wire protocols, it can be # mapped differently. For example, it will likely be mapped to some exceptions # in Java, but more likely mapped to some error codes in C. # # Other uses # The error model and the `Status` message can be used in a variety of # environments, either with or without APIs, to provide a # consistent developer experience across different environments. # Example uses of this error model include: # - Partial errors. If a service needs to return partial errors to the client, # it may embed the `Status` in the normal response to indicate the partial # errors. # - Workflow errors. A typical workflow has multiple steps. Each step may # have a `Status` message for error reporting. # - Batch operations. If a client uses batch request and batch response, the # `Status` message should be used directly inside batch response, one for # each error sub-response. # - Asynchronous operations. If an API call embeds asynchronous operation # results in its response, the status of those operations should be # represented directly using the `Status` message. # - Logging. If some API errors are stored in logs, the message `Status` could # be used directly after any stripping needed for security/privacy reasons. class Status include Google::Apis::Core::Hashable # The status code, which should be an enum value of google.rpc.Code. # Corresponds to the JSON property `code` # @return [Fixnum] attr_accessor :code # A list of messages that carry the error details. There is a common set of # message types for APIs to use. # Corresponds to the JSON property `details` # @return [Array>] attr_accessor :details # A developer-facing error message, which should be in English. Any # user-facing error message should be localized and sent in the # google.rpc.Status.details field, or localized by the client. # Corresponds to the JSON property `message` # @return [String] attr_accessor :message def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @code = args[:code] if args.key?(:code) @details = args[:details] if args.key?(:details) @message = args[:message] if args.key?(:message) end end # Stores the list of events and times they occured for major events in job # execution. class TimestampEvent include Google::Apis::Core::Hashable # String indicating the type of event # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # The time this event occured. # Corresponds to the JSON property `timestamp` # @return [String] attr_accessor :timestamp def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @description = args[:description] if args.key?(:description) @timestamp = args[:timestamp] if args.key?(:timestamp) end end # This event is generated when the execution of a container results in a # non-zero exit status that was not otherwise ignored. Execution will # continue, but only actions that are flagged as ALWAYS_RUN will be executed: # other actions will be skipped. class UnexpectedExitStatusEvent include Google::Apis::Core::Hashable # The numeric ID of the action that started the container. # Corresponds to the JSON property `actionId` # @return [Fixnum] attr_accessor :action_id # The exit status of the container. # Corresponds to the JSON property `exitStatus` # @return [Fixnum] attr_accessor :exit_status def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @action_id = args[:action_id] if args.key?(:action_id) @exit_status = args[:exit_status] if args.key?(:exit_status) end end # This event is generated once a worker VM has been assigned to run the # pipeline. class WorkerAssignedEvent include Google::Apis::Core::Hashable # The worker's instance name. # Corresponds to the JSON property `instance` # @return [String] attr_accessor :instance # The zone the worker is running in. # Corresponds to the JSON property `zone` # @return [String] attr_accessor :zone def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @instance = args[:instance] if args.key?(:instance) @zone = args[:zone] if args.key?(:zone) end end # This event is generated when the worker VM that was assigned to the pipeline # has been released (i.e., deleted). class WorkerReleasedEvent include Google::Apis::Core::Hashable # The worker's instance name. # Corresponds to the JSON property `instance` # @return [String] attr_accessor :instance # The zone the worker was running in. # Corresponds to the JSON property `zone` # @return [String] attr_accessor :zone def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @instance = args[:instance] if args.key?(:instance) @zone = args[:zone] if args.key?(:zone) end end end end end