Class: Google::Apis::RemotebuildexecutionV2::BuildBazelRemoteExecutionV2BatchUpdateBlobsResponseResponse

Inherits:
Object
  • Object
show all
Includes:
Core::Hashable, Core::JsonObjectSupport
Defined in:
generated/google/apis/remotebuildexecution_v2/classes.rb,
generated/google/apis/remotebuildexecution_v2/representations.rb,
generated/google/apis/remotebuildexecution_v2/representations.rb

Overview

A response corresponding to a single blob that the client tried to upload.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Core::JsonObjectSupport

#to_json

Methods included from Core::Hashable

process_value, #to_h

Constructor Details

#initialize(**args) ⇒ BuildBazelRemoteExecutionV2BatchUpdateBlobsResponseResponse

Returns a new instance of BuildBazelRemoteExecutionV2BatchUpdateBlobsResponseResponse



698
699
700
 
# File 'generated/google/apis/remotebuildexecution_v2/classes.rb', line 698

def initialize(**args)
   update!(**args)
end

Instance Attribute Details

#digest ⇒ Google::Apis::RemotebuildexecutionV2::BuildBazelRemoteExecutionV2Digest

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

Returns:



653
654
655
 
# File 'generated/google/apis/remotebuildexecution_v2/classes.rb', line 653

def digest
  @digest
end

#status ⇒ Google::Apis::RemotebuildexecutionV2::GoogleRpcStatus

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. 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 status

Returns:



696
697
698
 
# File 'generated/google/apis/remotebuildexecution_v2/classes.rb', line 696

def status
  @status
end

Instance Method Details

#update!(**args) ⇒ Object

Update properties of this object



703
704
705
706
 
# File 'generated/google/apis/remotebuildexecution_v2/classes.rb', line 703

def update!(**args)
  @digest = args[:digest] if args.key?(:digest)
  @status = args[:status] if args.key?(:status)
end