[Abandoned] Move url_open with dependencies to utils.net module.

swarm_trigger_step.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.
 
 """Triggers a Swarm request based off of a .isolated file.
 
 This script takes a .isolated file, packages it, and sends a Swarm manifest file
 to the Swarm server.  This is expected to be called as a build step with the cwd
 as the parent of the src/ directory.
 """
 
 import binascii
 import hashlib
 import json
 import optparse
 import os
 import sys
 import time
 import urllib
 
-import run_isolated
-
+from utils import net
 from utils import tools
 from utils import zip_package
 
 
 ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
 TOOLS_PATH = os.path.join(ROOT_DIR, 'tools')
 
 
 PLATFORM_MAPPING = {
   'cygwin': 'Windows',
@@ skipping 42 matching lines @@
     self.verbose = bool(verbose)
     self.profile = bool(profile)
     self.priority = priority
 
     self._zip_file_hash = ''
     self._tasks = []
     self._token_cache = None
 
   def _token(self):
     if not self._token_cache:
-      result = run_isolated.url_open(self._data_server_get_token)
+      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())
     return self._token_cache
 
   def add_task(self, task_name, actions, time_out=600):
     """Appends a new task to the swarm manifest file."""
     # See swarming/src/common/test_request_message.py TestObject constructor for
@@ skipping 10 matching lines @@
     """Zips up all the files necessary to run a shard and uploads to Swarming
     master.
     """
     assert not self._zip_file_hash
 
     start_time = time.time()
     zip_contents = self.bundle.zip_into_buffer()
     self._zip_file_hash = hashlib.sha1(zip_contents).hexdigest()
     print 'Zipping completed, time elapsed: %f' % (time.time() - start_time)
 
-    response = run_isolated.url_open(
+    response = net.url_open(
         self._data_server_has + '?token=%s' % self._token(),
         data=binascii.unhexlify(self._zip_file_hash),
         content_type='application/octet-stream')
     if response is None:
       print >> sys.stderr, (
           'Unable to query server for zip file presence, aborting.')
       return False
 
     if response.read(1) == chr(1):
       print 'Zip file already on server, no need to reupload.'
       return True
 
     print 'Zip file not on server, starting uploading.'
 
     url = '%s%s?priority=0&token=%s' % (
         self._data_server_storage, self._zip_file_hash, self._token())
-    response = run_isolated.url_open(
+    response = net.url_open(
         url, data=zip_contents, content_type='application/octet-stream')
     if response is None:
       print >> sys.stderr, 'Failed to upload the zip file: %s' % url
       return False
 
     return True
 
   def to_json(self):
     """Exports the current configuration into a swarm-readable manifest file.
 
@@ skipping 30 matching lines @@
       test_case['env_vars']['GTEST_TOTAL_SHARDS'] = '%(num_instances)s'
 
     return json.dumps(test_case, separators=(',',':'))
 
 
 def chromium_setup(manifest):
   """Sets up the commands to run.
 
   Highly chromium specific.
   """
+  import run_isolated
+
   # Add uncompressed zip here. It'll be compressed as part of the package sent
   # to Swarming server.
   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)
 
@@ skipping 29 matching lines @@
   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' % swarm_url)
   print('Job name: %s' % test_name)
   test_url = swarm_url.rstrip('/') + '/test'
   manifest_text = manifest.to_json()
-  result = run_isolated.url_open(test_url, data={'request': manifest_text})
+  result = net.url_open(test_url, data={'request': manifest_text})
   if not result:
     print >> sys.stderr, 'Failed to send test for %s\n%s' % (
         test_name, test_url)
     return 1
   try:
     json.load(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, str(e)
@@ skipping 61 matching lines @@
           options.priority)
       highest_exit_code = max(highest_exit_code, exit_code)
   except Failure as e:
     print >> sys.stderr, e.args[0]
     highest_exit_code = max(1, highest_exit_code)
   return highest_exit_code
 
 
 if __name__ == '__main__':
   sys.exit(main(None))