Make create_installer_archive.py operate silently by default.

chrome/tools/build/win/create_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.
 
 """Script to create Chrome Installer archive.
 
   This script is used to create an archive of all the files required for a
   Chrome install in appropriate directory structure. It reads chrome.release
   file as input, creates chrome.7z archive, compresses setup.exe and
@@ skipping 48 matching lines @@
       major = line[6:]
     elif line.startswith('MINOR='):
       minor = line[6:]
     elif line.startswith('BUILD='):
       build = line[6:]
     elif line.startswith('PATCH='):
       patch = line[6:]
   return '%s.%s.%s.%s' % (major, minor, build, patch)
 
 
-def CompressUsingLZMA(build_dir, compressed_file, input_file):
+def CompressUsingLZMA(build_dir, compressed_file, input_file, verbose):
   lzma_exec = GetLZMAExec(build_dir)
   cmd = [lzma_exec,
          'a', '-t7z',
           # Flags equivalent to -mx9 (ultra) but with the bcj2 turned on (exe
           # pre-filter). This results in a ~2.3MB decrease in installer size on
           # a 24MB installer.
           # Additionally, these settings reflect a 7zip 4.42 and up change in
           # the definition of -mx9, increasting the dicionary size moving to
           # 26bit = 64MB. This results in an additional ~3.5MB decrease.
           # Older 7zip versions can support these settings, as these changes
           # rely on existing functionality in the lzma format.
           '-m0=BCJ2',
           '-m1=LZMA:d27:fb128',
           '-m2=LZMA:d22:fb128:mf=bt2',
           '-m3=LZMA:d22:fb128:mf=bt2',
           '-mb0:1',
           '-mb0s1:2',
           '-mb0s2:3',
           compressed_file,
           input_file,]
   if os.path.exists(compressed_file):
     os.remove(compressed_file)
-  RunSystemCommand(cmd)
+  RunSystemCommand(cmd, verbose)
 
 
 def CopyAllFilesToStagingDir(config, distribution, staging_dir, build_dir,
                              enable_hidpi):
   """Copies the files required for installer archive.
   Copies all common files required for various distributions of Chromium and
   also files for the specific Chromium build specified by distribution.
   """
   CopySectionFilesToStagingDir(config, 'GENERAL', staging_dir, build_dir)
   if distribution:
@@ skipping 24 matching lines @@
         g_archive_inputs.append(src_path)
         shutil.copy(src_path, dst_dir)
 
 def GenerateDiffPatch(options, orig_file, new_file, patch_file):
   if (options.diff_algorithm == "COURGETTE"):
     exe_file = os.path.join(options.last_chrome_installer, COURGETTE_EXEC)
     cmd = '%s -gen "%s" "%s" "%s"' % (exe_file, orig_file, new_file, patch_file)
   else:
     exe_file = os.path.join(options.build_dir, BSDIFF_EXEC)
     cmd = [exe_file, orig_file, new_file, patch_file,]
-  RunSystemCommand(cmd)
+  RunSystemCommand(cmd, options.verbose)
 
 def GetLZMAExec(build_dir):
   lzma_exec = os.path.join(build_dir, "..", "..", "third_party",
                            "lzma_sdk", "Executable", "7za.exe")
   return lzma_exec
 
 def GetPrevVersion(build_dir, temp_dir, last_chrome_installer, output_name):
   if not last_chrome_installer:
     return ''
 
   lzma_exec = GetLZMAExec(build_dir)
   prev_archive_file = os.path.join(last_chrome_installer,
                                    output_name + ARCHIVE_SUFFIX)
   cmd = [lzma_exec,
          'x',
          '-o"%s"' % temp_dir,
          prev_archive_file,
          'Chrome-bin/*/chrome.dll',]
-  RunSystemCommand(cmd)
+  RunSystemCommand(cmd, options.verbose)
   dll_path = glob.glob(os.path.join(temp_dir, 'Chrome-bin', '*', 'chrome.dll'))
   return os.path.split(os.path.split(dll_path[0])[0])[1]
 
 def MakeStagingDirectories(staging_dir):
   """Creates a staging path for installer archive. If directory exists already,
   deletes the existing directory.
   """
   file_path = os.path.join(staging_dir, TEMP_ARCHIVE_DIR)
   if os.path.exists(file_path):
     shutil.rmtree(file_path)
@@ skipping 10 matching lines @@
   global variabes.
   """
   variables = {}
   variables['ChromeDir'] = CHROME_DIR
   variables['VersionDir'] = os.path.join(variables['ChromeDir'],
                                           current_version)
   config = ConfigParser.SafeConfigParser(variables)
   config.read(input_file)
   return config
 
