Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / google-api-python-client / dd49464a6262c0d1f71efcf11f131e2f591fe5f6 / . / docs / dyn / remotebuildexecution_v2.actionResults.html
blob: f6612223a2b2854006e0d47ebcde9593068b8c8b [file] [log] [blame]
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1<html><body>
2<style>
3
4body, h1, h2, h3, div, span, p, pre, a {
5 margin: 0;
6 padding: 0;
7 border: 0;
8 font-weight: inherit;
9 font-style: inherit;
10 font-size: 100%;
11 font-family: inherit;
12 vertical-align: baseline;
13}
14
15body {
16 font-size: 13px;
17 padding: 1em;
18}
19
20h1 {
21 font-size: 26px;
22 margin-bottom: 1em;
23}
24
25h2 {
26 font-size: 24px;
27 margin-bottom: 1em;
28}
29
30h3 {
31 font-size: 20px;
32 margin-bottom: 1em;
33 margin-top: 1em;
34}
35
36pre, code {
37 line-height: 1.5;
38 font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
39}
40
41pre {
42 margin-top: 0.5em;
43}
44
45h1, h2, h3, p {
46 font-family: Arial, sans serif;
47}
48
49h1, h2, h3 {
50 border-bottom: solid #CCC 1px;
51}
52
53.toc_element {
54 margin-top: 0.5em;
55}
56
57.firstline {
58 margin-left: 2 em;
59}
60
61.method {
62 margin-top: 1em;
63 border: solid 1px #CCC;
64 padding: 1em;
65 background: #EEE;
66}
67
68.details {
69 font-weight: bold;
70 font-size: 14px;
71}
72
73</style>
74
75<h1><a href="remotebuildexecution_v2.html">Remote Build Execution API</a> . <a href="remotebuildexecution_v2.actionResults.html">actionResults</a></h1>
76<h2>Instance Methods</h2>
77<p class="toc_element">
78 <code><a href="#get">get(instanceName, hash, sizeBytes, inlineStdout=None, inlineOutputFiles=None, inlineStderr=None, x__xgafv=None)</a></code></p>
79<p class="firstline">Retrieve a cached execution result.</p>
80<p class="toc_element">
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]81 <code><a href="#update">update(instanceName, hash, sizeBytes, body=None, resultsCachePolicy_priority=None, x__xgafv=None)</a></code></p>
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]82<p class="firstline">Upload a new execution result.</p>
83<h3>Method Details</h3>
84<div class="method">
85 <code class="details" id="get">get(instanceName, hash, sizeBytes, inlineStdout=None, inlineOutputFiles=None, inlineStderr=None, x__xgafv=None)</code>
86 <pre>Retrieve a cached execution result.
87
88Implementations SHOULD ensure that any blobs referenced from the
89ContentAddressableStorage
90are available at the time of returning the
91ActionResult and will be
92for some period of time afterwards. The TTLs of the referenced blobs SHOULD be increased
93if necessary and applicable.
94
95Errors:
96
97* `NOT_FOUND`: The requested `ActionResult` is not in the cache.
98
99Args:
100 instanceName: string, The instance of the execution system to operate against. A server may
101support multiple instances of the execution system (with their own workers,
102storage, caches, etc.). The server MAY require use of this field to select
103between them in an implementation-defined fashion, otherwise it can be
104omitted. (required)
105 hash: string, The hash. In the case of SHA-256, it will always be a lowercase hex string
106exactly 64 characters long. (required)
107 sizeBytes: string, The size of the blob, in bytes. (required)
108 inlineStdout: boolean, A hint to the server to request inlining stdout in the
109ActionResult message.
110 inlineOutputFiles: string, A hint to the server to inline the contents of the listed output files.
111Each path needs to exactly match one path in `output_files` in the
112Command message. (repeated)
113 inlineStderr: boolean, A hint to the server to request inlining stderr in the
114ActionResult message.
115 x__xgafv: string, V1 error format.
116 Allowed values
117 1 - v1 error format
118 2 - v2 error format
119
120Returns:
121 An object of the form:
122
123 { # An ActionResult represents the result of an
124 # Action being run.
125 "executionMetadata": { # ExecutedActionMetadata contains details about a completed execution. # The details of the execution that originally produced this result.
126 "outputUploadStartTimestamp": "A String", # When the worker started uploading action outputs.
127 "workerCompletedTimestamp": "A String", # When the worker completed the action, including all stages.
128 "queuedTimestamp": "A String", # When was the action added to the queue.
129 "worker": "A String", # The name of the worker which ran the execution.
130 "executionStartTimestamp": "A String", # When the worker started executing the action command.
131 "inputFetchStartTimestamp": "A String", # When the worker started fetching action inputs.
132 "workerStartTimestamp": "A String", # When the worker received the action.
133 "outputUploadCompletedTimestamp": "A String", # When the worker finished uploading action outputs.
134 "executionCompletedTimestamp": "A String", # When the worker completed executing the action command.
135 "inputFetchCompletedTimestamp": "A String", # When the worker finished fetching action inputs.
136 },
137 "outputFileSymlinks": [ # The output files of the action that are symbolic links to other files. Those
138 # may be links to other output files, or input files, or even absolute paths
139 # outside of the working directory, if the server supports
140 # SymlinkAbsolutePathStrategy.ALLOWED.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]141 # For each output file requested in the `output_files` or `output_paths`
142 # field of the Action, if the corresponding file existed after
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]143 # the action completed, a single entry will be present either in this field,
144 # or in the `output_files` field, if the file was not a symbolic link.
145 #
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]146 # If an output symbolic link of the same name as listed in `output_files` of
147 # the Command was found, but its target type was not a regular file, the
148 # server will return a FAILED_PRECONDITION.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]149 # If the action does not produce the requested output, then that output
150 # will be omitted from the list. The server is free to arrange the output
151 # list as desired; clients MUST NOT assume that the output list is sorted.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]152 #
153 # DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
154 # should still populate this field in addition to `output_symlinks`.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]155 { # An `OutputSymlink` is similar to a
156 # Symlink, but it is used as an
157 # output in an `ActionResult`.
158 #
159 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
160 "path": "A String", # The full path of the symlink relative to the working directory, including the
161 # filename. The path separator is a forward slash `/`. Since this is a
162 # relative path, it MUST NOT begin with a leading forward slash.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]163 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
164 # Action.
165 { # A single property for FileNodes,
166 # DirectoryNodes, and
167 # SymlinkNodes. The server is
168 # responsible for specifying the property `name`s that it accepts. If
169 # permitted by the server, the same `name` may occur multiple times.
170 "name": "A String", # The property name.
171 "value": "A String", # The property value.
172 },
173 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]174 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
175 # The target path can be relative to the parent directory of the symlink or
176 # it can be an absolute path starting with `/`. Support for absolute paths
177 # can be checked using the Capabilities
178 # API. The canonical form forbids the substrings `/./` and `//` in the target
179 # path. `..` components are allowed anywhere in the target path.
180 },
181 ],
182 "stderrDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest for a blob containing the standard error of the action, which
183 # can be retrieved from the
184 # ContentAddressableStorage.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]185 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]186 #
187 # The size is considered to be an integral part of the digest and cannot be
188 # separated. That is, even if the `hash` field is correctly specified but
189 # `size_bytes` is not, the server MUST reject the request.
190 #
191 # The reason for including the size in the digest is as follows: in a great
192 # many cases, the server needs to know the size of the blob it is about to work
193 # with prior to starting an operation with it, such as flattening Merkle tree
194 # structures or streaming it to a worker. Technically, the server could
195 # implement a separate metadata store, but this results in a significantly more
196 # complicated implementation as opposed to having the client specify the size
197 # up-front (or storing the size along with the digest in every message where
198 # digests are embedded). This does mean that the API leaks some implementation
199 # details of (what we consider to be) a reasonable server implementation, but
200 # we consider this to be a worthwhile tradeoff.
201 #
202 # When a `Digest` is used to refer to a proto message, it always refers to the
203 # message in binary encoded form. To ensure consistent hashing, clients and
204 # servers MUST ensure that they serialize messages according to the following
205 # rules, even if there are alternate valid encodings for the same message:
206 #
207 # * Fields are serialized in tag order.
208 # * There are no unknown fields.
209 # * There are no duplicate fields.
210 # * Fields are serialized according to the default semantics for their type.
211 #
212 # Most protocol buffer implementations will always follow these rules when
213 # serializing, but care should be taken to avoid shortcuts. For instance,
214 # concatenating two messages to merge them may produce duplicate fields.
215 "sizeBytes": "A String", # The size of the blob, in bytes.
216 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
217 # exactly 64 characters long.
218 },
219 "stdoutRaw": "A String", # The standard output buffer of the action. The server SHOULD NOT inline
220 # stdout unless requested by the client in the
221 # GetActionResultRequest
222 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
223 # would cause the response to exceed message size limits.
224 "stderrRaw": "A String", # The standard error buffer of the action. The server SHOULD NOT inline
225 # stderr unless requested by the client in the
226 # GetActionResultRequest
227 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
228 # would cause the response to exceed message size limits.
229 "stdoutDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest for a blob containing the standard output of the action, which
230 # can be retrieved from the
231 # ContentAddressableStorage.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]232 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]233 #
234 # The size is considered to be an integral part of the digest and cannot be
235 # separated. That is, even if the `hash` field is correctly specified but
236 # `size_bytes` is not, the server MUST reject the request.
237 #
238 # The reason for including the size in the digest is as follows: in a great
239 # many cases, the server needs to know the size of the blob it is about to work
240 # with prior to starting an operation with it, such as flattening Merkle tree
241 # structures or streaming it to a worker. Technically, the server could
242 # implement a separate metadata store, but this results in a significantly more
243 # complicated implementation as opposed to having the client specify the size
244 # up-front (or storing the size along with the digest in every message where
245 # digests are embedded). This does mean that the API leaks some implementation
246 # details of (what we consider to be) a reasonable server implementation, but
247 # we consider this to be a worthwhile tradeoff.
248 #
249 # When a `Digest` is used to refer to a proto message, it always refers to the
250 # message in binary encoded form. To ensure consistent hashing, clients and
251 # servers MUST ensure that they serialize messages according to the following
252 # rules, even if there are alternate valid encodings for the same message:
253 #
254 # * Fields are serialized in tag order.
255 # * There are no unknown fields.
256 # * There are no duplicate fields.
257 # * Fields are serialized according to the default semantics for their type.
258 #
259 # Most protocol buffer implementations will always follow these rules when
260 # serializing, but care should be taken to avoid shortcuts. For instance,
261 # concatenating two messages to merge them may produce duplicate fields.
262 "sizeBytes": "A String", # The size of the blob, in bytes.
263 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
264 # exactly 64 characters long.
265 },
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]266 "outputSymlinks": [ # New in v2.1: this field will only be populated if the command
267 # `output_paths` field was used, and not the pre v2.1 `output_files` or
268 # `output_directories` fields.
269 # The output paths of the action that are symbolic links to other paths. Those
270 # may be links to other outputs, or inputs, or even absolute paths
271 # outside of the working directory, if the server supports
272 # SymlinkAbsolutePathStrategy.ALLOWED.
273 # A single entry for each output requested in `output_paths`
274 # field of the Action, if the corresponding path existed after
275 # the action completed and was a symbolic link.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]276 #
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]277 # If the action does not produce a requested output, then that output
278 # will be omitted from the list. The server is free to arrange the output
279 # list as desired; clients MUST NOT assume that the output list is sorted.
280 { # An `OutputSymlink` is similar to a
281 # Symlink, but it is used as an
282 # output in an `ActionResult`.
283 #
284 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
285 "path": "A String", # The full path of the symlink relative to the working directory, including the
286 # filename. The path separator is a forward slash `/`. Since this is a
287 # relative path, it MUST NOT begin with a leading forward slash.
288 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
289 # Action.
290 { # A single property for FileNodes,
291 # DirectoryNodes, and
292 # SymlinkNodes. The server is
293 # responsible for specifying the property `name`s that it accepts. If
294 # permitted by the server, the same `name` may occur multiple times.
295 "name": "A String", # The property name.
296 "value": "A String", # The property value.
297 },
298 ],
299 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
300 # The target path can be relative to the parent directory of the symlink or
301 # it can be an absolute path starting with `/`. Support for absolute paths
302 # can be checked using the Capabilities
303 # API. The canonical form forbids the substrings `/./` and `//` in the target
304 # path. `..` components are allowed anywhere in the target path.
305 },
306 ],
307 "outputFiles": [ # The output files of the action. For each output file requested in the
308 # `output_files` or `output_paths` field of the Action, if the corresponding
309 # file existed after the action completed, a single entry will be present
310 # either in this field, or the `output_file_symlinks` field if the file was
311 # a symbolic link to another file (`output_symlinks` field after v2.1).
312 #
313 # If an output listed in `output_files` was found, but was a directory rather
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]314 # than a regular file, the server will return a FAILED_PRECONDITION.
315 # If the action does not produce the requested output, then that output
316 # will be omitted from the list. The server is free to arrange the output
317 # list as desired; clients MUST NOT assume that the output list is sorted.
318 { # An `OutputFile` is similar to a
319 # FileNode, but it is used as an
320 # output in an `ActionResult`. It allows a full file path rather than
321 # only a name.
322 "path": "A String", # The full path of the file relative to the working directory, including the
323 # filename. The path separator is a forward slash `/`. Since this is a
324 # relative path, it MUST NOT begin with a leading forward slash.
325 "isExecutable": True or False, # True if file is executable, false otherwise.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]326 "nodeProperties": [ # The supported node properties of the OutputFile, if requested by the Action.
327 { # A single property for FileNodes,
328 # DirectoryNodes, and
329 # SymlinkNodes. The server is
330 # responsible for specifying the property `name`s that it accepts. If
331 # permitted by the server, the same `name` may occur multiple times.
332 "name": "A String", # The property name.
333 "value": "A String", # The property value.
334 },
335 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]336 "digest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest of the file's content.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]337 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]338 #
339 # The size is considered to be an integral part of the digest and cannot be
340 # separated. That is, even if the `hash` field is correctly specified but
341 # `size_bytes` is not, the server MUST reject the request.
342 #
343 # The reason for including the size in the digest is as follows: in a great
344 # many cases, the server needs to know the size of the blob it is about to work
345 # with prior to starting an operation with it, such as flattening Merkle tree
346 # structures or streaming it to a worker. Technically, the server could
347 # implement a separate metadata store, but this results in a significantly more
348 # complicated implementation as opposed to having the client specify the size
349 # up-front (or storing the size along with the digest in every message where
350 # digests are embedded). This does mean that the API leaks some implementation
351 # details of (what we consider to be) a reasonable server implementation, but
352 # we consider this to be a worthwhile tradeoff.
353 #
354 # When a `Digest` is used to refer to a proto message, it always refers to the
355 # message in binary encoded form. To ensure consistent hashing, clients and
356 # servers MUST ensure that they serialize messages according to the following
357 # rules, even if there are alternate valid encodings for the same message:
358 #
359 # * Fields are serialized in tag order.
360 # * There are no unknown fields.
361 # * There are no duplicate fields.
362 # * Fields are serialized according to the default semantics for their type.
363 #
364 # Most protocol buffer implementations will always follow these rules when
365 # serializing, but care should be taken to avoid shortcuts. For instance,
366 # concatenating two messages to merge them may produce duplicate fields.
367 "sizeBytes": "A String", # The size of the blob, in bytes.
368 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
369 # exactly 64 characters long.
370 },
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]371 "contents": "A String", # The contents of the file if inlining was requested. The server SHOULD NOT inline
372 # file contents unless requested by the client in the
373 # GetActionResultRequest
374 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
375 # would cause the response to exceed message size limits.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]376 },
377 ],
378 "outputDirectorySymlinks": [ # The output directories of the action that are symbolic links to other
379 # directories. Those may be links to other output directories, or input
380 # directories, or even absolute paths outside of the working directory,
381 # if the server supports
382 # SymlinkAbsolutePathStrategy.ALLOWED.
383 # For each output directory requested in the `output_directories` field of
384 # the Action, if the directory existed after the action completed, a
385 # single entry will be present either in this field, or in the
386 # `output_directories` field, if the directory was not a symbolic link.
387 #
388 # If an output of the same name was found, but was a symbolic link to a file
389 # instead of a directory, the server will return a FAILED_PRECONDITION.
390 # If the action does not produce the requested output, then that output
391 # will be omitted from the list. The server is free to arrange the output
392 # list as desired; clients MUST NOT assume that the output list is sorted.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]393 #
394 # DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
395 # should still populate this field in addition to `output_symlinks`.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]396 { # An `OutputSymlink` is similar to a
397 # Symlink, but it is used as an
398 # output in an `ActionResult`.
399 #
400 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
401 "path": "A String", # The full path of the symlink relative to the working directory, including the
402 # filename. The path separator is a forward slash `/`. Since this is a
403 # relative path, it MUST NOT begin with a leading forward slash.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]404 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
405 # Action.
406 { # A single property for FileNodes,
407 # DirectoryNodes, and
408 # SymlinkNodes. The server is
409 # responsible for specifying the property `name`s that it accepts. If
410 # permitted by the server, the same `name` may occur multiple times.
411 "name": "A String", # The property name.
412 "value": "A String", # The property value.
413 },
414 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]415 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
416 # The target path can be relative to the parent directory of the symlink or
417 # it can be an absolute path starting with `/`. Support for absolute paths
418 # can be checked using the Capabilities
419 # API. The canonical form forbids the substrings `/./` and `//` in the target
420 # path. `..` components are allowed anywhere in the target path.
421 },
422 ],
423 "outputDirectories": [ # The output directories of the action. For each output directory requested
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]424 # in the `output_directories` or `output_paths` field of the Action, if the
425 # corresponding directory existed after the action completed, a single entry
426 # will be present in the output list, which will contain the digest of a
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]427 # Tree message containing the
428 # directory tree, and the path equal exactly to the corresponding Action
429 # output_directories member.
430 #
431 # As an example, suppose the Action had an output directory `a/b/dir` and the
432 # execution produced the following contents in `a/b/dir`: a file named `bar`
433 # and a directory named `foo` with an executable file named `baz`. Then,
434 # output_directory will contain (hashes shortened for readability):
435 #
436 # ```json
437 # // OutputDirectory proto:
438 # {
439 # path: "a/b/dir"
440 # tree_digest: {
441 # hash: "4a73bc9d03...",
442 # size: 55
443 # }
444 # }
445 # // Tree proto with hash "4a73bc9d03..." and size 55:
446 # {
447 # root: {
448 # files: [
449 # {
450 # name: "bar",
451 # digest: {
452 # hash: "4a73bc9d03...",
453 # size: 65534
454 # }
455 # }
456 # ],
457 # directories: [
458 # {
459 # name: "foo",
460 # digest: {
461 # hash: "4cf2eda940...",
462 # size: 43
463 # }
464 # }
465 # ]
466 # }
467 # children : {
468 # // (Directory proto with hash "4cf2eda940..." and size 43)
469 # files: [
470 # {
471 # name: "baz",
472 # digest: {
473 # hash: "b2c941073e...",
474 # size: 1294,
475 # },
476 # is_executable: true
477 # }
478 # ]
479 # }
480 # }
481 # ```
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]482 # If an output of the same name as listed in `output_files` of
483 # the Command was found in `output_directories`, but was not a directory, the
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]484 # server will return a FAILED_PRECONDITION.
485 { # An `OutputDirectory` is the output in an `ActionResult` corresponding to a
486 # directory's full contents rather than a single file.
487 "path": "A String", # The full path of the directory relative to the working directory. The path
488 # separator is a forward slash `/`. Since this is a relative path, it MUST
489 # NOT begin with a leading forward slash. The empty string value is allowed,
490 # and it denotes the entire working directory.
491 "treeDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest of the encoded
492 # Tree proto containing the
493 # directory's contents.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]494 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]495 #
496 # The size is considered to be an integral part of the digest and cannot be
497 # separated. That is, even if the `hash` field is correctly specified but
498 # `size_bytes` is not, the server MUST reject the request.
499 #
500 # The reason for including the size in the digest is as follows: in a great
501 # many cases, the server needs to know the size of the blob it is about to work
502 # with prior to starting an operation with it, such as flattening Merkle tree
503 # structures or streaming it to a worker. Technically, the server could
504 # implement a separate metadata store, but this results in a significantly more
505 # complicated implementation as opposed to having the client specify the size
506 # up-front (or storing the size along with the digest in every message where
507 # digests are embedded). This does mean that the API leaks some implementation
508 # details of (what we consider to be) a reasonable server implementation, but
509 # we consider this to be a worthwhile tradeoff.
510 #
511 # When a `Digest` is used to refer to a proto message, it always refers to the
512 # message in binary encoded form. To ensure consistent hashing, clients and
513 # servers MUST ensure that they serialize messages according to the following
514 # rules, even if there are alternate valid encodings for the same message:
515 #
516 # * Fields are serialized in tag order.
517 # * There are no unknown fields.
518 # * There are no duplicate fields.
519 # * Fields are serialized according to the default semantics for their type.
520 #
521 # Most protocol buffer implementations will always follow these rules when
522 # serializing, but care should be taken to avoid shortcuts. For instance,
523 # concatenating two messages to merge them may produce duplicate fields.
524 "sizeBytes": "A String", # The size of the blob, in bytes.
525 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
526 # exactly 64 characters long.
527 },
528 },
529 ],
530 "exitCode": 42, # The exit code of the command.
531 }</pre>
532</div>
533
534<div class="method">
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]535 <code class="details" id="update">update(instanceName, hash, sizeBytes, body=None, resultsCachePolicy_priority=None, x__xgafv=None)</code>
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]536 <pre>Upload a new execution result.
537
538In order to allow the server to perform access control based on the type of
539action, and to assist with client debugging, the client MUST first upload
540the Action that produced the
541result, along with its
542Command, into the
543`ContentAddressableStorage`.
544
545Errors:
546
547* `INVALID_ARGUMENT`: One or more arguments are invalid.
548* `FAILED_PRECONDITION`: One or more errors occurred in updating the
549 action result, such as a missing command or action.
550* `RESOURCE_EXHAUSTED`: There is insufficient storage space to add the
551 entry to the cache.
552
553Args:
554 instanceName: string, The instance of the execution system to operate against. A server may
555support multiple instances of the execution system (with their own workers,
556storage, caches, etc.). The server MAY require use of this field to select
557between them in an implementation-defined fashion, otherwise it can be
558omitted. (required)
559 hash: string, The hash. In the case of SHA-256, it will always be a lowercase hex string
560exactly 64 characters long. (required)
561 sizeBytes: string, The size of the blob, in bytes. (required)
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]562 body: object, The request body.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]563 The object takes the form of:
564
565{ # An ActionResult represents the result of an
566 # Action being run.
567 "executionMetadata": { # ExecutedActionMetadata contains details about a completed execution. # The details of the execution that originally produced this result.
568 "outputUploadStartTimestamp": "A String", # When the worker started uploading action outputs.
569 "workerCompletedTimestamp": "A String", # When the worker completed the action, including all stages.
570 "queuedTimestamp": "A String", # When was the action added to the queue.
571 "worker": "A String", # The name of the worker which ran the execution.
572 "executionStartTimestamp": "A String", # When the worker started executing the action command.
573 "inputFetchStartTimestamp": "A String", # When the worker started fetching action inputs.
574 "workerStartTimestamp": "A String", # When the worker received the action.
575 "outputUploadCompletedTimestamp": "A String", # When the worker finished uploading action outputs.
576 "executionCompletedTimestamp": "A String", # When the worker completed executing the action command.
577 "inputFetchCompletedTimestamp": "A String", # When the worker finished fetching action inputs.
578 },
579 "outputFileSymlinks": [ # The output files of the action that are symbolic links to other files. Those
580 # may be links to other output files, or input files, or even absolute paths
581 # outside of the working directory, if the server supports
582 # SymlinkAbsolutePathStrategy.ALLOWED.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]583 # For each output file requested in the `output_files` or `output_paths`
584 # field of the Action, if the corresponding file existed after
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]585 # the action completed, a single entry will be present either in this field,
586 # or in the `output_files` field, if the file was not a symbolic link.
587 #
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]588 # If an output symbolic link of the same name as listed in `output_files` of
589 # the Command was found, but its target type was not a regular file, the
590 # server will return a FAILED_PRECONDITION.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]591 # If the action does not produce the requested output, then that output
592 # will be omitted from the list. The server is free to arrange the output
593 # list as desired; clients MUST NOT assume that the output list is sorted.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]594 #
595 # DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
596 # should still populate this field in addition to `output_symlinks`.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]597 { # An `OutputSymlink` is similar to a
598 # Symlink, but it is used as an
599 # output in an `ActionResult`.
600 #
601 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
602 "path": "A String", # The full path of the symlink relative to the working directory, including the
603 # filename. The path separator is a forward slash `/`. Since this is a
604 # relative path, it MUST NOT begin with a leading forward slash.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]605 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
606 # Action.
607 { # A single property for FileNodes,
608 # DirectoryNodes, and
609 # SymlinkNodes. The server is
610 # responsible for specifying the property `name`s that it accepts. If
611 # permitted by the server, the same `name` may occur multiple times.
612 "name": "A String", # The property name.
613 "value": "A String", # The property value.
614 },
615 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]616 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
617 # The target path can be relative to the parent directory of the symlink or
618 # it can be an absolute path starting with `/`. Support for absolute paths
619 # can be checked using the Capabilities
620 # API. The canonical form forbids the substrings `/./` and `//` in the target
621 # path. `..` components are allowed anywhere in the target path.
622 },
623 ],
624 "stderrDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest for a blob containing the standard error of the action, which
625 # can be retrieved from the
626 # ContentAddressableStorage.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]627 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]628 #
629 # The size is considered to be an integral part of the digest and cannot be
630 # separated. That is, even if the `hash` field is correctly specified but
631 # `size_bytes` is not, the server MUST reject the request.
632 #
633 # The reason for including the size in the digest is as follows: in a great
634 # many cases, the server needs to know the size of the blob it is about to work
635 # with prior to starting an operation with it, such as flattening Merkle tree
636 # structures or streaming it to a worker. Technically, the server could
637 # implement a separate metadata store, but this results in a significantly more
638 # complicated implementation as opposed to having the client specify the size
639 # up-front (or storing the size along with the digest in every message where
640 # digests are embedded). This does mean that the API leaks some implementation
641 # details of (what we consider to be) a reasonable server implementation, but
642 # we consider this to be a worthwhile tradeoff.
643 #
644 # When a `Digest` is used to refer to a proto message, it always refers to the
645 # message in binary encoded form. To ensure consistent hashing, clients and
646 # servers MUST ensure that they serialize messages according to the following
647 # rules, even if there are alternate valid encodings for the same message:
648 #
649 # * Fields are serialized in tag order.
650 # * There are no unknown fields.
651 # * There are no duplicate fields.
652 # * Fields are serialized according to the default semantics for their type.
653 #
654 # Most protocol buffer implementations will always follow these rules when
655 # serializing, but care should be taken to avoid shortcuts. For instance,
656 # concatenating two messages to merge them may produce duplicate fields.
657 "sizeBytes": "A String", # The size of the blob, in bytes.
658 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
659 # exactly 64 characters long.
660 },
661 "stdoutRaw": "A String", # The standard output buffer of the action. The server SHOULD NOT inline
662 # stdout unless requested by the client in the
663 # GetActionResultRequest
664 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
665 # would cause the response to exceed message size limits.
666 "stderrRaw": "A String", # The standard error buffer of the action. The server SHOULD NOT inline
667 # stderr unless requested by the client in the
668 # GetActionResultRequest
669 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
670 # would cause the response to exceed message size limits.
671 "stdoutDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest for a blob containing the standard output of the action, which
672 # can be retrieved from the
673 # ContentAddressableStorage.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]674 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]675 #
676 # The size is considered to be an integral part of the digest and cannot be
677 # separated. That is, even if the `hash` field is correctly specified but
678 # `size_bytes` is not, the server MUST reject the request.
679 #
680 # The reason for including the size in the digest is as follows: in a great
681 # many cases, the server needs to know the size of the blob it is about to work
682 # with prior to starting an operation with it, such as flattening Merkle tree
683 # structures or streaming it to a worker. Technically, the server could
684 # implement a separate metadata store, but this results in a significantly more
685 # complicated implementation as opposed to having the client specify the size
686 # up-front (or storing the size along with the digest in every message where
687 # digests are embedded). This does mean that the API leaks some implementation
688 # details of (what we consider to be) a reasonable server implementation, but
689 # we consider this to be a worthwhile tradeoff.
690 #
691 # When a `Digest` is used to refer to a proto message, it always refers to the
692 # message in binary encoded form. To ensure consistent hashing, clients and
693 # servers MUST ensure that they serialize messages according to the following
694 # rules, even if there are alternate valid encodings for the same message:
695 #
696 # * Fields are serialized in tag order.
697 # * There are no unknown fields.
698 # * There are no duplicate fields.
699 # * Fields are serialized according to the default semantics for their type.
700 #
701 # Most protocol buffer implementations will always follow these rules when
702 # serializing, but care should be taken to avoid shortcuts. For instance,
703 # concatenating two messages to merge them may produce duplicate fields.
704 "sizeBytes": "A String", # The size of the blob, in bytes.
705 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
706 # exactly 64 characters long.
707 },
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]708 "outputSymlinks": [ # New in v2.1: this field will only be populated if the command
709 # `output_paths` field was used, and not the pre v2.1 `output_files` or
710 # `output_directories` fields.
711 # The output paths of the action that are symbolic links to other paths. Those
712 # may be links to other outputs, or inputs, or even absolute paths
713 # outside of the working directory, if the server supports
714 # SymlinkAbsolutePathStrategy.ALLOWED.
715 # A single entry for each output requested in `output_paths`
716 # field of the Action, if the corresponding path existed after
717 # the action completed and was a symbolic link.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]718 #
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]719 # If the action does not produce a requested output, then that output
720 # will be omitted from the list. The server is free to arrange the output
721 # list as desired; clients MUST NOT assume that the output list is sorted.
722 { # An `OutputSymlink` is similar to a
723 # Symlink, but it is used as an
724 # output in an `ActionResult`.
725 #
726 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
727 "path": "A String", # The full path of the symlink relative to the working directory, including the
728 # filename. The path separator is a forward slash `/`. Since this is a
729 # relative path, it MUST NOT begin with a leading forward slash.
730 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
731 # Action.
732 { # A single property for FileNodes,
733 # DirectoryNodes, and
734 # SymlinkNodes. The server is
735 # responsible for specifying the property `name`s that it accepts. If
736 # permitted by the server, the same `name` may occur multiple times.
737 "name": "A String", # The property name.
738 "value": "A String", # The property value.
739 },
740 ],
741 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
742 # The target path can be relative to the parent directory of the symlink or
743 # it can be an absolute path starting with `/`. Support for absolute paths
744 # can be checked using the Capabilities
745 # API. The canonical form forbids the substrings `/./` and `//` in the target
746 # path. `..` components are allowed anywhere in the target path.
747 },
748 ],
749 "outputFiles": [ # The output files of the action. For each output file requested in the
750 # `output_files` or `output_paths` field of the Action, if the corresponding
751 # file existed after the action completed, a single entry will be present
752 # either in this field, or the `output_file_symlinks` field if the file was
753 # a symbolic link to another file (`output_symlinks` field after v2.1).
754 #
755 # If an output listed in `output_files` was found, but was a directory rather
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]756 # than a regular file, the server will return a FAILED_PRECONDITION.
757 # If the action does not produce the requested output, then that output
758 # will be omitted from the list. The server is free to arrange the output
759 # list as desired; clients MUST NOT assume that the output list is sorted.
760 { # An `OutputFile` is similar to a
761 # FileNode, but it is used as an
762 # output in an `ActionResult`. It allows a full file path rather than
763 # only a name.
764 "path": "A String", # The full path of the file relative to the working directory, including the
765 # filename. The path separator is a forward slash `/`. Since this is a
766 # relative path, it MUST NOT begin with a leading forward slash.
767 "isExecutable": True or False, # True if file is executable, false otherwise.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]768 "nodeProperties": [ # The supported node properties of the OutputFile, if requested by the Action.
769 { # A single property for FileNodes,
770 # DirectoryNodes, and
771 # SymlinkNodes. The server is
772 # responsible for specifying the property `name`s that it accepts. If
773 # permitted by the server, the same `name` may occur multiple times.
774 "name": "A String", # The property name.
775 "value": "A String", # The property value.
776 },
777 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]778 "digest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest of the file's content.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]779 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]780 #
781 # The size is considered to be an integral part of the digest and cannot be
782 # separated. That is, even if the `hash` field is correctly specified but
783 # `size_bytes` is not, the server MUST reject the request.
784 #
785 # The reason for including the size in the digest is as follows: in a great
786 # many cases, the server needs to know the size of the blob it is about to work
787 # with prior to starting an operation with it, such as flattening Merkle tree
788 # structures or streaming it to a worker. Technically, the server could
789 # implement a separate metadata store, but this results in a significantly more
790 # complicated implementation as opposed to having the client specify the size
791 # up-front (or storing the size along with the digest in every message where
792 # digests are embedded). This does mean that the API leaks some implementation
793 # details of (what we consider to be) a reasonable server implementation, but
794 # we consider this to be a worthwhile tradeoff.
795 #
796 # When a `Digest` is used to refer to a proto message, it always refers to the
797 # message in binary encoded form. To ensure consistent hashing, clients and
798 # servers MUST ensure that they serialize messages according to the following
799 # rules, even if there are alternate valid encodings for the same message:
800 #
801 # * Fields are serialized in tag order.
802 # * There are no unknown fields.
803 # * There are no duplicate fields.
804 # * Fields are serialized according to the default semantics for their type.
805 #
806 # Most protocol buffer implementations will always follow these rules when
807 # serializing, but care should be taken to avoid shortcuts. For instance,
808 # concatenating two messages to merge them may produce duplicate fields.
809 "sizeBytes": "A String", # The size of the blob, in bytes.
810 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
811 # exactly 64 characters long.
812 },
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]813 "contents": "A String", # The contents of the file if inlining was requested. The server SHOULD NOT inline
814 # file contents unless requested by the client in the
815 # GetActionResultRequest
816 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
817 # would cause the response to exceed message size limits.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]818 },
819 ],
820 "outputDirectorySymlinks": [ # The output directories of the action that are symbolic links to other
821 # directories. Those may be links to other output directories, or input
822 # directories, or even absolute paths outside of the working directory,
823 # if the server supports
824 # SymlinkAbsolutePathStrategy.ALLOWED.
825 # For each output directory requested in the `output_directories` field of
826 # the Action, if the directory existed after the action completed, a
827 # single entry will be present either in this field, or in the
828 # `output_directories` field, if the directory was not a symbolic link.
829 #
830 # If an output of the same name was found, but was a symbolic link to a file
831 # instead of a directory, the server will return a FAILED_PRECONDITION.
832 # If the action does not produce the requested output, then that output
833 # will be omitted from the list. The server is free to arrange the output
834 # list as desired; clients MUST NOT assume that the output list is sorted.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]835 #
836 # DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
837 # should still populate this field in addition to `output_symlinks`.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]838 { # An `OutputSymlink` is similar to a
839 # Symlink, but it is used as an
840 # output in an `ActionResult`.
841 #
842 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
843 "path": "A String", # The full path of the symlink relative to the working directory, including the
844 # filename. The path separator is a forward slash `/`. Since this is a
845 # relative path, it MUST NOT begin with a leading forward slash.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]846 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
847 # Action.
848 { # A single property for FileNodes,
849 # DirectoryNodes, and
850 # SymlinkNodes. The server is
851 # responsible for specifying the property `name`s that it accepts. If
852 # permitted by the server, the same `name` may occur multiple times.
853 "name": "A String", # The property name.
854 "value": "A String", # The property value.
855 },
856 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]857 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
858 # The target path can be relative to the parent directory of the symlink or
859 # it can be an absolute path starting with `/`. Support for absolute paths
860 # can be checked using the Capabilities
861 # API. The canonical form forbids the substrings `/./` and `//` in the target
862 # path. `..` components are allowed anywhere in the target path.
863 },
864 ],
865 "outputDirectories": [ # The output directories of the action. For each output directory requested
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]866 # in the `output_directories` or `output_paths` field of the Action, if the
867 # corresponding directory existed after the action completed, a single entry
868 # will be present in the output list, which will contain the digest of a
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]869 # Tree message containing the
870 # directory tree, and the path equal exactly to the corresponding Action
871 # output_directories member.
872 #
873 # As an example, suppose the Action had an output directory `a/b/dir` and the
874 # execution produced the following contents in `a/b/dir`: a file named `bar`
875 # and a directory named `foo` with an executable file named `baz`. Then,
876 # output_directory will contain (hashes shortened for readability):
877 #
878 # ```json
879 # // OutputDirectory proto:
880 # {
881 # path: "a/b/dir"
882 # tree_digest: {
883 # hash: "4a73bc9d03...",
884 # size: 55
885 # }
886 # }
887 # // Tree proto with hash "4a73bc9d03..." and size 55:
888 # {
889 # root: {
890 # files: [
891 # {
892 # name: "bar",
893 # digest: {
894 # hash: "4a73bc9d03...",
895 # size: 65534
896 # }
897 # }
898 # ],
899 # directories: [
900 # {
901 # name: "foo",
902 # digest: {
903 # hash: "4cf2eda940...",
904 # size: 43
905 # }
906 # }
907 # ]
908 # }
909 # children : {
910 # // (Directory proto with hash "4cf2eda940..." and size 43)
911 # files: [
912 # {
913 # name: "baz",
914 # digest: {
915 # hash: "b2c941073e...",
916 # size: 1294,
917 # },
918 # is_executable: true
919 # }
920 # ]
921 # }
922 # }
923 # ```
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]924 # If an output of the same name as listed in `output_files` of
925 # the Command was found in `output_directories`, but was not a directory, the
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]926 # server will return a FAILED_PRECONDITION.
927 { # An `OutputDirectory` is the output in an `ActionResult` corresponding to a
928 # directory's full contents rather than a single file.
929 "path": "A String", # The full path of the directory relative to the working directory. The path
930 # separator is a forward slash `/`. Since this is a relative path, it MUST
931 # NOT begin with a leading forward slash. The empty string value is allowed,
932 # and it denotes the entire working directory.
933 "treeDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest of the encoded
934 # Tree proto containing the
935 # directory's contents.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]936 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]937 #
938 # The size is considered to be an integral part of the digest and cannot be
939 # separated. That is, even if the `hash` field is correctly specified but
940 # `size_bytes` is not, the server MUST reject the request.
941 #
942 # The reason for including the size in the digest is as follows: in a great
943 # many cases, the server needs to know the size of the blob it is about to work
944 # with prior to starting an operation with it, such as flattening Merkle tree
945 # structures or streaming it to a worker. Technically, the server could
946 # implement a separate metadata store, but this results in a significantly more
947 # complicated implementation as opposed to having the client specify the size
948 # up-front (or storing the size along with the digest in every message where
949 # digests are embedded). This does mean that the API leaks some implementation
950 # details of (what we consider to be) a reasonable server implementation, but
951 # we consider this to be a worthwhile tradeoff.
952 #
953 # When a `Digest` is used to refer to a proto message, it always refers to the
954 # message in binary encoded form. To ensure consistent hashing, clients and
955 # servers MUST ensure that they serialize messages according to the following
956 # rules, even if there are alternate valid encodings for the same message:
957 #
958 # * Fields are serialized in tag order.
959 # * There are no unknown fields.
960 # * There are no duplicate fields.
961 # * Fields are serialized according to the default semantics for their type.
962 #
963 # Most protocol buffer implementations will always follow these rules when
964 # serializing, but care should be taken to avoid shortcuts. For instance,
965 # concatenating two messages to merge them may produce duplicate fields.
966 "sizeBytes": "A String", # The size of the blob, in bytes.
967 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
968 # exactly 64 characters long.
969 },
970 },
971 ],
972 "exitCode": 42, # The exit code of the command.
973 }
974
975 resultsCachePolicy_priority: integer, The priority (relative importance) of this content in the overall cache.
976Generally, a lower value means a longer retention time or other advantage,
977but the interpretation of a given value is server-dependent. A priority of
9780 means a *default* value, decided by the server.
979
980The particular semantics of this field is up to the server. In particular,
981every server will have their own supported range of priorities, and will
982decide how these map into retention/eviction policy.
983 x__xgafv: string, V1 error format.
984 Allowed values
985 1 - v1 error format
986 2 - v2 error format
987
988Returns:
989 An object of the form:
990
991 { # An ActionResult represents the result of an
992 # Action being run.
993 "executionMetadata": { # ExecutedActionMetadata contains details about a completed execution. # The details of the execution that originally produced this result.
994 "outputUploadStartTimestamp": "A String", # When the worker started uploading action outputs.
995 "workerCompletedTimestamp": "A String", # When the worker completed the action, including all stages.
996 "queuedTimestamp": "A String", # When was the action added to the queue.
997 "worker": "A String", # The name of the worker which ran the execution.
998 "executionStartTimestamp": "A String", # When the worker started executing the action command.
999 "inputFetchStartTimestamp": "A String", # When the worker started fetching action inputs.
1000 "workerStartTimestamp": "A String", # When the worker received the action.
1001 "outputUploadCompletedTimestamp": "A String", # When the worker finished uploading action outputs.
1002 "executionCompletedTimestamp": "A String", # When the worker completed executing the action command.
1003 "inputFetchCompletedTimestamp": "A String", # When the worker finished fetching action inputs.
1004 },
1005 "outputFileSymlinks": [ # The output files of the action that are symbolic links to other files. Those
1006 # may be links to other output files, or input files, or even absolute paths
1007 # outside of the working directory, if the server supports
1008 # SymlinkAbsolutePathStrategy.ALLOWED.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1009 # For each output file requested in the `output_files` or `output_paths`
1010 # field of the Action, if the corresponding file existed after
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1011 # the action completed, a single entry will be present either in this field,
1012 # or in the `output_files` field, if the file was not a symbolic link.
1013 #
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1014 # If an output symbolic link of the same name as listed in `output_files` of
1015 # the Command was found, but its target type was not a regular file, the
1016 # server will return a FAILED_PRECONDITION.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1017 # If the action does not produce the requested output, then that output
1018 # will be omitted from the list. The server is free to arrange the output
1019 # list as desired; clients MUST NOT assume that the output list is sorted.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1020 #
1021 # DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
1022 # should still populate this field in addition to `output_symlinks`.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1023 { # An `OutputSymlink` is similar to a
1024 # Symlink, but it is used as an
1025 # output in an `ActionResult`.
1026 #
1027 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
1028 "path": "A String", # The full path of the symlink relative to the working directory, including the
1029 # filename. The path separator is a forward slash `/`. Since this is a
1030 # relative path, it MUST NOT begin with a leading forward slash.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1031 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
1032 # Action.
1033 { # A single property for FileNodes,
1034 # DirectoryNodes, and
1035 # SymlinkNodes. The server is
1036 # responsible for specifying the property `name`s that it accepts. If
1037 # permitted by the server, the same `name` may occur multiple times.
1038 "name": "A String", # The property name.
1039 "value": "A String", # The property value.
1040 },
1041 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1042 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
1043 # The target path can be relative to the parent directory of the symlink or
1044 # it can be an absolute path starting with `/`. Support for absolute paths
1045 # can be checked using the Capabilities
1046 # API. The canonical form forbids the substrings `/./` and `//` in the target
1047 # path. `..` components are allowed anywhere in the target path.
1048 },
1049 ],
1050 "stderrDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest for a blob containing the standard error of the action, which
1051 # can be retrieved from the
1052 # ContentAddressableStorage.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1053 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1054 #
1055 # The size is considered to be an integral part of the digest and cannot be
1056 # separated. That is, even if the `hash` field is correctly specified but
1057 # `size_bytes` is not, the server MUST reject the request.
1058 #
1059 # The reason for including the size in the digest is as follows: in a great
1060 # many cases, the server needs to know the size of the blob it is about to work
1061 # with prior to starting an operation with it, such as flattening Merkle tree
1062 # structures or streaming it to a worker. Technically, the server could
1063 # implement a separate metadata store, but this results in a significantly more
1064 # complicated implementation as opposed to having the client specify the size
1065 # up-front (or storing the size along with the digest in every message where
1066 # digests are embedded). This does mean that the API leaks some implementation
1067 # details of (what we consider to be) a reasonable server implementation, but
1068 # we consider this to be a worthwhile tradeoff.
1069 #
1070 # When a `Digest` is used to refer to a proto message, it always refers to the
1071 # message in binary encoded form. To ensure consistent hashing, clients and
1072 # servers MUST ensure that they serialize messages according to the following
1073 # rules, even if there are alternate valid encodings for the same message:
1074 #
1075 # * Fields are serialized in tag order.
1076 # * There are no unknown fields.
1077 # * There are no duplicate fields.
1078 # * Fields are serialized according to the default semantics for their type.
1079 #
1080 # Most protocol buffer implementations will always follow these rules when
1081 # serializing, but care should be taken to avoid shortcuts. For instance,
1082 # concatenating two messages to merge them may produce duplicate fields.
1083 "sizeBytes": "A String", # The size of the blob, in bytes.
1084 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
1085 # exactly 64 characters long.
1086 },
1087 "stdoutRaw": "A String", # The standard output buffer of the action. The server SHOULD NOT inline
1088 # stdout unless requested by the client in the
1089 # GetActionResultRequest
1090 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
1091 # would cause the response to exceed message size limits.
1092 "stderrRaw": "A String", # The standard error buffer of the action. The server SHOULD NOT inline
1093 # stderr unless requested by the client in the
1094 # GetActionResultRequest
1095 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
1096 # would cause the response to exceed message size limits.
1097 "stdoutDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest for a blob containing the standard output of the action, which
1098 # can be retrieved from the
1099 # ContentAddressableStorage.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1100 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1101 #
1102 # The size is considered to be an integral part of the digest and cannot be
1103 # separated. That is, even if the `hash` field is correctly specified but
1104 # `size_bytes` is not, the server MUST reject the request.
1105 #
1106 # The reason for including the size in the digest is as follows: in a great
1107 # many cases, the server needs to know the size of the blob it is about to work
1108 # with prior to starting an operation with it, such as flattening Merkle tree
1109 # structures or streaming it to a worker. Technically, the server could
1110 # implement a separate metadata store, but this results in a significantly more
1111 # complicated implementation as opposed to having the client specify the size
1112 # up-front (or storing the size along with the digest in every message where
1113 # digests are embedded). This does mean that the API leaks some implementation
1114 # details of (what we consider to be) a reasonable server implementation, but
1115 # we consider this to be a worthwhile tradeoff.
1116 #
1117 # When a `Digest` is used to refer to a proto message, it always refers to the
1118 # message in binary encoded form. To ensure consistent hashing, clients and
1119 # servers MUST ensure that they serialize messages according to the following
1120 # rules, even if there are alternate valid encodings for the same message:
1121 #
1122 # * Fields are serialized in tag order.
1123 # * There are no unknown fields.
1124 # * There are no duplicate fields.
1125 # * Fields are serialized according to the default semantics for their type.
1126 #
1127 # Most protocol buffer implementations will always follow these rules when
1128 # serializing, but care should be taken to avoid shortcuts. For instance,
1129 # concatenating two messages to merge them may produce duplicate fields.
1130 "sizeBytes": "A String", # The size of the blob, in bytes.
1131 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
1132 # exactly 64 characters long.
1133 },
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1134 "outputSymlinks": [ # New in v2.1: this field will only be populated if the command
1135 # `output_paths` field was used, and not the pre v2.1 `output_files` or
1136 # `output_directories` fields.
1137 # The output paths of the action that are symbolic links to other paths. Those
1138 # may be links to other outputs, or inputs, or even absolute paths
1139 # outside of the working directory, if the server supports
1140 # SymlinkAbsolutePathStrategy.ALLOWED.
1141 # A single entry for each output requested in `output_paths`
1142 # field of the Action, if the corresponding path existed after
1143 # the action completed and was a symbolic link.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1144 #
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1145 # If the action does not produce a requested output, then that output
1146 # will be omitted from the list. The server is free to arrange the output
1147 # list as desired; clients MUST NOT assume that the output list is sorted.
1148 { # An `OutputSymlink` is similar to a
1149 # Symlink, but it is used as an
1150 # output in an `ActionResult`.
1151 #
1152 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
1153 "path": "A String", # The full path of the symlink relative to the working directory, including the
1154 # filename. The path separator is a forward slash `/`. Since this is a
1155 # relative path, it MUST NOT begin with a leading forward slash.
1156 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
1157 # Action.
1158 { # A single property for FileNodes,
1159 # DirectoryNodes, and
1160 # SymlinkNodes. The server is
1161 # responsible for specifying the property `name`s that it accepts. If
1162 # permitted by the server, the same `name` may occur multiple times.
1163 "name": "A String", # The property name.
1164 "value": "A String", # The property value.
1165 },
1166 ],
1167 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
1168 # The target path can be relative to the parent directory of the symlink or
1169 # it can be an absolute path starting with `/`. Support for absolute paths
1170 # can be checked using the Capabilities
1171 # API. The canonical form forbids the substrings `/./` and `//` in the target
1172 # path. `..` components are allowed anywhere in the target path.
1173 },
1174 ],
1175 "outputFiles": [ # The output files of the action. For each output file requested in the
1176 # `output_files` or `output_paths` field of the Action, if the corresponding
1177 # file existed after the action completed, a single entry will be present
1178 # either in this field, or the `output_file_symlinks` field if the file was
1179 # a symbolic link to another file (`output_symlinks` field after v2.1).
1180 #
1181 # If an output listed in `output_files` was found, but was a directory rather
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1182 # than a regular file, the server will return a FAILED_PRECONDITION.
1183 # If the action does not produce the requested output, then that output
1184 # will be omitted from the list. The server is free to arrange the output
1185 # list as desired; clients MUST NOT assume that the output list is sorted.
1186 { # An `OutputFile` is similar to a
1187 # FileNode, but it is used as an
1188 # output in an `ActionResult`. It allows a full file path rather than
1189 # only a name.
1190 "path": "A String", # The full path of the file relative to the working directory, including the
1191 # filename. The path separator is a forward slash `/`. Since this is a
1192 # relative path, it MUST NOT begin with a leading forward slash.
1193 "isExecutable": True or False, # True if file is executable, false otherwise.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1194 "nodeProperties": [ # The supported node properties of the OutputFile, if requested by the Action.
1195 { # A single property for FileNodes,
1196 # DirectoryNodes, and
1197 # SymlinkNodes. The server is
1198 # responsible for specifying the property `name`s that it accepts. If
1199 # permitted by the server, the same `name` may occur multiple times.
1200 "name": "A String", # The property name.
1201 "value": "A String", # The property value.
1202 },
1203 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1204 "digest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest of the file's content.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1205 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1206 #
1207 # The size is considered to be an integral part of the digest and cannot be
1208 # separated. That is, even if the `hash` field is correctly specified but
1209 # `size_bytes` is not, the server MUST reject the request.
1210 #
1211 # The reason for including the size in the digest is as follows: in a great
1212 # many cases, the server needs to know the size of the blob it is about to work
1213 # with prior to starting an operation with it, such as flattening Merkle tree
1214 # structures or streaming it to a worker. Technically, the server could
1215 # implement a separate metadata store, but this results in a significantly more
1216 # complicated implementation as opposed to having the client specify the size
1217 # up-front (or storing the size along with the digest in every message where
1218 # digests are embedded). This does mean that the API leaks some implementation
1219 # details of (what we consider to be) a reasonable server implementation, but
1220 # we consider this to be a worthwhile tradeoff.
1221 #
1222 # When a `Digest` is used to refer to a proto message, it always refers to the
1223 # message in binary encoded form. To ensure consistent hashing, clients and
1224 # servers MUST ensure that they serialize messages according to the following
1225 # rules, even if there are alternate valid encodings for the same message:
1226 #
1227 # * Fields are serialized in tag order.
1228 # * There are no unknown fields.
1229 # * There are no duplicate fields.
1230 # * Fields are serialized according to the default semantics for their type.
1231 #
1232 # Most protocol buffer implementations will always follow these rules when
1233 # serializing, but care should be taken to avoid shortcuts. For instance,
1234 # concatenating two messages to merge them may produce duplicate fields.
1235 "sizeBytes": "A String", # The size of the blob, in bytes.
1236 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
1237 # exactly 64 characters long.
1238 },
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1239 "contents": "A String", # The contents of the file if inlining was requested. The server SHOULD NOT inline
1240 # file contents unless requested by the client in the
1241 # GetActionResultRequest
1242 # message. The server MAY omit inlining, even if requested, and MUST do so if inlining
1243 # would cause the response to exceed message size limits.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1244 },
1245 ],
1246 "outputDirectorySymlinks": [ # The output directories of the action that are symbolic links to other
1247 # directories. Those may be links to other output directories, or input
1248 # directories, or even absolute paths outside of the working directory,
1249 # if the server supports
1250 # SymlinkAbsolutePathStrategy.ALLOWED.
1251 # For each output directory requested in the `output_directories` field of
1252 # the Action, if the directory existed after the action completed, a
1253 # single entry will be present either in this field, or in the
1254 # `output_directories` field, if the directory was not a symbolic link.
1255 #
1256 # If an output of the same name was found, but was a symbolic link to a file
1257 # instead of a directory, the server will return a FAILED_PRECONDITION.
1258 # If the action does not produce the requested output, then that output
1259 # will be omitted from the list. The server is free to arrange the output
1260 # list as desired; clients MUST NOT assume that the output list is sorted.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1261 #
1262 # DEPRECATED as of v2.1. Servers that wish to be compatible with v2.0 API
1263 # should still populate this field in addition to `output_symlinks`.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1264 { # An `OutputSymlink` is similar to a
1265 # Symlink, but it is used as an
1266 # output in an `ActionResult`.
1267 #
1268 # `OutputSymlink` is binary-compatible with `SymlinkNode`.
1269 "path": "A String", # The full path of the symlink relative to the working directory, including the
1270 # filename. The path separator is a forward slash `/`. Since this is a
1271 # relative path, it MUST NOT begin with a leading forward slash.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1272 "nodeProperties": [ # The supported node properties of the OutputSymlink, if requested by the
1273 # Action.
1274 { # A single property for FileNodes,
1275 # DirectoryNodes, and
1276 # SymlinkNodes. The server is
1277 # responsible for specifying the property `name`s that it accepts. If
1278 # permitted by the server, the same `name` may occur multiple times.
1279 "name": "A String", # The property name.
1280 "value": "A String", # The property value.
1281 },
1282 ],
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1283 "target": "A String", # The target path of the symlink. The path separator is a forward slash `/`.
1284 # The target path can be relative to the parent directory of the symlink or
1285 # it can be an absolute path starting with `/`. Support for absolute paths
1286 # can be checked using the Capabilities
1287 # API. The canonical form forbids the substrings `/./` and `//` in the target
1288 # path. `..` components are allowed anywhere in the target path.
1289 },
1290 ],
1291 "outputDirectories": [ # The output directories of the action. For each output directory requested
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1292 # in the `output_directories` or `output_paths` field of the Action, if the
1293 # corresponding directory existed after the action completed, a single entry
1294 # will be present in the output list, which will contain the digest of a
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1295 # Tree message containing the
1296 # directory tree, and the path equal exactly to the corresponding Action
1297 # output_directories member.
1298 #
1299 # As an example, suppose the Action had an output directory `a/b/dir` and the
1300 # execution produced the following contents in `a/b/dir`: a file named `bar`
1301 # and a directory named `foo` with an executable file named `baz`. Then,
1302 # output_directory will contain (hashes shortened for readability):
1303 #
1304 # ```json
1305 # // OutputDirectory proto:
1306 # {
1307 # path: "a/b/dir"
1308 # tree_digest: {
1309 # hash: "4a73bc9d03...",
1310 # size: 55
1311 # }
1312 # }
1313 # // Tree proto with hash "4a73bc9d03..." and size 55:
1314 # {
1315 # root: {
1316 # files: [
1317 # {
1318 # name: "bar",
1319 # digest: {
1320 # hash: "4a73bc9d03...",
1321 # size: 65534
1322 # }
1323 # }
1324 # ],
1325 # directories: [
1326 # {
1327 # name: "foo",
1328 # digest: {
1329 # hash: "4cf2eda940...",
1330 # size: 43
1331 # }
1332 # }
1333 # ]
1334 # }
1335 # children : {
1336 # // (Directory proto with hash "4cf2eda940..." and size 43)
1337 # files: [
1338 # {
1339 # name: "baz",
1340 # digest: {
1341 # hash: "b2c941073e...",
1342 # size: 1294,
1343 # },
1344 # is_executable: true
1345 # }
1346 # ]
1347 # }
1348 # }
1349 # ```
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1350 # If an output of the same name as listed in `output_files` of
1351 # the Command was found in `output_directories`, but was not a directory, the
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1352 # server will return a FAILED_PRECONDITION.
1353 { # An `OutputDirectory` is the output in an `ActionResult` corresponding to a
1354 # directory's full contents rather than a single file.
1355 "path": "A String", # The full path of the directory relative to the working directory. The path
1356 # separator is a forward slash `/`. Since this is a relative path, it MUST
1357 # NOT begin with a leading forward slash. The empty string value is allowed,
1358 # and it denotes the entire working directory.
1359 "treeDigest": { # A content digest. A digest for a given blob consists of the size of the blob # The digest of the encoded
1360 # Tree proto containing the
1361 # directory's contents.
Dan O'Mearadd494642020-05-01 07:42:23 -0700[diff] [blame^]1362 # and its hash. The hash algorithm to use is defined by the server.
Bu Sun Kim715bd7f2019-06-14 16:50:42 -0700[diff] [blame]1363 #
1364 # The size is considered to be an integral part of the digest and cannot be
1365 # separated. That is, even if the `hash` field is correctly specified but
1366 # `size_bytes` is not, the server MUST reject the request.
1367 #
1368 # The reason for including the size in the digest is as follows: in a great
1369 # many cases, the server needs to know the size of the blob it is about to work
1370 # with prior to starting an operation with it, such as flattening Merkle tree
1371 # structures or streaming it to a worker. Technically, the server could
1372 # implement a separate metadata store, but this results in a significantly more
1373 # complicated implementation as opposed to having the client specify the size
1374 # up-front (or storing the size along with the digest in every message where
1375 # digests are embedded). This does mean that the API leaks some implementation
1376 # details of (what we consider to be) a reasonable server implementation, but
1377 # we consider this to be a worthwhile tradeoff.
1378 #
1379 # When a `Digest` is used to refer to a proto message, it always refers to the
1380 # message in binary encoded form. To ensure consistent hashing, clients and
1381 # servers MUST ensure that they serialize messages according to the following
1382 # rules, even if there are alternate valid encodings for the same message:
1383 #
1384 # * Fields are serialized in tag order.
1385 # * There are no unknown fields.
1386 # * There are no duplicate fields.
1387 # * Fields are serialized according to the default semantics for their type.
1388 #
1389 # Most protocol buffer implementations will always follow these rules when
1390 # serializing, but care should be taken to avoid shortcuts. For instance,
1391 # concatenating two messages to merge them may produce duplicate fields.
1392 "sizeBytes": "A String", # The size of the blob, in bytes.
1393 "hash": "A String", # The hash. In the case of SHA-256, it will always be a lowercase hex string
1394 # exactly 64 characters long.
1395 },
1396 },
1397 ],
1398 "exitCode": 42, # The exit code of the command.
1399 }</pre>
1400</div>
1401
1402</body></html>