remoting/host/installer/build-installer-archive.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """Creates a zip archive for the Chrome Remote Desktop Host installer.
   7
   8 This script builds a zip file that contains all the files needed to build an
   9 installer for Chrome Remote Desktop Host.
  10
  11 This zip archive is then used by the signing bots to:
  12 (1) Sign the binaries
  13 (2) Build the final installer
  14
  15 TODO(garykac) We should consider merging this with build-webapp.py.
  16 """
  17
  18 import os
  19 import shutil
  20 import subprocess
  21 import sys
  22 import zipfile
  23
  24
  25 def cleanDir(dir):
  26   """Deletes and recreates the dir to make sure it is clean.
  27
  28   Args:
  29     dir: The directory to clean.
  30   """
  31   try:
  32     shutil.rmtree(dir)
  33   except OSError:
  34     if os.path.exists(dir):
  35       raise
  36     else:
  37       pass
  38   os.makedirs(dir, 0775)
  39
  40
  41 def buildDefDictionary(definitions):
  42   """Builds the definition dictionary from the VARIABLE=value array.
  43
  44   Args:
  45     defs: Array of variable definitions: 'VARIABLE=value'.
  46
  47     Returns:
  48       Dictionary with the definitions.
  49   """
  50   defs = {}
  51   for d in definitions:
  52     (key, val) = d.split('=')
  53     defs[key] = val
  54   return defs
  55
  56
  57 def createZip(zip_path, directory):
  58   """Creates a zipfile at zip_path for the given directory.
  59
  60   Args:
  61     zip_path: Path to zip file to create.
  62     directory: Directory with contents to archive.
  63   """
  64   zipfile_base = os.path.splitext(os.path.basename(zip_path))[0]
  65   zip = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
  66   for (root, dirs, files) in os.walk(directory):
  67     for f in files:
  68       full_path = os.path.join(root, f)
  69       rel_path = os.path.relpath(full_path, directory)
  70       zip.write(full_path, os.path.join(zipfile_base, rel_path))
  71   zip.close()
  72
  73
  74 def remapSrcFile(dst_root, src_roots, src_file):
  75   """Calculates destination file path and creates directory.
  76
  77   Any matching |src_roots| prefix is stripped from |src_file| before
  78   appending to |dst_root|.
  79
  80   For example, given:
  81     dst_root = '/output'
  82     src_roots = ['host/installer/mac']
  83     src_file = 'host/installer/mac/Scripts/keystone_install.sh'
  84   The final calculated path is:
  85     '/output/Scripts/keystone_install.sh'
  86
  87   The |src_file| must match one of the |src_roots| prefixes. If there are no
  88   matches, then an error is reported.
  89
  90   If multiple |src_roots| match, then only the first match is applied. Because
  91   of this, if you have roots that share a common prefix, the longest string
  92   should be first in this array.
  93
  94   Args:
  95     dst_root: Target directory where files are copied.
  96     src_roots: Array of path prefixes which will be stripped of |src_file|
  97                (if they match) before appending it to the |dst_root|.
  98     src_file: Source file to be copied.
  99   Returns:
 100     Full path to destination file in |dst_root|.
 101   """
 102   # Strip of directory prefix.
 103   found_root = False
 104   for root in src_roots:
 105     root = os.path.normpath(root)
 106     src_file = os.path.normpath(src_file)
 107     if os.path.commonprefix([root, src_file]) == root:
 108       src_file = os.path.relpath(src_file, root)
 109       found_root = True
 110       break
 111
 112   if not found_root:
 113     error('Unable to match prefix for %s' % src_file)
 114
 115   dst_file = os.path.join(dst_root, src_file)
 116   # Make sure target directory exists.
 117   dst_dir = os.path.dirname(dst_file)
 118   if not os.path.exists(dst_dir):
 119     os.makedirs(dst_dir, 0775)
 120   return dst_file
 121
 122
 123 def copyFileWithDefs(src_file, dst_file, defs):
 124   """Copies from src_file to dst_file, performing variable substitution.
 125
 126   Any @@VARIABLE@@ in the source is replaced with the value of VARIABLE
 127   in the |defs| dictionary when written to the destination file.
 128
 129   Args:
 130     src_file: Full or relative path to source file to copy.
 131     dst_file: Relative path (and filename) where src_file should be copied.
 132     defs: Dictionary of variable definitions.
 133   """
 134   data = open(src_file, 'r').read()
 135   for key, val in defs.iteritems():
 136     try:
 137       data = data.replace('@@' + key + '@@', val)
 138     except TypeError:
 139       print repr(key), repr(val)
 140   open(dst_file, 'w').write(data)
 141   shutil.copystat(src_file, dst_file)
 142
 143
 144 def copyZipIntoArchive(out_dir, files_root, zip_file):
 145   """Expands the zip_file into the out_dir, preserving the directory structure.
 146
 147   Args:
 148     out_dir: Target directory where unzipped files are copied.
 149     files_root: Path prefix which is stripped of zip_file before appending
 150                 it to the out_dir.
 151     zip_file: Relative path (and filename) to the zip file.
 152   """
 153   base_zip_name = os.path.basename(zip_file)
 154
 155   # We don't use the 'zipfile' module here because it doesn't restore all the
 156   # file permissions correctly. We use the 'unzip' command manually.
 157   old_dir = os.getcwd();
 158   os.chdir(os.path.dirname(zip_file))
 159   subprocess.call(['unzip', '-qq', '-o', base_zip_name])
 160   os.chdir(old_dir)
 161
 162   # Unzip into correct dir in out_dir.
 163   out_zip_path = remapSrcFile(out_dir, files_root, zip_file)
 164   out_zip_dir = os.path.dirname(out_zip_path)
 165
 166   (src_dir, ignore1) = os.path.splitext(zip_file)
 167   (base_dir_name, ignore2) = os.path.splitext(base_zip_name)
 168   shutil.copytree(src_dir, os.path.join(out_zip_dir, base_dir_name))
 169
 170
 171 def buildHostArchive(temp_dir, zip_path, source_file_roots, source_files,
 172                      gen_files, gen_files_dst, defs):
 173   """Builds a zip archive with the files needed to build the installer.
 174
 175   Args:
 176     temp_dir: Temporary dir used to build up the contents for the archive.
 177     zip_path: Full path to the zip file to create.
 178     source_file_roots: Array of path prefixes to strip off |files| when adding
 179                        to the archive.
 180     source_files: The array of files to add to archive. The path structure is
 181                   preserved (except for the |files_root| prefix).
 182     gen_files: Full path to binaries to add to archive.
 183     gen_files_dst: Relative path of where to add binary files in archive.
 184                    This array needs to parallel |binaries_src|.
 185     defs: Dictionary of variable definitions.
 186   """
 187   cleanDir(temp_dir)
 188
 189   for f in source_files:
 190     dst_file = remapSrcFile(temp_dir, source_file_roots, f)
 191     base_file = os.path.basename(f)
 192     (base, ext) = os.path.splitext(f)
 193     if ext == '.zip':
 194       copyZipIntoArchive(temp_dir, source_file_roots, f)
 195     elif ext in ['.packproj', '.pkgproj', '.plist', '.props', '.sh', '.json']:
 196       copyFileWithDefs(f, dst_file, defs)
 197     else:
 198       shutil.copy2(f, dst_file)
 199
 200   for bs, bd in zip(gen_files, gen_files_dst):
 201     dst_file = os.path.join(temp_dir, bd)
 202     if not os.path.exists(os.path.dirname(dst_file)):
 203       os.makedirs(os.path.dirname(dst_file))
 204     if os.path.isdir(bs):
 205       shutil.copytree(bs, dst_file)
 206     else:
 207       shutil.copy2(bs, dst_file)
 208
 209   createZip(zip_path, temp_dir)
 210
 211
 212 def error(msg):
 213   sys.stderr.write('ERROR: %s\n' % msg)
 214   sys.exit(1)
 215
 216
 217 def usage():
 218   """Display basic usage information."""
 219   print ('Usage: %s\n'
 220          '  <temp-dir> <zip-path>\n'
 221          '  --source-file-roots <list of roots to strip off source files...>\n'
 222          '  --source-files <list of source files...>\n'
 223          '  --generated-files <list of generated target files...>\n'
 224          '  --generated-files-dst <dst for each generated file...>\n'
 225          '  --defs <list of VARIABLE=value definitions...>'
 226          ) % sys.argv[0]
 227
 228
 229 def main():
 230   if len(sys.argv) < 2:
 231     usage()
 232     error('Too few arguments')
 233
 234   temp_dir = sys.argv[1]
 235   zip_path = sys.argv[2]
 236
 237   arg_mode = ''
 238   source_file_roots = []
 239   source_files = []
 240   generated_files = []
 241   generated_files_dst = []
 242   definitions = []
 243   for arg in sys.argv[3:]:
 244     if arg == '--source-file-roots':
 245       arg_mode = 'src-roots'
 246     elif arg == '--source-files':
 247       arg_mode = 'files'
 248     elif arg == '--generated-files':
 249       arg_mode = 'gen-src'
 250     elif arg == '--generated-files-dst':
 251       arg_mode = 'gen-dst'
 252     elif arg == '--defs':
 253       arg_mode = 'defs'
 254
 255     elif arg_mode == 'src-roots':
 256       source_file_roots.append(arg)
 257     elif arg_mode == 'files':
 258       source_files.append(arg)
 259     elif arg_mode == 'gen-src':
 260       generated_files.append(arg)
 261     elif arg_mode == 'gen-dst':
 262       generated_files_dst.append(arg)
 263     elif arg_mode == 'defs':
 264       definitions.append(arg)
 265     else:
 266       usage()
 267       error('Expected --source-files')
 268
 269   # Make sure at least one file was specified.
 270   if len(source_files) == 0 and len(generated_files) == 0:
 271     error('At least one input file must be specified.')
 272
 273   # Sort roots to ensure the longest one is first. See comment in remapSrcFile
 274   # for why this is necessary.
 275   source_file_roots = map(os.path.normpath, source_file_roots)
 276   source_file_roots.sort(key=len, reverse=True)
 277
 278   # Verify that the 2 generated_files arrays have the same number of elements.
 279   if len(generated_files) != len(generated_files_dst):
 280     error('len(--generated-files) != len(--generated-files-dst)')
 281
 282   defs = buildDefDictionary(definitions)
 283
 284   result = buildHostArchive(temp_dir, zip_path, source_file_roots,
 285                             source_files, generated_files, generated_files_dst,
 286                             defs)
 287
 288   return 0
 289
 290
 291 if __name__ == '__main__':
 292   sys.exit(main())