Switch trace_inputs.py and isolate.py to subcommand.py.

trace_inputs.py

 #!/usr/bin/env python
 # coding=utf-8
 # 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.
 
 """Traces an executable and its child processes and extract the files accessed
 by them.
 
 The implementation uses OS-specific API. The native Kernel logger and the ETL
@@ skipping 19 matching lines @@
 import re
 import stat
 import subprocess
 import sys
 import tempfile
 import threading
 import time
 import unicodedata
 import weakref
 
+from third_party import colorama
+from third_party.depot_tools import fix_encoding
+from third_party.depot_tools import subcommand
+
 ## OS-specific imports
 
 if sys.platform == 'win32':
   from ctypes.wintypes import byref, create_unicode_buffer, c_int, c_wchar_p
   from ctypes.wintypes import windll, FormatError  # pylint: disable=E0611
   from ctypes.wintypes import GetLastError  # pylint: disable=E0611
 elif sys.platform == 'darwin':
   import Carbon.File  #  pylint: disable=F0401
   import MacOS  # pylint: disable=F0401
 
@@ skipping 3579 matching lines @@
   - cwd: current directory to start the process in.
   - api: a tracing api instance.
   - output: if True, returns output, otherwise prints it at the console.
   """
   cmd = fix_python_path(cmd)
   api.clean_trace(logfile)
   with api.get_tracer(logfile) as tracer:
     return tracer.trace(cmd, cwd, 'default', output)
 
 
-def CMDclean(args):
+def CMDclean(parser, args):
   """Cleans up traces."""
-  parser = OptionParserTraceInputs(command='clean')
   options, args = parser.parse_args(args)
   api = get_api()
   api.clean_trace(options.log)
   return 0
 
 
-def CMDtrace(args):
+def CMDtrace(parser, args):
   """Traces an executable."""
-  parser = OptionParserTraceInputs(command='trace')
   parser.allow_interspersed_args = False
   parser.add_option(
       '-q', '--quiet', action='store_true',
       help='Redirects traced executable output to /dev/null')
   parser.add_option(
       '-s', '--sudo', action='store_true',
       help='Use sudo when shelling out the tracer tool (ignored on Windows)')
   parser.add_option(
       '-n', '--no-sudo', action='store_false',
       help='Don\'t use sudo')
   options, args = parser.parse_args(args)
 
   if not args:
     parser.error('Please provide a command to run')
 
   if not os.path.isabs(args[0]) and os.access(args[0], os.X_OK):
     args[0] = os.path.abspath(args[0])
 
   # options.sudo default value is None, which is to do whatever tracer defaults
   # do.
   api = get_api(use_sudo=options.sudo)
   return trace(options.log, args, os.getcwd(), api, options.quiet)[0]
 
 
-def CMDread(args):
+def CMDread(parser, args):
   """Reads the logs and prints the result."""
-  parser = OptionParserTraceInputs(command='read')
   parser.add_option(
       '-V', '--variable',
       nargs=2,
       action='append',
       dest='variables',
       metavar='VAR_NAME directory',
       default=[],
       help=('Variables to replace relative directories against. Example: '
             '"-v \'$HOME\' \'/home/%s\'" will replace all occurence of your '
             'home dir with $HOME') % getpass.getuser())
@@ skipping 77 matching lines @@
 
   def parse_args(self, *args, **kwargs):
     options, args = optparse.OptionParser.parse_args(self, *args, **kwargs)
     levels = [logging.ERROR, logging.INFO, logging.DEBUG]
     logging.basicConfig(
         level=levels[min(len(levels)-1, options.verbose)],
         format='%(levelname)5s %(module)15s(%(lineno)3d): %(message)s')
     return options, args
 
 
-class OptionParserWithNiceDescription(OptionParserWithLogging):
-  """Generates the description with the command's docstring."""
-  def __init__(self, **kwargs):
-    """Sets 'description' and 'usage' if not already specified."""
-    command = kwargs.pop('command', 'help')
-    kwargs.setdefault(
-        'description',
-        re.sub('[\r\n ]{2,}', ' ', get_command_handler(command).__doc__))
-    kwargs.setdefault('usage', '%%prog %s [options]' % command)
-    OptionParserWithLogging.__init__(self, **kwargs)
-
-
-class OptionParserTraceInputs(OptionParserWithNiceDescription):
+class OptionParserTraceInputs(OptionParserWithLogging):
   """Adds automatic --log handling."""
   def __init__(self, **kwargs):
-    OptionParserWithNiceDescription.__init__(self, **kwargs)
+    OptionParserWithLogging.__init__(self, **kwargs)
     self.add_option(
         '-l', '--log', help='Log file to generate or read, required')
 
   def parse_args(self, *args, **kwargs):
     """Makes sure the paths make sense.
 
     On Windows, / and \ are often mixed together in a path.
     """
-    options, args = OptionParserWithNiceDescription.parse_args(
+    options, args = OptionParserWithLogging.parse_args(
         self, *args, **kwargs)
     if not options.log:
       self.error('Must supply a log file with -l')
     options.log = os.path.abspath(options.log)
     return options, args
 
 
-def extract_documentation():
-  """Returns a dict {command: description} for each of documented command."""
-  commands = (
-      fn[3:]
-      for fn in dir(sys.modules['__main__'])
-      if fn.startswith('CMD') and get_command_handler(fn[3:]).__doc__)
-  return dict((fn, get_command_handler(fn).__doc__) for fn in commands)
-
-
-def CMDhelp(args):
-  """Prints list of commands or help for a specific command."""
-  doc = extract_documentation()
-  # Calculates the optimal offset.
-  offset = max(len(cmd) for cmd in doc)
-  format_str = '  %-' + str(offset + 2) + 's %s'
-  # Generate a one-liner documentation of each commands.
-  commands_description = '\n'.join(
-       format_str % (cmd, doc[cmd].split('\n')[0]) for cmd in sorted(doc))
-
-  parser = OptionParserWithNiceDescription(
-      usage='%prog <command> [options]',
-      description='Commands are:\n%s\n' % commands_description)
-  parser.format_description = lambda _: parser.description
-
-  # Strip out any -h or --help argument.
-  _, args = parser.parse_args([i for i in args if not i in ('-h', '--help')])
-  if len(args) == 1:
-    if not get_command_handler(args[0]):
-      parser.error('Unknown command %s' % args[0])
-    # The command was "%prog help command", replaces ourself with
-    # "%prog command --help" so help is correctly printed out.
-    return main(args + ['--help'])
-  elif args:
-    parser.error('Unknown argument "%s"' % ' '.join(args))
-  parser.print_help()
-  return 0
-
-
-def get_command_handler(name):
-  """Returns the command handler or CMDhelp if it doesn't exist."""
-  return getattr(sys.modules['__main__'], 'CMD%s' % name, None)
-
-
-def main_impl(argv):
-  command = get_command_handler(argv[0] if argv else 'help')
-  if not command:
-    return CMDhelp(argv)
-  return command(argv[1:])
-
 def main(argv):
-  disable_buffering()
+  dispatcher = subcommand.CommandDispatcher(__name__)
   try:
-    main_impl(argv)
+    return dispatcher.execute(OptionParserTraceInputs(), argv)
   except TracingFailure, e:
     sys.stderr.write('\nError: ')
     sys.stderr.write(str(e))
     sys.stderr.write('\n')
     return 1
 
 
 if __name__ == '__main__':
+  fix_encoding.fix_encoding()
+  disable_buffering()
+  colorama.init()
   sys.exit(main(sys.argv[1:]))