resque-aps 0.9.9 → 0.9.10

data/lib/resque_aps/application.rb

@@ -3,166 +3,177 @@ require 'openssl'
 module Resque
   module Plugins
     module Aps
-  class Application
-    include Resque::Plugins::Aps::Helper
-    extend Resque::Plugins::Aps::Helper
+      class Application
+        include Resque::Plugins::Aps::Helper
+        extend Resque::Plugins::Aps::Helper
 
-    attr_accessor :name, :cert_file, :cert_passwd
+        attr_accessor :name, :cert_file, :cert_passwd
 
-    @queue = "apple_push_service"
+        @queue = "apple_push_service"
 
-    def inspect
-      "#<#{self.class.name} #{name.inspect}, #{cert_passwd.inspect}, #{cert_file.inspect}>"
-    end
+        def inspect
+          "#<#{self.class.name} #{name.inspect}, #{cert_passwd.inspect}, #{cert_file.inspect}>"
+        end
     
-    def self.perform(*args)
-      count = 0
-      start = Time.now
-      app_name = args[0]
-      Resque.aps_application(app_name).socket do |socket, app|
-        while true
-          n = Resque.dequeue_aps(app_name)
-          if n.nil?
-            if app.aps_nil_notification_retry? count, start
-              next
-            else
-              break
+        def self.perform(*args)
+          count = 0
+          start = Time.now
+          app_name = args[0]
+          Resque.aps_application(app_name).socket do |socket, app|
+            while true
+              n = Resque.dequeue_aps(app_name)
+              if n.nil?
+                if app.aps_nil_notification_retry? count, start
+                  next
+                else
+                  break
+                end
+              end
+
+              app.before_aps_write n
+              begin
+                n.batch_id = count + 1
+                n.expiry   = (Time.now.utc + 1.hour).to_i
+                socket.write(n.formatted)
+                app.after_aps_write n
+                count += 1
+                unless (resp = socket.read).blank?
+                  logger.error "Failure response: #{resp.inspect}" if logger
+                  break
+                end
+              rescue
+                logger.error Application.application_exception($!, app_name) if logger
+                app.failed_aps_write n, $!
+                logger.error "Sent #{count} notifications before failure." if logger
+                redis.rpush(aps_application_queue_key(app_name), encode(n.to_hash))
+                break
+              end
             end
           end
+          logger.info("Sent #{count} #{app_name} notifications in batch over #{Time.now - start} sec.") if logger
+        ensure
+          Resque.dequeue_aps_application(app_name)
+        end
+    
+        #
+        # Create the TCP and SSL sockets for sending the notification
+        #
+        def self.create_sockets(cert, passphrase, host, port)
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.key = OpenSSL::PKey::RSA.new(cert, passphrase)
+          ctx.cert = OpenSSL::X509::Certificate.new(cert)
+
+          s = TCPSocket.new(host, port)
+          ssl = OpenSSL::SSL::SSLSocket.new(s, ctx)
+          ssl.sync = true
+
+          return s, ssl
+        end
 
-          app.before_aps_write n
+        #
+        # Close the sockets
+        #
+        def self.close_sockets(socket, ssl_socket)
           begin
-            socket.write(n.formatted)
-            app.after_aps_write n
-            count += 1
+            if ssl_socket
+              ssl_socket.close
+            end
           rescue
-            logger.error Application.application_exception($!, name) if logger
-            app.failed_aps_write n, $!
+            Resque.logger.error("#{$!}: #{$!.backtrace.join("\n")}") if Resque.logger
           end
-        end
-      end
-      logger.info("Sent #{count} #{app_name} notifications in batch over #{Time.now - start} sec.") if logger
-    end
-    
-    #
-    # Create the TCP and SSL sockets for sending the notification
-    #
-    def self.create_sockets(cert, passphrase, host, port)
-      ctx = OpenSSL::SSL::SSLContext.new
-      ctx.key = OpenSSL::PKey::RSA.new(cert, passphrase)
-      ctx.cert = OpenSSL::X509::Certificate.new(cert)
-
-      s = TCPSocket.new(host, port)
-      ssl = OpenSSL::SSL::SSLSocket.new(s, ctx)
-      ssl.sync = true
-
-      return s, ssl
-    end
 
-    #
-    # Close the sockets
-    #
-    def self.close_sockets(socket, ssl_socket)
-      begin
-        if ssl_socket
-          ssl_socket.close
+          begin
+            if socket
+              socket.close
+            end
+          rescue
+            Resque.logger.error("#{$!}: #{$!.backtrace.join("\n")}") if Resque.logger
+          end
         end
-      rescue
-        Resque.logger.error("#{$!}: #{$!.backtrace.join("\n")}") if Resque.logger
-      end
 
-      begin
-        if socket
-          socket.close
+        def self.application_exception(exception, name)
+          exc = Exception.new("#{exception} (#{name})")
+          exc.set_backtrace(exception.backtrace)
+          return exc
         end
