Upgrade gsutil to 3.4

third_party/gsutil/boto/boto/gs/resumable_upload_handler.py

 # Copyright 2010 Google Inc.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
 #
 # The above copyright notice and this permission notice shall be included
 # in all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
 # ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
 # SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 # IN THE SOFTWARE.
 
 import cgi
 import errno
 import httplib
 import os
+import random
 import re
 import socket
 import time
 import urlparse
 import boto
 from boto import config
 from boto.connection import AWSAuthConnection
 from boto.exception import InvalidUriError
 from boto.exception import ResumableTransferDisposition
 from boto.exception import ResumableUploadException
 
 """
-Handler for Google Storage resumable uploads. See
+Handler for Google Cloud Storage resumable uploads. See
 http://code.google.com/apis/storage/docs/developer-guide.html#resumable
 for details.
 
 Resumable uploads will retry failed uploads, resuming at the byte
 count completed by the last upload attempt. If too many retries happen with
 no progress (per configurable num_retries param), the upload will be
 aborted in the current process.
 
 The caller can optionally specify a tracker_file_name param in the
 ResumableUploadHandler constructor. If you do this, that file will
@@ skipping 87 matching lines @@
 
     def _set_tracker_uri(self, uri):
         """
         Called when we start a new resumable upload or get a new tracker
         URI for the upload. Saves URI and resets upload state.
 
         Raises InvalidUriError if URI is syntactically invalid.
         """
         parse_result = urlparse.urlparse(uri)
         if (parse_result.scheme.lower() not in ['http', 'https'] or
-            not parse_result.netloc or not parse_result.query):
-            raise InvalidUriError('Invalid tracker URI (%s)' % uri)
-        qdict = cgi.parse_qs(parse_result.query)
-        if not qdict or not 'upload_id' in qdict:
+            not parse_result.netloc):
             raise InvalidUriError('Invalid tracker URI (%s)' % uri)
         self.tracker_uri = uri
         self.tracker_uri_host = parse_result.netloc
-        self.tracker_uri_path = '%s/?%s' % (parse_result.netloc,
-                                            parse_result.query)
+        self.tracker_uri_path = '%s?%s' % (
+            parse_result.path, parse_result.query)
         self.server_has_bytes = 0
 
     def get_tracker_uri(self):
         """
         Returns upload tracker URI, or None if the upload has not yet started.
         """
         return self.tracker_uri
 
     def _remove_tracker_file(self):
         if (self.tracker_file_name and
             os.path.exists(self.tracker_file_name)):
                 os.unlink(self.tracker_file_name)
 
     def _build_content_range_header(self, range_spec='*', length_spec='*'):
         return 'bytes %s/%s' % (range_spec, length_spec)
 
     def _query_server_state(self, conn, file_length):
         """
-        Queries server to find out what bytes it currently has.
+        Queries server to find out state of given upload.
 
         Note that this method really just makes special case use of the
         fact that the upload server always returns the current start/end
         state whenever a PUT doesn't complete.
 
