Merging in latest boto.

boto/exception.py

 # Copyright (c) 2006-2010 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2010, Eucalyptus Systems, Inc.
 # All rights reserved.
 #
 # 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-
@@ skipping 17 matching lines @@
 import xml.sax
 from boto import handler
 from boto.resultset import ResultSet
 
 
 class BotoClientError(StandardError):
     """
     General Boto Client error (error accessing AWS)
     """
 
-    def __init__(self, reason):
-        StandardError.__init__(self)
+    def __init__(self, reason, *args):
+        StandardError.__init__(self, reason, *args)
         self.reason = reason
 
     def __repr__(self):
         return 'BotoClientError: %s' % self.reason
 
     def __str__(self):
         return 'BotoClientError: %s' % self.reason
 
 class SDBPersistenceError(StandardError):
 
@@ skipping 12 matching lines @@
     pass
 
 class GSPermissionsError(StoragePermissionsError):
     """
     Permissions error when accessing a bucket or key on GS.
     """
     pass
 
 class BotoServerError(StandardError):
 
-    def __init__(self, status, reason, body=None):
-        StandardError.__init__(self)
+    def __init__(self, status, reason, body=None, *args):
+        StandardError.__init__(self, status, reason, body, *args)
         self.status = status
         self.reason = reason
         self.body = body or ''
         self.request_id = None
         self.error_code = None
         self.error_message = None
         self.box_usage = None
 
         # Attempt to parse the error response. If body isn't present,
         # then just ignore the error response.
         if self.body:
             try:
                 h = handler.XmlHandler(self, self)
                 xml.sax.parseString(self.body, h)
             except xml.sax.SAXParseException, pe:
-                # Go ahead and clean up anything that may have
-                # managed to get into the error data so we
-                # don't get partial garbage.
-                print "Warning: failed to parse error message from AWS: %s" % pe
-                self._cleanupParsedProperties()
+                # Remove unparsable message body so we don't include garbage
+                # in exception. But first, save self.body in self.error_message
+                # because occasionally we get error messages from Eucalyptus
+                # that are just text strings that we want to preserve.
+                self.error_message = self.body
+                self.body = None
 
     def __getattr__(self, name):
         if name == 'message':
             return self.error_message
         if name == 'code':
             return self.error_code
         raise AttributeError
 
     def __repr__(self):
         return '%s: %s %s\n%s' % (self.__class__.__name__,
@@ skipping 110 matching lines @@
     def _cleanupParsedProperties(self):
         BotoServerError._cleanupParsedProperties(self)
         for p in ('detail', 'type'):
             setattr(self, p, None)
 
 class SQSDecodeError(BotoClientError):
     """
     Error when decoding an SQS message.
     """
     def __init__(self, reason, message):
-        BotoClientError.__init__(self, reason)
+        BotoClientError.__init__(self, reason, message)
         self.message = message
 
     def __repr__(self):
         return 'SQSDecodeError: %s' % self.reason
 
     def __str__(self):
         return 'SQSDecodeError: %s' % self.reason
 
 class StorageResponseError(BotoServerError):
     """
@@ skipping 116 matching lines @@
     """
     pass
 
 class FPSResponseError(BotoServerError):
     pass
 
 class InvalidUriError(Exception):
     """Exception raised when URI is invalid."""
 
     def __init__(self, message):
-        Exception.__init__(self)
+        Exception.__init__(self, message)
         self.message = message
 
 class InvalidAclError(Exception):
     """Exception raised when ACL XML is invalid."""
 
     def __init__(self, message):
-        Exception.__init__(self)
+        Exception.__init__(self, message)
         self.message = message
 
 class NoAuthHandlerFound(Exception):
     """Is raised when no auth handlers were found ready to authenticate."""
     pass
 
 class TooManyAuthHandlerReadyToAuthenticate(Exception):
     """Is raised when there are more than one auth handler ready.
 
     In normal situation there should only be one auth handler that is ready to
     authenticate. In case where more than one auth handler is ready to
     authenticate, we raise this exception, to prevent unpredictable behavior
     when multiple auth handlers can handle a particular case and the one chosen
     depends on the order they were checked.
     """
     pass
 
 # Enum class for resumable upload failure disposition.
 class ResumableTransferDisposition(object):
     # START_OVER means an attempt to resume an existing transfer failed,
     # and a new resumable upload should be attempted (without delay).
     START_OVER = 'START_OVER'
 
     # WAIT_BEFORE_RETRY means the resumable transfer failed but that it can
-    # be retried after a time delay.
+    # be retried after a time delay within the current process.
     WAIT_BEFORE_RETRY = 'WAIT_BEFORE_RETRY'
 
-    # ABORT means the resumable transfer failed and that delaying/retrying
-    # within the current process will not help.
+    # ABORT_CUR_PROCESS means the resumable transfer failed and that
+    # delaying/retrying within the current process will not help. If
+    # resumable transfer included a state tracker file the upload can be
+    # retried again later, in another process (e.g., a later run of gsutil).
+    ABORT_CUR_PROCESS = 'ABORT_CUR_PROCESS'
+
+    # ABORT means the resumable transfer failed in a way that it does not
+    # make sense to continue in the current process, and further that the 
+    # current tracker ID should not be preserved (in a tracker file if one
+    # was specified at resumable upload start time). If the user tries again
+    # later (e.g., a separate run of gsutil) it will get a new resumable
+    # upload ID.
     ABORT = 'ABORT'
 
 class ResumableUploadException(Exception):
     """
     Exception raised for various resumable upload problems.
 
     self.disposition is of type ResumableTransferDisposition.
     """
 
     def __init__(self, message, disposition):
-        Exception.__init__(self)
+        Exception.__init__(self, message, disposition)
         self.message = message
         self.disposition = disposition
 
     def __repr__(self):
         return 'ResumableUploadException("%s", %s)' % (
             self.message, self.disposition)
 
 class ResumableDownloadException(Exception):
     """
     Exception raised for various resumable download problems.
 
     self.disposition is of type ResumableTransferDisposition.
     """
 
     def __init__(self, message, disposition):
-        Exception.__init__(self)
+        Exception.__init__(self, message, disposition)
         self.message = message
         self.disposition = disposition
 
     def __repr__(self):
         return 'ResumableDownloadException("%s", %s)' % (
             self.message, self.disposition)