Report all swarming and isolate fatal errors in a consistent way.

swarming.py

 #!/usr/bin/env python
 # Copyright 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.
 
 """Client tool to trigger tasks or retrieve results from a Swarming server."""
 
 __version__ = '0.1'
 
 import hashlib
@@ skipping 115 matching lines @@
     start_time = time.time()
     self._isolate_item = isolateserver.BufferItem(
         self.bundle.zip_into_buffer(), self._algo, is_isolated=True)
     print 'Zipping completed, time elapsed: %f' % (time.time() - start_time)
 
     try:
       start_time = time.time()
       uploaded = self.storage.upload_items([self._isolate_item])
       elapsed = time.time() - start_time
     except (IOError, OSError) as exc:
-      print >> sys.stderr, 'Failed to upload the zip file: %s' % exc
+      tools.report_error('Failed to upload the zip file: %s' % exc)
       return False
 
     if self._isolate_item in uploaded:
       print 'Upload complete, time elapsed: %f' % elapsed
     else:
       print 'Zip file already on server, time elapsed: %f' % elapsed
 
     return True
 
   def to_json(self):
@@ skipping 193 matching lines @@
     file_hash_or_isolated, test_name, shards, test_filter, slave_os,
     working_dir, isolate_server, swarming, verbose, profile, priority, algo):
   """Process the manifest file and send off the swarm test request.
 
   Optionally archives an .isolated file.
   """
   if file_hash_or_isolated.endswith('.isolated'):
     file_hash = archive(
         file_hash_or_isolated, isolate_server, slave_os, algo, verbose)
     if not file_hash:
-      print >> sys.stderr, 'Archival failure %s' % file_hash_or_isolated
+      tools.report_error('Archival failure %s' % file_hash_or_isolated)
       return 1
   elif isolateserver.is_valid_hash(file_hash_or_isolated, algo):
     file_hash = file_hash_or_isolated
   else:
-    print >> sys.stderr, 'Invalid hash %s' % file_hash_or_isolated
+    tools.report_error('Invalid hash %s' % file_hash_or_isolated)
     return 1
 
   try:
     manifest = Manifest(
         file_hash,
         test_name,
         shards,
         test_filter,
         PLATFORM_MAPPING_SWARMING[slave_os],
         working_dir,
         isolate_server,
         verbose,
         profile,
         priority,
         algo)
   except ValueError as e:
-    print >> sys.stderr, 'Unable to process %s: %s' % (test_name, e)
+    tools.report_error('Unable to process %s: %s' % (test_name, e))
     return 1
 
   chromium_setup(manifest)
 
   # Zip up relevant files.
   print('Zipping up files...')
   if not manifest.zip_and_upload():
     return 1
 
   # Send test requests off to swarm.
   print('Sending test requests to swarm.')
   print('Server: %s' % swarming)
   print('Job name: %s' % test_name)
   test_url = swarming + '/test'
   manifest_text = manifest.to_json()
   result = net.url_read(test_url, data={'request': manifest_text})
   if not result:
-    print >> sys.stderr, 'Failed to send test for %s\n%s' % (
-        test_name, test_url)
+    tools.report_error(
+        'Failed to send test for %s\n%s' % (test_name, test_url))
     return 1
   try:
     json.loads(result)
   except (ValueError, TypeError) as e:
-    print >> sys.stderr, 'Failed to send test for %s' % test_name
-    print >> sys.stderr, 'Manifest: %s' % manifest_text
-    print >> sys.stderr, 'Bad response: %s' % result
-    print >> sys.stderr, str(e)
+    msg = '\n'.join((
+        'Failed to send test for %s' % test_name,
+        'Manifest: %s' % manifest_text,
+        'Bad response: %s' % result,
+        str(e)))
+    tools.report_error(msg)
     return 1
   return 0
 
 
 def trigger(
     slave_os,
     tasks,
     task_prefix,
     working_dir,
     isolate_server,
@@ skipping 121 matching lines @@
   add_collect_options(parser)
   (options, args) = parser.parse_args(args)
   if not args:
     parser.error('Must specify one test name.')
   elif len(args) > 1:
     parser.error('Must specify only one test name.')
 
   try:
     return collect(options.swarming, args[0], options.timeout, options.decorate)
   except Failure as e:
-    parser.error(e.args[0])
+    tools.report_error(e)
+    return 1
 
 
 @subcommand.usage('[hash|isolated ...]')
 def CMDrun(parser, args):
   """Triggers a job and wait for the results.
 
   Basically, does everything to run command(s) remotely.
   """
   add_trigger_options(parser)
   add_collect_options(parser)
@@ skipping 13 matching lines @@
           options.task_prefix,
           options.working_dir,
           options.isolate_server,
           options.swarming,
           options.verbose,
           options.profile,
           options.priority)
     except Failure as e:
       result = e.args[0]
     if result:
-      print >> sys.stderr, 'Failed to trigger %s: %s' % (arg, result)
+      tools.report_error('Failed to trigger %s: %s' % (arg, result))
     else:
       success.append(os.path.basename(arg))
 
   if not success:
-    print >> sys.stderr, 'Failed to trigger any job.'
+    tools.report_error('Failed to trigger any job.')
     return result
 
   code = 0
   for arg in success:
     logging.info('Collecting %s', arg)
     try:
       new_code = collect(
           options.swarming,
           options.task_prefix + arg,
           options.timeout,
           options.decorate)
       code = max(code, new_code)
     except Failure as e:
       code = max(code, 1)
-      print >> sys.stderr, e.args[0]
+      tools.report_error(e)
   return code
 
 
 def CMDtrigger(parser, args):
   """Triggers Swarm request(s).
 
   Accepts one or multiple --task requests, with either the hash (sha1) of a
   .isolated file already uploaded or the path to an .isolated file to archive,
   packages it if needed and sends a Swarm manifest file to the Swarm server.
   """
@@ skipping 17 matching lines @@
         options.os,
         options.tasks,
         options.task_prefix,
         options.working_dir,
         options.isolate_server,
         options.swarming,
         options.verbose,
         options.profile,
         options.priority)
   except Failure as e:
-    parser.error(e.args[0])
+    tools.report_error(e)
+    return 1
 
 
 class OptionParserSwarming(tools.OptionParserWithLogging):
   def __init__(self, **kwargs):
     tools.OptionParserWithLogging.__init__(
         self, prog='swarming.py', **kwargs)
     self.add_option(
         '-S', '--swarming',
         metavar='URL', default='',
         help='Swarming server to use')
 
   def parse_args(self, *args, **kwargs):
     options, args = tools.OptionParserWithLogging.parse_args(
         self, *args, **kwargs)
     options.swarming = options.swarming.rstrip('/')
     if not options.swarming:
       self.error('--swarming is required.')
     return options, args
 
 
 def main(args):
   dispatcher = subcommand.CommandDispatcher(__name__)
   try:
     return dispatcher.execute(OptionParserSwarming(version=__version__), args)
-  except Failure as e:
-    sys.stderr.write('\nError: ')
-    sys.stderr.write(str(e))
-    sys.stderr.write('\n')
+  except Exception as e:
+    tools.report_error(e)
     return 1
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   tools.disable_buffering()
   colorama.init()
   sys.exit(main(sys.argv[1:]))