Move url_open with dependencies to utils.net module.

isolateserver_archive.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.
 
 """Archives a set of files to a server."""
 
 import binascii
 import cStringIO
 import hashlib
 import itertools
 import logging
 import optparse
 import os
 import sys
 import time
 import urllib
 import zlib
 
 import run_isolated
 
+from utils import net
 from utils import threading_utils
 from utils import tools
 
 
 # The minimum size of files to upload directly to the blobstore.
 MIN_SIZE_FOR_DIRECT_BLOBSTORE = 20 * 1024
 
 # The number of files to check the isolate server per /contains query.
 # All files are sorted by likelihood of a change in the file content
 # (currently file size is used to estimate this: larger the file -> larger the
@@ skipping 79 matching lines @@
     while True:
       # Read in 1mb chunks.
       chunk = f.read(1024*1024)
       if not chunk:
         break
       digest.update(chunk)
   return digest.hexdigest()
 
 
 def url_read(url, **kwargs):
-  result = run_isolated.url_read(url, **kwargs)
+  result = net.url_read(url, **kwargs)
   if result is None:
     # If we get no response from the server, assume it is down and raise an
     # exception.
     raise run_isolated.MappingError('Unable to connect to server %s' % url)
   return result
 
 
 def upload_hash_content_to_blobstore(
     generate_upload_url, data, hash_key, content):
   """Uploads the given hash contents directly to the blobstore via a generated
   url.
 
   Arguments:
     generate_upload_url: The url to get the new upload url from.
     data: extra POST data.
     hash_key: sha1 of the uncompressed version of content.
     content: The contents to upload. Must fit in memory for now.
   """
   logging.debug('Generating url to directly upload file to blobstore')
   assert isinstance(hash_key, str), hash_key
   assert isinstance(content, str), (hash_key, content)
   # TODO(maruel): Support large files. This would require streaming support.
   content_type, body = encode_multipart_formdata(
       data, [('content', hash_key, content)])
-  for attempt in xrange(run_isolated.URL_OPEN_MAX_ATTEMPTS):
+  for attempt in xrange(net.URL_OPEN_MAX_ATTEMPTS):
     # Retry HTTP 50x here.
-    upload_url = run_isolated.url_read(generate_upload_url, data=data)
+    upload_url = net.url_read(generate_upload_url, data=data)
     if not upload_url:
       raise run_isolated.MappingError(
           'Unable to connect to server %s' % generate_upload_url)
 
     # Do not retry this request on HTTP 50x. Regenerate an upload url each time
     # since uploading "consumes" the upload url.
-    result = run_isolated.url_read(
+    result = net.url_read(
         upload_url, data=body, content_type=content_type, retry_50x=False)
     if result is not None:
       return result
-    if attempt != run_isolated.URL_OPEN_MAX_ATTEMPTS - 1:
-      run_isolated.HttpService.sleep_before_retry(attempt, None)
+    if attempt != net.URL_OPEN_MAX_ATTEMPTS - 1:
+      net.HttpService.sleep_before_retry(attempt, None)
   raise run_isolated.MappingError(
       'Unable to connect to server %s' % generate_upload_url)
 
 
 class UploadRemote(run_isolated.Remote):
   def __init__(self, namespace, base_url, token):
     self.namespace = str(namespace)
     self._token = token
     super(UploadRemote, self).__init__(base_url)
 
@@ skipping 229 matching lines @@
   with tools.Profiler('Archive'):
     return upload_sha1_tree(
         base_url=options.remote,
         indir=os.getcwd(),
         infiles=infiles,
         namespace=options.namespace)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))