-def RunSystemCommand(cmd, **kw):
-  print 'Running', cmd
+def RunSystemCommand(cmd, verbose, **kw):
+  """Runs |cmd|, printing verbose output if |verbose| and redirecting its output
+  to os.devnull otherwise.
+  """
+  if verbose:
+    print 'Running', cmd
+  else:
+    kw['stdout'] = open(os.devnull, "w")
   exit_code = subprocess.call(cmd, **kw)
   if (exit_code != 0):
     raise Exception("Error while running cmd: %s, exit_code: %s" %

[grt (UTC plus 2), 2015/09/30 18:25:08]

is it possible to capture the command's stdout in the non-verbose case and emit
it here? i imagine it would make diagnosing failures in official builds easier
if the output was included in case of error.

[gab, 2015/10/01 14:21:18]

Improved the way stdout/stderr capture is done by this method, PTAL.

[grt (UTC plus 2), 2015/10/01 14:31:56]

awesome!

                     (cmd, exit_code))
 
 def CreateArchiveFile(options, staging_dir, current_version, prev_version):
   """Creates a new installer archive file after deleting any existing old file.
   """
   # First create an uncompressed archive file for the current build (chrome.7z)
   lzma_exec = GetLZMAExec(options.build_dir)
   archive_file = os.path.join(options.output_dir,
                               options.output_name + ARCHIVE_SUFFIX)
   if options.depfile:
@@ skipping 36 matching lines @@
 
   cmd = [lzma_exec,
          'a',
          '-t7z',
          archive_file,
          os.path.join(staging_dir, CHROME_DIR),
          '-mx0',]
   # There doesnt seem to be any way in 7za.exe to override existing file so
   # we always delete before creating a new one.
   if not os.path.exists(archive_file):
-    RunSystemCommand(cmd)
+    RunSystemCommand(cmd, options.verbose)
   elif options.skip_rebuild_archive != "true":
     os.remove(archive_file)
-    RunSystemCommand(cmd)
+    RunSystemCommand(cmd, options.verbose)
 
   # Do not compress the archive in developer (component) builds.
   if options.component_build == '1':
     compressed_file = os.path.join(
         options.output_dir, options.output_name + COMPRESSED_ARCHIVE_SUFFIX)
     if os.path.exists(compressed_file):
       os.remove(compressed_file)
     return os.path.basename(archive_file)
 
   # If we are generating a patch, run bsdiff against previous build and
   # compress the resulting patch file. If this is not a patch just compress the
   # uncompressed archive file.
   patch_name_prefix = options.output_name + CHROME_PATCH_FILE_SUFFIX
   if options.last_chrome_installer:
     prev_archive_file = os.path.join(options.last_chrome_installer,
                                      options.output_name + ARCHIVE_SUFFIX)
     patch_file = os.path.join(options.build_dir, patch_name_prefix +
                                                   PATCH_FILE_EXT)
     GenerateDiffPatch(options, prev_archive_file, archive_file, patch_file)
     compressed_archive_file = patch_name_prefix + '_' + \
                               current_version + '_from_' + prev_version + \
                               COMPRESSED_FILE_EXT
     orig_file = patch_file
   else:
     compressed_archive_file = options.output_name + COMPRESSED_ARCHIVE_SUFFIX
     orig_file = archive_file
 
   compressed_archive_file_path = os.path.join(options.output_dir,
                                               compressed_archive_file)
