| #!/usr/bin/env python | |
| # Copyright (c) 2015, the Dart 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. | |
| # | |
| # This python script creates a tar archive and a C++ source file which contains | |
| # the tar archive as an array of bytes. | |
| import os | |
| import sys | |
| from os.path import join, splitext | |
| import time | |
| from optparse import OptionParser | |
| from datetime import date | |
| import tarfile | |
| import tempfile | |
| import gzip | |
| def CreateTarArchive(tar_path, client_root, compress, files): | |
| mode_string = 'w' | |
| tar = tarfile.open(tar_path, mode=mode_string) | |
| for input_file_name in files: | |
| # Chop off client_root. | |
| archive_file_name = input_file_name[len(client_root):] | |
| # Replace back slash with forward slash. So we do not have Windows paths. | |
| archive_file_name = archive_file_name.replace("\\", "/") | |
| # Open input file and add it to the archive. | |
| with open(input_file_name, 'rb') as input_file: | |
| tarInfo = tarfile.TarInfo(name=archive_file_name) | |
| input_file.seek(0, 2) | |
| tarInfo.size = input_file.tell() | |
| tarInfo.mtime = 0 # For deterministic builds. | |
| input_file.seek(0) | |
| tar.addfile(tarInfo, fileobj=input_file) | |
| tar.close() | |
| if compress: | |
| with open(tar_path, "rb") as fin: | |
| uncompressed = fin.read() | |
| with open(tar_path, "wb") as fout: | |
| # mtime=0 for deterministic builds. | |
| gz = gzip.GzipFile(fileobj=fout, mode="wb", filename="", mtime=0) | |
| gz.write(uncompressed) | |
| gz.close() | |
| def MakeArchive(options): | |
| if not options.client_root: | |
| sys.stderr.write('--client_root not specified') | |
| return -1 | |
| files = [] | |
| for dirname, dirnames, filenames in os.walk(options.client_root): | |
| # strip out all dot files. | |
| filenames = [f for f in filenames if not f[0] == '.'] | |
| dirnames[:] = [d for d in dirnames if not d[0] == '.'] | |
| for f in filenames: | |
| src_path = os.path.join(dirname, f) | |
| if (os.path.isdir(src_path)): | |
| continue | |
| files.append(src_path) | |
| # Ensure consistent file ordering for reproducible builds. | |
| files.sort() | |
| # Write out archive. | |
| CreateTarArchive(options.tar_output, options.client_root, options.compress, | |
| files) | |
| return 0 | |
| def WriteCCFile( | |
| output_file, | |
| outer_namespace, | |
| inner_namespace, | |
| name, | |
| tar_archive, | |
| ): | |
| with open(output_file, 'w') as out: | |
| out.write(''' | |
| // Copyright (c) %d, the Dart 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. | |
| ''' % date.today().year) | |
| out.write(''' | |
| #include <stdint.h> | |
| ''') | |
| out.write('namespace %s {\n' % outer_namespace) | |
| if inner_namespace != None: | |
| out.write('namespace %s {\n' % inner_namespace) | |
| out.write('\n\n') | |
| # Write the byte contents of the archive as a comma separated list of | |
| # integers, one integer for each byte. | |
| out.write('static const uint8_t %s_[] = {\n' % name) | |
| line = ' ' | |
| lineCounter = 0 | |
| for byte in tar_archive: | |
| line += r" %d," % (byte if isinstance(byte, int) else ord(byte)) | |
| lineCounter += 1 | |
| if lineCounter == 10: | |
| out.write(line + '\n') | |
| line = ' ' | |
| lineCounter = 0 | |
| if lineCounter != 0: | |
| out.write(line + '\n') | |
| out.write('};\n') | |
| out.write('\nunsigned int %s_len = %d;\n' % (name, len(tar_archive))) | |
| out.write('\nconst uint8_t* %s = %s_;\n\n' % (name, name)) | |
| if inner_namespace != None: | |
| out.write('} // namespace %s\n' % inner_namespace) | |
| out.write('} // namespace %s\n' % outer_namespace) | |
| def MakeCCFile(options): | |
| if not options.output: | |
| sys.stderr.write('--output not specified\n') | |
| return -1 | |
| if not options.name: | |
| sys.stderr.write('--name not specified\n') | |
| return -1 | |
| if not options.tar_input: | |
| sys.stderr.write('--tar_input not specified\n') | |
| return -1 | |
| # Read it back in. | |
| with open(options.tar_input, 'rb') as tar_file: | |
| tar_archive = tar_file.read() | |
| # Write CC file. | |
| WriteCCFile(options.output, options.outer_namespace, | |
| options.inner_namespace, options.name, tar_archive) | |
| return 0 | |
| def Main(args): | |
| try: | |
| # Parse input. | |
| parser = OptionParser() | |
| parser.add_option( | |
| "--output", action="store", type="string", help="output file name") | |
| parser.add_option("--tar_input",\ | |
| action="store", type="string", | |
| help="input tar archive") | |
| parser.add_option( | |
| "--tar_output", | |
| action="store", | |
| type="string", | |
| help="tar output file name") | |
| parser.add_option( | |
| "--outer_namespace", | |
| action="store", | |
| type="string", | |
| help="outer C++ namespace", | |
| default="dart") | |
| parser.add_option( | |
| "--inner_namespace", | |
| action="store", | |
| type="string", | |
| help="inner C++ namespace", | |
| default="bin") | |
| parser.add_option( | |
| "--name", | |
| action="store", | |
| type="string", | |
| help="name of tar archive symbol") | |
| parser.add_option("--compress", action="store_true", default=False) | |
| parser.add_option( | |
| "--client_root", | |
| action="store", | |
| type="string", | |
| help="root directory client resources") | |
| (options, args) = parser.parse_args() | |
| if options.tar_output: | |
| return MakeArchive(options) | |
| else: | |
| return MakeCCFile(options) | |
| except Exception as inst: | |
| sys.stderr.write('create_archive.py exception\n') | |
| sys.stderr.write(str(inst)) | |
| sys.stderr.write('\n') | |
| return -1 | |
| if __name__ == '__main__': | |
| sys.exit(Main(sys.argv)) |