-        Returns (server_start, server_end), where the values are inclusive.
-        For example, (0, 2) would mean that the server has bytes 0, 1, *and* 2.
+        Returns HTTP response from sending request.
 
         Raises ResumableUploadException if problem querying server.
         """
         # Send an empty PUT so that server replies with this resumable
         # transfer's state.
         put_headers = {}
         put_headers['Content-Range'] = (
             self._build_content_range_header('*', file_length))
         put_headers['Content-Length'] = '0'
-        resp = AWSAuthConnection.make_request(conn, 'PUT',
+        return AWSAuthConnection.make_request(conn, 'PUT',
                                               path=self.tracker_uri_path,
                                               auth_path=self.tracker_uri_path,
                                               headers=put_headers,
                                               host=self.tracker_uri_host)
+
+    def _query_server_pos(self, conn, file_length):
+        """
+        Queries server to find out what bytes it currently has.
+
+        Returns (server_start, server_end), where the values are inclusive.
+        For example, (0, 2) would mean that the server has bytes 0, 1, *and* 2.
+
+        Raises ResumableUploadException if problem querying server.
+        """
+        resp = self._query_server_state(conn, file_length)
         if resp.status == 200:
             return (0, file_length)  # Completed upload.
         if resp.status != 308:
             # This means the server didn't have any state for the given
             # upload ID, which can happen (for example) if the caller saved
             # the tracker URI to a file and then tried to restart the transfer
             # after that upload ID has gone stale. In that case we need to
             # start a new transfer (and the caller will then save the new
             # tracker URI to the tracker file).
             raise ResumableUploadException(
@@ skipping 51 matching lines @@
                     ResumableTransferDisposition.ABORT)
             post_headers[k] = headers[k]
         post_headers[conn.provider.resumable_upload_header] = 'start'
 
         resp = conn.make_request(
             'POST', key.bucket.name, key.name, post_headers)
         # Get tracker URI from response 'Location' header.
         body = resp.read()
 
         # Check for various status conditions.
-        if resp.status == 500 or resp.status == 503:
+        if resp.status in [500, 503]:
             # Retry status 500 and 503 errors after a delay.
             raise ResumableUploadException(
                 'Got status %d from attempt to start resumable upload. '
                 'Will wait/retry' % resp.status,
                 ResumableTransferDisposition.WAIT_BEFORE_RETRY)
         elif resp.status != 200 and resp.status != 201:
             raise ResumableUploadException(
                 'Got status %d from attempt to start resumable upload. '
                 'Aborting' % resp.status,
                 ResumableTransferDisposition.ABORT)
@@ skipping 59 matching lines @@
             if cb:
                 i += 1
                 if i == cb_count or cb_count == -1:
                     cb(total_bytes_uploaded, file_length)
                     i = 0
             buf = fp.read(self.BUFFER_SIZE)
         if cb:
             cb(total_bytes_uploaded, file_length)
         if total_bytes_uploaded != file_length:
             # Abort (and delete the tracker file) so if the user retries
-            # they'll start a new resumable uplaod rather than potentially
+            # they'll start a new resumable upload rather than potentially
             # attempting to pick back up later where we left off.
             raise ResumableUploadException(
                 'File changed during upload: EOF at %d bytes of %d byte file.' %
                 (total_bytes_uploaded, file_length),
                 ResumableTransferDisposition.ABORT)
         resp = http_conn.getresponse()
         body = resp.read()
         # Restore http connection debug level.
         http_conn.set_debuglevel(conn.debug)
 
-        additional_note = ''
         if resp.status == 200:
             return resp.getheader('etag')  # Success
-        elif resp.status == 408:
-          # Request Timeout. Try again later within the current process.
-            disposition = ResumableTransferDisposition.WAIT_BEFORE_RETRY
-        elif resp.status/100 == 4:
-            # Abort for any other 4xx errors.
-            disposition = ResumableTransferDisposition.ABORT
-            # Add some more informative note for particular 4xx error codes.
-            if resp.status == 400:
-                additional_note = ('This can happen for various reasons; one '
-                                   'common case is if you attempt to upload a '
-                                   'different size file on a already partially '
-                                   'uploaded resumable upload')
-        # Retry status 500 and 503 errors after a delay.
-        elif resp.status == 500 or resp.status == 503:
+        # Retry timeout (408) and status 500 and 503 errors after a delay.
+        elif resp.status in [408, 500, 503]:
             disposition = ResumableTransferDisposition.WAIT_BEFORE_RETRY
         else:
             # Catch all for any other error codes.
             disposition = ResumableTransferDisposition.ABORT
         raise ResumableUploadException('Got response code %d while attempting '
-                                       'upload (%s)%s' %
-                                       (resp.status, resp.reason,
-                                        additional_note), disposition)
+                                       'upload (%s)' %
+                                       (resp.status, resp.reason), disposition)
 
     def _attempt_resumable_upload(self, key, fp, file_length, headers, cb,
                                   num_cb):
         """
         Attempts a resumable upload.
 
         Returns etag from server upon success.
 
         Raises ResumableUploadException if any problems occur.
         """
         (server_start, server_end) = self.SERVER_HAS_NOTHING
         conn = key.bucket.connection
         if self.tracker_uri:
             # Try to resume existing resumable upload.
             try:
                 (server_start, server_end) = (
-                    self._query_server_state(conn, file_length))
+                    self._query_server_pos(conn, file_length))
                 self.server_has_bytes = server_start
                 key=key
                 if conn.debug >= 1:
                     print 'Resuming transfer.'
             except ResumableUploadException, e:
                 if conn.debug >= 1:
                     print 'Unable to resume transfer (%s).' % e.message
                 self._start_new_resumable_upload(key, headers)
         else:
             self._start_new_resumable_upload(key, headers)
@@ skipping 25 matching lines @@
         http_conn = conn.new_http_connection(self.tracker_uri_host,
                                              conn.is_secure)
         http_conn.set_debuglevel(conn.debug)
 
         # Make sure to close http_conn at end so if a local file read
         # failure occurs partway through server will terminate current upload
         # and can report that progress on next attempt.
         try:
             return self._upload_file_bytes(conn, http_conn, fp, file_length,
                                            total_bytes_uploaded, cb, num_cb)
+        except (ResumableUploadException, socket.error):
+            resp = self._query_server_state(conn, file_length)
+            if resp.status == 400:
+                raise ResumableUploadException('Got 400 response from server '
+                    'state query after failed resumable upload attempt. This '
+                    'can happen for various reasons, including specifying an '
+                    'invalid request (e.g., an invalid canned ACL) or if the '
+                    'file size changed between upload attempts',
+                    ResumableTransferDisposition.ABORT)
+            else:
+                raise
         finally:
             http_conn.close()
 
     def _check_final_md5(self, key, etag):
         """
         Checks that etag from server agrees with md5 computed before upload.
         This is important, since the upload could have spanned a number of
         hours and multiple processes (e.g., gsutil runs), and the user could
         change some of the file and not realize they have inconsistent data.
         """
@@ skipping 39 matching lines @@
             parameter, this parameter determines the granularity of the callback
             by defining the maximum number of times the callback will be called
             during the file transfer. Providing a negative integer will cause
             your callback to be called with each buffer read.
              
         Raises ResumableUploadException if a problem occurs during the transfer.
         """
 
         if not headers:
             headers = {}
