[Chromoting] Include pkg-dmg script into installer archive.

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

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Creates a zip archive for the Chrome Remote Desktop Host installer.
 
 This script builds a zip file that contains all the files needed to build an
 installer for Chrome Remote Desktop Host.
 
@@ skipping 53 matching lines @@
   zipfile_base = os.path.splitext(os.path.basename(zip_path))[0]
   zip = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
   for (root, dirs, files) in os.walk(directory):
     for f in files:
       full_path = os.path.join(root, f)
       rel_path = os.path.relpath(full_path, directory)
       zip.write(full_path, os.path.join(zipfile_base, rel_path))
   zip.close()
 
 
-def remapSrcFile(dst_root, src_root, src_file):
+def remapSrcFile(dst_root, src_roots, src_file):
   """Calculates destination file path and creates directory.
 
-  The |src_root| prefix is stripped from |src_file| before
+  Any matching |src_roots| prefix is stripped from |src_file| before
   appending to |dst_root|.
 
   For example, given:
-    dst_root = /output
-    src_root = host/installer/mac
-    src_file = host/installer/mac/Scripts/keystone_install.sh
+    dst_root = '/output'
+    src_roots = ['host/installer/mac']
+    src_file = 'host/installer/mac/Scripts/keystone_install.sh'
   The final calculated path is:
-    /output/Scripts/keystone_install.sh
+    '/output/Scripts/keystone_install.sh'
+
+  The |src_file| must match one of the |src_roots| prefixes. If there are no
+  matches, then an error is reported.
+
+  If multiple |src_roots| match, then only the first match is applied. Because
+  of this, if you have roots that share a common prefix, the longest string
+  should be first in this array.
 
   Args:
     dst_root: Target directory where files are copied.
-    src_root: Path prefix which is stripped of |src_file| before appending
-              it to the |dst_root|.
+    src_roots: Array of path prefixes which will be stripped of |src_file|
+               (if they match) before appending it to the |dst_root|.
     src_file: Source file to be copied.
   Returns:
     Full path to destination file in |dst_root|.
   """
   # Strip of directory prefix.
-  if src_file.startswith(src_root):
-    src_file = src_file[len(src_root):]
+  found_root = False
+  for root in src_roots:
+    if src_file.startswith(root):
+      src_file = src_file[len(root):]
+      found_root = True
+      break
+
+  if not found_root:
+    error('Unable to match prefix for %s' % src_file)
+
   dst_file = os.path.join(dst_root, src_file)
   # Make sure target directory exists.
   dst_dir = os.path.dirname(dst_file)
   if not os.path.exists(dst_dir):
     os.makedirs(dst_dir, 0775)
   return dst_file
 
 
 def copyFileWithDefs(src_file, dst_file, defs):
   """Copies from src_file to dst_file, performing variable substitution.
@@ skipping 36 matching lines @@
 
   # Unzip into correct dir in out_dir.
   out_zip_path = remapSrcFile(out_dir, files_root, zip_file)
   out_zip_dir = os.path.dirname(out_zip_path)
 
   (src_dir, ignore1) = os.path.splitext(zip_file)
   (base_dir_name, ignore2) = os.path.splitext(base_zip_name)
   shutil.copytree(src_dir, os.path.join(out_zip_dir, base_dir_name))
 
 
-def buildHostArchive(temp_dir, zip_path, source_files_root, source_files,
+def buildHostArchive(temp_dir, zip_path, source_file_roots, source_files,
                      gen_files, gen_files_dst, defs):
   """Builds a zip archive with the files needed to build the installer.
 
   Args:
     temp_dir: Temporary dir used to build up the contents for the archive.
     zip_path: Full path to the zip file to create.
