resque-aps 0.9.0

data/.gitignore

@@ -0,0 +1 @@
+*.pem

data/HISTORY.md

@@ -0,0 +1,4 @@
+## 0.9.0 (2010-07-05)
+
+* Initial code
+

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010 Ashley Martens
+
+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,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,55 @@
+load 'tasks/resque_aps.rake'
+
+$LOAD_PATH.unshift 'lib'
+
+task :default => :test
+
+desc "Run tests"
+task :test do
+  Dir['test/*_test.rb'].each do |f|
+    require f
+  end
+end
+
+
+desc "Build a gem"
+task :gem => [ :test, :gemspec, :build ]
+
+begin
+  begin
+    require 'jeweler'
+  rescue LoadError
+    puts "Jeweler not available. Install it with: "
+    puts "gem install jeweler"
+  end
+
+  require 'resque_aps/version'
+
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "resque-aps"
+    gemspec.summary = "Queuing system for Apple's Push Service on top of Resque"
+    gemspec.description = %{Queuing system for Apple's Push Service on top of Resque.
+  Adds methods enqueue_aps to queue a notification message.
+  Also includes helper classes and methods to format JSON.}
+    gemspec.email = "ashleym1972@gmail.com"
+    gemspec.homepage = "http://github.com/ashleym1972/resque-aps"
+    gemspec.authors = ["Ashley Martens"]
+    gemspec.version = ResqueAps::Version
+
+    gemspec.add_dependency "redis", ">= 2.0.1"
+    gemspec.add_dependency "resque", ">= 1.8.0"
+    gemspec.add_development_dependency "jeweler"
+    gemspec.add_development_dependency "mocha"
+    gemspec.add_development_dependency "rack-test"
+  end
+end
+
+
+desc "Push a new version to Gemcutter"
+task :publish => [ :test, :gemspec, :build ] do
+  system "git tag v#{ResqueAps::Version}"
+  system "git push origin v#{ResqueAps::Version}"
+  system "git push origin master"
+  system "gem push pkg/resque-aps-#{ResqueAps::Version}.gem"
+  system "git clean -fd"
+end

data/lib/resque_aps/application.rb

@@ -0,0 +1,142 @@
+require 'openssl'
+
+module ResqueAps
+  class Application
+    include ResqueAps::Helper
+    extend ResqueAps::Helper
+
+    attr_accessor :name, :cert_file, :cert_passwd
+
+    @queue = "apple_push_service"
+
+    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
+            end
+          end
+
+          app.before_aps_write n
+          begin
+            socket.write(n.formatted)
+            app.after_aps_write n
+          rescue
+            logger.error application_exception($!) if logger
+            app.failed_aps_write n
+          end
+          count += 1
+        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_file, passphrase, host, port)
+      cert = File.read(cert_file)
+
+      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
+        end
+      rescue
+        Resque.logger.error("#{$!}: #{$!.backtrace.join("\n")}") if Resque.logger
+      end
+
+      begin
+        if socket
+          socket.close
+        end
+      rescue
+        Resque.logger.error("#{$!}: #{$!.backtrace.join("\n")}") if Resque.logger
+      end
+    end
+
+    def initialize(attributes)
+      attributes.each do |k, v|
+        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(ResqueAps::UnknownAttributeError, "unknown attribute: #{k}")
+      end
+    end
+    
+    def socket(&block)
+      logger.debug("resque-aps: ssl_socket(#{name})") if logger
+      exc = nil
+
+      socket, ssl_socket = Application.create_sockets(cert_file, cert_passwd, Resque.aps_gateway_host, Resque.aps_gateway_port)
+
+      begin
+        ssl_socket.connect
+        yield ssl_socket, self if block_given?
+      rescue
+        exc = application_exception($!)
+        if $! =~ /^SSL_connect .* certificate (expired|revoked)/
+          notify_aps_admin exc
+        end
+        raise exc
+      ensure
+        Application.close_sockets(socket, ssl_socket)
+      end
+
+      exc
+    end
+
+    def application_exception(exception)
+      exc = Exception.new("#{exception} (#{name})")
+      exc.set_backtrace(exception.backtrace)
+      return exc
+    end
+    
+    def to_hash
+      {'name' => name, 'cert_file' => cert_file, 'cert_passwd' => cert_passwd}
+    end
+    
+    def to_json
+      to_hash.to_json
+    end
+
+    def before_aps_write(notification)
+    end
+
+    def after_aps_write(notification)
+    end
+
+    def failed_aps_write(notification)
+    end
+
+    def notify_aps_admin(exception)
+    end
+
+    def aps_nil_notification_retry?(sent_count, start_time)
+      false
+    end
+
+  end
+end

