Merge pull request djacobs#189 from microamp/feature/minor-refactoring

Minor enhancements

Author: djacobs

apns.py

@@ -52,31 +52,31 @@
 ENHANCED_NOTIFICATION_COMMAND = 1
 
 NOTIFICATION_FORMAT = (
-     '!'   # network big-endian
-     'B'   # command
-     'H'   # token length
-     '32s' # token
-     'H'   # payload length
-     '%ds' # payload
-    )
+    '!'   # network big-endian
+    'B'   # command
+    'H'   # token length
+    '32s' # token
+    'H'   # payload length
+    '%ds' # payload
+)
 
 ENHANCED_NOTIFICATION_FORMAT = (
-     '!'   # network big-endian
-     'B'   # command
-     'I'   # identifier
-     'I'   # expiry
-     'H'   # token length
-     '32s' # token
-     'H'   # payload length
-     '%ds' # payload
-    )
+    '!'   # network big-endian
+    'B'   # command
+    'I'   # identifier
+    'I'   # expiry
+    'H'   # token length
+    '32s' # token
+    'H'   # payload length
+    '%ds' # payload
+)
 
 ERROR_RESPONSE_FORMAT = (
-     '!'   # network big-endian
-     'B'   # command
-     'B'   # status
-     'I'   # identifier
-    )
+    '!'   # network big-endian
+    'B'   # command
+    'B'   # status
+    'I'   # identifier
+)
 
 TOKEN_LENGTH = 32
 ERROR_RESPONSE_LENGTH = 6
@@ -140,7 +140,7 @@ def unpacked_uint_big_endian(bytes):
         Returns an unsigned int from a packed big-endian (network) byte array
         """
         return unpack('>I', bytes)[0]
-    
+
     @staticmethod
     def unpacked_char_big_endian(bytes):
         """
@@ -230,7 +230,7 @@ def _connect(self):
                         sys.exc_clear()
                     else:
                        raise
-        
+
         self.connection_alive = True
         _logger.debug("%s APNS connection established" % self.__class__.__name__)
 
@@ -255,14 +255,14 @@ def write(self, string):
         if self.enhanced: # nonblocking socket
             self._last_activity_time = time.time()
             _, wlist, _ = select.select([], [self._connection()], [], WAIT_WRITE_TIMEOUT_SEC)
-            
+
             if len(wlist) > 0:
                 length = self._connection().sendall(string)
                 if length == 0:
                     _logger.debug("sent length: %d" % length) #DEBUG
             else:
                 _logger.warning("write socket descriptor is not ready after " + str(WAIT_WRITE_TIMEOUT_SEC))
-            
+
         else: # blocking socket
             return self._connection().write(string)
 
@@ -298,7 +298,7 @@ def __init__(self, payload_size):
 
 class Payload(object):
     """A class representing an APNs message payload"""