-    source_files_root: Path prefix to strip off |files| when adding to archive.
+    source_file_roots: Array of path prefixes to strip off |files| when adding
+                       to the archive.
     source_files: The array of files to add to archive. The path structure is
                   preserved (except for the |files_root| prefix).
     gen_files: Full path to binaries to add to archive.
     gen_files_dst: Relative path of where to add binary files in archive.
                    This array needs to parallel |binaries_src|.
     defs: Dictionary of variable definitions.
   """
   cleanDir(temp_dir)
 
   for f in source_files:
-    dst_file = remapSrcFile(temp_dir, source_files_root, f)
+    dst_file = remapSrcFile(temp_dir, source_file_roots, f)
     base_file = os.path.basename(f)
     (base, ext) = os.path.splitext(f)
     if ext == '.zip':
-      copyZipIntoArchive(temp_dir, source_files_root, f)
+      copyZipIntoArchive(temp_dir, source_file_roots, f)
     elif ext in ['.sh', '.packproj', '.plist']:
       copyFileWithDefs(f, dst_file, defs)
     else:
-      shutil.copy2(src_file, dst_file)
+      shutil.copy2(f, dst_file)
 
   for bs, bd in zip(gen_files, gen_files_dst):
-    dst_file = remapSrcFile(temp_dir, source_files_root, bd)
+    dst_file = os.path.join(temp_dir, bd)
     if os.path.isdir(bs):
       shutil.copytree(bs, dst_file)
     else:
       shutil.copy2(bs, dst_file)
 
   createZip(zip_path, temp_dir)
 
 
 def error(msg):
-  sys.stderr.write('ERROR: %s' % msg)
+  sys.stderr.write('ERROR: %s\n' % msg)
   sys.exit(1)
 
 
 def usage():
   """Display basic usage information."""
   print ('Usage: %s\n'
-         '  <temp-dir> <zip-path> <files-root-dir>\n'
+         '  <temp-dir> <zip-path>\n'
+         '  --source-file-roots <list of roots to strip off source files...>\n'
          '  --source-files <list of source files...>\n'
          '  --generated-files <list of generated target files...>\n'
          '  --generated-files-dst <dst for each generated file...>\n'
          '  --defs <list of VARIABLE=value definitions...>'
          ) % sys.argv[0]
 
 
 def main():
-  if len(sys.argv) < 3:
+  if len(sys.argv) < 2:
     usage()
     error('Too few arguments')
 
   temp_dir = sys.argv[1]
   zip_path = sys.argv[2]
-  source_files_root = sys.argv[3]
 
   arg_mode = ''
+  source_file_roots = []
   source_files = []
   generated_files = []
   generated_files_dst = []
   definitions = []
-  for arg in sys.argv[4:]:
-    if arg == '--source-files':
+  for arg in sys.argv[3:]:
+    if arg == '--source-file-roots':
+      arg_mode = 'src-roots'
+    elif arg == '--source-files':
       arg_mode = 'files'
     elif arg == '--generated-files':
       arg_mode = 'gen-src'
     elif arg == '--generated-files-dst':
       arg_mode = 'gen-dst'
     elif arg == '--defs':
       arg_mode = 'defs'
 
+    elif arg_mode == 'src-roots':
+      source_file_roots.append(arg)
     elif arg_mode == 'files':
       source_files.append(arg)
     elif arg_mode == 'gen-src':
       generated_files.append(arg)
     elif arg_mode == 'gen-dst':
       generated_files_dst.append(arg)
     elif arg_mode == 'defs':
       definitions.append(arg)
     else:
       usage()
       error('Expected --source-files')
 
   # Make sure at least one file was specified.
   if len(source_files) == 0 and len(generated_files) == 0:
     error('At least one input file must be specified.')
 
-  # Ensure that source_files_root ends with a directory separator.
-  if source_files_root[-1:] != os.sep:
-    source_files_root += os.sep
+  # Ensure that each path in source_file_roots ends with a directory separator.
+  for root in source_file_roots:
+    if root[-1:] != os.sep:
+      error('Each source-file-root should end with a "\": %s' % root)
+
+  # Sort roots to ensure the longest one is first. See comment in remapSrcFile
+  # for why this is necessary.
+  source_file_roots.sort(key=len, reverse=True)
 
   # Verify that the 2 generated_files arrays have the same number of elements.
   if len(generated_files) != len(generated_files_dst):
     error('len(--generated-files) != len(--generated-files-dst)')
 
   defs = buildDefDictionary(definitions)
 
-  result = buildHostArchive(temp_dir, zip_path, source_files_root,
+  result = buildHostArchive(temp_dir, zip_path, source_file_roots,
                             source_files, generated_files, generated_files_dst,
                             defs)
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())