data/lib/resque_aps/helper.rb

@@ -0,0 +1,11 @@
+
+module ResqueAps
+  module Helper
+    extend Resque::Helpers
+
+    def logger
+      Resque.logger
+    end
+
+  end
+end

data/lib/resque_aps/notification.rb

@@ -0,0 +1,193 @@
+module ResqueAps
+  class Notification
+    include ResqueAps::Helper
+    extend ResqueAps::Helper
+
+    attr_accessor :application_name, :device_token, :payload
+
+    def initialize(attributes)
+      attributes.each do |k, v|
+        respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(ResqueAps::UnknownAttributeError, "unknown attribute: #{k}")
+      end
+    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_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
+
+    # 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
+
+    #
+    # 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
+        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
+
+        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
+    
+    #
+    # The message formatted for sending in binary
+    #
+    def formatted
+      ResqueAps::Notification.format_message_for_sending(self.device_token, self.payload)
+    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
+
+    #
+    # 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
+end

data/lib/resque_aps/server/views/aps_applications.erb

@@ -0,0 +1,25 @@
+<h1>Apple Push Notification Applications</h1>
+
+<p class='intro'>
+  The list below contains the APN application queues.
+</p>
+
+<p class='sub'>
+  Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%=size = resque.aps_applications_count %></b> applications.
+</p>
+
+<table>
+  <tr>
+    <th></th>
+    <th>Application</th>
+    <th>Notification count</th>
+  </tr>
+  <% resque.aps_application_names(start, start+20).each do |application_name| %>
+    <tr>
+      <td><a href="<%= url "aps_applicatons/#{application_name}" %>"><%= application_name %></a></td>
+      <td><%= resque.aps_notification_count_for_application(application_name) %></td>
+    </tr>
+  <% end %>
+</table>
+
+<%= partial :next_more, :start => start, :size => size %>

data/lib/resque_aps/server/views/notifications.erb

@@ -0,0 +1,24 @@
+<% application_name = params[:application_name] %>
+
+<h1>Apple Push Service Notifications scheduled for <%= application_name %></h1>
+
+<p class='sub'>Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%=size = resque.aps_notification_count_for_application(application_name)%></b> notifications</p>
+
+<table class='jobs'>
+  <tr>
+    <th>Payload</th>
+  </tr>
+  <% notifications = resque.aps_notifications_for_application(application_name, start, 20) %>
+  <% notifications.each do |notification| %>
+    <tr>
+      <td class='args'><%=h notification.to_s %></td>
+    </tr>
+  <% end %>
+  <% if notifications.empty? %>
+    <tr>
+      <td class='no-data' colspan='2'>There are no pending notifications scheduled for this application.</td>
+    </tr>
+  <% end %>
+</table>
+
+<%= partial :next_more, :start => start, :size => size %>

data/lib/resque_aps/server.rb

@@ -0,0 +1,29 @@
+
+# Extend Resque::Server to add tabs
+module ResqueAps
+  
+  module Server
+
+    def self.included(base)
+
+      base.class_eval do
+
+        get "/aps" do
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/aps_applications.erb'))
+        end
+
+        get "/aps/:application_name" do
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/notifications.erb'))
+        end
+        
+      end
+
+    end
+
+    Resque::Server.tabs << 'APS'
+
+  end
+  
+end

data/lib/resque_aps/tasks.rb

@@ -0,0 +1,14 @@
+# require 'resque/tasks'
+# will give you the resque tasks
+
+namespace :resque do
+  task :setup
+
+  desc "Queue an APN in Resque"
+  task :aps => :setup do
+    require 'resque'
+    require 'resque_aps'
+
+  end
+
+end

