Scripts to watch the evolution of generated files

Archive the evolution of generated files over a range of revisions.

Signed-off-by: Gilles Peskine <[email protected]>

Author: gilles-peskine-arm

tools/bin/mbedtls-trace-files.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+
+"""Archive the contents of the specified files for the specified Git revisions.
+
+Run this script from a clean Git worktree.
+This script runs `make FILE` to generate the desired files.
+The outputs are stored in a subdirectory named for each commit hash.
+"""
+
+# Copyright The Mbed TLS Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+import argparse
+import os
+import shutil
+import subprocess
+from typing import List, Optional
+
+
+class UncommittedChangesException(Exception):
+    "You have uncommitted changes. Please stash or commit them."
+    pass
+
+
+class Archiver:
+    """Archive the contents of some files for some Git revisions."""
+
+    def __init__(
+            self,
+            build_dir: Optional[str] = None,
+            output_dir: Optional[str] = None,
+            run_after: Optional[str] = None,
+            run_before: Optional[str] = None,
+    ) -> None:
+        """Configure an archiver for generated files.
+
+        `build_dir`: directory where ``make`` will be run.
+        `output_dir`: parent directory for the per-revision directories.
+        `run_before`: shell command to run before ``make``.
+        `run_after`: shell command to run after ``make``.
+        """
+        self.build_dir = build_dir if build_dir is not None else os.curdir
+        self.output_dir = output_dir if output_dir is not None else os.curdir
+        self.run_before = run_before
+        self.run_after = run_after
+        self.prepare()
+
+    def prepare(self) -> None:
+        """Prepare the working directory."""
+        try:
+            subprocess.check_call(['git', 'diff', '--quiet'])
+        except subprocess.CalledProcessError:
+            raise UncommittedChangesException()
+        self.initial_revision = subprocess.check_output(
+            ['git', 'rev-parse', '--abbrev-ref', 'HEAD']
+        ).decode('ascii').strip()
+
+    def done(self) -> None:
+        """Restore the working directory."""
+        subprocess.check_call(['git', 'checkout', self.initial_revision])
+
+    def archive_revision(self, revision: str, files: List[str]) -> None:
+        """Archive generated files for a given revision.
+
+        `revision`: Git revision to check out.
+        `files`: list of files to archive.
+        """
+        subprocess.check_call(['git', 'checkout', revision])
+        if self.run_before:
+            subprocess.check_call(self.run_before, shell=True)
+        subprocess.check_call(['make'] + files,
+                              cwd=self.build_dir)
+        for filename in files:
+            target_dir = os.path.join(self.output_dir,
+                                      revision,
+                                      os.path.dirname(filename))
+            os.makedirs(target_dir, exist_ok=True)
+            shutil.copy2(filename, target_dir)
+        if self.run_after:
+            subprocess.check_call(self.run_after, shell=True)
+
+    def archive_revisions(self, revision_range: str, files: List[str]) -> None:
+        """Archive generated files for a given revision range.
+
+        `revision`: Git revision range to check out.
+        `files`: list of files to archive.
+        """
+        self.prepare()
+        try:
+            revisions = subprocess.check_output(
+                ['git', 'log', '--format=%H', revision_range]
+            ).decode('ascii').split()
+            for revision in revisions:
+                self.archive_revision(revision, files)
+        finally:
+            self.done()
+
+
+def main() -> None:
+    """Command line entry point."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--build-dir', '-b', metavar='DIR',
+                        help='Run `make` in DIR')
+    parser.add_argument('--output-dir', '-o', metavar='DIR',
+                        help='Put output directories under DIR')
+    parser.add_argument('--run-after', '-R', metavar='CMD',
+                        help='Shell command to run after each build')
+    parser.add_argument('--run-before', '-r', metavar='CMD',
+                        help='Shell command to run before each build')
+    parser.add_argument('revisions', metavar='REVISIONS',
+                        help='Comma-separated of Git revisions (see gitrevisions(7))')
+    parser.add_argument('files', metavar='FILE', nargs='*',
+                        help='File to archive')
+    options = parser.parse_args()
+    revision_ranges = options.revisions.split(',')
+    del options.revisions
+    files = options.files
+    del options.files
+    archiver = Archiver(**vars(options))
+    for revision_range in revision_ranges:
+        archiver.archive_revisions(revision_range, files)
+
+if __name__ == '__main__':
+    main()

tools/bin/mbedtls-trace-files.sh

@@ -0,0 +1,82 @@
+#!/bin/sh
+
+set -eu
+
+help () {
+    cat <<EOF
+Usage: $0 [OPTION]... REVISIONS [FILE]...
+Log the values of the specified files for the specified Git revisions.
+
+Run this script from a clean Git worktree.
+This script runs \`make FILE\` to generate the desired files.
+The outputs are stored in a subdirectory named for each commit hash.
+REVISIONS is a comma-separated of Git revisions (see gitrevisions(7)).
+
+Options:
+  -U        Run even if the worktree is not clean
+  -b DIR    Directory where to run \`make\` (default: .)
+  -o DIR    Directory where the outputs will be stored (default: .)
+  -r CMD    Shell command to run before each build
+EOF
+}
+
+if [ $# -eq 0 ] || [ "$1" = "--help" ]; then
+    help
+    exit
+fi
+
+
+force_unclean=
+build_dir=.
+output_root=.
+pre_command=
+
+while getopts : OPTLET; do
+    case $OPTLET in
+        U) force_unclean=1;;
+        b) build_dir=$OPTARG;;
+        o) output_root=$OPTARG;;
+        r) pre_command=$OPTARG;;
+        \?) exit 120;;
+    esac
+done
+shift $((OPTIND - 1))
+all_revisions=$1
+
+## trace_revision REVISION [FILE]...
+trace_revision () {
+    git checkout "$1"
+    shift
+    (cd -- "$output_root" && exec make -C  "$@")
+    for file
+    do
+        mkdir -p -- "$output_root/$file"
+        cp -p -- "$build_dir/$file" "$output_root/$file"
+    done
+}
+
+## trace_revisions REVISION_RANGE [FILE]...
+trace_revisions () {
+    revisions=$(git log --format=%H "$1")
+    shift
+    for revision in $revisions; do
+        trace_revision "$revision" "$@"
+    done
+}
+
+if [ -z "$force_unclean" ]; then
+    if ! git diff -q; then
+        echo >&2 "$0: You have uncommitted changes. Please stash or commit them."
+        exit 3
+    fi
+fi
+
+initial_revision=$(git rev-parse --abbrev-ref HEAD)
+
+while case $all_revisions in *,*) true;; *) false;; esac do
+    trace_revisions "${all_revisions%%,*}" "$@"
+    all_revisions=${all_revisions#*,}
+done
+trace_revisions "$all_revisions" "$@"
+
+git checkout $initial_revision