Blame - docs/dyn/remotebuildexecution_v2.actionResults.html - platform/external/python/google-api-python-client

<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

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

Dan O'Meara

dd49464

2020-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 Kim

715bd7f

2019-06-14 16:50:42 -0700

[diff] [blame]

82

<p class="firstline">Upload a new execution result.</p>

83

<h3>Method Details</h3>

84

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

88

Implementations SHOULD ensure that any blobs referenced from the

89

ContentAddressableStorage

90

are available at the time of returning the

91

ActionResult and will be

92

for some period of time afterwards. The TTLs of the referenced blobs SHOULD be increased

93

if necessary and applicable.

Errors:

* `NOT_FOUND`: The requested `ActionResult` is not in the cache.

98

99

Args:

100

instanceName: string, The instance of the execution system to operate against. A server may

101

support multiple instances of the execution system (with their own workers,

102

storage, caches, etc.). The server MAY require use of this field to select

103

between them in an implementation-defined fashion, otherwise it can be

104

omitted. (required)

105

hash: string, The hash. In the case of SHA-256, it will always be a lowercase hex string

106

exactly 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

109

ActionResult message.

110

inlineOutputFiles: string, A hint to the server to inline the contents of the listed output files.

111

Each path needs to exactly match one path in `output_files` in the

112

Command message. (repeated)

113

inlineStderr: boolean, A hint to the server to request inlining stderr in the

114

ActionResult message.

115

x__xgafv: string, V1 error format.

Allowed values

1 - v1 error format

2 - v2 error format

Returns:

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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

185

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

232

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-06-14 16:50:42 -0700

[diff] [blame]

276

#

Dan O'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

337

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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:

# {

# 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...",

474

# size: 1294,

475

# },

476

# is_executable: true

# }

# ]

# }

# }

# ```

Dan O'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

494

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

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

},

},

],

"exitCode": 42, # The exit code of the command.

}</pre>

</div>

Dan O'Meara

2020-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 Kim

715bd7f

2019-06-14 16:50:42 -0700

[diff] [blame]

536

<pre>Upload a new execution result.

537

538

In order to allow the server to perform access control based on the type of

539

action, and to assist with client debugging, the client MUST first upload

540

the Action that produced the

541

result, along with its

542

Command, into the

543

`ContentAddressableStorage`.

Errors:

* `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

entry to the cache.

Args:

instanceName: string, The instance of the execution system to operate against. A server may

555

support multiple instances of the execution system (with their own workers,

556

storage, caches, etc.). The server MAY require use of this field to select

557

between them in an implementation-defined fashion, otherwise it can be

558

omitted. (required)

559

hash: string, The hash. In the case of SHA-256, it will always be a lowercase hex string

560

exactly 64 characters long. (required)

561

sizeBytes: string, The size of the blob, in bytes. (required)

Dan O'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

562

body: object, The request body.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

627

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

674

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-06-14 16:50:42 -0700

[diff] [blame]

718

#

Dan O'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

779

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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:

# {

# 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...",

916

# size: 1294,

917

# },

918

# is_executable: true

# }

# ]

# }

# }

# ```

Dan O'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

936

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

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

},

},

],

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

976

Generally, a lower value means a longer retention time or other advantage,

977

but the interpretation of a given value is server-dependent. A priority of

978

0 means a *default* value, decided by the server.

979

980

The particular semantics of this field is up to the server. In particular,

981

every server will have their own supported range of priorities, and will

982

decide how these map into retention/eviction policy.

983

x__xgafv: string, V1 error format.

Allowed values

1 - v1 error format

2 - v2 error format

Returns:

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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

1053

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

1100

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-06-14 16:50:42 -0700

[diff] [blame]

1144

#

Dan O'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

1205

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-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 Kim

715bd7f

2019-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:

# {

# 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...",

1342

# size: 1294,

1343

# },

1344

# is_executable: true

# }

# ]

# }

# }

# ```

Dan O'Meara

dd49464

2020-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 Kim

715bd7f

2019-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'Meara

dd49464

2020-05-01 07:42:23 -0700

[diff] [blame]

1362

# and its hash. The hash algorithm to use is defined by the server.

Bu Sun Kim

715bd7f

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

},

},

],

"exitCode": 42, # The exit code of the command.

}</pre>

</div>

</body></html>