-  CompressUsingLZMA(options.build_dir, compressed_archive_file_path, orig_file)
+  CompressUsingLZMA(options.build_dir, compressed_archive_file_path, orig_file,
+                    options.verbose)
 
   return compressed_archive_file
 
 
 def PrepareSetupExec(options, current_version, prev_version):
   """Prepares setup.exe for bundling in mini_installer based on options."""
   if options.setup_exe_format == "FULL":
     setup_file = SETUP_EXEC
   elif options.setup_exe_format == "DIFF":
     if not options.last_chrome_installer:
       raise Exception(
           "To use DIFF for setup.exe, --last_chrome_installer is needed.")
     prev_setup_file = os.path.join(options.last_chrome_installer, SETUP_EXEC)
     new_setup_file = os.path.join(options.build_dir, SETUP_EXEC)
     patch_file = os.path.join(options.build_dir, SETUP_PATCH_FILE_PREFIX +
                                                   PATCH_FILE_EXT)
     GenerateDiffPatch(options, prev_setup_file, new_setup_file, patch_file)
     setup_file = SETUP_PATCH_FILE_PREFIX + '_' + current_version + \
                  '_from_' + prev_version + COMPRESSED_FILE_EXT
     setup_file_path = os.path.join(options.build_dir, setup_file)
-    CompressUsingLZMA(options.build_dir, setup_file_path, patch_file)
+    CompressUsingLZMA(options.build_dir, setup_file_path, patch_file,
+                      options.verbose)
   else:
     cmd = ['makecab.exe',
            '/D', 'CompressionType=LZX',
            '/V1',
            '/L', options.output_dir,
            os.path.join(options.build_dir, SETUP_EXEC),]
     # Send useless makecab progress on stdout to the bitbucket.
-    RunSystemCommand(cmd, stdout=open(os.devnull, "w"))
+    RunSystemCommand(cmd, options.verbose, stdout=open(os.devnull, "w"))

[csharp, 2015/09/29 17:38:00]

What about removing the stdout setting here and just always pass in false for
verbose? You don't get this command printed, but then you can drop **kw

[gab, 2015/09/29 17:44:02]

Feels knowing the actual command could be useful.

@grt?

[gab, 2015/10/01 14:21:19]

Revised this as it made things more complicated for the change I just made to
RunSystemCommand().

The default output of makecab really isn't that bad (2 lines by default looks
like..) plus now that we don't emit it by default unless it fails it's really
irrelevant to specifically omit it.

     setup_file = SETUP_EXEC[:-1] + "_"
   return setup_file
 
 
 _RESOURCE_FILE_HEADER = """\
 // This file is automatically generated by create_installer_archive.py.
 // It contains the resource entries that are going to be linked inside
 // mini_installer.exe. For each file to be linked there should be two
 // lines:
 // - The first line contains the output filename (without path) and the
@@ skipping 298 matching lines @@
       help='Whether this archive is packaging a component build. This will '
            'also turn off compression of chrome.7z into chrome.packed.7z and '
            'helpfully delete any old chrome.packed.7z in |output_dir|.')
   parser.add_option('--depfile',
       help='Generate a depfile with the given name listing the implicit inputs '
            'to the archive process that can be used with a build system.')
   parser.add_option('--target_arch', default='x86',
       help='Specify the target architecture for installer - this is used '
            'to determine which CRT runtime files to pull and package '
            'with the installer archive {x86|x64}.')
+  parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
+                    default=False)
 
   options, _ = parser.parse_args()
   if not options.build_dir:
     parser.error('You must provide a build dir.')
 
   options.build_dir = os.path.normpath(options.build_dir)
 
   if not options.staging_dir:
     parser.error('You must provide a staging dir.')
 
   if not options.input_file:
     parser.error('You must provide an input file')
 
   if not options.output_dir:
     options.output_dir = options.build_dir
 
   if not options.resource_file_path:
     options.resource_file_path = os.path.join(options.build_dir,
                                               MINI_INSTALLER_INPUT_FILE)
 
   return options
 
 
 if '__main__' == __name__:
-  print sys.argv
-  sys.exit(main(_ParseOptions()))
+  options = _ParseOptions()
+  if options.verbose:
+    print sys.argv
+  sys.exit(main(options))