[NaCl SDK] Make build_projects quiet by default.

native_client_sdk/src/build_tools/build_projects.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 import multiprocessing
 import optparse
 import os
 import posixpath
 import sys
@@ skipping 22 matching lines @@
   'bionic',
   'newlib',
   'glibc',
   'pnacl',
   'win',
   'linux',
   'mac',
 ]
 
 # Global verbosity setting.
-# If set to try (normally via a command line arg) then build_projects will
+# If set to True (normally via a command line arg) then build_projects will
 # add V=1 to all calls to 'make'
 verbose = False
 
 
+def Trace(msg):
+  if verbose:
+    sys.stderr.write(str(msg) + '\n')
+
+
+def CopyFile(src, dst):
+  buildbot_common.CopyFile(src, dst, verbose)
+
+
+def CopyDir(src, dst, **kwargs):
+  buildbot_common.CopyDir(src, dst, verbose=verbose, **kwargs)
+
+
+def RemoveDir(dst):
+  buildbot_common.RemoveDir(dst, verbose)
+
+
+def MakeDir(dst):
+  buildbot_common.MakeDir(dst, verbose)
+
+
 def CopyFilesFromTo(filelist, srcdir, dstdir):
   for filename in filelist:
     srcpath = os.path.join(srcdir, filename)
     dstpath = os.path.join(dstdir, filename)
-    buildbot_common.CopyFile(srcpath, dstpath)
+    CopyFile(srcpath, dstpath)
 
 
 def UpdateHelpers(pepperdir, clobber=False):
   tools_dir = os.path.join(pepperdir, 'tools')
   if not os.path.exists(tools_dir):
     buildbot_common.ErrorExit('SDK tools dir is missing: %s' % tools_dir)
 
   exampledir = os.path.join(pepperdir, 'examples')
   if clobber:
-    buildbot_common.RemoveDir(exampledir)
-  buildbot_common.MakeDir(exampledir)
+    RemoveDir(exampledir)
+  MakeDir(exampledir)
 
   # Copy files for individual build and landing page
   files = ['favicon.ico', 'httpd.cmd', 'index.css', 'index.js',
       'button_close.png', 'button_close_hover.png']
   CopyFilesFromTo(files, SDK_RESOURCE_DIR, exampledir)
 
   # Copy tools scripts and make includes
-  buildbot_common.CopyDir(os.path.join(SDK_SRC_DIR, 'tools', '*.py'),
-      tools_dir)
-  buildbot_common.CopyDir(os.path.join(SDK_SRC_DIR, 'tools', '*.mk'),
-      tools_dir)
+  CopyDir(os.path.join(SDK_SRC_DIR, 'tools', '*.py'), tools_dir)
+  CopyDir(os.path.join(SDK_SRC_DIR, 'tools', '*.mk'), tools_dir)
 
   # Copy tools/lib scripts
   tools_lib_dir = os.path.join(pepperdir, 'tools', 'lib')
-  buildbot_common.MakeDir(tools_lib_dir)
-  buildbot_common.CopyDir(os.path.join(SDK_SRC_DIR, 'tools', 'lib', '*.py'),
-      tools_lib_dir)
+  MakeDir(tools_lib_dir)
+  CopyDir(os.path.join(SDK_SRC_DIR, 'tools', 'lib', '*.py'), tools_lib_dir)
 
   # On Windows add a prebuilt make
   if getos.GetPlatform() == 'win':
     buildbot_common.BuildStep('Add MAKE')
     make_url = posixpath.join(GSTORE, MAKE)
     make_exe = os.path.join(tools_dir, 'make.exe')
     with open(make_exe, 'wb') as f:
       f.write(urllib2.urlopen(make_url).read())
 
 
@@ skipping 35 matching lines @@
 
   ValidateToolchains(toolchains)
 
   # Create the library output directories
   libdir = os.path.join(pepperdir, 'lib')
   platform = getos.GetPlatform()
   for config in configs:
     for arch in LIB_DICT[platform]:
       dirpath = os.path.join(libdir, '%s_%s_host' % (platform, arch), config)
       if clobber:
-        buildbot_common.RemoveDir(dirpath)
-      buildbot_common.MakeDir(dirpath)
+        RemoveDir(dirpath)
+      MakeDir(dirpath)
 
   landing_page = None
   for branch, projects in project_tree.iteritems():
     dirpath = os.path.join(pepperdir, branch)
     if clobber:
-      buildbot_common.RemoveDir(dirpath)
-    buildbot_common.MakeDir(dirpath)
+      RemoveDir(dirpath)
+    MakeDir(dirpath)
     targets = [desc['NAME'] for desc in projects]
     deps = GetDeps(projects)
 
     # Generate master make for this branch of projects
     generate_make.GenerateMasterMakefile(pepperdir,
                                          os.path.join(pepperdir, branch),
                                          targets, deps)
 
     if branch.startswith('examples') and not landing_page:
       landing_page = LandingPage()
 
     # Generate individual projects
     for desc in projects:
       srcroot = os.path.dirname(desc['FILEPATH'])
       generate_make.ProcessProject(pepperdir, srcroot, pepperdir, desc,
                                    toolchains, configs=configs,
-                                   first_toolchain=first_toolchain)
+                                   first_toolchain=first_toolchain,
+                                   verbose=verbose)
 
       if branch.startswith('examples'):
         landing_page.AddDesc(desc)
 
   if landing_page:
     # Generate the landing page text file.
     index_html = os.path.join(pepperdir, 'examples', 'index.html')
     index_template = os.path.join(SDK_RESOURCE_DIR, 'index.html.template')
     with open(index_html, 'w') as fh:
       out = landing_page.GeneratePage(index_template)