+        # If Content-Type header is present and set to None, remove it.
+        # This is gsutil's way of asking boto to refrain from auto-generating
+        # that header.
+        CT = 'Content-Type'
+        if CT in headers and headers[CT] is None:
+          del headers[CT]
 
         fp.seek(0, os.SEEK_END)
         file_length = fp.tell()
         fp.seek(0)
         debug = key.bucket.connection.debug
 
         # Use num-retries from constructor if one was provided; else check
         # for a value specified in the boto config file; else default to 5.
         if self.num_retries is None:
             self.num_retries = config.getint('Boto', 'num_retries', 5)
@@ skipping 47 matching lines @@
             else:
                 progress_less_iterations += 1
 
             if progress_less_iterations > self.num_retries:
                 # Don't retry any longer in the current process.
                 raise ResumableUploadException(
                     'Too many resumable upload attempts failed without '
                     'progress. You might try this upload again later',
                     ResumableTransferDisposition.ABORT_CUR_PROCESS)
 
-            sleep_time_secs = 2**progress_less_iterations
+            # Use binary exponential backoff to desynchronize client requests
+            sleep_time_secs = random.random() * (2**progress_less_iterations)
             if debug >= 1:
                 print ('Got retryable failure (%d progress-less in a row).\n'
-                       'Sleeping %d seconds before re-trying' %
+                       'Sleeping %3.1f seconds before re-trying' %
                        (progress_less_iterations, sleep_time_secs))
             time.sleep(sleep_time_secs)