data/lib/resque_aps/unknown_attribute_error.rb

@@ -0,0 +1,4 @@
+module ResqueAps
+  class UnknownAttributeError < Exception
+  end
+end

data/lib/resque_aps/version.rb

@@ -0,0 +1,3 @@
+module ResqueAps
+  Version = '0.9.0'
+end

data/lib/resque_aps.rb

@@ -0,0 +1,145 @@
+require 'rubygems'
+require 'resque'
+require 'logger'
+require 'resque/server'
+require 'resque_aps/helper'
+require 'resque_aps/version'
+require 'resque_aps/server'
+require 'resque_aps/application'
+require 'resque_aps/notification'
+
+module ResqueAps
+
+  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)
+    push(aps_application_queue_key(application_name), notification.to_hash)
+    enqueue(ResqueAps::Application, application_name) if count <= aps_queue_size_lower || count >= aps_queue_size_upper
+    true
+  end
+
+  def dequeue_aps(application_name)
+    h = pop(aps_application_queue_key(application_name))
+    return ResqueAps::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)
+    size(aps_application_queue_key(application_name))
+  end
+
+  # Returns an array of queued notifications for the given application
+  def aps_notifications_for_application(application_name, start = 0, count = 1)
+    r = peek(aps_application_queue_key(application_name), start, count)
+    if r 
+      r.map { |h| ResqueAps::Notification.new(h) }
+    else
+      []
+    end
+  end
+
+  def aps_application_class=(klass)
+    @aps_application_class = klass
+  end
+  
+  def aps_application_class
+    @aps_application_class ||= ResqueAps::Application
+  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 aps_application_class.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)
+    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
+
+  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
+end
+
+Resque.extend ResqueAps
+Resque::Server.class_eval do
+  include ResqueAps::Server
+end

data/tasks/resque_aps.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'resque_aps/tasks'