@@ skipping 42 matching lines @@
     make_cmd.append('IGNORE_DEPS=1')
 
   if verbose:
     make_cmd.append('V=1')
 
   if args:
     make_cmd += args
   else:
     make_cmd.append('TOOLCHAIN=all')
 
-  buildbot_common.Run(make_cmd, cwd=make_dir, env=env)
+  buildbot_common.Run(make_cmd, cwd=make_dir, env=env, verbose=verbose)
   if clean:
     # Clean to remove temporary files but keep the built
-    buildbot_common.Run(make_cmd + ['clean'], cwd=make_dir, env=env)
+    buildbot_common.Run(make_cmd + ['clean'], cwd=make_dir, env=env,
+                        verbose=verbose)
 
 
 def BuildProjects(pepperdir, project_tree, deps=True,
                   clean=False, config='Debug'):
-
   # Make sure we build libraries (which live in 'src') before
   # any of the examples.
   build_first = [p for p in project_tree if p != 'src']
   build_second = [p for p in project_tree if p == 'src']
 
   for branch in build_first + build_second:
     BuildProjectsBranch(pepperdir, branch, deps, clean, config)
 
 
 def main(argv):
   parser = optparse.OptionParser()
   parser.add_option('-c', '--clobber',
       help='Clobber project directories before copying new files',
       action='store_true', default=False)
   parser.add_option('-b', '--build',
-      help='Build the projects.', action='store_true')
+      help='Build the projects. Otherwise the projects are only copied.',
+      action='store_true')
   parser.add_option('--config',
       help='Choose configuration to build (Debug or Release).  Builds both '
            'by default')
   parser.add_option('--bionic',
       help='Enable bionic projects', action='store_true')
   parser.add_option('-x', '--experimental',
       help='Build experimental projects', action='store_true')
   parser.add_option('-t', '--toolchain',
       help='Build using toolchain. Can be passed more than once.',
       action='append', default=[])
   parser.add_option('-d', '--dest',
       help='Select which build destinations (project types) are valid.',
       action='append')
   parser.add_option('-v', '--verbose', action='store_true')
 
   # To setup bash completion for this command first install optcomplete
   # and then add this line to your .bashrc:
   #  complete -F _optcomplete build_projects.py
   try:
     import optcomplete
     optcomplete.autocomplete(parser)
   except ImportError:
     pass
 
   options, args = parser.parse_args(argv[1:])
 
+  global verbose
+  if options.verbose:
+    verbose = True
+
   if 'NACL_SDK_ROOT' in os.environ:
     # We don't want the currently configured NACL_SDK_ROOT to have any effect
     # on the build.
     del os.environ['NACL_SDK_ROOT']
 
   pepper_ver = str(int(build_version.ChromeMajorVersion()))
   pepperdir = os.path.join(OUT_DIR, 'pepper_' + pepper_ver)
 
   if not options.toolchain:
     # Order matters here: the default toolchain for an example's Makefile will
     # be the first toolchain in this list that is available in the example.
     # e.g. If an example supports newlib and glibc, then the default will be
     # newlib.
     options.toolchain = ['pnacl', 'newlib', 'glibc', 'host']
     if options.experimental or options.bionic:
       options.toolchain.append('bionic')
 
   if 'host' in options.toolchain:
     options.toolchain.remove('host')
     options.toolchain.append(getos.GetPlatform())
-    print 'Adding platform: ' + getos.GetPlatform()
+    Trace('Adding platform: ' + getos.GetPlatform())
 
   ValidateToolchains(options.toolchain)
 
   filters = {}
   if options.toolchain:
     filters['TOOLS'] = options.toolchain
-    print 'Filter by toolchain: ' + str(options.toolchain)
+    Trace('Filter by toolchain: ' + str(options.toolchain))
   if not options.experimental:
     filters['EXPERIMENTAL'] = False
   if options.dest:
     filters['DEST'] = options.dest
-    print 'Filter by type: ' + str(options.dest)
+    Trace('Filter by type: ' + str(options.dest))
   if args:
     filters['NAME'] = args
-    print 'Filter by name: ' + str(args)
+    Trace('Filter by name: ' + str(args))
 
   try:
     project_tree = parse_dsc.LoadProjectTree(SDK_SRC_DIR, include=filters)
   except parse_dsc.ValidationError as e:
     buildbot_common.ErrorExit(str(e))
-  parse_dsc.PrintProjectTree(project_tree)
+
+  if verbose:
+    parse_dsc.PrintProjectTree(project_tree)
 
   UpdateHelpers(pepperdir, clobber=options.clobber)
   UpdateProjects(pepperdir, project_tree, options.toolchain,
                  clobber=options.clobber)
 
-  if options.verbose:
-    global verbose
-    verbose = True
-
   if options.build:
     if options.config:
       configs = [options.config]
     else:
       configs = ['Debug', 'Release']
     for config in configs:
       BuildProjects(pepperdir, project_tree, config=config)
 
   return 0
 
 
 if __name__ == '__main__':
   script_name = os.path.basename(sys.argv[0])
   try:
     sys.exit(main(sys.argv))
   except parse_dsc.ValidationError as e:
     buildbot_common.ErrorExit('%s: %s' % (script_name, e))
   except KeyboardInterrupt:
     buildbot_common.ErrorExit('%s: interrupted' % script_name)