-      rescue
-        Resque.logger.error("#{$!}: #{$!.backtrace.join("\n")}") if Resque.logger
-      end
-    end
-
-    def self.application_exception(exception, name)
-      exc = Exception.new("#{exception} (#{name})")
-      exc.set_backtrace(exception.backtrace)
-      return exc
-    end
     
-    def initialize(attributes)
-      attributes.each do |k, v|
-        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
-      end
-    end
+        def initialize(attributes)
+          attributes.each do |k, v|
+            respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
+          end
+        end
     
-    def socket(cert = nil, certp = nil, host = nil, port = nil, &block)
-      logger.debug("resque-aps: ssl_socket(#{name})") if logger
-      exc = nil
-
-      begin
-        socket, ssl_socket = Application.create_sockets(cert || File.read(cert_file),
-                                                        certp || cert_passwd,
-                                                        host || Resque.aps_gateway_host,
-                                                        port || Resque.aps_gateway_port)
-      rescue
-        raise Application.application_exception($!, name)
-      end
+        def socket(cert = nil, certp = nil, host = nil, port = nil, &block)
+          logger.debug("resque-aps: ssl_socket(#{name})") if logger
+          exc = nil
+
+          begin
+            socket, ssl_socket = Application.create_sockets(cert || File.read(cert_file),
+                                                            certp || cert_passwd,
+                                                            host || Resque.aps_gateway_host,
+                                                            port || Resque.aps_gateway_port)
+          rescue
+            raise Application.application_exception($!, name)
+          end
       
-      begin
-        ssl_socket.connect
-        yield ssl_socket, self if block_given?
-      rescue
-        exc = Application.application_exception($!, name)
-        if $!.message =~ /^SSL_connect .* certificate (expired|revoked)/
-          notify_aps_admin exc
-        end
-        raise exc
-      ensure
-        Application.close_sockets(socket, ssl_socket)
-      end
+          begin
+            ssl_socket.connect
+            yield ssl_socket, self if block_given?
+          rescue
+            exc = Application.application_exception($!, name)
+            if $!.message =~ /^SSL_connect .* certificate (expired|revoked)/
+              notify_aps_admin exc
+            end
+            raise exc
+          ensure
+            Application.close_sockets(socket, ssl_socket)
+          end
 
-      exc
-    end
+          exc
+        end
 
-    def to_hash
-      {'name' => name, 'cert_file' => cert_file, 'cert_passwd' => cert_passwd}
-    end
+        def to_hash
+          {'name' => name, 'cert_file' => cert_file, 'cert_passwd' => cert_passwd}
+        end
     
-    def to_json
-      to_hash.to_json
-    end
+        def to_json
+          to_hash.to_json
+        end
 
-    def before_aps_write(notification)
-      logger.debug("ResqueAps[before_write]: #{notification}") if logger
-    end
+        def before_aps_write(notification)
+          logger.debug("ResqueAps[before_write]: #{notification}") if logger
+        end
 
-    def after_aps_write(notification)
-      logger.debug("ResqueAps[after_write]: #{notification}") if logger
-    end
+        def after_aps_write(notification)
+          logger.debug("ResqueAps[after_write]: #{notification}") if logger
+        end
 
-    def failed_aps_write(notification, exception)
-      logger.error("ResqueAps[write_failed]: #{exception} (#{notification}): #{exception.backtrace.join("\n")}") if logger
-    end
+        def failed_aps_write(notification, exception)
+          logger.error("ResqueAps[write_failed]: #{exception} (#{notification}): #{exception.backtrace.join("\n")}") if logger
+        end
 
-    def notify_aps_admin(exception)
-    end
+        def notify_aps_admin(exception)
+        end
 
-    def aps_nil_notification_retry?(sent_count, start_time)
-      false
-    end
+        def aps_nil_notification_retry?(sent_count, start_time)
+          false
+        end
 
-    def before_aps_read
-      logger.debug("ResqueAps[before_read]:") if logger
-    end
+        def before_aps_read
+          logger.debug("ResqueAps[before_read]:") if logger
+        end
     
-    def after_aps_read(feedback)
-      logger.debug("ResqueAps[after_read]: #{feedback.to_s}") if logger
-    end
+        def after_aps_read(feedback)
+          logger.debug("ResqueAps[after_read]: #{feedback.to_s}") if logger
+        end
     
-    def aps_read_error(exception)
-      logger.error("ResqueAps[read_error]: #{exception} (#{name}): #{exception.backtrace.join("\n")}") if logger
-    end
+        def aps_read_error(exception)
+          logger.error("ResqueAps[read_error]: #{exception} (#{name}): #{exception.backtrace.join("\n")}") if logger
+        end
 
-    def aps_read_failed
-      logger.error("ResqueAps[read_failed]: Bad data on the socket (#{name})") if logger
-    end
+        def aps_read_failed
+          logger.error("ResqueAps[read_failed]: Bad data on the socket (#{name})") if logger
+        end
 
       end
     end

