| # 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. | |
| r"""Command line diffing tool that compares two bazel aquery invocations. | |
| This script compares the proto output of two bazel aquery invocations. For | |
| each set of output files of an action, it compares the command lines that | |
| generated the files. | |
| Example usage: | |
| bazel aquery //path/to:target_one --output=textproto > \ | |
| /path/to/output_one.textproto | |
| bazel aquery //path/to:target_two --output=textproto > \ | |
| /path/to/output_two.textproto | |
| From a bazel repo: | |
| bazel run //tools/cmd_line_differ:cmd_line_differ -- \ | |
| --before=/path/to/output_one.textproto \ | |
| --after=/path/to/output_two.textproto | |
| --input_type=textproto | |
| """ | |
| import os | |
| from absl import app | |
| from absl import flags | |
| from google.protobuf import text_format | |
| from src.main.protobuf import analysis_pb2 | |
| flags.DEFINE_string("before", None, "Aquery output before the change") | |
| flags.DEFINE_string("after", None, "Aquery output after the change") | |
| flags.DEFINE_enum( | |
| "input_type", "proto", ["proto", "textproto"], | |
| "The format of the aquery proto input. One of 'proto' and 'textproto.") | |
| flags.mark_flag_as_required("before") | |
| flags.mark_flag_as_required("after") | |
| def _map_artifact_id_to_path(artifacts): | |
| return {artifact.id: artifact.exec_path for artifact in artifacts} | |
| def _map_output_files_to_command_line(actions, artifacts): | |
| output_files_to_command_line = {} | |
| for action in actions: | |
| output_files = " ".join( | |
| sorted([artifacts[output_id] for output_id in action.output_ids])) | |
| output_files_to_command_line[output_files] = action.arguments | |
| return output_files_to_command_line | |
| def _aquery_diff(before, after): | |
| """Returns differences between command lines that generate same outputs.""" | |
| # TODO(bazel-team): Currently we compare only command lines of actions that | |
| # generate the same output files. Expand the differ to compare other values as | |
| # well (e.g. mnemonic, inputs, execution tags...). | |
| found_difference = False | |
| artifacts_before = _map_artifact_id_to_path(before.artifacts) | |
| artifacts_after = _map_artifact_id_to_path(after.artifacts) | |
| output_to_command_line_before = _map_output_files_to_command_line( | |
| before.actions, artifacts_before) | |
| output_to_command_line_after = _map_output_files_to_command_line( | |
| after.actions, artifacts_after) | |
| output_files_before = set(output_to_command_line_before.keys()) | |
| output_files_after = set(output_to_command_line_after.keys()) | |
| before_after_diff = output_files_before - output_files_after | |
| after_before_diff = output_files_after - output_files_before | |
| if before_after_diff: | |
| print(("Aquery output before change contains an action that generates " | |
| "the following outputs that aquery output after change doesn't:" | |
| "\n%s\n") % "\n".join(before_after_diff)) | |
| found_difference = True | |
| if after_before_diff: | |
| print(("Aquery output after change contains an action that generates " | |
| "the following outputs that aquery output before change doesn't:" | |
| "\n%s\n") % "\n".join(after_before_diff)) | |
| found_difference = True | |
| for output_files in output_to_command_line_before: | |
| arguments = output_to_command_line_before[output_files] | |
| after_arguments = output_to_command_line_after.get(output_files, None) | |
| if after_arguments and arguments != after_arguments: | |
| print(("Difference in action that generates the following outputs:\n%s\n" | |
| "Aquery output before change has the following command line:\n%s\n" | |
| "Aquery output after change has the following command line:\n%s\n") | |
| % ("\n".join(output_files.split()), "\n".join(arguments), | |
| "\n".join(after_arguments))) | |
| found_difference = True | |
| if not found_difference: | |
| print("No difference") | |
| def to_absolute_path(path): | |
| path = os.path.expanduser(path) | |
| if os.path.isabs(path): | |
| return path | |
| else: | |
| if "BUILD_WORKING_DIRECTORY" in os.environ: | |
| return os.path.join(os.environ["BUILD_WORKING_DIRECTORY"], path) | |
| else: | |
| return path | |
| def main(unused_argv): | |
| before_file = to_absolute_path(flags.FLAGS.before) | |
| after_file = to_absolute_path(flags.FLAGS.after) | |
| input_type = flags.FLAGS.input_type | |
| before_proto = analysis_pb2.ActionGraphContainer() | |
| after_proto = analysis_pb2.ActionGraphContainer() | |
| if input_type == "proto": | |
| with open(before_file, "rb") as f: | |
| before_proto.ParseFromString(f.read()) | |
| with open(after_file, "rb") as f: | |
| after_proto.ParseFromString(f.read()) | |
| else: | |
| with open(before_file, "r") as f: | |
| before_text = f.read() | |
| text_format.Merge(before_text, before_proto) | |
| with open(after_file, "r") as f: | |
| after_text = f.read() | |
| text_format.Merge(after_text, after_proto) | |
| _aquery_diff(before_proto, after_proto) | |
| if __name__ == "__main__": | |
| app.run(main) |