generated/google/apis/remotebuildexecution_v1/classes.rb in google-api-client-0.31.0 vs generated/google/apis/remotebuildexecution_v1/classes.rb in google-api-client-0.32.0

- old
+ new

@@ -1594,16 +1594,16 @@ # AcceleratorConfig defines the accelerator cards to attach to the VM. class GoogleDevtoolsRemotebuildexecutionAdminV1alphaAcceleratorConfig include Google::Apis::Core::Hashable - # The number of the guest accelerator cards exposed to this VM. + # The number of guest accelerator cards exposed to each VM. # Corresponds to the JSON property `acceleratorCount` # @return [Fixnum] attr_accessor :accelerator_count - # The type of accelerator to attach to this VM, e.g. "nvidia-tesla-k80" for + # The type of accelerator to attach to each VM, e.g. "nvidia-tesla-k80" for # nVidia Tesla K80. # Corresponds to the JSON property `acceleratorType` # @return [String] attr_accessor :accelerator_type @@ -2006,10 +2006,19 @@ # See [CPU Platforms](https://cloud.google.com/compute/docs/cpu-platforms). # Corresponds to the JSON property `minCpuPlatform` # @return [String] attr_accessor :min_cpu_platform + # Determines the type of network access granted to workers. Possible values: + # - "public": Workers can connect to the public internet. + # - "private": Workers can only connect to Google APIs and services. + # - "restricted-private": Workers can only connect to Google APIs that are + # reachable through `restricted.googleapis.com` (`199.36.153.4/30`). + # Corresponds to the JSON property `networkAccess` + # @return [String] + attr_accessor :network_access + # Determines whether the worker is reserved (equivalent to a Compute Engine # on-demand VM and therefore won't be preempted). # See [Preemptible VMs](https://cloud.google.com/preemptible-vms/) for more # details. # Corresponds to the JSON property `reserved` @@ -2027,10 +2036,11 @@ @disk_size_gb = args[:disk_size_gb] if args.key?(:disk_size_gb) @disk_type = args[:disk_type] if args.key?(:disk_type) @labels = args[:labels] if args.key?(:labels) @machine_type = args[:machine_type] if args.key?(:machine_type) @min_cpu_platform = args[:min_cpu_platform] if args.key?(:min_cpu_platform) + @network_access = args[:network_access] if args.key?(:network_access) @reserved = args[:reserved] if args.key?(:reserved) end end # A worker pool resource in the Remote Build Execution API. @@ -2073,998 +2083,10 @@ @worker_config = args[:worker_config] if args.key?(:worker_config) @worker_count = args[:worker_count] if args.key?(:worker_count) end end - # An ActionResult represents the result of an - # Action being run. - class GoogleDevtoolsRemoteexecutionV1testActionResult - include Google::Apis::Core::Hashable - - # The exit code of the command. - # Corresponds to the JSON property `exitCode` - # @return [Fixnum] - attr_accessor :exit_code - - # The output directories of the action. For each output directory requested - # in the `output_directories` field of the Action, if the corresponding - # directory existed after the action completed, a single entry will be - # present in the output list, which will contain the digest of - # a Tree message containing - # the directory tree, and the path equal exactly to the corresponding Action - # output_directories member. - # As an example, suppose the Action had an output directory `a/b/dir` and the - # execution produced the following contents in `a/b/dir`: a file named `bar` - # and a directory named `foo` with an executable file named `baz`. Then, - # output_directory will contain (hashes shortened for readability): - # ```json - # // OutputDirectory proto: - # ` - # path: "a/b/dir" - # tree_digest: ` - # hash: "4a73bc9d03...", - # size: 55 - # ` - # ` - # // Tree proto with hash "4a73bc9d03..." and size 55: - # ` - # root: ` - # files: [ - # ` - # name: "bar", - # digest: ` - # hash: "4a73bc9d03...", - # size: 65534 - # ` - # ` - # ], - # directories: [ - # ` - # name: "foo", - # digest: ` - # hash: "4cf2eda940...", - # size: 43 - # ` - # ` - # ] - # ` - # children : ` - # // (Directory proto with hash "4cf2eda940..." and size 43) - # files: [ - # ` - # name: "baz", - # digest: ` - # hash: "b2c941073e...", - # size: 1294, - # `, - # is_executable: true - # ` - # ] - # ` - # ` - # ``` - # Corresponds to the JSON property `outputDirectories` - # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testOutputDirectory>] - attr_accessor :output_directories - - # The output files of the action. For each output file requested in the - # `output_files` field of the Action, if the corresponding file existed after - # the action completed, a single entry will be present in the output list. - # If the action does not produce the requested output, or produces a - # directory where a regular file is expected or vice versa, then that output - # will be omitted from the list. The server is free to arrange the output - # list as desired; clients MUST NOT assume that the output list is sorted. - # Corresponds to the JSON property `outputFiles` - # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testOutputFile>] - attr_accessor :output_files - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `stderrDigest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :stderr_digest - - # The standard error buffer of the action. The server will determine, based - # on the size of the buffer, whether to return it in raw form or to return - # a digest in `stderr_digest` that points to the buffer. If neither is set, - # then the buffer is empty. The client SHOULD NOT assume it will get one of - # the raw buffer or a digest on any given request and should be prepared to - # handle either. - # Corresponds to the JSON property `stderrRaw` - # NOTE: Values are automatically base64 encoded/decoded in the client library. - # @return [String] - attr_accessor :stderr_raw - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `stdoutDigest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :stdout_digest - - # The standard output buffer of the action. The server will determine, based - # on the size of the buffer, whether to return it in raw form or to return - # a digest in `stdout_digest` that points to the buffer. If neither is set, - # then the buffer is empty. The client SHOULD NOT assume it will get one of - # the raw buffer or a digest on any given request and should be prepared to - # handle either. - # Corresponds to the JSON property `stdoutRaw` - # NOTE: Values are automatically base64 encoded/decoded in the client library. - # @return [String] - attr_accessor :stdout_raw - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @exit_code = args[:exit_code] if args.key?(:exit_code) - @output_directories = args[:output_directories] if args.key?(:output_directories) - @output_files = args[:output_files] if args.key?(:output_files) - @stderr_digest = args[:stderr_digest] if args.key?(:stderr_digest) - @stderr_raw = args[:stderr_raw] if args.key?(:stderr_raw) - @stdout_digest = args[:stdout_digest] if args.key?(:stdout_digest) - @stdout_raw = args[:stdout_raw] if args.key?(:stdout_raw) - end - end - - # A `Command` is the actual command executed by a worker running an - # Action. - # Except as otherwise required, the environment (such as which system - # libraries or binaries are available, and what filesystems are mounted where) - # is defined by and specific to the implementation of the remote execution API. - class GoogleDevtoolsRemoteexecutionV1testCommand - include Google::Apis::Core::Hashable - - # The arguments to the command. The first argument must be the path to the - # executable, which must be either a relative path, in which case it is - # evaluated with respect to the input root, or an absolute path. - # The working directory will always be the input root. - # Corresponds to the JSON property `arguments` - # @return [Array<String>] - attr_accessor :arguments - - # The environment variables to set when running the program. The worker may - # provide its own default environment variables; these defaults can be - # overridden using this field. Additional variables can also be specified. - # In order to ensure that equivalent `Command`s always hash to the same - # value, the environment variables MUST be lexicographically sorted by name. - # Sorting of strings is done by code point, equivalently, by the UTF-8 bytes. - # Corresponds to the JSON property `environmentVariables` - # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable>] - attr_accessor :environment_variables - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @arguments = args[:arguments] if args.key?(:arguments) - @environment_variables = args[:environment_variables] if args.key?(:environment_variables) - end - end - - # An `EnvironmentVariable` is one variable to set in the running program's - # environment. - class GoogleDevtoolsRemoteexecutionV1testCommandEnvironmentVariable - include Google::Apis::Core::Hashable - - # The variable name. - # Corresponds to the JSON property `name` - # @return [String] - attr_accessor :name - - # The variable value. - # Corresponds to the JSON property `value` - # @return [String] - attr_accessor :value - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @name = args[:name] if args.key?(:name) - @value = args[:value] if args.key?(:value) - end - end - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - class GoogleDevtoolsRemoteexecutionV1testDigest - include Google::Apis::Core::Hashable - - # The hash. In the case of SHA-256, it will always be a lowercase hex string - # exactly 64 characters long. - # Corresponds to the JSON property `hash` - # @return [String] - attr_accessor :hash_prop - - # The size of the blob, in bytes. - # Corresponds to the JSON property `sizeBytes` - # @return [Fixnum] - attr_accessor :size_bytes - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @hash_prop = args[:hash_prop] if args.key?(:hash_prop) - @size_bytes = args[:size_bytes] if args.key?(:size_bytes) - end - end - - # A `Directory` represents a directory node in a file tree, containing zero or - # more children FileNodes - # and DirectoryNodes. - # Each `Node` contains its name in the directory, the digest of its content - # (either a file blob or a `Directory` proto), as well as possibly some - # metadata about the file or directory. - # In order to ensure that two equivalent directory trees hash to the same - # value, the following restrictions MUST be obeyed when constructing a - # a `Directory`: - # - Every child in the directory must have a path of exactly one segment. - # Multiple levels of directory hierarchy may not be collapsed. - # - Each child in the directory must have a unique path segment (file name). - # - The files and directories in the directory must each be sorted in - # lexicographical order by path. The path strings must be sorted by code - # point, equivalently, by UTF-8 bytes. - # A `Directory` that obeys the restrictions is said to be in canonical form. - # As an example, the following could be used for a file named `bar` and a - # directory named `foo` with an executable file named `baz` (hashes shortened - # for readability): - # ```json - # // (Directory proto) - # ` - # files: [ - # ` - # name: "bar", - # digest: ` - # hash: "4a73bc9d03...", - # size: 65534 - # ` - # ` - # ], - # directories: [ - # ` - # name: "foo", - # digest: ` - # hash: "4cf2eda940...", - # size: 43 - # ` - # ` - # ] - # ` - # // (Directory proto with hash "4cf2eda940..." and size 43) - # ` - # files: [ - # ` - # name: "baz", - # digest: ` - # hash: "b2c941073e...", - # size: 1294, - # `, - # is_executable: true - # ` - # ] - # ` - # ``` - class GoogleDevtoolsRemoteexecutionV1testDirectory - include Google::Apis::Core::Hashable - - # The subdirectories in the directory. - # Corresponds to the JSON property `directories` - # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectoryNode>] - attr_accessor :directories - - # The files in the directory. - # Corresponds to the JSON property `files` - # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testFileNode>] - attr_accessor :files - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @directories = args[:directories] if args.key?(:directories) - @files = args[:files] if args.key?(:files) - end - end - - # A `DirectoryNode` represents a child of a - # Directory which is itself - # a `Directory` and its associated metadata. - class GoogleDevtoolsRemoteexecutionV1testDirectoryNode - include Google::Apis::Core::Hashable - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `digest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :digest - - # The name of the directory. - # 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) - @digest = args[:digest] if args.key?(:digest) - @name = args[:name] if args.key?(:name) - end - end - - # Metadata about an ongoing - # execution, which - # will be contained in the metadata - # field of the - # Operation. - class GoogleDevtoolsRemoteexecutionV1testExecuteOperationMetadata - include Google::Apis::Core::Hashable - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `actionDigest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :action_digest - - # - # Corresponds to the JSON property `stage` - # @return [String] - attr_accessor :stage - - # If set, the client can use this name with - # ByteStream.Read to stream the - # standard error. - # Corresponds to the JSON property `stderrStreamName` - # @return [String] - attr_accessor :stderr_stream_name - - # If set, the client can use this name with - # ByteStream.Read to stream the - # standard output. - # Corresponds to the JSON property `stdoutStreamName` - # @return [String] - attr_accessor :stdout_stream_name - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @action_digest = args[:action_digest] if args.key?(:action_digest) - @stage = args[:stage] if args.key?(:stage) - @stderr_stream_name = args[:stderr_stream_name] if args.key?(:stderr_stream_name) - @stdout_stream_name = args[:stdout_stream_name] if args.key?(:stdout_stream_name) - end - end - - # The response message for - # Execution.Execute, - # which will be contained in the response - # field of the - # Operation. - class GoogleDevtoolsRemoteexecutionV1testExecuteResponse - include Google::Apis::Core::Hashable - - # True if the result was served from cache, false if it was executed. - # Corresponds to the JSON property `cachedResult` - # @return [Boolean] - attr_accessor :cached_result - alias_method :cached_result?, :cached_result - - # An ActionResult represents the result of an - # Action being run. - # Corresponds to the JSON property `result` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testActionResult] - attr_accessor :result - - # An optional list of additional log outputs the server wishes to provide. A - # server can use this to return execution-specific logs however it wishes. - # This is intended primarily to make it easier for users to debug issues that - # may be outside of the actual job execution, such as by identifying the - # worker executing the action or by providing logs from the worker's setup - # phase. The keys SHOULD be human readable so that a client can display them - # to a user. - # Corresponds to the JSON property `serverLogs` - # @return [Hash<String,Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testLogFile>] - attr_accessor :server_logs - - # 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). Each `Status` message contains - # three pieces of data: error code, error message, and error details. - # You can find out more about this error model and how to work with it in the - # [API Design Guide](https://cloud.google.com/apis/design/errors). - # Corresponds to the JSON property `status` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleRpcStatus] - attr_accessor :status - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @cached_result = args[:cached_result] if args.key?(:cached_result) - @result = args[:result] if args.key?(:result) - @server_logs = args[:server_logs] if args.key?(:server_logs) - @status = args[:status] if args.key?(:status) - end - end - - # A `FileNode` represents a single file and associated metadata. - class GoogleDevtoolsRemoteexecutionV1testFileNode - include Google::Apis::Core::Hashable - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `digest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :digest - - # True if file is executable, false otherwise. - # Corresponds to the JSON property `isExecutable` - # @return [Boolean] - attr_accessor :is_executable - alias_method :is_executable?, :is_executable - - # The name of the file. - # 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) - @digest = args[:digest] if args.key?(:digest) - @is_executable = args[:is_executable] if args.key?(:is_executable) - @name = args[:name] if args.key?(:name) - end - end - - # A `LogFile` is a log stored in the CAS. - class GoogleDevtoolsRemoteexecutionV1testLogFile - include Google::Apis::Core::Hashable - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `digest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :digest - - # This is a hint as to the purpose of the log, and is set to true if the log - # is human-readable text that can be usefully displayed to a user, and false - # otherwise. For instance, if a command-line client wishes to print the - # server logs to the terminal for a failed action, this allows it to avoid - # displaying a binary file. - # Corresponds to the JSON property `humanReadable` - # @return [Boolean] - attr_accessor :human_readable - alias_method :human_readable?, :human_readable - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @digest = args[:digest] if args.key?(:digest) - @human_readable = args[:human_readable] if args.key?(:human_readable) - end - end - - # An `OutputDirectory` is the output in an `ActionResult` corresponding to a - # directory's full contents rather than a single file. - class GoogleDevtoolsRemoteexecutionV1testOutputDirectory - include Google::Apis::Core::Hashable - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `digest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :digest - - # The full path of the directory relative to the working directory. The path - # separator is a forward slash `/`. Since this is a relative path, it MUST - # NOT begin with a leading forward slash. The empty string value is allowed, - # and it denotes the entire working directory. - # Corresponds to the JSON property `path` - # @return [String] - attr_accessor :path - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `treeDigest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :tree_digest - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @digest = args[:digest] if args.key?(:digest) - @path = args[:path] if args.key?(:path) - @tree_digest = args[:tree_digest] if args.key?(:tree_digest) - end - end - - # An `OutputFile` is similar to a - # FileNode, but it is - # tailored for output as part of an `ActionResult`. It allows a full file path - # rather than only a name, and allows the server to include content inline. - # `OutputFile` is binary-compatible with `FileNode`. - class GoogleDevtoolsRemoteexecutionV1testOutputFile - include Google::Apis::Core::Hashable - - # The raw content of the file. - # This field may be used by the server to provide the content of a file - # inline in an - # ActionResult and - # avoid requiring that the client make a separate call to - # [ContentAddressableStorage.GetBlob] to retrieve it. - # The client SHOULD NOT assume that it will get raw content with any request, - # and always be prepared to retrieve it via `digest`. - # Corresponds to the JSON property `content` - # NOTE: Values are automatically base64 encoded/decoded in the client library. - # @return [String] - attr_accessor :content - - # A content digest. A digest for a given blob consists of the size of the blob - # and its hash. The hash algorithm to use is defined by the server, but servers - # SHOULD use SHA-256. - # The size is considered to be an integral part of the digest and cannot be - # separated. That is, even if the `hash` field is correctly specified but - # `size_bytes` is not, the server MUST reject the request. - # The reason for including the size in the digest is as follows: in a great - # many cases, the server needs to know the size of the blob it is about to work - # with prior to starting an operation with it, such as flattening Merkle tree - # structures or streaming it to a worker. Technically, the server could - # implement a separate metadata store, but this results in a significantly more - # complicated implementation as opposed to having the client specify the size - # up-front (or storing the size along with the digest in every message where - # digests are embedded). This does mean that the API leaks some implementation - # details of (what we consider to be) a reasonable server implementation, but - # we consider this to be a worthwhile tradeoff. - # When a `Digest` is used to refer to a proto message, it always refers to the - # message in binary encoded form. To ensure consistent hashing, clients and - # servers MUST ensure that they serialize messages according to the following - # rules, even if there are alternate valid encodings for the same message. - # - Fields are serialized in tag order. - # - There are no unknown fields. - # - There are no duplicate fields. - # - Fields are serialized according to the default semantics for their type. - # Most protocol buffer implementations will always follow these rules when - # serializing, but care should be taken to avoid shortcuts. For instance, - # concatenating two messages to merge them may produce duplicate fields. - # Corresponds to the JSON property `digest` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDigest] - attr_accessor :digest - - # True if file is executable, false otherwise. - # Corresponds to the JSON property `isExecutable` - # @return [Boolean] - attr_accessor :is_executable - alias_method :is_executable?, :is_executable - - # The full path of the file relative to the input root, including the - # filename. The path separator is a forward slash `/`. Since this is a - # relative path, it MUST NOT begin with a leading forward slash. - # 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) - @content = args[:content] if args.key?(:content) - @digest = args[:digest] if args.key?(:digest) - @is_executable = args[:is_executable] if args.key?(:is_executable) - @path = args[:path] if args.key?(:path) - end - end - - # An optional Metadata to attach to any RPC request to tell the server about an - # external context of the request. The server may use this for logging or other - # purposes. To use it, the client attaches the header to the call using the - # canonical proto serialization: - # name: google.devtools.remoteexecution.v1test.requestmetadata-bin - # contents: the base64 encoded binary RequestMetadata message. - class GoogleDevtoolsRemoteexecutionV1testRequestMetadata - include Google::Apis::Core::Hashable - - # An identifier that ties multiple requests to the same action. - # For example, multiple requests to the CAS, Action Cache, and Execution - # API are used in order to compile foo.cc. - # Corresponds to the JSON property `actionId` - # @return [String] - attr_accessor :action_id - - # An identifier to tie multiple tool invocations together. For example, - # runs of foo_test, bar_test and baz_test on a post-submit of a given patch. - # Corresponds to the JSON property `correlatedInvocationsId` - # @return [String] - attr_accessor :correlated_invocations_id - - # Details for the tool used to call the API. - # Corresponds to the JSON property `toolDetails` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testToolDetails] - attr_accessor :tool_details - - # An identifier that ties multiple actions together to a final result. - # For example, multiple actions are required to build and run foo_test. - # Corresponds to the JSON property `toolInvocationId` - # @return [String] - attr_accessor :tool_invocation_id - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @action_id = args[:action_id] if args.key?(:action_id) - @correlated_invocations_id = args[:correlated_invocations_id] if args.key?(:correlated_invocations_id) - @tool_details = args[:tool_details] if args.key?(:tool_details) - @tool_invocation_id = args[:tool_invocation_id] if args.key?(:tool_invocation_id) - end - end - - # Details for the tool used to call the API. - class GoogleDevtoolsRemoteexecutionV1testToolDetails - include Google::Apis::Core::Hashable - - # Name of the tool, e.g. bazel. - # Corresponds to the JSON property `toolName` - # @return [String] - attr_accessor :tool_name - - # Version of the tool used for the request, e.g. 5.0.3. - # Corresponds to the JSON property `toolVersion` - # @return [String] - attr_accessor :tool_version - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @tool_name = args[:tool_name] if args.key?(:tool_name) - @tool_version = args[:tool_version] if args.key?(:tool_version) - end - end - - # A `Tree` contains all the - # Directory protos in a - # single directory Merkle tree, compressed into one message. - class GoogleDevtoolsRemoteexecutionV1testTree - include Google::Apis::Core::Hashable - - # All the child directories: the directories referred to by the root and, - # recursively, all its children. In order to reconstruct the directory tree, - # the client must take the digests of each of the child directories and then - # build up a tree starting from the `root`. - # Corresponds to the JSON property `children` - # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory>] - attr_accessor :children - - # A `Directory` represents a directory node in a file tree, containing zero or - # more children FileNodes - # and DirectoryNodes. - # Each `Node` contains its name in the directory, the digest of its content - # (either a file blob or a `Directory` proto), as well as possibly some - # metadata about the file or directory. - # In order to ensure that two equivalent directory trees hash to the same - # value, the following restrictions MUST be obeyed when constructing a - # a `Directory`: - # - Every child in the directory must have a path of exactly one segment. - # Multiple levels of directory hierarchy may not be collapsed. - # - Each child in the directory must have a unique path segment (file name). - # - The files and directories in the directory must each be sorted in - # lexicographical order by path. The path strings must be sorted by code - # point, equivalently, by UTF-8 bytes. - # A `Directory` that obeys the restrictions is said to be in canonical form. - # As an example, the following could be used for a file named `bar` and a - # directory named `foo` with an executable file named `baz` (hashes shortened - # for readability): - # ```json - # // (Directory proto) - # ` - # files: [ - # ` - # name: "bar", - # digest: ` - # hash: "4a73bc9d03...", - # size: 65534 - # ` - # ` - # ], - # directories: [ - # ` - # name: "foo", - # digest: ` - # hash: "4cf2eda940...", - # size: 43 - # ` - # ` - # ] - # ` - # // (Directory proto with hash "4cf2eda940..." and size 43) - # ` - # files: [ - # ` - # name: "baz", - # digest: ` - # hash: "b2c941073e...", - # size: 1294, - # `, - # is_executable: true - # ` - # ] - # ` - # ``` - # Corresponds to the JSON property `root` - # @return [Google::Apis::RemotebuildexecutionV1::GoogleDevtoolsRemoteexecutionV1testDirectory] - attr_accessor :root - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @children = args[:children] if args.key?(:children) - @root = args[:root] if args.key?(:root) - end - end - # AdminTemp is a prelimiary set of administration tasks. It's called "Temp" # because we do not yet know the best way to represent admin tasks; it's # possible that this will be entirely replaced in later versions of this API. # If this message proves to be sufficient, it will be renamed in the alpha or # beta release of this API. @@ -3778,82 +2800,9 @@ # 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 - - # A Change indicates the most recent state of an element. - class GoogleWatcherV1Change - include Google::Apis::Core::Hashable - - # If true, this Change is followed by more Changes that are in the same group - # as this Change. - # Corresponds to the JSON property `continued` - # @return [Boolean] - attr_accessor :continued - alias_method :continued?, :continued - - # The actual change data. This field is present only when `state() == EXISTS` - # or `state() == ERROR`. Please see google.protobuf.Any about how to use - # the Any type. - # Corresponds to the JSON property `data` - # @return [Hash<String,Object>] - attr_accessor :data - - # Name of the element, interpreted relative to the entity's actual - # name. "" refers to the entity itself. The element name is a valid - # UTF-8 string. - # Corresponds to the JSON property `element` - # @return [String] - attr_accessor :element - - # If present, provides a compact representation of all the messages that have - # been received by the caller for the given entity, e.g., it could be a - # sequence number or a multi-part timestamp/version vector. This marker can - # be provided in the Request message, allowing the caller to resume the - # stream watching at a specific point without fetching the initial state. - # Corresponds to the JSON property `resumeMarker` - # NOTE: Values are automatically base64 encoded/decoded in the client library. - # @return [String] - attr_accessor :resume_marker - - # The state of the `element`. - # Corresponds to the JSON property `state` - # @return [String] - attr_accessor :state - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @continued = args[:continued] if args.key?(:continued) - @data = args[:data] if args.key?(:data) - @element = args[:element] if args.key?(:element) - @resume_marker = args[:resume_marker] if args.key?(:resume_marker) - @state = args[:state] if args.key?(:state) - end - end - - # A batch of Change messages. - class GoogleWatcherV1ChangeBatch - include Google::Apis::Core::Hashable - - # A list of Change messages. - # Corresponds to the JSON property `changes` - # @return [Array<Google::Apis::RemotebuildexecutionV1::GoogleWatcherV1Change>] - attr_accessor :changes - - def initialize(**args) - update!(**args) - end - - # Update properties of this object - def update!(**args) - @changes = args[:changes] if args.key?(:changes) end end end end end