data/lib/resque_aps/feedback.rb

@@ -3,90 +3,90 @@ require 'timeout'
 module Resque
   module Plugins
     module Aps
-  class Feedback
-    include Resque::Plugins::Aps::Helper
-    extend Resque::Plugins::Aps::Helper
+      class Feedback
+        include Resque::Plugins::Aps::Helper
+        extend Resque::Plugins::Aps::Helper
 
-    @queue = "apple_push_service"
+        @queue = "apple_push_service"
     
-    attr_accessor :application_name, :device_token, :received_at
+        attr_accessor :application_name, :device_token, :received_at
 
-    def initialize(attributes)
-      attributes.each do |k, v|
-        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
-      end
-    end
+        def initialize(attributes)
+          attributes.each do |k, v|
+            respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
+          end
+        end
         
-    def inspect
-      "#<#{self.class.name} #{application_name.inspect}, #{device_token.inspect}, #{received_at.inspect}>"
-    end
+        def inspect
+          "#<#{self.class.name} #{application_name.inspect}, #{device_token.inspect}, #{received_at.inspect}>"
+        end
     
-    def to_s
-      "#{application_name} #{received_at} #{device_token}"
-    end
+        def to_s
+          "#{application_name} #{received_at} #{device_token}"
+        end
 
-    def to_hash
-      {:application_name => application_name, :device_token => device_token, :received_at => received_at}
-    end
+        def to_hash
+          {:application_name => application_name, :device_token => device_token, :received_at => received_at}
+        end
 
-    def self.read_feedback(ssl_socket, application_name, product_id)
-        data_str = ssl_socket.read(4)
-        return nil unless data_str
-        data_ary = data_str.unpack('N')
-        return nil unless data_ary && data_ary[0]
-        time     = Time.at(data_ary[0])
+        def self.read_feedback(ssl_socket, application_name, product_id)
+            data_str = ssl_socket.read(4)
+            return nil unless data_str
+            data_ary = data_str.unpack('N')
+            return nil unless data_ary && data_ary[0]
+            time     = Time.at(data_ary[0])
 
-        data_str = ssl_socket.read(2)
-        return nil unless data_str
-        data_ary = data_str.unpack('n')
-        return nil unless data_ary && data_ary[0]
-        tl       = data_ary[0]
+            data_str = ssl_socket.read(2)
+            return nil unless data_str
+            data_ary = data_str.unpack('n')
+            return nil unless data_ary && data_ary[0]
+            tl       = data_ary[0]
 
-        data_str = ssl_socket.read(tl)
-        return nil unless data_str
-        data_ary = data_str.unpack('H*')
-        return nil unless data_ary && data_ary[0]
-        token    = data_ary[0]
+            data_str = ssl_socket.read(tl)
+            return nil unless data_str
+            data_ary = data_str.unpack('H*')
+            return nil unless data_ary && data_ary[0]
+            token    = data_ary[0]
 
-        feedback = Feedback.new({:received_at => time, :device_token => token, :application_name => application_name})
-        return feedback
-    end
+            feedback = Feedback.new({:received_at => time, :device_token => token, :application_name => application_name})
+            return feedback
+        end
 
-    #
-    # Perform a Feedback check on the APN server, for the given app key (which must be the first argument)
-    #
-    def self.perform(*args)
-      app_name = args[0]
-      start    = Time.now
-      count    = 0
-      appl     = Resque.aps_application(app_name)
+        #
+        # Perform a Feedback check on the APN server, for the given app key (which must be the first argument)
+        #
+        def self.perform(*args)
+          app_name = args[0]
+          start    = Time.now
+          count    = 0
+          appl     = Resque.aps_application(app_name)
 
-      return unless appl
+          return unless appl
       
-      appl.socket(nil, nil, Resque.aps_feedback_host, Resque.aps_feedback_port) do |socket, app|
-        begin
-          logger.debug("Feedback: Reading feedbacks for #{app_name}.") if logger
-          timeout(5) do
-            until socket.eof?
-              app.before_aps_read
-              feedback = read_feedback(socket, app_name, product_id)
-              if feedback
-                count += 1
-                app.after_app_read(feedback)
-              else
-                app.aps_read_failed
+          appl.socket(nil, nil, Resque.aps_feedback_host, Resque.aps_feedback_port) do |socket, app|
+            begin
+              logger.debug("Feedback: Reading feedbacks for #{app_name}.") if logger
+              timeout(5) do
+                until socket.eof?
+                  app.before_aps_read
+                  feedback = read_feedback(socket, app_name, product_id)
+                  if feedback
+                    count += 1
+                    app.after_aps_read(feedback)
+                  else
+                    app.aps_read_failed
+                  end
+                end
               end
+            rescue
+              logger.error Application.application_exception($!, app_name) if logger
+              app.aps_read_error(Application.application_exception($!, app_name))
             end
           end
