Fix running 'import run_isolated' at python interactive prompt.

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 binascii
@@ skipping 53 matching lines @@
   """Generic failure."""
   pass
 
 
 class Manifest(object):
   """Represents a Swarming task manifest.
 
   Also includes code to zip code and upload itself.
   """
   def __init__(
-      self, manifest_hash, test_name, shards, test_filter, slave_os,
+      self, isolated_hash, test_name, shards, test_filter, slave_os,
       working_dir, isolate_server, verbose, profile, priority, algo):
     """Populates a manifest object.
       Args:
-        manifest_hash - The manifest's sha-1 that the slave is going to fetch.
+        isolated_hash - The manifest's sha-1 that the slave is going to fetch.
         test_name - The name to give the test request.
         shards - The number of swarm shards to request.
         test_filter - The gtest filter to apply when running the test.
         slave_os - OS to run on.
         working_dir - Relative working directory to start the script.
         isolate_server - isolate server url.
         verbose - if True, have the slave print more details.
         profile - if True, have the slave print more timing data.
         priority - int between 0 and 1000, lower the higher priority.
         algo - hashing algorithm used.
     """
-    self.manifest_hash = manifest_hash
+    self.isolated_hash = isolated_hash
     self.bundle = zip_package.ZipPackage(ROOT_DIR)
 
     self._test_name = test_name
     self._shards = shards
     self._test_filter = test_filter
-    self._target_platform = PLATFORM_MAPPING_SWARMING[slave_os]
+    self._target_platform = slave_os
     self._working_dir = working_dir
 
     self.isolate_server = isolate_server
     self._data_server_retrieval = isolate_server + '/content/retrieve/default/'
     self._data_server_storage = isolate_server + '/content/store/default/'
     self._data_server_has = isolate_server + '/content/contains/default'
     self._data_server_get_token = isolate_server + '/content/get_token'
 
     self.verbose = bool(verbose)
     self.profile = bool(profile)
     self.priority = priority
     self._algo = algo
 
     self._zip_file_hash = ''
     self._tasks = []
-    self._files = {}
     self._token_cache = None
 
   def _token(self):
     if not self._token_cache:
       result = net.url_open(self._data_server_get_token)
       if not result:
         # TODO(maruel): Implement authentication.
         raise Failure('Failed to get token, need authentication')
       # Quote it right away, so creating the urls is simpler.
       self._token_cache = urllib.quote(result.read())
@@ skipping 47 matching lines @@
 
     return True
 
   def to_json(self):
     """Exports the current configuration into a swarm-readable manifest file.
 
     This function doesn't mutate the object.
     """
     test_case = {
       'test_case_name': self._test_name,
-      'data': [
-        [self._data_server_retrieval + urllib.quote(self._zip_file_hash),
-         'swarm_data.zip'],
-      ],
+      'data': [],
       'tests': self._tasks,
       'env_vars': {},
       'configurations': [
         {
           'min_instances': self._shards,
           'config_name': self._target_platform,
           'dimensions': {
             'os': self._target_platform,
           },
         },
       ],
       'working_dir': self._working_dir,
       'restart_on_failure': True,
       'cleanup': 'root',
       'priority': self.priority,
     }
-
+    if self._zip_file_hash:
+      test_case['data'].append(
+          [
+            self._data_server_retrieval + urllib.quote(self._zip_file_hash),
+            'swarm_data.zip',
+          ])
     # These flags are googletest specific.
     if self._test_filter and self._test_filter != '*':
       test_case['env_vars']['GTEST_FILTER'] = self._test_filter
     if self._shards > 1:
       test_case['env_vars']['GTEST_SHARD_INDEX'] = '%(instance_index)s'
       test_case['env_vars']['GTEST_TOTAL_SHARDS'] = '%(num_instances)s'
 
     return json.dumps(test_case, separators=(',',':'))
 
 
@@ skipping 21 matching lines @@
       continue
     return json.loads(result)
 
   raise Failure(
       'Error: Unable to find any tests with the name, %s, on swarm server'
       % test_name)
 
 
 def retrieve_results(base_url, test_key, timeout, should_stop):
   """Retrieves results for a single test_key."""
-  assert isinstance(timeout, float)
+  assert isinstance(timeout, float), timeout
   params = [('r', test_key)]
   result_url = '%s/get_result?%s' % (base_url, urllib.urlencode(params))
   start = now()
   while True:
     if timeout and (now() - start) >= timeout:
       logging.error('retrieve_results(%s) timed out', base_url)
       return {}
     # Do retries ourselves.
     response = net.url_read(result_url, retry_404=False, retry_50x=False)
     if response is None:
       # Aggressively poll for results. Do not use retry_404 so
       # should_stop is polled more often.
       remaining = min(5, timeout - (now() - start)) if timeout else 5
       if remaining > 0:
+        if should_stop.get():
+          return {}
         net.sleep_before_retry(1, remaining)
     else:
       try:
         data = json.loads(response) or {}
       except (ValueError, TypeError):
         logging.warning(
             'Received corrupted data for test_key %s. Retrying.', test_key)
       else:
         if data['output']:
           return data
@@ skipping 50 matching lines @@
   run_test_name = 'run_isolated.zip'
   manifest.bundle.add_buffer(run_test_name,
     run_isolated.get_as_zip_package().zip_into_buffer(compress=False))
 
   cleanup_script_name = 'swarm_cleanup.py'
   manifest.bundle.add_file(os.path.join(TOOLS_PATH, cleanup_script_name),
     cleanup_script_name)
 
   run_cmd = [
     'python', run_test_name,
-    '--hash', manifest.manifest_hash,
+    '--hash', manifest.isolated_hash,
     '--isolate-server', manifest.isolate_server,
   ]
   if manifest.verbose or manifest.profile:
     # Have it print the profiling section.
     run_cmd.append('--verbose')
   manifest.add_task('Run Test', run_cmd)
 
   # Clean up
   manifest.add_task('Clean Up', ['python', cleanup_script_name])
 
@@ skipping 35 matching lines @@
       print >> sys.stderr, '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
     return 1
 
   try:
     manifest = Manifest(
-        file_hash, test_name, shards, test_filter, slave_os,
-        working_dir, isolate_server, verbose, profile, priority, algo)
+        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)
     return 1
 
   chromium_setup(manifest)
 
   # Zip up relevant files.
   print('Zipping up files...')
   if not manifest.zip_and_upload():
     return 1
@@ skipping 278 matching lines @@
     sys.stderr.write(str(e))
     sys.stderr.write('\n')
     return 1
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   tools.disable_buffering()
   colorama.init()
   sys.exit(main(sys.argv[1:]))