tools/create_dx_replay.py

#!/usr/bin/env python3
# Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.

# Take a file where each line is a tab-separated list of arguments for DX (or
# D8) and create a self-contained directory with all the input files
# and a script which replays the same DX invocations as the original list.
#
# Usage:
#
#     create_dx_replay.py <dx-args-script> <output-dir>
#
# The <dx-args-script> is a text file where each line contains tab-separated
# arguments for a DX (D8) call.
# The script 'tools/test_android_cts.py' can log DX invocations during an AOSP
# build to such a file. Use 'test_android_cts.py --tool=d8 --d8log=<file> ...'.

from __future__ import print_function
from os.path import join, isdir, exists, basename
from os import rmdir
from shutil import copy2
import argparse
import os
import stat
import sys

import utils

IN_SUBDIR = 'in'  # subdirectory for the local copy of the input files
OUT_SUBDIR = 'out'  # subdirectory prefix for the output of DX
REPLAY_SCRIPT_NAME = 'replay_script.py'


# This function will be called with arguments of the original DX invocation. It
# copies the original input files into the local input directory and replaces
# the references in orig_args to the local input files.
# Returns the new line to be appended to the replay script.
def process_line(out_dir, input_counter, orig_args):
    args = []
    inputs = []
    for arg in orig_args:
        if arg.startswith('--output='):
            continue  # nothing to do, just skip this arg
        if arg.startswith('--'):
            args.append(arg)
        else:
            # 'arg' is the path of an input file: copy arg to local dir with
            # a new, unique name
            if isdir(arg):
                raise IOError(
                    "Adding directories ('{}') to the replay script is not"
                    " implemented.".format(arg))
            elif not exists(arg):
                print("The input file to DX does not exist: '{}'.".format(arg))

            input_file = '{}_{}'.format(input_counter, basename(arg))

            copy2(arg, join(out_dir, join(IN_SUBDIR, input_file)))
            inputs.append(input_file)

    return 'call_dx({}, {}, {})\n'.format(input_counter, args, inputs)


def parse_arguments():
    parser = argparse.ArgumentParser(
        description='Creates a self-contained directory for playing back a '
        ' sequence of DX calls.')
    parser.add_argument(
        'dx_call_log',
        help='File containing tab-separated arguments for a DX call on each'
        ' line.')
    parser.add_argument(
        'output_dir',
        help='Target path the create the self-contained directory at.')
    return parser.parse_args()


def Main():
    args = parse_arguments()

    if isdir(args.output_dir):
        rmdir(args.output_dir)  # make sure to write only to empty out dir

    utils.makedirs_if_needed(join(args.output_dir, IN_SUBDIR))

    # create the first lines of the replay script
    replay_script = \
  """#!/usr/bin/env python3
import os
import shutil
import subprocess
import sys

SCRIPT_DIR = os.path.abspath(os.path.normpath(os.path.join(__file__, '..')))
IN_SUBDIR = '{}'
OUT_SUBDIR = '{}'

def call_dx(input_counter, args, inputs):
  out_dir = os.path.join(SCRIPT_DIR, OUT_SUBDIR, str(input_counter))
  if not os.path.isdir(out_dir):
    os.makedirs(out_dir)
  full_inputs = [os.path.join(SCRIPT_DIR, IN_SUBDIR, i) for i in inputs]
  subprocess.check_call(sys.argv[1:] + args + ['--output=' + out_dir]
      + full_inputs)

if len(sys.argv) < 2:
  raise IOError('Usage: create_dx_replay.py <dx-command>'
      ' # can be multiple args')
abs_out_dir = os.path.join(SCRIPT_DIR, OUT_SUBDIR)
if os.path.isdir(abs_out_dir):
  shutil.rmtree(abs_out_dir)

""".format(IN_SUBDIR, OUT_SUBDIR)

    with open(args.dx_call_log) as f:
        lines = f.read().splitlines()

    input_counter = 1
    for line in lines:
        replay_script += \
            process_line(args.output_dir, input_counter, line.split('\t'))
        input_counter += 1

    script_file = join(args.output_dir, REPLAY_SCRIPT_NAME)
    with open(script_file, 'w') as f:
        f.write(replay_script)

    # chmod +x for script_file
    st = os.stat(script_file)
    os.chmod(script_file,
             st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)


if __name__ == '__main__':
    sys.exit(Main())