-        rescue
-          logger.error Application.application_exception($!, app_name) if logger
-          app.aps_read_error(Application.application_exception($!, app_name))
+          logger.info("Read #{count} #{app_name} feedbacks over #{Time.now - start} sec.") if logger
         end
+
       end
-      logger.info("Read #{count} #{app_name} feedbacks over #{Time.now - start} sec.") if logger
     end
-
-  end
   end
-end
 end

data/lib/resque_aps/notification.rb

@@ -1,197 +1,203 @@
 module Resque
   module Plugins
     module Aps
-  class Notification
-    include Resque::Plugins::Aps::Helper
-    extend Resque::Plugins::Aps::Helper
+      class Notification
+        include Resque::Plugins::Aps::Helper
+        extend Resque::Plugins::Aps::Helper
 
-    attr_accessor :application_name, :device_token, :payload
+        attr_accessor :application_name, :device_token, :payload, :batch_id, :expiry
 
-    def initialize(attributes)
-      attributes.each do |k, v|
-        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
-      end
-    end
+        def initialize(attributes)
+          attributes.each do |k, v|
+            respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
+          end
+        end
         
-    def inspect
-      "#<#{self.class.name} #{application_name.inspect}, #{device_token.inspect}, #{payload.inspect}>"
-    end
+        def inspect
+          "#<#{self.class.name} #{application_name.inspect}, #{device_token.inspect}, #{payload.inspect}>"
+        end
     
-    def to_s
-      "#{device_token.inspect}, #{payload.inspect}"
-    end
+        def to_s
+          "#{device_token.inspect}, #{payload.inspect}"
+        end
     
-    def to_hash
-      {:application_name => application_name, :device_token => device_token, :payload => payload}
-    end
+        def to_hash
+          {:application_name => application_name, :device_token => device_token, :payload => payload}
+        end
 
-    # SSL Configuration
-    #   open Keychain Access, and export the "Apple Development Push" certificate associated with your app in p12 format
-    #   Convert the certificate to PEM using openssl:
-    #      openssl pkcs12 -in mycert.p12 -out client-cert.pem -nodes -clcerts
+        # SSL Configuration
+        #   open Keychain Access, and export the "Apple Development Push" certificate associated with your app in p12 format
+        #   Convert the certificate to PEM using openssl:
+        #      openssl pkcs12 -in mycert.p12 -out client-cert.pem -nodes -clcerts
 
-    # To use with cross application push
-    # Notification.new(:user => user, :current_product => product, :cross_app => { :capabilities => 'cross_app', :payload => '{aps.....}' })
+        # To use with cross application push
+        # Notification.new(:user => user, :current_product => product, :cross_app => { :capabilities => 'cross_app', :payload => '{aps.....}' })
 