data/test/application_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "ResqueAps::Application" do
+  test "has a nice #inspect" do
+    n = ResqueAps::Application.new('name' => 'SomeApp', 'cert_file' => '/var/apps/certificates/some_app.pem', 'cert_passwd' => 'hello')
+    assert_equal '#<ResqueAps::Application "SomeApp", "hello", "/var/apps/certificates/some_app.pem">', n.inspect
+  end
+
+  test "can create and close sockets" do
+    socket, ssl = ResqueAps::Application.create_sockets(File.dirname(__FILE__) + "/../test-dev.pem", nil, Resque.aps_gateway_host, Resque.aps_gateway_port)
+    ResqueAps::Application.close_sockets(socket, ssl)
+  end
+
+  test "can run socket block" do
+    a = ResqueAps::Application.new(:name => "TestApp", :cert_file => File.dirname(__FILE__) + "/../test-dev.pem")
+    a.socket do |s, a|
+    end
+  end
+  
+  test "can perform" do
+    n = ResqueAps::Notification.new('application_name' => 'TestApp', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+    assert Resque.enqueue_aps('TestApp', n)
+    Resque.create_aps_application('TestApp', File.dirname(__FILE__) + "/../test-dev.pem", nil)
+    ResqueAps::Application.perform('TestApp')
+  end
+
+  context "ApplicationWithHooks" do
+    class ApplicationWithHooks < ResqueAps::Application
+      def before_aps_write(notification)
+        logger.debug "before_aps_write #{notification.inspect}"
+      end
+
+      def after_aps_write(notification)
+        logger.debug "after_aps_write #{notification.inspect}"
+      end
+
+      def failed_aps_write(notification)
+        logger.debug "failed_aps_write #{notification.inspect}"
+      end
+
+      def notify_aps_admin(exception)
+        logger.debug "notify_aps_admin #{exception}"
+      end
+
+      def aps_nil_notification_retry?(sent_count, start_time)
+        logger.debug "aps_nil_notification_retry #{sent_count}"
+        false
+      end
+    end
+    
+    test "can perform with logging hooks" do
+      n = ResqueAps::Notification.new('application_name' => 'TestApp', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+      assert Resque.enqueue_aps('TestApp', n)
+      Resque.aps_application_class = ApplicationWithHooks
+      Resque.create_aps_application('TestApp', File.dirname(__FILE__) + "/../test-dev.pem", nil)
+      ResqueAps::Application.perform('TestApp')
+    end
+  end
+end

data/test/notification_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "ResqueAps::Notification" do
+  test "has a nice #inspect" do
+    n = ResqueAps::Notification.new('application_name' => 'SomeApp', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+    assert_equal '#<ResqueAps::Notification "SomeApp", "aihdf08u2402hbdfquhiwr", "{\"aps\": { \"alert\": \"hello\"}}">', n.inspect
+  end
+end

data/test/redis-test.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/test/resque-web_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Pull in the server test_helper from resque
+require 'resque/server/test_helper.rb'
+
+context "on GET to /aps" do
+  setup { get "/aps" }
+
+  should_respond_with_success
+end
+
+context "on GET to /aps with applications" do
+  setup do 
+    Resque.redis.flushall
+    Resque.create_aps_application(:some_ivar_application, nil, nil)
+    Resque.create_aps_application(:someother_ivar_application, nil, nil)
+    get "/aps"
+  end
+
+  should_respond_with_success
+
+  test 'see the applications' do
+    assert last_response.body.include?('some_ivar_application')
+    assert last_response.body.include?('someother_ivar_application')
+  end
+end
+
+context "on GET to /aps/some_ivar_application" do
+  setup do
+    Resque.redis.flushall
+    Resque.create_aps_application(:some_ivar_application, nil, nil)
+    n = ResqueAps::Notification.new('application_name' => 'some_ivar_application', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+    assert Resque.enqueue_aps(:some_ivar_application, n)
+    assert Resque.enqueue_aps(:some_ivar_application, n)
+    assert Resque.enqueue_aps(:some_ivar_application, n)
+    assert Resque.enqueue_aps(:some_ivar_application, n)
+    get "/aps/some_ivar_application"
+  end
+
+  should_respond_with_success
+
+  test 'see the applications' do
+    assert last_response.body.include?('some_ivar_application')
+  end
+end

data/test/resque_aps_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "ResqueAps" do
+  setup do
+    Resque.redis.flushall
+  end
+
+  # test "needs to infer a queue with enqueue" do
+  #   assert_raises Resque::NoQueueError do
+  #     Resque.enqueue(SomeJob, 20, '/tmp')
+  #   end
+  # end
+
+  test "can create an application" do
+    assert Resque.create_aps_application('SomeApp', '/var/apps/certificates/someapp.pem')
+    assert_equal 1, Resque.aps_applications_count
+    assert Resque.create_aps_application('SomeApp2', '/var/apps/certificates/someapp2.pem', 'secret')
+    assert_equal 2, Resque.aps_applications_count
+  end
+  
+  test "can get an application" do
+    Resque.create_aps_application('SomeApp', '/var/apps/certificates/someapp.pem', 'secret')
+    a = Resque.aps_application('SomeApp')
+    assert_equal 'SomeApp', a.name
+    assert_equal '/var/apps/certificates/someapp.pem', a.cert_file
+    assert_equal 'secret', a.cert_passwd
+  end
+  
+  # test "can update an application" do
+  # end
+  
+  test "knows how big the application queue is" do
+    assert_equal 0, Resque.aps_applications_count
+
+    Resque.create_aps_application('SomeApp', '/var/apps/certificates/someapp.pem', 'secret')
+    assert_equal 1, Resque.aps_applications_count
+  end
+
+  test "can get a list of application names" do
+    assert Resque.create_aps_application('SomeApp', '/var/apps/certificates/someapp.pem')
+    assert Resque.create_aps_application('SomeApp2', '/var/apps/certificates/someapp2.pem', 'secret')
+    assert_equal ['SomeApp2', 'SomeApp'], Resque.aps_application_names(0, 2)
+  end
+
+  test "can enqueue aps notifications" do
+    n = ResqueAps::Notification.new('application_name' => 'SomeApp', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert_equal 1, Resque.aps_notification_count_for_application('SomeApp')
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert_equal 2, Resque.aps_notification_count_for_application('SomeApp')
+  end
+
+  test "can dequeue aps notifications" do
+    n = ResqueAps::Notification.new('application_name' => 'SomeApp', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert_equal 1, Resque.aps_notification_count_for_application('SomeApp')
+
+    nn = Resque.dequeue_aps('SomeApp')
+
+    assert nn
+    assert_kind_of ResqueAps::Notification, nn
+    assert_equal n.application_name, nn.application_name
+    assert_equal n.device_token,     nn.device_token
+    assert_equal n.payload,          nn.payload
+  end
+
+  test "knows how big the application notification queue is" do
+    n = ResqueAps::Notification.new('application_name' => 'SomeApp', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert_equal 1, Resque.aps_notification_count_for_application('SomeApp')
+
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert_equal 2, Resque.aps_notification_count_for_application('SomeApp')
+  end
+
+  test "can get a list of application notifications" do
+    n = ResqueAps::Notification.new('application_name' => 'SomeApp', 'device_token' => 'aihdf08u2402hbdfquhiwr', 'payload' => '{"aps": { "alert": "hello"}}')
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert Resque.enqueue_aps('SomeApp', n)
+    assert_equal 3, Resque.aps_notification_count_for_application('SomeApp')
+    a = Resque.aps_notifications_for_application('SomeApp', 0, 20)
+    assert_equal 3, a.size
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,78 @@
+
+# Pretty much copied this file from the resque test_helper since we want
+# to do all the same stuff
+
+dir = File.dirname(File.expand_path(__FILE__))
+
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'resque'
+require File.join(dir, '../lib/resque_aps')
+$LOAD_PATH.unshift File.dirname(File.expand_path(__FILE__)) + '/../lib'
+
+
+#
+# make sure we can run redis
+#
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+
+#
+# start our own redis when the tests start,
+# kill it when they end
+#
+
+at_exit do
+  next if $!
+
+  if defined?(MiniTest)
+    exit_code = MiniTest::Unit.new.run(ARGV)
+  else
+    exit_code = Test::Unit::AutoRunner.run
+  end
+
+  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+  puts "Killing test redis server..."
+  `rm -f #{dir}/dump.rdb`
+  Process.kill("KILL", pid.to_i)
+  exit exit_code
+end
+
+puts "Starting redis for testing at localhost:9736..."
+`redis-server #{dir}/redis-test.conf`
+Resque.redis = 'localhost:9736'
+
+##
+# test/spec/mini 3
+# http://gist.github.com/25455
+# chris@ozmm.org
+#
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  require 'test/unit'
+  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+    end 
+    def self.xtest(*args) end 
+    def self.setup(&block) define_method(:setup, &block) end 
+    def self.teardown(&block) define_method(:teardown, &block) end 
+  end 
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval &block
+end
+
+class SomeJob
+  def self.perform(repo_id, path)
+  end
+end
+
+class SomeIvarJob < SomeJob
+  @queue = :ivar
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification 
+name: resque-aps
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- Ashley Martens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: resque
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 8
+        - 0
+        version: 1.8.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: |-
+  Queuing system for Apple's Push Service on top of Resque.
+    Adds methods enqueue_aps to queue a notification message.
+    Also includes helper classes and methods to format JSON.
+email: ashleym1972@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- .gitignore
+- HISTORY.md
+- LICENSE
+- README
+- Rakefile
+- lib/resque_aps.rb
+- lib/resque_aps/application.rb
+- lib/resque_aps/helper.rb
+- lib/resque_aps/notification.rb
+- lib/resque_aps/server.rb
+- lib/resque_aps/server/views/aps_applications.erb
+- lib/resque_aps/server/views/notifications.erb
+- lib/resque_aps/tasks.rb
+- lib/resque_aps/unknown_attribute_error.rb
+- lib/resque_aps/version.rb
+- tasks/resque_aps.rake
+- test/application_test.rb
+- test/notification_test.rb
+- test/redis-test.conf
+- test/resque-web_test.rb
+- test/resque_aps_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/ashleym1972/resque-aps
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Queuing system for Apple's Push Service on top of Resque
+test_files: 
+- test/application_test.rb
+- test/notification_test.rb
+- test/resque-web_test.rb
+- test/resque_aps_test.rb
+- test/test_helper.rb