|  | // Copyright 2018 The Bazel Authors. All rights reserved. | 
|  | // | 
|  | // Licensed under the Apache License, Version 2.0 (the "License"); | 
|  | // you may not use this file except in compliance with the License. | 
|  | // You may obtain a copy of the License at | 
|  | // | 
|  | //    http://www.apache.org/licenses/LICENSE-2.0 | 
|  | // | 
|  | // Unless required by applicable law or agreed to in writing, software | 
|  | // distributed under the License is distributed on an "AS IS" BASIS, | 
|  | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | 
|  | // See the License for the specific language governing permissions and | 
|  | // limitations under the License. | 
|  |  | 
|  | syntax = "proto3"; | 
|  |  | 
|  | package tools.protos; | 
|  |  | 
|  | import "google/protobuf/duration.proto"; | 
|  | import "google/protobuf/timestamp.proto"; | 
|  |  | 
|  | option java_package = "com.google.devtools.build.lib.exec"; | 
|  | option java_outer_classname = "Protos"; | 
|  |  | 
|  | // This file defines the output formats emitted by the --execution_log_* flags. | 
|  | // The purpose of the execution log is to enable comparisons of multiple builds | 
|  | // to diagnose output differences or more subtle problems such as remote cache | 
|  | // misses. | 
|  |  | 
|  | // Digest of a file or action cache entry. | 
|  | message Digest { | 
|  | // The content hash as a lowercase hex string including any leading zeroes. | 
|  | string hash = 1; | 
|  |  | 
|  | // The original content size in bytes. | 
|  | int64 size_bytes = 2; | 
|  |  | 
|  | // The name of the digest function used to compute the hash. | 
|  | string hash_function_name = 3; | 
|  | } | 
|  |  | 
|  | message File { | 
|  | // Path to the file relative to the execution root. | 
|  | string path = 1; | 
|  |  | 
|  | // Symlink target path. | 
|  | // Only set for unresolved symlinks. | 
|  | string symlink_target_path = 4; | 
|  |  | 
|  | // File digest. | 
|  | // Always omitted for unresolved symlinks. May be omitted for empty files. | 
|  | Digest digest = 2; | 
|  |  | 
|  | // Whether the file is a tool. | 
|  | // Only set for inputs, never for outputs. | 
|  | bool is_tool = 3; | 
|  | } | 
|  |  | 
|  | // Contents of command environment. | 
|  | message EnvironmentVariable { | 
|  | string name = 1; | 
|  | string value = 2; | 
|  | } | 
|  |  | 
|  | // Command execution platform. This message needs to be kept in sync | 
|  | // with [Platform][google.devtools.remoteexecution.v1test.Platform]. | 
|  | message Platform { | 
|  | message Property { | 
|  | string name = 1; | 
|  | string value = 2; | 
|  | } | 
|  | repeated Property properties = 1; | 
|  | } | 
|  |  | 
|  | // Timing, size, and memory statistics for a SpawnExec. | 
|  | message SpawnMetrics { | 
|  | // Total wall time spent running a spawn, measured locally. | 
|  | google.protobuf.Duration total_time = 1; | 
|  | // Time taken to convert the spawn into a network request. | 
|  | google.protobuf.Duration parse_time = 2; | 
|  | // Time spent communicating over the network. | 
|  | google.protobuf.Duration network_time = 3; | 
|  | // Time spent fetching remote outputs. | 
|  | google.protobuf.Duration fetch_time = 4; | 
|  | // Time spent waiting in queues. | 
|  | google.protobuf.Duration queue_time = 5; | 
|  | // Time spent setting up the environment in which the spawn is run. | 
|  | google.protobuf.Duration setup_time = 6; | 
|  | // Time spent uploading outputs to a remote store. | 
|  | google.protobuf.Duration upload_time = 7; | 
|  | // Time spent running the subprocess. | 
|  | google.protobuf.Duration execution_wall_time = 8; | 
|  | // Time spent by the execution framework processing outputs. | 
|  | google.protobuf.Duration process_outputs_time = 9; | 
|  | // Time spent in previous failed attempts, not including queue time. | 
|  | google.protobuf.Duration retry_time = 10; | 
|  | // Total size in bytes of inputs or 0 if unavailable. | 
|  | int64 input_bytes = 11; | 
|  | // Total number of input files or 0 if unavailable. | 
|  | int64 input_files = 12; | 
|  | // Estimated memory usage or 0 if unavailable. | 
|  | int64 memory_estimate_bytes = 13; | 
|  | // Limit of total size of inputs or 0 if unavailable. | 
|  | int64 input_bytes_limit = 14; | 
|  | // Limit of total number of input files or 0 if unavailable. | 
|  | int64 input_files_limit = 15; | 
|  | // Limit of total size of outputs or 0 if unavailable. | 
|  | int64 output_bytes_limit = 16; | 
|  | // Limit of total number of output files or 0 if unavailable. | 
|  | int64 output_files_limit = 17; | 
|  | // Memory limit or 0 if unavailable. | 
|  | int64 memory_bytes_limit = 18; | 
|  | // Time limit or 0 if unavailable. | 
|  | google.protobuf.Duration time_limit = 19; | 
|  | // Instant when the spawn started to execute. | 
|  | google.protobuf.Timestamp start_time = 20; | 
|  | } | 
|  |  | 
|  | // Details of an executed spawn. | 
|  | // This is the format generated by --execution_log_{binary,json}_file. | 
|  |  | 
|  | // Each message contains an executed command, its full inputs and outputs, and | 
|  | // other information. This format is relatively costly to produce and results | 
|  | // in very large files, due to the amount of repeated information. The | 
|  | // --experimental_execution_log_compact_file format provides a better | 
|  | // alternative. | 
|  | message SpawnExec { | 
|  | // The command that was run. | 
|  | repeated string command_args = 1; | 
|  |  | 
|  | // The command environment. | 
|  | repeated EnvironmentVariable environment_variables = 2; | 
|  |  | 
|  | // The command execution platform. | 
|  | Platform platform = 3; | 
|  |  | 
|  | // The inputs at the time of the execution. | 
|  | repeated File inputs = 4; | 
|  |  | 
|  | // All the listed outputs paths. The paths are relative to the execution root. | 
|  | // Actual outputs are a subset of the listed outputs. These paths are sorted. | 
|  | repeated string listed_outputs = 5; | 
|  |  | 
|  | // Whether the spawn was allowed to run remotely. | 
|  | bool remotable = 6; | 
|  |  | 
|  | // Whether the spawn was allowed to be cached. | 
|  | bool cacheable = 7; | 
|  |  | 
|  | // The spawn timeout. | 
|  | int64 timeout_millis = 8; | 
|  |  | 
|  | // The mnemonic of the action this spawn belongs to. | 
|  | string mnemonic = 10; | 
|  |  | 
|  | // The outputs generated by the execution. | 
|  | // In order for one of the listed_outputs to appear here, it must have been | 
|  | // produced and have the expected type (file, directory or symlink). | 
|  | repeated File actual_outputs = 11; | 
|  |  | 
|  | // If the spawn did not hit a disk or remote cache, this will be the name of | 
|  | // the runner, e.g. "remote", "linux-sandbox" or "worker". | 
|  | // | 
|  | // If the spawn hit a disk or remote cache, this will be "disk cache hit" or | 
|  | // "remote cache hit", respectively. This includes the case where a remote | 
|  | // cache was hit while executing the spawn remotely. | 
|  | // | 
|  | // Note that spawns whose owning action hits the persistent action cache | 
|  | // are never reported at all. | 
|  | // | 
|  | // This won't always match the spawn strategy. For the dynamic strategy, it | 
|  | // will be the runner for the first branch to complete. For the remote | 
|  | // strategy, it might be a local runner in case of a fallback. | 
|  | string runner = 12; | 
|  |  | 
|  | // Whether the spawn hit a disk or remote cache. | 
|  | bool cache_hit = 13; | 
|  |  | 
|  | // A text status describing an execution error. Empty in case of success. | 
|  | string status = 14; | 
|  |  | 
|  | // This field contains the contents of SpawnResult.exitCode. | 
|  | // Its semantics varies greatly depending on the status field. | 
|  | // Dependable: if status is empty, exit_code is guaranteed to be zero. | 
|  | int32 exit_code = 15; | 
|  |  | 
|  | // Whether the spawn was allowed to be cached remotely. | 
|  | bool remote_cacheable = 16; | 
|  |  | 
|  | // The canonical label of the target this spawn belongs to. | 
|  | string target_label = 18; | 
|  |  | 
|  | // The action cache digest. | 
|  | // Only available when remote execution, remote cache or disk cache was | 
|  | // enabled for this spawn. | 
|  | Digest digest = 19; | 
|  |  | 
|  | // Timing, size and memory statistics. | 
|  | SpawnMetrics metrics = 20; | 
|  |  | 
|  | reserved 9, 17; | 
|  | } | 
|  |  | 
|  | // An entry in the compact log format. | 
|  | // This is the format generated by --experimental_execution_log_compact_file. | 
|  | // | 
|  | // Each entry describes either an executed spawn or non-spawn action or a piece | 
|  | // of data referenced by other entries. This considerably reduces the runtime | 
|  | // overhead and the size of the log when compared to the | 
|  | // --execution_log_{binary,json}_file formats. | 
|  | // | 
|  | // To ensure that the log can be parsed in a single pass, every entry must be | 
|  | // serialized after all other entries it references by ID. However, entries | 
|  | // aren't guaranteed to be serialized in increasing ID order. | 
|  | // | 
|  | // Entries other than Invocation, Spawn and SymlinkSction must not be assumed to | 
|  | // be canonical: they may be serialized multiple times with different IDs for | 
|  | // performance reasons. | 
|  | message ExecLogEntry { | 
|  | // Information pertaining to the entire invocation. | 
|  | // May appear at most once in the initial position. | 
|  | message Invocation { | 
|  | // The hash function used to compute digests. | 
|  | string hash_function_name = 1; | 
|  |  | 
|  | // The name of the subdirectory of the runfiles tree corresponding to the | 
|  | // main repository (also known as the "workspace name"). | 
|  | // | 
|  | // With --enable_bzlmod, this is always "_main", but can vary when using | 
|  | // WORKSPACE. | 
|  | string workspace_runfiles_directory = 2; | 
|  |  | 
|  | // Whether --experimental_sibling_repository_layout is enabled. | 
|  | bool sibling_repository_layout = 3; | 
|  |  | 
|  | // The ID of the invocation. | 
|  | string id = 4; | 
|  | } | 
|  |  | 
|  | // An input or output file. | 
|  | message File { | 
|  | // The file path. | 
|  | string path = 1; | 
|  | // A digest of the file contents. | 
|  | // The hash function name is omitted. It can be obtained from Invocation. | 
|  | // May be omitted for empty files. | 
|  | Digest digest = 2; | 
|  | } | 
|  |  | 
|  | // An input or output directory. | 
|  | // May be a source directory, a fileset tree, or a tree artifact. | 
|  | message Directory { | 
|  | // The directory path. | 
|  | string path = 1; | 
|  | // The contained files, whose paths are relative to the directory. | 
|  | repeated File files = 2; | 
|  | } | 
|  |  | 
|  | // An unresolved symlink. | 
|  | message UnresolvedSymlink { | 
|  | // The symlink path. | 
|  | string path = 1; | 
|  | // The path the symlink points to. | 
|  | string target_path = 2; | 
|  | } | 
|  |  | 
|  | // A set of spawn inputs. | 
|  | // The contents of the set are the directly contained entries in addition to | 
|  | // the contents of all transitively referenced sets. When order matters, | 
|  | // transitive sets come before direct entries and within a set, entries are | 
|  | // considered in left-to-right order ("postorder"). | 
|  | // Sets are not canonical: two sets with different structure may yield the | 
|  | // same contents. | 
|  | message InputSet { | 
|  | // Entry IDs of files, directories, unresolved symlinks or runfiles trees | 
|  | // belonging to this set. | 
|  | repeated uint32 input_ids = 5; | 
|  | // Entry IDs of other input sets contained in this set. | 
|  | repeated uint32 transitive_set_ids = 4; | 
|  |  | 
|  | reserved 1, 2, 3; | 
|  | } | 
|  |  | 
|  | // A collection of runfiles symlinked at custom locations. | 
|  | // The contents of the set are the directly contained entries in addition to | 
|  | // the contents of all transitively referenced sets. When order matters, | 
|  | // transitive sets come before direct entries and within a set, entries are | 
|  | // considered in left-to-right order ("postorder"). | 
|  | // Sets are not canonical: two sets with different structure may yield the | 
|  | // same contents. | 
|  | message SymlinkEntrySet { | 
|  | // A map from relative paths of runfiles symlinks to the entry IDs of the | 
|  | // symlink target, which may be a file, directory, or unresolved symlink. | 
|  | map<string, uint32> direct_entries = 1; | 
|  | // Entry IDs of other symlink entry sets transitively contained in this set. | 
|  | repeated uint32 transitive_set_ids = 2; | 
|  | } | 
|  |  | 
|  | // A structured representation of the .runfiles directory of an executable. | 
|  | // | 
|  | // Instead of storing the directory directly, the tree is represented | 
|  | // similarly to its in-memory representation in Bazel and needs to be | 
|  | // reassembled from the following parts (in case of path collisions, later | 
|  | // entries overwrite earlier ones): | 
|  | // | 
|  | // 1. symlinks (symlinks_id) | 
|  | // 2. artifacts at canonical locations (input_set_id) | 
|  | // 3. empty files (empty_files) | 
|  | // 4. root symlinks (root_symlinks_id) | 
|  | // 5. the _repo_mapping file with the repo mapping manifest | 
|  | // (repo_mapping_manifest) | 
|  | // 6. the <workspace runfiles directory>/.runfile file (if the workspace | 
|  | // runfiles directory | 
|  | //    wouldn't exist otherwise) | 
|  | // | 
|  | // See SpawnLogReconstructor#reconstructRunfilesDir for details. | 
|  | message RunfilesTree { | 
|  | reserved 7; | 
|  |  | 
|  | // The runfiles tree path. | 
|  | string path = 1; | 
|  | // The entry ID of the set of artifacts in the runfiles tree that are | 
|  | // symlinked at their canonical locations relative to the tree path. | 
|  | // See SpawnLogReconstructor#getRunfilesPaths for how to recover the | 
|  | // tree-relative paths of the artifacts from their exec paths. | 
|  | // | 
|  | // In case of path collisions, later artifacts overwrite earlier ones and | 
|  | // artifacts override custom symlinks. | 
|  | // | 
|  | // The referenced set must not transitively contain any runfile trees. | 
|  | uint32 input_set_id = 2; | 
|  | // The entry ID of the set of symlink entries with paths relative to the | 
|  | // subdirectory of the runfiles tree root corresponding to the main | 
|  | // repository. | 
|  | uint32 symlinks_id = 3; | 
|  | // The entry ID of the set of symlink entries with paths relative to the | 
|  | // root of the runfiles tree. | 
|  | uint32 root_symlinks_id = 4; | 
|  | // The paths of empty files relative to the subdirectory of the runfiles | 
|  | // tree root corresponding to the main repository. | 
|  | repeated string empty_files = 5; | 
|  | // The "_repo_mapping" file at the root of the runfiles tree, if it exists. | 
|  | // Only the digest is stored as the relative path is fixed. | 
|  | File repo_mapping_manifest = 6; | 
|  | } | 
|  |  | 
|  | // A spawn output. | 
|  | message Output { | 
|  | oneof type { | 
|  | // The ID of a file (ctx.actions.declare_file), directory | 
|  | // (ctx.actions.declare_directory) or unresolved symlink | 
|  | // (ctx.actions.declare_symlink) that is an output of the spawn. | 
|  | uint32 output_id = 5; | 
|  | // A declared output that is either missing or has the wrong type | 
|  | // (e.g., a file where a directory was expected). | 
|  | string invalid_output_path = 4; | 
|  | } | 
|  |  | 
|  | reserved 1, 2, 3; | 
|  | } | 
|  |  | 
|  | // An executed spawn. | 
|  | message Spawn { | 
|  | // The command line arguments. | 
|  | repeated string args = 1; | 
|  |  | 
|  | // The environment variables. | 
|  | repeated EnvironmentVariable env_vars = 2; | 
|  |  | 
|  | // The execution platform. | 
|  | Platform platform = 3; | 
|  |  | 
|  | // Entry ID of the set of inputs. Unset means empty. | 
|  | uint32 input_set_id = 4; | 
|  |  | 
|  | // Entry ID of the subset of inputs that are tools. Unset means empty. | 
|  | uint32 tool_set_id = 5; | 
|  |  | 
|  | // The set of outputs. | 
|  | repeated Output outputs = 6; | 
|  |  | 
|  | // See SpawnExec.label. | 
|  | string target_label = 7; | 
|  |  | 
|  | // See SpawnExec.mnemonic. | 
|  | string mnemonic = 8; | 
|  |  | 
|  | // See SpawnExec.exit_code. | 
|  | int32 exit_code = 9; | 
|  |  | 
|  | // See SpawnExec.status. | 
|  | string status = 10; | 
|  |  | 
|  | // See SpawnExec.runner. | 
|  | string runner = 11; | 
|  |  | 
|  | // See SpawnExec.cache_hit. | 
|  | bool cache_hit = 12; | 
|  |  | 
|  | // See SpawnExec.remotable. | 
|  | bool remotable = 13; | 
|  |  | 
|  | // See SpawnExec.cacheable. | 
|  | bool cacheable = 14; | 
|  |  | 
|  | // See SpawnExec.remote_cacheable. | 
|  | bool remote_cacheable = 15; | 
|  |  | 
|  | // See SpawnExec.digest. | 
|  | // The hash function name is omitted. It can be obtained from Invocation. | 
|  | // Unset if the file is empty. | 
|  | Digest digest = 16; | 
|  |  | 
|  | // See SpawnExec.timeout_millis. | 
|  | int64 timeout_millis = 17; | 
|  |  | 
|  | // See SpawnExec.metrics. | 
|  | SpawnMetrics metrics = 18; | 
|  | } | 
|  |  | 
|  | // A symlink action, which is not backed by a spawn. | 
|  | message SymlinkAction { | 
|  | // The path of the input file of the action (i.e., the target of the | 
|  | // symlink). | 
|  | string input_path = 1; | 
|  |  | 
|  | // The path of the output file of the action (i.e., the symlink itself). | 
|  | string output_path = 2; | 
|  |  | 
|  | // The canonical label of the target this action belongs to. | 
|  | string target_label = 3; | 
|  |  | 
|  | // The mnemonic of the action. | 
|  | string mnemonic = 4; | 
|  | } | 
|  |  | 
|  | // If nonzero, then this entry may be referenced by later entries by this ID. | 
|  | // Nonzero IDs are unique within an execution log, but may not be contiguous. | 
|  | uint32 id = 1; | 
|  |  | 
|  | // The entry payload. | 
|  | oneof type { | 
|  | Invocation invocation = 2; | 
|  | File file = 3; | 
|  | Directory directory = 4; | 
|  | UnresolvedSymlink unresolved_symlink = 5; | 
|  | InputSet input_set = 6; | 
|  | Spawn spawn = 7; | 
|  | SymlinkAction symlink_action = 8; | 
|  | SymlinkEntrySet symlink_entry_set = 9; | 
|  | RunfilesTree runfiles_tree = 10; | 
|  | } | 
|  | } |