-    #
-    # https://developer.apple.com/iphone/prerelease/library/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/ApplePushService/ApplePushService.html#//apple_ref/doc/uid/TP40008194-CH100-SW1
-    #
-    # Table 2-1  Keys and values of the aps dictionary
-    # alert |  string or dictionary
-    # => If this property is included, iPhone OS displays a standard alert. You may specify a string as the value of alert or a dictionary as its value.
-    # => If you specify a string, it becomes the message text of an alert with two buttons: Close and View. If the user taps View, the application is launched.
-    # => Alternatively, you can specify a dictionary as the value of alert. See Table 2-2 for descriptions of the keys of this dictionary.
-    #
-    # badge |  number
-    # => The number to display as the badge of the application icon. If this property is absent, any badge number currently shown is removed.
-    #
-    # sound |  string
-    # => The name of a sound file in the application bundle. The sound in this file is played as an alert.
-    # => If the sound file doesn’t exist or default is specified as the value, the default alert sound is played.
-    # => The audio must be in one of the audio data formats that are compatible with system sounds; see “Preparing Custom Alert Sounds” for details.
-    #
-    # Table 2-2  Child properties of the alert property
-    # body |  string
-    # => The text of the alert message.
-    #
-    # action-loc-key |  string or null
-    # => If a string is specified, displays an alert with two buttons, whose behavior is described in Table 2-1.
-    # => However, iPhone OS uses the string as a key to get a localized string in the current localization to use for the right button’s title instead of “View”. 
-    # => If the value is null, the system displays an alert with a single OK button that simply dismisses the alert when tapped. 
-    #
-    # loc-key |  string
-    # => A key to an alert-message string in a Localizable.strings file for the current localization (which is set by the user’s language preference). 
-    # => The key string can be formatted with %@ and %n$@ specifiers to take the variables specified in loc-args. See “Localized Formatted Strings” for more information.
-    #
-    # loc-args |  array of strings
-    # => Variable string values to appear in place of the format specifiers in loc-key. See “Localized Formatted Strings” for more information.
-    #
-    #
-    # Example Result:
-    # {
-    #    "aps" : {
-    #        "alert" : "You got your emails.",
-    #        "badge" : 9,
-    #        "sound" : "bingbong.aiff"
-    #    },
-    #    "acme1" : "bar",
-    #    "acme2" : 42
-    #}
-    # Or
-    # {
-    #    "aps" : {
-    #        "alert" : {
-    #            "action-loc-key" : "PLAY",
-    #            "loc-key" : "SERVER.ERROR"
-    #            "loc-args" : ["bob", "sierra"]
-    #        },
-    #        "badge" : 9,
-    #        "sound" : "bingbong.aiff"
-    #    },
-    #    "acme1" : "bar",
-    #    "acme2" : 42
-    #}
-    def self.to_payload(alert = nil, badge = nil, sound = nil, app_data = nil)
-      result = ActiveSupport::OrderedHash.new
-      result['aps'] = ActiveSupport::OrderedHash.new
-      result['aps']['alert'] = self.format_alert(alert) unless alert.blank?
-      result['aps']['badge'] = badge.to_i unless badge.blank?
-      result['aps']['sound'] = sound unless sound.blank?
-      result.merge!(app_data) unless app_data.blank?
-      self.to_json(result)
-    end
+        #
+        # https://developer.apple.com/iphone/prerelease/library/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/ApplePushService/ApplePushService.html#//apple_ref/doc/uid/TP40008194-CH100-SW1
+        #
+        # Table 2-1  Keys and values of the aps dictionary
+        # alert |  string or dictionary
+        # => If this property is included, iPhone OS displays a standard alert. You may specify a string as the value of alert or a dictionary as its value.
+        # => If you specify a string, it becomes the message text of an alert with two buttons: Close and View. If the user taps View, the application is launched.
+        # => Alternatively, you can specify a dictionary as the value of alert. See Table 2-2 for descriptions of the keys of this dictionary.
+        #
+        # badge |  number
+        # => The number to display as the badge of the application icon. If this property is absent, any badge number currently shown is removed.
+        #
+        # sound |  string
+        # => The name of a sound file in the application bundle. The sound in this file is played as an alert.
+        # => If the sound file doesn’t exist or default is specified as the value, the default alert sound is played.
+        # => The audio must be in one of the audio data formats that are compatible with system sounds; see “Preparing Custom Alert Sounds” for details.
+        #
+        # Table 2-2  Child properties of the alert property
+        # body |  string
+        # => The text of the alert message.
+        #
+        # action-loc-key |  string or null
+        # => If a string is specified, displays an alert with two buttons, whose behavior is described in Table 2-1.
+        # => However, iPhone OS uses the string as a key to get a localized string in the current localization to use for the right button’s title instead of “View”. 
+        # => If the value is null, the system displays an alert with a single OK button that simply dismisses the alert when tapped. 
+        #
+        # loc-key |  string
+        # => A key to an alert-message string in a Localizable.strings file for the current localization (which is set by the user’s language preference). 
+        # => The key string can be formatted with %@ and %n$@ specifiers to take the variables specified in loc-args. See “Localized Formatted Strings” for more information.
+        #
+        # loc-args |  array of strings
+        # => Variable string values to appear in place of the format specifiers in loc-key. See “Localized Formatted Strings” for more information.
+        #
+        #
+        # Example Result:
+        # {
+        #    "aps" : {
+        #        "alert" : "You got your emails.",
+        #        "badge" : 9,
+        #        "sound" : "bingbong.aiff"
+        #    },
+        #    "acme1" : "bar",
+        #    "acme2" : 42
+        #}
+        # Or
+        # {
+        #    "aps" : {
+        #        "alert" : {
+        #            "action-loc-key" : "PLAY",
+        #            "loc-key" : "SERVER.ERROR"
+        #            "loc-args" : ["bob", "sierra"]
+        #        },
+        #        "badge" : 9,
+        #        "sound" : "bingbong.aiff"
+        #    },
+        #    "acme1" : "bar",
+        #    "acme2" : 42
+        #}
+        def self.to_payload(alert = nil, badge = nil, sound = nil, app_data = nil)
+          result = ActiveSupport::OrderedHash.new
+          result['aps'] = ActiveSupport::OrderedHash.new
+          result['aps']['alert'] = self.format_alert(alert) unless alert.blank?
+          result['aps']['badge'] = badge.to_i unless badge.blank?
+          result['aps']['sound'] = sound unless sound.blank?
+          result.merge!(app_data) unless app_data.blank?
+          self.to_json(result)
+        end
 
