chrome/tools/build/win/create_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 """Script to create Chrome Installer archive.
   7
   8   This script is used to create an archive of all the files required for a
   9   Chrome install in appropriate directory structure. It reads chrome.release
  10   file as input, creates chrome.7z archive, compresses setup.exe and
  11   generates packed_files.txt for mini_installer project.
  12
  13 """
  14
  15 import ConfigParser
  16 import glob
  17 import optparse
  18 import os
  19 import shutil
  20 import subprocess
  21 import sys
  22
  23
  24 ARCHIVE_DIR = "installer_archive"
  25
  26 # suffix to uncompresed full archive file, appended to options.output_name
  27 ARCHIVE_SUFFIX = ".7z"
  28 BSDIFF_EXEC = "bsdiff.exe"
  29 CHROME_DIR = "Chrome-bin"
  30 CHROME_PATCH_FILE_SUFFIX = "_patch"  # prefixed by options.output_name
  31
  32 # compressed full archive suffix, will be prefixed by options.output_name
  33 COMPRESSED_ARCHIVE_SUFFIX = ".packed.7z"
  34
  35 COMPRESSED_FILE_EXT = ".packed.7z"     # extension of patch archive file
  36 COURGETTE_EXEC = "courgette.exe"
  37 MINI_INSTALLER_INPUT_FILE = "packed_files.txt"
  38 PATCH_FILE_EXT = '.diff'
  39 SETUP_EXEC = "setup.exe"
  40 SETUP_PATCH_FILE_PREFIX = "setup_patch"
  41 TEMP_ARCHIVE_DIR = "temp_installer_archive"
  42 VERSION_FILE = "VERSION"
  43
  44
  45 def BuildVersion(build_dir):
  46   """Returns the full build version string constructed from information in
  47   VERSION_FILE.  Any segment not found in that file will default to '0'.
  48   """
  49   major = 0
  50   minor = 0
  51   build = 0
  52   patch = 0
  53   for line in open(os.path.join(build_dir, '../../chrome', VERSION_FILE), 'r'):
  54     line = line.rstrip()
  55     if line.startswith('MAJOR='):
  56       major = line[6:]
  57     elif line.startswith('MINOR='):
  58       minor = line[6:]
  59     elif line.startswith('BUILD='):
  60       build = line[6:]
  61     elif line.startswith('PATCH='):
  62       patch = line[6:]
  63   return '%s.%s.%s.%s' % (major, minor, build, patch)
  64
  65
  66 def CompressUsingLZMA(build_dir, compressed_file, input_file):
  67   lzma_exec = GetLZMAExec(build_dir)
  68   cmd = [lzma_exec,
  69          'a', '-t7z',
  70           # Flags equivalent to -mx9 (ultra) but with the bcj2 turned on (exe
  71           # pre-filter). This results in a ~2.3MB decrease in installer size on
  72           # a 24MB installer.
  73           # Additionally, these settings reflect a 7zip 4.42 and up change in
  74           # the definition of -mx9, increasting the dicionary size moving to
  75           # 26bit = 64MB. This results in an additional ~3.5MB decrease.
  76           # Older 7zip versions can support these settings, as these changes
  77           # rely on existing functionality in the lzma format.
  78           '-m0=BCJ2',
  79           '-m1=LZMA:d27:fb128',
  80           '-m2=LZMA:d22:fb128:mf=bt2',
  81           '-m3=LZMA:d22:fb128:mf=bt2',
  82           '-mb0:1',
  83           '-mb0s1:2',
  84           '-mb0s2:3',
  85           compressed_file,
  86           input_file,]
  87   if os.path.exists(compressed_file):
  88     os.remove(compressed_file)
  89   RunSystemCommand(cmd)
  90
  91
  92 def CopyAllFilesToStagingDir(config, distribution, staging_dir, build_dir,
  93                              enable_hidpi, enable_touch_ui):
  94   """Copies the files required for installer archive.
  95   Copies all common files required for various distributions of Chromium and
  96   also files for the specific Chromium build specified by distribution.
  97   """
  98   CopySectionFilesToStagingDir(config, 'GENERAL', staging_dir, build_dir)
  99   if distribution:
 100     if len(distribution) > 1 and distribution[0] == '_':
 101       distribution = distribution[1:]
 102     CopySectionFilesToStagingDir(config, distribution.upper(),
 103                                  staging_dir, build_dir)
 104   if enable_hidpi == '1':
 105     CopySectionFilesToStagingDir(config, 'HIDPI', staging_dir, build_dir)
 106   if enable_touch_ui == '1':
 107     CopySectionFilesToStagingDir(config, 'TOUCH', staging_dir, build_dir)
 108
 109
 110 def CopySectionFilesToStagingDir(config, section, staging_dir, src_dir):
 111   """Copies installer archive files specified in section from src_dir to
 112   staging_dir. This method reads section from config and copies all the
 113   files specified from src_dir to staging dir.
 114   """
 115   for option in config.options(section):
 116     if option.endswith('dir'):
 117       continue
 118
 119     dst_dir = os.path.join(staging_dir, config.get(section, option))
 120     src_paths = glob.glob(os.path.join(src_dir, option))
 121     if src_paths and not os.path.exists(dst_dir):
 122       os.makedirs(dst_dir)
 123     for src_path in src_paths:
 124       dst_path = os.path.join(dst_dir, os.path.basename(src_path))
 125       if not os.path.exists(dst_path):
 126         shutil.copy(src_path, dst_dir)
 127
 128 def GenerateDiffPatch(options, orig_file, new_file, patch_file):
 129   if (options.diff_algorithm == "COURGETTE"):
 130     exe_file = os.path.join(options.last_chrome_installer, COURGETTE_EXEC)
 131     cmd = '%s -gen "%s" "%s" "%s"' % (exe_file, orig_file, new_file, patch_file)
 132   else:
 133     exe_file = os.path.join(options.build_dir, BSDIFF_EXEC)
 134     cmd = [exe_file, orig_file, new_file, patch_file,]
 135   RunSystemCommand(cmd)
 136
 137 def GetLZMAExec(build_dir):
 138   lzma_exec = os.path.join(build_dir, "..", "..", "third_party",
 139                            "lzma_sdk", "Executable", "7za.exe")
 140   return lzma_exec
 141
 142 def GetPrevVersion(build_dir, temp_dir, last_chrome_installer, output_name):
 143   if not last_chrome_installer:
 144     return ''
 145
 146   lzma_exec = GetLZMAExec(build_dir)
 147   prev_archive_file = os.path.join(last_chrome_installer,
 148                                    output_name + ARCHIVE_SUFFIX)
 149   cmd = [lzma_exec,
 150          'x',
 151          '-o"%s"' % temp_dir,
 152          prev_archive_file,
 153          'Chrome-bin/*/chrome.dll',]
 154   RunSystemCommand(cmd)
 155   dll_path = glob.glob(os.path.join(temp_dir, 'Chrome-bin', '*', 'chrome.dll'))
 156   return os.path.split(os.path.split(dll_path[0])[0])[1]
 157
 158 def MakeStagingDirectories(staging_dir):
 159   """Creates a staging path for installer archive. If directory exists already,
 160   deletes the existing directory.
 161   """
 162   file_path = os.path.join(staging_dir, TEMP_ARCHIVE_DIR)
 163   if os.path.exists(file_path):
 164     shutil.rmtree(file_path)
 165   os.makedirs(file_path)
 166
 167   temp_file_path = os.path.join(staging_dir, TEMP_ARCHIVE_DIR)
 168   if os.path.exists(temp_file_path):
 169     shutil.rmtree(temp_file_path)
 170   os.makedirs(temp_file_path)
 171   return (file_path, temp_file_path)
 172
 173 def Readconfig(input_file, current_version):
 174   """Reads config information from input file after setting default value of
 175   global variabes.
 176   """
 177   variables = {}
 178   variables['ChromeDir'] = CHROME_DIR
 179   variables['VersionDir'] = os.path.join(variables['ChromeDir'],
 180                                           current_version)
 181   config = ConfigParser.SafeConfigParser(variables)
 182   config.read(input_file)
 183   return config
 184
 185 def RunSystemCommand(cmd, **kw):
 186   print 'Running', cmd
 187   exit_code = subprocess.call(cmd, **kw)
 188   if (exit_code != 0):
 189     raise Exception("Error while running cmd: %s, exit_code: %s" %
 190                     (cmd, exit_code))
 191
 192 def CreateArchiveFile(options, staging_dir, current_version, prev_version):
 193   """Creates a new installer archive file after deleting any existing old file.
 194   """
 195   # First create an uncompressed archive file for the current build (chrome.7z)
 196   lzma_exec = GetLZMAExec(options.build_dir)
 197   archive_file = os.path.join(options.output_dir,
 198                               options.output_name + ARCHIVE_SUFFIX)
 199   cmd = [lzma_exec,
 200          'a',
 201          '-t7z',
 202          archive_file,
 203          os.path.join(staging_dir, CHROME_DIR),
 204          '-mx0',]
 205   # There doesnt seem to be any way in 7za.exe to override existing file so
 206   # we always delete before creating a new one.
 207   if not os.path.exists(archive_file):
 208     RunSystemCommand(cmd)
 209   elif options.skip_rebuild_archive != "true":
 210     os.remove(archive_file)
 211     RunSystemCommand(cmd)
 212
 213   # Do not compress the archive in developer (component) builds.
 214   if options.component_build == '1':
 215     compressed_file = os.path.join(
 216         options.output_dir, options.output_name + COMPRESSED_ARCHIVE_SUFFIX)
 217     if os.path.exists(compressed_file):
 218       os.remove(compressed_file)
 219     return os.path.basename(archive_file)
 220
 221   # If we are generating a patch, run bsdiff against previous build and
 222   # compress the resulting patch file. If this is not a patch just compress the
 223   # uncompressed archive file.
 224   patch_name_prefix = options.output_name + CHROME_PATCH_FILE_SUFFIX
 225   if options.last_chrome_installer:
 226     prev_archive_file = os.path.join(options.last_chrome_installer,
 227                                      options.output_name + ARCHIVE_SUFFIX)
 228     patch_file = os.path.join(options.build_dir, patch_name_prefix +
 229                                                   PATCH_FILE_EXT)
 230     GenerateDiffPatch(options, prev_archive_file, archive_file, patch_file)
 231     compressed_archive_file = patch_name_prefix + '_' + \
 232                               current_version + '_from_' + prev_version + \
 233                               COMPRESSED_FILE_EXT
 234     orig_file = patch_file
 235   else:
 236     compressed_archive_file = options.output_name + COMPRESSED_ARCHIVE_SUFFIX
 237     orig_file = archive_file
 238
 239   compressed_archive_file_path = os.path.join(options.output_dir,
 240                                               compressed_archive_file)
 241   CompressUsingLZMA(options.build_dir, compressed_archive_file_path, orig_file)
 242
 243   return compressed_archive_file
 244
 245
 246 def PrepareSetupExec(options, current_version, prev_version):
 247   """Prepares setup.exe for bundling in mini_installer based on options."""
 248   if options.setup_exe_format == "FULL":
 249     setup_file = SETUP_EXEC
 250   elif options.setup_exe_format == "DIFF":
 251     if not options.last_chrome_installer:
 252       raise Exception(
 253           "To use DIFF for setup.exe, --last_chrome_installer is needed.")
 254     prev_setup_file = os.path.join(options.last_chrome_installer, SETUP_EXEC)
 255     new_setup_file = os.path.join(options.build_dir, SETUP_EXEC)
 256     patch_file = os.path.join(options.build_dir, SETUP_PATCH_FILE_PREFIX +
 257                                                   PATCH_FILE_EXT)
 258     GenerateDiffPatch(options, prev_setup_file, new_setup_file, patch_file)
 259     setup_file = SETUP_PATCH_FILE_PREFIX + '_' + current_version + \
 260                  '_from_' + prev_version + COMPRESSED_FILE_EXT
 261     setup_file_path = os.path.join(options.build_dir, setup_file)
 262     CompressUsingLZMA(options.build_dir, setup_file_path, patch_file)
 263   else:
 264     cmd = ['makecab.exe',
 265            '/D', 'CompressionType=LZX',
 266            '/V1',
 267            '/L', options.output_dir,
 268            os.path.join(options.build_dir, SETUP_EXEC),]
 269     # Send useless makecab progress on stdout to the bitbucket.
 270     RunSystemCommand(cmd, stdout=open(os.devnull, "w"))
 271     setup_file = SETUP_EXEC[:-1] + "_"
 272   return setup_file
 273
 274
 275 _RESOURCE_FILE_TEMPLATE = """\
 276 // This file is automatically generated by create_installer_archive.py.
 277 // It contains the resource entries that are going to be linked inside
 278 // mini_installer.exe. For each file to be linked there should be two
 279 // lines:
 280 // - The first line contains the output filename (without path) and the
 281 // type of the resource ('BN' - not compressed , 'BL' - LZ compressed,
 282 // 'B7' - LZMA compressed)
 283 // - The second line contains the path to the input file. Uses '/' to
 284 // separate path components.
 285
 286 %(setup_file)s  %(setup_file_resource_type)s
 287     "%(setup_file_path)s"
 288
 289 %(archive_file)s  B7
 290     "%(archive_file_path)s"
 291 """
 292
 293
 294 def CreateResourceInputFile(
 295     output_dir, setup_format, archive_file, setup_file, resource_file_path):
 296   """Creates resource input file (packed_files.txt) for mini_installer project.
 297
 298   This method checks the format of setup.exe being used and according sets
 299   its resource type.
 300   """
 301   setup_resource_type = "BL"
 302   if (setup_format == "FULL"):
 303     setup_resource_type = "BN"
 304   elif (setup_format == "DIFF"):
 305     setup_resource_type = "B7"
 306
 307   # Expand the resource file template.
 308   args = {
 309       'setup_file': setup_file,
 310       'setup_file_resource_type': setup_resource_type,
 311       'setup_file_path':
 312           os.path.join(output_dir, setup_file).replace("\\","/"),
 313       'archive_file': archive_file,
 314       'archive_file_path':
 315           os.path.join(output_dir, archive_file).replace("\\","/"),
 316       }
 317   resource_file = _RESOURCE_FILE_TEMPLATE % args
 318
 319   with open(resource_file_path, 'w') as f:
 320     f.write(resource_file)
 321
 322
 323 # Reads |manifest_name| from |build_dir| and writes |manifest_name| to
 324 # |output_dir| with the same content plus |inserted_string| added just before
 325 # |insert_before|.
 326 def CopyAndAugmentManifest(build_dir, output_dir, manifest_name,
 327                            inserted_string, insert_before):
 328   manifest_file = open(os.path.join(build_dir, manifest_name), 'r')
 329   manifest_lines = manifest_file.readlines()
 330   manifest_file.close()
 331
 332   insert_line = -1
 333   insert_pos = -1
 334   for i in xrange(len(manifest_lines)):
 335     insert_pos = manifest_lines[i].find(insert_before)
 336     if insert_pos != -1:
 337       insert_line = i
 338       break
 339   if insert_line == -1:
 340     raise ValueError('Could not find {0} in the manifest:\n{1}'.format(
 341         insert_before, ''.join(manifest_lines)))
 342   old = manifest_lines[insert_line]
 343   manifest_lines[insert_line] = (old[:insert_pos] + inserted_string +
 344                                  old[insert_pos:])
 345
 346   modified_manifest_file = open(
 347       os.path.join(output_dir, manifest_name), 'w')
 348   modified_manifest_file.write(''.join(manifest_lines))
 349   modified_manifest_file.close()
 350
 351
 352 # Copy the relevant CRT DLLs to |build_dir|. We copy DLLs from all versions
 353 # of VS installed to make sure we have the correct CRT version, unused DLLs
 354 # should not conflict with the others anyways.
 355 def CopyVisualStudioRuntimeDLLs(build_dir, target_arch):
 356   is_debug = os.path.basename(build_dir).startswith('Debug')
 357   if not is_debug and not os.path.basename(build_dir).startswith('Release'):
 358     print ("Warning: could not determine build configuration from "
 359            "output directory, assuming Release build.")
 360
 361   crt_dlls = []
 362   sys_dll_dir = None
 363   if is_debug:
 364     crt_dlls = glob.glob(
 365         "C:/Program Files (x86)/Microsoft Visual Studio */VC/redist/"
 366         "Debug_NonRedist/" + target_arch + "/Microsoft.*.DebugCRT/*.dll")
 367   else:
 368     crt_dlls = glob.glob(
 369         "C:/Program Files (x86)/Microsoft Visual Studio */VC/redist/" +
 370         target_arch + "/Microsoft.*.CRT/*.dll")
 371
 372   # Also handle the case where someone is building using only winsdk and
 373   # doesn't have Visual Studio installed.
 374   if not crt_dlls:
 375     if target_arch == 'x64':
 376       # check we are are on a 64bit system by existence of WOW64 dir
 377       if os.access("C:/Windows/SysWOW64", os.F_OK):
 378         sys_dll_dir = "C:/Windows/System32"
 379       else:
 380         # only support packaging of 64bit installer on 64bit system
 381         # but this just as bad as not finding DLLs at all so we
 382         # don't abort here to mirror behavior below
 383         print ("Warning: could not find x64 CRT DLLs on x86 system.")
 384     else:
 385       # On a 64-bit system, 32-bit dlls are in SysWOW64 (don't ask).
 386       if os.access("C:/Windows/SysWOW64", os.F_OK):
 387         sys_dll_dir = "C:/Windows/SysWOW64"
 388       else:
 389         sys_dll_dir = "C:/Windows/System32"
 390
 391     if sys_dll_dir is not None:
 392       if is_debug:
 393         crt_dlls = glob.glob(os.path.join(sys_dll_dir, "msvc*0d.dll"))
 394       else:
 395         crt_dlls = glob.glob(os.path.join(sys_dll_dir, "msvc*0.dll"))
 396
 397   if not crt_dlls:
 398     print ("Warning: could not find CRT DLLs to copy to build dir - target "
 399            "may not run on a system that doesn't have those DLLs.")
 400
 401   for dll in crt_dlls:
 402     shutil.copy(dll, build_dir)
 403
 404
 405 # Copies component build DLLs and generates required config files and manifests
 406 # in order for chrome.exe and setup.exe to be able to find those DLLs at
 407 # run-time.
 408 # This is meant for developer builds only and should never be used to package
 409 # an official build.
 410 def DoComponentBuildTasks(staging_dir, build_dir, target_arch, current_version):
 411   # Get the required directories for the upcoming operations.
 412   chrome_dir = os.path.join(staging_dir, CHROME_DIR)
 413   version_dir = os.path.join(chrome_dir, current_version)
 414   installer_dir = os.path.join(version_dir, 'Installer')
 415   # |installer_dir| is technically only created post-install, but we need it
 416   # now to add setup.exe's config and manifest to the archive.
 417   if not os.path.exists(installer_dir):
 418     os.mkdir(installer_dir)
 419
 420   # Copy the VS CRT DLLs to |build_dir|. This must be done before the general
 421   # copy step below to ensure the CRT DLLs are added to the archive and marked
 422   # as a dependency in the exe manifests generated below.
 423   CopyVisualStudioRuntimeDLLs(build_dir, target_arch)
 424
 425   # Copy all the DLLs in |build_dir| to the version directory. Simultaneously
 426   # build a list of their names to mark them as dependencies of chrome.exe and
 427   # setup.exe later.
 428   dlls = glob.glob(os.path.join(build_dir, '*.dll'))
 429   dll_names = []
 430   for dll in dlls:
 431     # remoting_*.dll's don't belong in the archive (it doesn't depend on them
 432     # in gyp). Trying to copy them causes a build race when creating the
 433     # installer archive in component mode. See: crbug.com/180996
 434     if os.path.basename(dll).startswith('remoting_'):
 435       continue
 436     shutil.copy(dll, version_dir)
 437     dll_names.append(os.path.splitext(os.path.basename(dll))[0])
 438
 439   exe_config = (
 440       "<configuration>\n"
 441       "  <windows>\n"
 442       "    <assemblyBinding xmlns='urn:schemas-microsoft-com:asm.v1'>\n"
 443       "        <probing privatePath='{rel_path}'/>\n"
 444       "    </assemblyBinding>\n"
 445       "  </windows>\n"
 446       "</configuration>")
 447
 448   # Write chrome.exe.config to point to the version directory.
 449   chrome_exe_config_file = open(
 450       os.path.join(chrome_dir, 'chrome.exe.config'), 'w')
 451   chrome_exe_config_file.write(exe_config.format(rel_path=current_version))
 452   chrome_exe_config_file.close()
 453
 454   # Write setup.exe.config to point to the version directory (which is one
 455   # level up from setup.exe post-install).
 456   setup_exe_config_file = open(
 457       os.path.join(installer_dir, 'setup.exe.config'), 'w')
 458   setup_exe_config_file.write(exe_config.format(rel_path='..'))
 459   setup_exe_config_file.close()
 460
 461   # Add a dependency for each DLL in |dlls| to the existing manifests for
 462   # chrome.exe and setup.exe. Some of these DLLs are not actually used by
 463   # either process, but listing them all as dependencies doesn't hurt as it
 464   # only makes them visible to the exes, just like they already are in the
 465   # build output directory.
 466   exe_manifest_dependencies_list = []
 467   for name in dll_names:
 468     exe_manifest_dependencies_list.append(
 469         "<dependency>"
 470         "<dependentAssembly>"
 471         "<assemblyIdentity type='win32' name='chrome.{dll_name}' "
 472         "version='0.0.0.0' language='*'/>"
 473         "</dependentAssembly>"
 474         "</dependency>".format(dll_name=name))
 475
 476   exe_manifest_dependencies = ''.join(exe_manifest_dependencies_list)
 477
 478   # Write a modified chrome.exe.manifest beside chrome.exe.
 479   CopyAndAugmentManifest(build_dir, chrome_dir, 'chrome.exe.manifest',
 480                          exe_manifest_dependencies, '</assembly>')
 481
 482   # Write a modified setup.exe.manifest beside setup.exe in
 483   # |version_dir|/Installer.
 484   CopyAndAugmentManifest(build_dir, installer_dir, 'setup.exe.manifest',
 485                          exe_manifest_dependencies, '</assembly>')
 486
 487   # Generate assembly manifests for each DLL in |dlls|. These do not interfere
 488   # with the private manifests potentially embedded in each DLL. They simply
 489   # allow chrome.exe and setup.exe to see those DLLs although they are in a
 490   # separate directory post-install.
 491   for name in dll_names:
 492     dll_manifest = (
 493         "<assembly\n"
 494         "    xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>\n"
 495         "  <assemblyIdentity name='chrome.{dll_name}' version='0.0.0.0'\n"
 496         "      type='win32'/>\n"
 497         "  <file name='{dll_name}.dll'/>\n"
 498         "</assembly>".format(dll_name=name))
 499
 500     dll_manifest_file = open(os.path.join(
 501         version_dir, "chrome.{dll_name}.manifest".format(dll_name=name)), 'w')
 502     dll_manifest_file.write(dll_manifest)
 503     dll_manifest_file.close()
 504
 505
 506 def main(options):
 507   """Main method that reads input file, creates archive file and write
 508   resource input file.
 509   """
 510   current_version = BuildVersion(options.build_dir)
 511
 512   config = Readconfig(options.input_file, current_version)
 513
 514   (staging_dir, temp_dir) = MakeStagingDirectories(options.staging_dir)
 515
 516   prev_version = GetPrevVersion(options.build_dir, temp_dir,
 517                                 options.last_chrome_installer,
 518                                 options.output_name)
 519
 520   # Preferentially copy the files we can find from the output_dir, as
 521   # this is where we'll find the Syzygy-optimized executables when
 522   # building the optimized mini_installer.
 523   if options.build_dir != options.output_dir:
 524     CopyAllFilesToStagingDir(config, options.distribution,
 525                              staging_dir, options.output_dir,
 526                              options.enable_hidpi, options.enable_touch_ui)
 527
 528   # Now copy the remainder of the files from the build dir.
 529   CopyAllFilesToStagingDir(config, options.distribution,
 530                            staging_dir, options.build_dir,
 531                            options.enable_hidpi, options.enable_touch_ui)
 532
 533   if options.component_build == '1':
 534     DoComponentBuildTasks(staging_dir, options.build_dir,
 535                           options.target_arch, current_version)
 536
 537   version_numbers = current_version.split('.')
 538   current_build_number = version_numbers[2] + '.' + version_numbers[3]
 539   prev_build_number = ''
 540   if prev_version:
 541     version_numbers = prev_version.split('.')
 542     prev_build_number = version_numbers[2] + '.' + version_numbers[3]
 543
 544   # Name of the archive file built (for example - chrome.7z or
 545   # patch-<old_version>-<new_version>.7z or patch-<new_version>.7z
 546   archive_file = CreateArchiveFile(options, staging_dir,
 547                                    current_build_number, prev_build_number)
 548
 549   setup_file = PrepareSetupExec(options,
 550                                 current_build_number, prev_build_number)
 551
 552   CreateResourceInputFile(options.output_dir, options.setup_exe_format,
 553                           archive_file, setup_file, options.resource_file_path)
 554
 555 def _ParseOptions():
 556   parser = optparse.OptionParser()
 557   parser.add_option('-i', '--input_file',
 558       help='Input file describing which files to archive.')
 559   parser.add_option('-b', '--build_dir',
 560       help='Build directory. The paths in input_file are relative to this.')
 561   parser.add_option('--staging_dir',
 562       help='Staging directory where intermediate files and directories '
 563            'will be created')
 564   parser.add_option('-o', '--output_dir',
 565       help='The output directory where the archives will be written. '
 566             'Defaults to the build_dir.')
 567   parser.add_option('--resource_file_path',
 568       help='The path where the resource file will be output. '
 569            'Defaults to %s in the build directory.' %
 570                MINI_INSTALLER_INPUT_FILE)
 571   parser.add_option('-d', '--distribution',
 572       help='Name of Chromium Distribution. Optional.')
 573   parser.add_option('-s', '--skip_rebuild_archive',
 574       default="False", help='Skip re-building Chrome.7z archive if it exists.')
 575   parser.add_option('-l', '--last_chrome_installer',
 576       help='Generate differential installer. The value of this parameter '
 577            'specifies the directory that contains base versions of '
 578            'setup.exe, courgette.exe (if --diff_algorithm is COURGETTE) '
 579            '& chrome.7z.')
 580   parser.add_option('-f', '--setup_exe_format', default='COMPRESSED',
 581       help='How setup.exe should be included {COMPRESSED|DIFF|FULL}.')
 582   parser.add_option('-a', '--diff_algorithm', default='BSDIFF',
 583       help='Diff algorithm to use when generating differential patches '
 584            '{BSDIFF|COURGETTE}.')
 585   parser.add_option('-n', '--output_name', default='chrome',
 586       help='Name used to prefix names of generated archives.')
 587   parser.add_option('--enable_hidpi', default='0',
 588       help='Whether to include HiDPI resource files.')
 589   parser.add_option('--enable_touch_ui', default='0',
 590       help='Whether to include resource files from the "TOUCH" section of the '
 591            'input file.')
 592   parser.add_option('--component_build', default='0',
 593       help='Whether this archive is packaging a component build. This will '
 594            'also turn off compression of chrome.7z into chrome.packed.7z and '
 595            'helpfully delete any old chrome.packed.7z in |output_dir|.')
 596   parser.add_option('--target_arch', default='x86',
 597       help='Specify the target architecture for installer - this is used '
 598            'to determine which CRT runtime files to pull and package '
 599            'with the installer archive {x86|x64}.')
 600
 601   options, _ = parser.parse_args()
 602   if not options.build_dir:
 603     parser.error('You must provide a build dir.')
 604
 605   options.build_dir = os.path.normpath(options.build_dir)
 606
 607   if not options.staging_dir:
 608     parser.error('You must provide a staging dir.')
 609
 610   if not options.input_file:
 611     parser.error('You must provide an input file')
 612
 613   if not options.output_dir:
 614     options.output_dir = options.build_dir
 615
 616   if not options.resource_file_path:
 617     options.resource_file_path = os.path.join(options.build_dir,
 618                                               MINI_INSTALLER_INPUT_FILE)
 619
 620   return options
 621
 622
 623 if '__main__' == __name__:
 624   print sys.argv
 625   sys.exit(main(_ParseOptions()))