Pull in upstream boto from github at bcb719937de9ac2851e632d62b777352029a6d55

boto/ses/connection.py

 # Copyright (c) 2010 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2011 Harry Marr http://hmarr.com/
 #
 # 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 10 matching lines @@
 # IN THE SOFTWARE.
 
 from boto.connection import AWSAuthConnection
 from boto.exception import BotoServerError
 from boto.regioninfo import RegionInfo
 import boto
 import boto.jsonresponse
 
 import urllib
 import base64
+from boto.ses import exceptions as ses_exceptions
 
 
 class SESConnection(AWSAuthConnection):
 
     ResponseError = BotoServerError
     DefaultRegionName = 'us-east-1'
     DefaultRegionEndpoint = 'email.us-east-1.amazonaws.com'
     APIVersion = '2010-12-01'
 
     def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
@@ skipping 23 matching lines @@
         :param items: Items to be included in the list
 
         :type label: string
         :param label: The parameter list's name
         """
         if isinstance(items, basestring):
             items = [items]
         for i in range(1, len(items) + 1):
             params['%s.%d' % (label, i)] = items[i - 1]
 
-
     def _make_request(self, action, params=None):
         """Make a call to the SES API.
 
         :type action: string
         :param action: The API method to use (e.g. SendRawEmail)
 
         :type params: dict
         :param params: Parameters that will be sent as POST data with the API
-                       call.
+            call.
         """
         ct = 'application/x-www-form-urlencoded; charset=UTF-8'
         headers = {'Content-Type': ct}
         params = params or {}
         params['Action'] = action
 
         for k, v in params.items():
             if isinstance(v, unicode):  # UTF-8 encode only if it's Unicode
                 params[k] = v.encode('utf-8')
 
         response = super(SESConnection, self).make_request(
             'POST',
             '/',
             headers=headers,
             data=urllib.urlencode(params)
         )
         body = response.read()
         if response.status == 200:
             list_markers = ('VerifiedEmailAddresses', 'SendDataPoints')
             e = boto.jsonresponse.Element(list_marker=list_markers)
             h = boto.jsonresponse.XmlHandler(e, None)
             h.parse(body)
             return e
         else:
-            boto.log.error('%s %s' % (response.status, response.reason))
-            boto.log.error('%s' % body)
-            raise self.ResponseError(response.status, response.reason, body)
+            # HTTP codes other than 200 are considered errors. Go through
+            # some error handling to determine which exception gets raised,
+            self._handle_error(response, body)
 
+    def _handle_error(self, response, body):
+        """
+        Handle raising the correct exception, depending on the error. Many
+        errors share the same HTTP response code, meaning we have to get really
+        kludgey and do string searches to figure out what went wrong.
+        """
+        boto.log.error('%s %s' % (response.status, response.reason))
+        boto.log.error('%s' % body)
+
+        if "Address blacklisted." in body:
+            # Delivery failures happened frequently enough with the recipient's
+            # email address for Amazon to blacklist it. After a day or three,
+            # they'll be automatically removed, and delivery can be attempted
+            # again (if you write the code to do so in your application).
+            ExceptionToRaise = ses_exceptions.SESAddressBlacklistedError
+            exc_reason = "Address blacklisted."
+        elif "Email address is not verified." in body:
+            # This error happens when the "Reply-To" value passed to
+            # send_email() hasn't been verified yet.
+            ExceptionToRaise = ses_exceptions.SESAddressNotVerifiedError
+            exc_reason = "Email address is not verified."
+        elif "Daily message quota exceeded." in body:
+            # Encountered when your account exceeds the maximum total number
+            # of emails per 24 hours.
+            ExceptionToRaise = ses_exceptions.SESDailyQuotaExceededError
+            exc_reason = "Daily message quota exceeded."
+        elif "Maximum sending rate exceeded." in body:
+            # Your account has sent above its allowed requests a second rate.
+            ExceptionToRaise = ses_exceptions.SESMaxSendingRateExceededError
+            exc_reason = "Maximum sending rate exceeded."
+        else:
+            # This is either a common AWS error, or one that we don't devote
+            # its own exception to.
+            ExceptionToRaise = self.ResponseError
+            exc_reason = response.reason
+
+        raise ExceptionToRaise(response.status, exc_reason, body)
 
     def send_email(self, source, subject, body, to_addresses, cc_addresses=None,
                    bcc_addresses=None, format='text', reply_addresses=None,
                    return_path=None, text_body=None, html_body=None):
         """Composes an email message based on input data, and then immediately
         queues the message for sending.
 
         :type source: string
         :param source: The sender's email address.
 
@@ skipping 110 matching lines @@
             Refer to the Amazon SES Developer Guide for more details.
           - Content must be base64-encoded, if MIME requires it.
 
         :type destinations: list of strings or string
         :param destinations: A list of destinations for the message.
 
         """
         params = {
             'RawMessage.Data': base64.b64encode(raw_message),
         }
-        
+
         if source:
             params['Source'] = source
 
         if destinations:
             self._build_list_params(params, destinations,
                                    'Destinations.member')
 
         return self._make_request('SendRawEmail', params)
 
     def list_verified_email_addresses(self):
@@ skipping 50 matching lines @@
         :type email_adddress: string
         :param email_address: The email address to be verified.
 
         :rtype: dict
         :returns: A VerifyEmailAddressResponse structure. Note that keys must
                   be unicode strings.
         """
         return self._make_request('VerifyEmailAddress', {
             'EmailAddress': email_address,
         })