-    #
-    # Create an ordered hash of the data in the given alert hash
-    #
-    def self.format_alert(alert)
-      if alert.is_a? Hash
-        result = ActiveSupport::OrderedHash.new
-        result['action-loc-key'] = alert['action-loc-key'] unless alert['action-loc-key'].blank?
-        result['loc-key']        = alert['loc-key']        unless alert['loc-key'].blank?
-        unless alert['loc-args'].blank?
-          if alert['loc-args'].is_a? Hash
-            result['loc-args']     = Array.new(alert['loc-args'].size)
-            alert['loc-args'].map do |key,value|
-              result['loc-args'][key.to_i] = value
+        #
+        # Create an ordered hash of the data in the given alert hash
+        #
+        def self.format_alert(alert)
+          if alert.is_a? Hash
+            result = ActiveSupport::OrderedHash.new
+            result['action-loc-key'] = alert['action-loc-key'] unless alert['action-loc-key'].blank?
+            result['loc-key']        = alert['loc-key']        unless alert['loc-key'].blank?
+            unless alert['loc-args'].blank?
+              if alert['loc-args'].is_a? Hash
+                result['loc-args']     = Array.new(alert['loc-args'].size)
+                alert['loc-args'].map do |key,value|
+                  result['loc-args'][key.to_i] = value
+                end
+              else
+                result['loc-args'] = alert['loc-args']
+              end
             end
+            return result
           else
-            result['loc-args'] = alert['loc-args']
+            return alert
           end
         end
-        return result
-      else
-        return alert
-      end
-    end
 
-    #
-    # Generate a JSON string from the given Hash/Array which does not screw up the ordering of the Hash
-    #
-    def self.to_json(hash)
-      if hash.is_a? Hash
-        hash_keys = hash.keys
+        #
+        # Generate a JSON string from the given Hash/Array which does not screw up the ordering of the Hash
+        #
+        def self.to_json(hash)
+          if hash.is_a? Hash
+            hash_keys = hash.keys
 
-        result = '{'
-        result << hash_keys.map do |key|
-          if hash[key].is_a?(Hash) || hash[key].is_a?(Array)
-            "#{key.to_s.to_json}:#{to_json(hash[key])}"
-          else
-            "#{key.to_s.to_json}:#{hash[key].to_json}"
+            result = '{'
+            result << hash_keys.map do |key|
+              if hash[key].is_a?(Hash) || hash[key].is_a?(Array)
+                "#{key.to_s.to_json}:#{to_json(hash[key])}"
+              else
+                "#{key.to_s.to_json}:#{hash[key].to_json}"
+              end
+            end * ','
+            result << '}'
+          elsif hash.is_a? Array
+            result = '['
+            result << hash.map do |value|
+              if value.is_a?(Hash) || value.is_a?(Array)
+                "#{to_json(value)}"
+              else
+                value.to_json
+              end
+            end * ','
+            result << ']'
           end
-        end * ','
-        result << '}'
-      elsif hash.is_a? Array
-        result = '['
-        result << hash.map do |value|
-          if value.is_a?(Hash) || value.is_a?(Array)
-            "#{to_json(value)}"
-          else
-            value.to_json
-          end
-        end * ','
-        result << ']'
-      end
-    end
+        end
     
-    #
-    # The message formatted for sending in binary
-    #
-    def formatted
-      Resque::Plugins::Aps::Notification.format_message_for_sending(self.device_token, self.payload)
-    end
+        #
+        # The message formatted for sending in binary
+        #
+        def formatted
+          Resque::Plugins::Aps::Notification.format_message_for_sending(self.device_token, self.payload, self.batch_id, self.expiry)
+        end
 
-    #
-    # A HEX dump of the formatted message so that you can debug the binary data
-    #
-    def to_hex
-      formatted.unpack('H*')
-    end
+        #
+        # A HEX dump of the formatted message so that you can debug the binary data
+        #
+        def to_hex
+          formatted.unpack('H*')
+        end
 
-    #
-    # HEX version of the device token
-    #
-    def self.device_token_hex(device_token)
-      #self.device_token
-      [device_token.gsub(' ', '')].pack('H*')
-    end
+        #
+        # HEX version of the device token
+        #
+        def self.device_token_hex(device_token)
+          #self.device_token
+          [device_token.gsub(' ', '')].pack('H*')
+        end
 
-    #
-    # Combine the device token and JSON into a binary package to send.
-    #
-  	def self.format_message_for_sending(device_token, json)
-  	  token_hex = self.device_token_hex(device_token)
-      tl = [token_hex.length].pack('n')
-      # puts("token length [#{tl.unpack('H*')}]")
-      # puts("device token [#{token_hex.unpack('H*')}]")
-      # logger.debug "Formatting #{json} for #{self.device_token}"
-      jl = [json.length].pack('n')
-      # puts("json length  [#{jl.unpack('H*')}]")
-      # puts("json         [#{json}]")
-      "\0#{tl}#{token_hex}#{jl}#{json}"
-      # "\0\0 #{token_hex}\0#{json.length.chr}#{json}"
-  	end
-  end
+        #
+        # Combine the device token and JSON into a binary package to send.
+        #
+      	def self.format_message_for_sending(device_token, json, batch_id = nil, expiry = nil)
+      	  token_hex = self.device_token_hex(device_token)
+          tl = [token_hex.length].pack('n')
+          # puts("token length [#{tl.unpack('H*')}]")
+          # puts("device token [#{token_hex.unpack('H*')}]")
+          # logger.debug "Formatting #{json} for #{self.device_token}"
+          jl = [json.length].pack('n')
+          # puts("json length  [#{jl.unpack('H*')}]")
+          # puts("json         [#{json}]")
+          unless batch_id
+            "\0#{tl}#{token_hex}#{jl}#{json}"
+            # "\0\0 #{token_hex}\0#{json.length.chr}#{json}"
+          else
+            bid = [batch_id].pack('N')
+            exp = [expiry].pack('N')
+            "\1#{bid}#{exp}#{tl}#{token_hex}#{jl}#{json}"
+          end
+      	end
+      end
+    end
   end