-    def __init__(self, alert=None, badge=None, sound=None, category=None, custom={}, content_available=False,
+    def __init__(self, alert=None, badge=None, sound=None, category=None, custom=None, content_available=False,
                  mutable_content=False):
         super(Payload, self).__init__()
         self.alert = alert
@@ -334,7 +334,8 @@ def dict(self):
             d.update({'mutable-content': 1})
 
         d = { 'aps': d }
-        d.update(self.custom)
+        if self.custom:
+            d.update(self.custom)
         return d
 
     def json(self):
@@ -465,20 +466,20 @@ class GatewayConnection(APNsConnection):
     """
     A class that represents a connection to the APNs gateway server
     """
-    
+
     def __init__(self, use_sandbox=False, **kwargs):
         super(GatewayConnection, self).__init__(**kwargs)
         self.server = (
             'gateway.push.apple.com',
             'gateway.sandbox.push.apple.com')[use_sandbox]
         self.port = 2195
-        if self.enhanced == True: #start error-response monitoring thread       
+        if self.enhanced == True: #start error-response monitoring thread
             self._last_activity_time = time.time()
-            
+
             self._send_lock = threading.RLock()
             self._error_response_handler_worker = None
             self._response_listener = None
-            
+
         self._sent_notifications = collections.deque(maxlen=SENT_BUFFER_QTY)
 
     def _init_error_response_handler_worker(self):
@@ -515,7 +516,7 @@ def _get_enhanced_notification(self, token_hex, payload, identifier, expiry):
         notification = pack(fmt, ENHANCED_NOTIFICATION_COMMAND, identifier, expiry,
                             TOKEN_LENGTH, token, len(payload), payload)
         return notification
-         
+
     def send_notification(self, token_hex, payload, identifier=0, expiry=0):
         """
         in enhanced mode, send_notification may return error response from APNs if any
@@ -524,7 +525,7 @@ def send_notification(self, token_hex, payload, identifier=0, expiry=0):
             self._last_activity_time = time.time()
             message = self._get_enhanced_notification(token_hex, payload,
                                                            identifier, expiry)
-            
+
             for i in range(WRITE_RETRY):
                 try:
                     with self._send_lock:
@@ -534,16 +535,16 @@ def send_notification(self, token_hex, payload, identifier=0, expiry=0):
                     break
                 except socket_error as e:
                     delay = 10 + (i * 2)
-                    _logger.exception("sending notification with id:" + str(identifier) + 
-                                 " to APNS failed: " + str(type(e)) + ": " + str(e) + 
+                    _logger.exception("sending notification with id:" + str(identifier) +
+                                 " to APNS failed: " + str(type(e)) + ": " + str(e) +
                                  " in " + str(i+1) + "th attempt, will wait " + str(delay) + " secs for next action")
                     time.sleep(delay) # wait potential error-response to be read
 
         else:
             self.write(self._get_notification(token_hex, payload))
-    
+
     def _make_sure_error_response_handler_worker_alive(self):
-        if (not self._error_response_handler_worker 
+        if (not self._error_response_handler_worker
             or not self._error_response_handler_worker.is_alive()):
             self._init_error_response_handler_worker()
             TIMEOUT_SEC = 10
@@ -557,45 +558,45 @@ def _make_sure_error_response_handler_worker_alive(self):
     def send_notification_multiple(self, frame):
         self._sent_notifications += frame.get_notifications(self)
         return self.write(frame.get_frame())
-    
+
     def register_response_listener(self, response_listener):
         self._response_listener = response_listener
-    
+
     def force_close(self):
         if self._error_response_handler_worker:
             self._error_response_handler_worker.close()
-    
+
     def _is_idle_timeout(self):
         TIMEOUT_IDLE = 30
         return (time.time() - self._last_activity_time) >= TIMEOUT_IDLE
-    
+
     class ErrorResponseHandlerWorker(threading.Thread):
         def __init__(self, apns_connection):
             threading.Thread.__init__(self, name=self.__class__.__name__)
             self._apns_connection = apns_connection
             self._close_signal = False
-        
+
         def close(self):
             self._close_signal = True
-        
+
         def run(self):
             while True:
                 if self._close_signal:
                     _logger.debug("received close thread signal")
                     break
-                
+
                 if self._apns_connection._is_idle_timeout():
                     idled_time = (time.time() - self._apns_connection._last_activity_time)
                     _logger.debug("connection idle after %d secs" % idled_time)
                     break
-                
+
                 if not self._apns_connection.connection_alive:
                     time.sleep(1)
                     continue
-                
+
                 try:
                     rlist, _, _ = select.select([self._apns_connection._connection()], [], [], WAIT_READ_TIMEOUT_SEC)
-                    
+
                     if len(rlist) > 0: # there's some data from APNs
                         with self._apns_connection._send_lock:
                             buff = self._apns_connection.read(ERROR_RESPONSE_LENGTH)
@@ -611,23 +612,23 @@ def run(self):
                             if len(buff) == 0:
                                 _logger.warning("read socket got 0 bytes data") #DEBUG
                                 self._apns_connection._disconnect()
-                                
+
                 except socket_error as e: # APNS close connection arbitrarily
                     _logger.exception("exception occur when reading APNS error-response: " + str(type(e)) + ": " + str(e)) #DEBUG
                     self._apns_connection._disconnect()
                     continue
-                            
+
                 time.sleep(0.1) #avoid crazy loop if something bad happened. e.g. using invalid certificate
-            
+
             self._apns_connection._disconnect()
             _logger.debug("error-response handler worker closed") #DEBUG
-    
+
         def _resend_notifications_by_id(self, failed_identifier):
             fail_idx = Util.getListIndexFromID(self._apns_connection._sent_notifications, failed_identifier)
             #pop-out success notifications till failed one
             self._resend_notification_by_range(fail_idx+1, len(self._apns_connection._sent_notifications))
             return
-    
+
         def _resend_notification_by_range(self, start_idx, end_idx):
             self._apns_connection._sent_notifications = collections.deque(itertools.islice(self._apns_connection._sent_notifications, start_idx, end_idx))
             _logger.info("resending %s notifications to APNS" % len(self._apns_connection._sent_notifications)) #DEBUG
@@ -643,7 +644,7 @@ def _resend_notification_by_range(self, start_idx, end_idx):
 class Util(object):
     @classmethod
     def getListIndexFromID(this_class, the_list, identifier):
-        return next(index for (index, d) in enumerate(the_list) 
+        return next(index for (index, d) in enumerate(the_list)
                         if d['id'] == identifier)
     @classmethod
     def convert_error_response_to_dict(this_class, error_response_tuple):