Update 'requests' lib to v2.0.

utils/net.py

 # Copyright 2013 The Chromium Authors. All rights reserved.

[Vadim Sh., 2013/09/27 22:28:46]

Really modified file #2.

 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Classes and functions for generic network communication over HTTP."""
 
 import cookielib
 import cStringIO as StringIO
 import httplib
 import itertools
 import logging
@@ skipping 366 matching lines @@
           logging.error(
               'Authentication is required for %s on attempt %d.\n%s',
               request.get_full_url(), attempt.attempt, e.format())
           # Try to authenticate only once. If it doesn't help, then server does
           # not support app engine authentication.
           if not auth_attempted:
             auth_attempted = True
             if self.authenticator and self.authenticator.authenticate():
               # Success! Run request again immediately.
               attempt.skip_sleep = True
+              # Also refresh cookies used by request engine.
+              self.engine.reload_cookies()
               continue
           # Authentication attempt was unsuccessful.
           logging.error(
               'Unable to authenticate to %s.\n%s',
               request.get_full_url(), e.format(verbose=True))
           return None
 
         # Hit a error that can not be retried -> stop retry loop.
         if not self.is_transient_http_error(e.code, retry_404, retry_50x):
           # This HttpError means we reached the server and there was a problem
@@ skipping 101 matching lines @@
 
     Returns HttpResponse.
 
     Raises:
       ConnectionError - failed to establish connection to the server.
       TimeoutError - timeout while connecting or reading response.
       HttpError - server responded with >= 400 error code.
     """
     raise NotImplementedError()
 
+  def reload_cookies(self):
+    """Reloads cookies from original cookie jar."""
+    # This method is optional.
+    pass
+
 
 class Authenticator(object):
   """Base class for objects that know how to authenticate into http services."""
 
   def authenticate(self):
     """Authenticates in the app engine service."""
     raise NotImplementedError()
 
 
 class Urllib2Engine(RequestEngine):
@@ skipping 32 matching lines @@
   # Preferred number of connections in a connection pool.
   CONNECTION_POOL_SIZE = 64
   # If True will not open more than CONNECTION_POOL_SIZE connections.
   CONNECTION_POOL_BLOCK = False
   # Maximum number of internal connection retries in a connection pool.
   CONNECTION_RETRIES = 0
 
   def __init__(self, cookie_jar, ca_certs):
     super(RequestsLibEngine, self).__init__()
     self.session = requests.Session()
+    self.cookie_jar = cookie_jar
     # Configure session.
     self.session.trust_env = False
     if cookie_jar:
       self.session.cookies = cookie_jar
     self.session.verify = ca_certs
     # Configure connection pools.
     for protocol in ('https://', 'http://'):
       self.session.mount(protocol, adapters.HTTPAdapter(
           pool_connections=self.CONNECTION_POOL_SIZE,
           pool_maxsize=self.CONNECTION_POOL_SIZE,
@@ skipping 16 matching lines @@
       else:
         stream = StringIO.StringIO(response.content)
       return HttpResponse(stream, request.get_full_url(), response.headers)
     except requests.Timeout as e:
       raise TimeoutError(e)
     except requests.HTTPError as e:
       raise HttpError(e.response.status_code, e)
     except (requests.ConnectionError, socket.timeout, ssl.SSLError) as e:
       raise ConnectionError(e)
 
+  def reload_cookies(self):
+    if self.cookie_jar:
+      self.session.cookies = self.cookie_jar
+
 
 class AppEngineAuthenticator(Authenticator):
   """Helper class to perform AppEngine authentication dance via upload.py."""
 
   # This lock ensures that user won't be confused with multiple concurrent
   # login prompts.
   _auth_lock = threading.Lock()
 
   def __init__(self, urlhost, cookie_jar, email=None, password=None):
     super(AppEngineAuthenticator, self).__init__()
@@ skipping 158 matching lines @@
     attemp_obj = RetryAttempt(attempt, remaining)
     yield attemp_obj
     if attemp_obj.skip_sleep:
       continue
     # Only sleep if we are going to try again.
     if max_attempts and attempt != max_attempts - 1:
       remaining = (timeout - (current_time() - start)) if timeout else None
       if remaining is not None and remaining < 0:
         break
       sleep_before_retry(attempt, remaining)