-end
 end

data/lib/resque_aps/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module Aps
-  Version = '0.9.9'
+      Version = '0.9.10'
     end
   end
 end

data/lib/resque_aps.rb

@@ -14,126 +14,146 @@ module Resque
   module Plugins
     module Aps
 
-  def logger=(logger)
-    @logger = logger
-  end
-  
-  def logger
-    unless @logger
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::WARN
-    end
-    @logger
-  end
-  
-  def aps_gateway_host=(host)
-    @aps_gateway_host = host
-  end
-  
-  def aps_gateway_host
-    @aps_gateway_host ||= "gateway.sandbox.push.apple.com"
-  end
-  
-  def aps_gateway_port=(port)
-    @aps_gateway_port = port
-  end
-  
-  def aps_gateway_port
-    @aps_gateway_port ||= 2195
-  end
-  
-  def aps_feedback_host=(host)
-    @aps_feedback_host = host
-  end
-  
-  def aps_feedback_host
-    @aps_feedback_host ||= "feedback.sandbox.push.apple.com"
-  end
-  
-  def aps_feedback_port=(port)
-    @aps_feedback_port = port
-  end
-  
-  def aps_feedback_port
-    @aps_feedback_port ||= 2196
-  end
-  
-  def aps_queue_size_lower=(size)
-    @aps_queue_size_lower = size
-  end
-  
-  def aps_queue_size_lower
-    @aps_queue_size_lower ||= 0
-  end
-  
-  def aps_queue_size_upper=(size)
-    @aps_queue_size_upper = size
-  end
-  
-  def aps_queue_size_upper
-    @aps_queue_size_upper ||= 500
-  end
-  
-  def enqueue_aps(application_name, notification)
-    count = aps_notification_count_for_application(application_name)
-    redis.rpush(aps_application_queue_key(application_name), encode(notification.to_hash))
-    enqueue(Resque::Plugins::Aps::Application, application_name) if count <= aps_queue_size_lower || count >= aps_queue_size_upper
-    true
-  end
+      def logger=(logger)
+        @logger = logger
+      end
+  
+      def logger
+        unless @logger
+          @logger = Logger.new(STDOUT)
+          @logger.level = Logger::WARN
+        end
+        @logger
+      end
+  
+      def aps_gateway_host=(host)
+        @aps_gateway_host = host
+      end
+  
+      def aps_gateway_host
+        @aps_gateway_host ||= "gateway.sandbox.push.apple.com"
+      end
+  
+      def aps_gateway_port=(port)
+        @aps_gateway_port = port
+      end
+  
+      def aps_gateway_port
+        @aps_gateway_port ||= 2195
+      end
+  
+      def aps_feedback_host=(host)
+        @aps_feedback_host = host
+      end
+  
+      def aps_feedback_host
+        @aps_feedback_host ||= "feedback.sandbox.push.apple.com"
+      end
+  
+      def aps_feedback_port=(port)
+        @aps_feedback_port = port
+      end
+  
+      def aps_feedback_port
+        @aps_feedback_port ||= 2196
+      end
+  
+      def aps_queue_size_upper=(size)
+        @aps_queue_size_upper = size
+      end
+  
+      def aps_queue_size_upper
+        @aps_queue_size_upper ||= 1000
+      end
+  
+      def aps_application_job_limit=(size)
+        @aps_queue_size_upper = size
+      end
+  
+      def aps_application_job_limit
+        @aps_application_job_limit ||= 5
+      end
+  
+      def aps_applications_queued_count(application_name)
+        redis.get(aps_application_queued_key(application_name)) || 0
+      end
+  
+      def enqueue_aps_application(application_name, override = false)
+        count_apps = aps_applications_queued_count(application_name)
+        count_not  = aps_notification_count_for_application(application_name)
+        if override || count_apps <= 0 || (count_apps < aps_application_job_limit && (count_not > aps_queue_size_upper && count_not % (aps_queue_size_upper / 10) == 0))
+          enqueue(Resque::Plugins::Aps::Application, application_name)
+          redis.incr(aps_application_queued_key(application_name))
+        end
+      end
+      
+      def dequeue_aps_application(application_name)
+        redis.decr(aps_application_queued_key(application_name)) if aps_applications_queued_count(application_name) > 0
+      end
+      
+      def enqueue_aps(application_name, notification)
+        redis.rpush(aps_application_queue_key(application_name), encode(notification.to_hash))
+        enqueue_aps_application(application_name)
+        true
+      end
 
