Merging in latest boto.

boto/s3/resumable_download_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:
 #
@@ skipping 47 matching lines @@
     Proxy class that translates progress callbacks made by
     boto.s3.Key.get_file(), taking into account that we're resuming
     a download.
     """
     def __init__(self, proxied_cb, download_start_point):
         self.proxied_cb = proxied_cb
         self.download_start_point = download_start_point
 
     def call(self, total_bytes_uploaded, total_size):
         self.proxied_cb(self.download_start_point + total_bytes_uploaded,
-                        self.download_start_point + total_size)
+                        total_size)
 
 
 def get_cur_file_size(fp, position_to_eof=False):
     """
     Returns size of file, optionally leaving fp positioned at EOF.
     """
     if not position_to_eof:
         cur_pos = fp.tell()
     fp.seek(0, os.SEEK_END)
     cur_file_size = fp.tell()
@@ skipping 208 matching lines @@
                                                  torrent, version_id)
                 # Download succceded, so remove the tracker file (if have one).
                 self._remove_tracker_file()
                 self._check_final_md5(key, fp.name)
                 if debug >= 1:
                     print 'Resumable download complete.'
                 return
             except self.RETRYABLE_EXCEPTIONS, e:
                 if debug >= 1:
                     print('Caught exception (%s)' % e.__repr__())
+                if isinstance(e, IOError) and e.errno == errno.EPIPE:
+                    # Broken pipe error causes httplib to immediately
+                    # close the socket (http://bugs.python.org/issue5542),
+                    # so we need to close and reopen the key before resuming
+                    # the download.
+                    key.get_file(fp, headers, cb, num_cb, torrent, version_id,
+                                 override_num_retries=0)
             except ResumableDownloadException, e:
-                if e.disposition == ResumableTransferDisposition.ABORT:
+                if (e.disposition ==
+                    ResumableTransferDisposition.ABORT_CUR_PROCESS):
                     if debug >= 1:
                         print('Caught non-retryable ResumableDownloadException '
                               '(%s)' % e.message)
                     raise
+                elif (e.disposition ==
+                    ResumableTransferDisposition.ABORT):
+                    if debug >= 1:
+                        print('Caught non-retryable ResumableDownloadException '
+                              '(%s); aborting and removing tracker file' %
+                              e.message)
+                    self._remove_tracker_file()
+                    raise
                 else:
                     if debug >= 1:
                         print('Caught ResumableDownloadException (%s) - will '
                               'retry' % e.message)
 
             # At this point we had a re-tryable failure; see if made progress.
             if get_cur_file_size(fp) > had_file_bytes_before_attempt:
                 progress_less_iterations = 0
             else:
                 progress_less_iterations += 1
 
             if progress_less_iterations > self.num_retries:
                 # Don't retry any longer in the current process.
                 raise ResumableDownloadException(
                     'Too many resumable download attempts failed without '
                     'progress. You might try this download again later',
-                    ResumableTransferDisposition.ABORT)
+                    ResumableTransferDisposition.ABORT_CUR_PROCESS)
 
             # Close the key, in case a previous download died partway
             # through and left data in the underlying key HTTP buffer.
-            key.close()
+            # Do this within a try/except block in case the connection is
+            # closed (since key.close() attempts to do a final read, in which
+            # case this read attempt would get an IncompleteRead exception,
+            # which we can safely ignore.
+            try:
+                key.close()
+            except httplib.IncompleteRead:
+                pass
 
             sleep_time_secs = 2**progress_less_iterations
             if debug >= 1:
                 print('Got retryable failure (%d progress-less in a row).\n'
                       'Sleeping %d seconds before re-trying' %
                       (progress_less_iterations, sleep_time_secs))
             time.sleep(sleep_time_secs)