-  def dequeue_aps(application_name)
-    h = decode(redis.lpop(aps_application_queue_key(application_name)))
-    return Resque::Plugins::Aps::Notification.new(h) if h
-    nil
-  end
-  
-  # Returns the number of queued notifications for a given application
-  def aps_notification_count_for_application(application_name)
-    redis.llen(aps_application_queue_key(application_name)).to_i
-  end
+      def dequeue_aps(application_name)
+        h = decode(redis.lpop(aps_application_queue_key(application_name)))
+        return Resque::Plugins::Aps::Notification.new(h) if h
+        nil
+      end
+  
+      # Returns the number of queued notifications for a given application
+      def aps_notification_count_for_application(application_name)
+        redis.llen(aps_application_queue_key(application_name)).to_i
+      end
 
-  # Returns an array of queued notifications for the given application
-  def aps_notifications_for_application(application_name, start = 0, count = 1)
-    r = redis.lrange(aps_application_queue_key(application_name), start, count)
-    if r 
-      r.map { |h| Resque::Plugins::Aps::Notification.new(decode(h)) }
-    else
-      []
-    end
-  end
+      # Returns an array of queued notifications for the given application
+      def aps_notifications_for_application(application_name, start = 0, count = 1)
+        r = redis.lrange(aps_application_queue_key(application_name), start, count)
+        if r 
+          r.map { |h| Resque::Plugins::Aps::Notification.new(decode(h)) }
+        else
+          []
+        end
+      end
 
-  def create_aps_application(name, cert_file, cert_passwd = nil)
-    redis.set(aps_application_key(name), encode({'name' => name, 'cert_file' => cert_file, 'cert_passwd' => cert_passwd}))
-    redis.sadd(:aps_applications, name)
-  end
-  
-  def aps_application(name)
-    h = decode(redis.get(aps_application_key(name)))
-    return Resque::Plugins::Aps::Application.new(h) if h
-    nil
-  end
-  
-  # Returns an array of applications based on start and count
-  def aps_application_names(start = 0, count = 1)
-    a = redis.smembers(:aps_applications)
-    return a if count == 0
-    ret = a[start..(start + count)]
-    return [] unless ret
-    ret
-  end
+      def create_aps_application(name, cert_file, cert_passwd = nil)
+        redis.set(aps_application_key(name), encode({'name' => name, 'cert_file' => cert_file, 'cert_passwd' => cert_passwd}))
+        redis.sadd(:aps_applications, name)
+      end
+  
+      def aps_application(name)
+        h = decode(redis.get(aps_application_key(name)))
+        return Resque::Plugins::Aps::Application.new(h) if h
+        nil
+      end
+  
+      # Returns an array of applications based on start and count
+      def aps_application_names(start = 0, count = 1)
+        a = redis.smembers(:aps_applications)
+        return a if count == 0
+        ret = a[start..(start + count)]
+        return [] unless ret
+        ret
+      end
 
-  # Returns the number of application queues
-  def aps_applications_count
-    redis.smembers(:aps_applications).size
-  end
+      # Returns the number of application queues
+      def aps_applications_count
+        redis.smembers(:aps_applications).size
+      end
 
-  def aps_application_key(application_name)
-    "aps:application:#{application_name}"
-  end
-  
-  def aps_application_queue_key(application_name)
-    "#{aps_application_key(application_name)}:queue"
-  end
+      def aps_application_key(application_name)
+        "aps:application:#{application_name}"
+      end
+  
+      def aps_application_queued_key(application_name)
+        "#{aps_application_key(application_name)}:queued"
+      end
+      
+      def aps_application_queue_key(application_name)
+        "#{aps_application_key(application_name)}:queue"
+      end
     end
   end
 end

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: resque-aps
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 9
-  - 9
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors: 
 - Ashley Martens
@@ -14,73 +9,59 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-10 00:00:00 -07:00
+date: 2010-08-31 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: redis
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 0
-        - 7
         version: 1.0.7
-  type: :runtime
-  version_requirements: *id001
+    version: 
 - !ruby/object:Gem::Dependency 
   name: resque
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 5
-        - 0
         version: 1.5.0
-  type: :runtime
-  version_requirements: *id002
+    version: 
 - !ruby/object:Gem::Dependency 
   name: jeweler
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
-  type: :development
-  version_requirements: *id003
+    version: 
 - !ruby/object:Gem::Dependency 
   name: mocha
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
-  type: :development
-  version_requirements: *id004
+    version: 
 - !ruby/object:Gem::Dependency 
   name: rack-test
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
-  type: :development
-  version_requirements: *id005
+    version: 
 description: |-
   Queuing system for Apple's Push Service on top of Resque.
     Adds methods enqueue_aps to queue a notification message.
@@ -132,20 +113,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Queuing system for Apple's Push Service on top of Resque