apn_sender 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Kali Donovan
+
+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/README.rdoc

@@ -0,0 +1,60 @@
+= apn_sender
+
+So you're building the server component of an iPhone application in Ruby.  And you want to send background notifications through the Apple Push Notification servers, which doesn't seem too bad.  But then you read in the {Apple Documentation}[https://developer.apple.com/iphone/library/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/WhatAreRemoteNotif/WhatAreRemoteNotif.html#//apple_ref/doc/uid/TP40008194-CH102-SW7] (<em>Apple Dev account required</em>) that the Apple's servers may treat non-persistent connections as a Denial of Service attack, and things started looking more complicated.
+
+If this doesn't sound familiar, this gem probably isn't anything you need.  If it does, though...
+
+The apn_sender gem includes a background daemon which processes background messages from your application and sends them along to Apple <em>over a single, persistent socket</em>.  It also includes helper methods for enqueueing your jobs and a sample monit config to make sure the background worker is around when you need it.
+
+
+== Usage
+
+=== Queueing Messages From Your Application
+
+To queue a message for sending through Apple's Push Notification service from your Rails application:
+
+  APN.notify(token, opts_hash)
+  
+where +token+ is the unique identifier of the iPhone to receive the notification and +opts_hash+ can have any of the following keys:
+
+  # :alert  #=> The alert to send
+  # :badge  #=> The badge number to send
+  # :sound  #=> The sound file to play on receipt, or true to play the default sound installed with your app
+  # :custom #=> Hash of application-specific custom data to send along with the notification
+
+=== Getting Messages Actually Sent to Apple
+
+Put your <code>apn_development.pem</code> and <code>apn_production.pem</code> certificates from Apple in your <code>RAILS_ROOT/config/certs</code> directory.
+
+Once this is done, you can fire off a background worker with
+
+  $ rake apn:sender
+  
+For production, you're probably better off running a dedicated daemon and setting up monit to watch over it for you.  Luckily, that's pretty easy:
+
+  # To run standard daemon
+  ./script/apn_sender
+  
+  # To pass in options
+  ./script/apn_sender -- --cert-path=PATH_TO_NONSTANDARD_FOLDER_WITH_PEM_FILES --environment=production
+
+Note the --environment must be explicitly set (separately from your <code>RAILS_ENV</code>) to production in order to send messages via the production APN servers.  Any other environment sends messages through Apple's sandbox servers at <code>gateway.sandbox.push.apple.com</code>.
+
+=== Keeping Your Workers Working
+
+There's also an included sample <code>apn_sender.monitrc</code> file in the <code>contrib/</code> folder to help monit handle server restarts and unexpected disasters.
+
+
+== Installation
+
+APN is built on top of {Resque}[http://github.com/defunkt/resque] (an awesome {Redis}[http://code.google.com/p/redis/]-based background runner similar to {delayed_job}[http://github.com/collectiveidea/delayed_job]). Read through the {Resque README}[http://github.com/defunkt/resque#readme] to get a feel for what's going on, follow the installation instructions there, and then run:
+
+  $ sudo gem install apple_push_notification
+
+In your Rails app, add
+
+  config.gem 'apple_push_notification'
+
+== Copyright
+
+Copyright (c) 2010 Kali Donovan. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+load 'lib/apn/tasks.rb'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "apn_sender"
+    gem.summary = %Q{Resque-based background worker to send Apple Push Notifications over a persistent TCP socket.}
+    gem.description = %Q{Resque-based background worker to send Apple Push Notifications over a persistent TCP socket. Includes Resque tweaks to allow persistent sockets between jobs, helper methods for enqueueing APN notifications, and a background daemon to send them.}
+    gem.email = "kali.donovan@gmail.com"
+    gem.homepage = "http://github.com/kdonovan/apple_push_notification"
+    gem.authors = ["Kali Donovan"]
+    gem.add_dependency 'resque'
+    gem.add_dependency 'resque-access_worker_from_job'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "apple_push_notification #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/apn_sender.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{apn_sender}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kali Donovan"]
+  s.date = %q{2010-04-25}
+  s.description = %q{Resque-based background worker to send Apple Push Notifications over a persistent TCP socket. Includes Resque tweaks to allow persistent sockets between jobs, helper methods for enqueueing APN notifications, and a background daemon to send them.}
+  s.email = %q{kali.donovan@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "apn_sender.gemspec",
+     "contrib/apn_sender.monitrc",
+     "generators/apple_push_notification_generator.rb",
+     "generators/templates/script",
+     "init.rb",
+     "lib/apn.rb",
+     "lib/apn/notification.rb",
+     "lib/apn/notification_job.rb",
+     "lib/apn/queue_manager.rb",
+     "lib/apn/sender.rb",
+     "lib/apn/sender_daemon.rb",
+     "lib/apn/tasks.rb",
+     "lib/resque/hooks/before_unregister_worker.rb",
+     "rails/init.rb",
+     "test/helper.rb",
+     "test/test_apple_push_notification.rb"
+  ]
+  s.homepage = %q{http://github.com/kdonovan/apple_push_notification}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Resque-based background worker to send Apple Push Notifications over a persistent TCP socket.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_apple_push_notification.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<resque>, [">= 0"])
+      s.add_runtime_dependency(%q<resque-access_worker_from_job>, [">= 0"])
+    else
+      s.add_dependency(%q<resque>, [">= 0"])
+      s.add_dependency(%q<resque-access_worker_from_job>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<resque>, [">= 0"])
+    s.add_dependency(%q<resque-access_worker_from_job>, [">= 0"])
+  end
+end
+

data/contrib/apn_sender.monitrc

@@ -0,0 +1,13 @@
+# an example Monit configuration file for running the apple_push_notification background sender
+#
+# To use:
+# 1. copy to /var/www/apps/{app_name}/shared/apn_sender.monitrc
+# 2. replace {app_name} as appropriate
+# 3. add this to your /etc/monit/monitrc
+#
+#   include /var/www/apps/{app_name}/shared/apn_sender.monitrc
+
+check process apn_sender
+  with pidfile /var/www/apps/{app_name}/shared/pids/apn_sender.pid
+  start program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/apn_sender start"
+  stop program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/apn_sender stop"

data/generators/apple_push_notification_generator.rb

@@ -0,0 +1,9 @@
+class ApplePushNotificationGenerator < Rails::Generator::Base
+
+  def manifest
+    record do |m|
+      m.template 'script', 'script/apn_sender', :chmod => 0755
+    end
+  end
+
+end

data/generators/templates/script

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# Daemons sets pwd to /, so we have to explicitly set RAILS_ROOT
+RAILS_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+require File.join(File.dirname(__FILE__), *%w(.. vendor plugins apple_push_notification lib apple_push_notification sender_daemon))
+APN::SenderDaemon.new(ARGV).daemonize

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init.rb"

data/lib/apn/notification.rb

@@ -0,0 +1,65 @@
+module APN
+  # Encapsulates the logic necessary to convert an iPhone token and an array of options into a string of the format required
+  # by Apple's servers to send the notification.  Much of the processing code here copied with many thanks from
+  # http://github.com/samsoffes/apple_push_notification/blob/master/lib/apple_push_notification.rb
+  #
+  # APN::Notification.new's first argument is the token of the iPhone which should receive the notification.  The second argument
+  # is a hash with any of :alert, :badge, and :sound keys. All three accept string arguments, while :sound can also be set to +true+
+  # to play the default sound installed with the application. At least one of these keys must exist. The hash also accepts a
+  # :custom key to send a hash of custom application data:
+  #
+  #   APN::Notification.new(token, {:alert => 'Stuff', :custom => {:code => 23}})
+  #   # Writes this JSON to servers: {"code":23,"aps":{"alert":"Stuff"}}
+  # 
+  # As a shortcut, APN::Notification.new also accepts a string as the second argument, which it converts into the alert to send.  The 
+  # following two lines are equivalent:
+  #
+  #   APN::Notification.new(token, 'Some Alert')
+  #   APN::Notification.new(token, {:alert => 'Some Alert'})
+  #
+  class Notification
+    attr_accessor :message, :options, :json
+    def initialize(token, opts)
+      @options = hash_as_symbols(opts.is_a?(Hash) ? opts : {:alert => opts})
+      @json = generate_apple_json
+      hex_token = [token.delete(' ')].pack('H*')
+      @message = "\0\0 #{hex_token}\0#{json.length.chr}#{json}"
+      raise "The maximum size allowed for a notification payload is 256 bytes." if @message.size.to_i > 256
+    end
+
+    def to_s
+      @message      
+    end
+    
+    def valid?
+      return true if %w(alert badge sound).any?{|key| options.keys.include?(key.to_sym) }
+      false
+    end
+    
+    protected
+    
+    # Convert the supplied options into the JSON needed for Apple's push notification servers
+    def generate_apple_json
+      hsh = {'aps' => {}}
+      hsh['aps']['alert'] = @options[:alert].to_s if @options[:alert]
+      hsh['aps']['badge'] = @options[:badge].to_i if @options[:badge]
+      hsh['aps']['sound'] = @options[:sound] if @options[:sound] and @options[:sound].is_a? String
+      hsh['aps']['sound'] = 'default' if @options[:sound] and @options[:sound].is_a? TrueClass
+      hsh.merge!(@options[:custom]) if @options[:custom]
+      hsh.to_json
+    end
+
+    # Symbolize keys, using ActiveSupport if available
+    def hash_as_symbols(hash)
+      if hash.respond_to?(:symbolize_keys)
+        return hash.symbolize_keys
+      else
+       hash.inject({}) do |opt, (key, value)|
+         opt[(key.to_sym rescue key) || key] = value
+         opt
+       end
+     end
+   end
+   
+ end   
+end

data/lib/apn/notification_job.rb

@@ -0,0 +1,22 @@
+module APN
+  # This is the class that's actually enqueued via Resque when user calls +APN.notify+.
+  # It gets added to the +apple_server_notifications+ Resque queue, which should only be operated on by
+  # workers of the +APN::Sender+ class.
+  class NotificationJob
+    # Behind the scenes, this is the name of our Resque queue
+    @queue = APN::QUEUE_NAME
+    
+    # Build a notification from arguments and send to Apple
+    def self.perform(token, opts)
+      msg = APN::Notification.new(token, opts)
+      raise "Invalid notification options: #{opts.inspect}" unless msg.valid?
+      worker.send_to_apple( msg )
+    end
+   
+   
+    # Only execute this job in specialized APN::Sender workers, since
+    # standard Resque workers don't maintain the persistent TCP connection.
+    extend Resque::Plugins::AccessWorkerFromJob
+    self.required_worker_class = 'APN::Sender'
+  end
+end

data/lib/apn/queue_manager.rb

@@ -0,0 +1,51 @@
+# Extending Resque to respond to the +before_unregister_worker+ hook. Note this requires a matching
+# monkeypatch in the Resque::Worker class. See +resque/hooks/before_unregister_worker.rb+ for an
+# example implementation
+
+module APN
+  # Extends Resque, allowing us to add all the callbacks to Resque we desire without affecting the expected
+  # functionality in the parent app, if we're included in e.g. a Rails application.
+  class QueueManager
+    extend Resque
+
+    def self.before_unregister_worker(&block)
+      block ? (@before_unregister_worker = block) : @before_unregister_worker
+    end
+
+    def self.before_unregister_worker=(before_unregister_worker)
+      @before_unregister_worker = before_unregister_worker
+    end
+
+    def self.to_s
+      "APN::QueueManager (Resque Client) connected to #{redis.server}"
+    end
+  end
+  
+end
+
+# Ensures we close any open sockets when the worker exits
+APN::QueueManager.before_unregister_worker do |worker|
+  worker.send(:teardown_connection) if worker.respond_to?(:teardown_connection)
+end
+
+
+# # Run N jobs per fork, rather than creating a new fork for each notification
+# # By defunkt - http://gist.github.com/349376
+# APN::QueueManager.after_fork do |job|
+#   # How many jobs should we process in each fork?
+#   jobs_per_fork = 10
+# 
+#   # Set hook to nil to prevent running this hook over
+#   # and over while processing more jobs in this fork.
+#   Resque.after_fork = nil
+# 
+#   # Make sure we process jobs in the right order.
+#   job.worker.process(job)
+# 
+#   # One less than specified because the child will run a
+#   # final job after exiting this hook.
+#   (jobs_per_fork.to_i - 1).times do
+#     job.worker.process
+#   end
+# end
+

data/lib/apn/sender.rb

@@ -0,0 +1,133 @@
+require 'socket'
+require 'openssl'
+require 'resque'
+
+module APN
+  # Subclass of Resque::Worker which initializes a single TCP socket on creation to communicate with Apple's Push Notification servers.
+  # Shares this socket with each child process forked off by Resque to complete a job. Socket is closed in the before_unregister_worker
+  # callback, which gets called on normal or exceptional exits.
+  #
+  # End result: single persistent TCP connection to Apple, so they don't ban you for frequently opening and closing connections,
+  # which they apparently view as a DOS attack.
+  #
+  # Accepts <code>:environment</code> (production vs anything else) and <code>:cert_path</code> options on initialization.  If called in a 
+  # Rails context, will default to RAILS_ENV and RAILS_ROOT/config/certs. :environment will default to development.  
+  # APN::Sender expects two files to exist in the specified <code>:cert_path</code> directory: 
+  # <code>apn_production.pem</code> and <code>apn_development.pem</code>.
+  class Sender < ::Resque::Worker
+    APN_PORT = 2195
+    attr_accessor :apn_cert, :apn_host, :socket, :socket_tcp, :opts
+    
+    class << self
+      attr_accessor :logger
+    end
+    
+    self.logger = if defined?(Merb::Logger)
+      Merb.logger
+    elsif defined?(RAILS_DEFAULT_LOGGER)
+      RAILS_DEFAULT_LOGGER
+    end
+
+    def initialize(opts = {})
+      @opts = opts
+
+      # Set option defaults
+      @opts[:cert_path] ||= File.join(File.expand_path(RAILS_ROOT), "config", "certs") if defined?(RAILS_ROOT)
+      @opts[:environment] ||= RAILS_ENV if defined?(RAILS_ENV)
+      
+      logger.info "APN::Sender initializing. Establishing connections first..." if @opts[:verbose]
+      setup_paths
+      setup_connection
+      
+      super( APN::QUEUE_NAME )
+    end
+        
+    # Send a raw string over the socket to Apple's servers (presumably already formatted by APN::Notification)
+    def send_to_apple(msg)
+      @socket.write( msg.to_s )
+    rescue SocketError => error
+      logger.error("Error with connection to #{@apn_host}: #{error}")
+      raise "Error with connection to #{@apn_host}: #{error}"
+    end
+            
+    protected
+    
+    def apn_production?
+      @opts[:environment] && @opts[:environment] != '' && :production == @opts[:environment].to_sym
+    end
+    
+    # Get a fix on the .pem certificate we'll be using for SSL
+    def setup_paths
+      raise "Missing certificate path. Please specify :cert_path when initializing class." unless @opts[:cert_path]
+      @apn_host = apn_production? ? "gateway.push.apple.com" : "gateway.sandbox.push.apple.com"
+      cert_name = apn_production? ? "apn_production.pem" : "apn_development.pem"
+      cert_path = File.join(@opts[:cert_path], cert_name)
+
+      @apn_cert = File.exists?(cert_path) ? File.read(cert_path) : nil
+      raise "Missing apple push notification certificate in #{cert_path}" unless @apn_cert
+    end
+
+    # Open socket to Apple's servers
+    def setup_connection
+      raise "Missing apple push notification certificate" unless @apn_cert
+      raise "Trying to open already-open socket" if @socket || @socket_tcp
+      
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.cert = OpenSSL::X509::Certificate.new(@apn_cert)
+      ctx.key = OpenSSL::PKey::RSA.new(@apn_cert)
+
+      @socket_tcp = TCPSocket.new(@apn_host, APN_PORT)
+      @socket = OpenSSL::SSL::SSLSocket.new(@socket_tcp, ctx)
+      @socket.sync = true
+      @socket.connect
+    rescue SocketError => error
+      logger.error("Error with connection to #{@apn_host}: #{error}")
+      raise "Error with connection to #{@apn_host}: #{error}"      
+    end
+    
+    # Close open sockets
+    def teardown_connection
+      logger.info "Closing connections..." if @opts[:verbose]
+
+      begin
+        @socket.close if @socket
+      rescue Exception => e
+        logger.error("Error closing SSL Socket: #{e}")
+      end
+      
+      begin
+        @socket_tcp.close if @socket_tcp
+      rescue Exception => e
+        logger.error("Error closing TCP Socket: #{e}")
+      end
+    end
+    
+  end
+
+end
+
+
+__END__
+
+# irb -r 'lib/apple_push_notification'
+
+## To enqueue test job
+Resque.enqueue APN::NotificationJob, 'ceecdc18 ef17b2d0 745475e0 0a6cd5bf 54534184 ac2649eb 40873c81 ae76dbe8', {:alert => 'Resque Test'}
+
+
+## To run worker from rake task
+CERT_PATH=/Users/kali/Code/insurrection/certs/ ENVIRONMENT=production rake apn:work
+
+## To run worker from IRB 
+Resque.workers.map(&:unregister_worker)
+require 'ruby-debug'
+worker = APN::Sender.new(:cert_path => '/Users/kali/Code/insurrection/certs/', :environment => :production)
+worker.very_verbose = true
+worker.work(5)
+
+## To run worker as daemon - NOT YET TESTED
+APN::SenderDaemon.new(ARGV).daemonize
+
+## TESTING - check the broken pipe errors
+
+## TESTING - then check implementation of resque-web

data/lib/apn/sender_daemon.rb

@@ -0,0 +1,65 @@
+# Modified slightly from delayed_job's delayed/command.rb
+require 'rubygems'
+require 'daemons'
+require 'optparse'
+
+module APN
+  class SenderDaemon
+    attr_accessor :worker_count
+    
+    def initialize(args)
+      @options = {:quiet => true}
+      @worker_count = 1
+      
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
+
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit 1
+        end
+        opts.on('-e', '--environment=NAME', 'Specifies the environment to run this apn_sender under ([development]/production).') do |e|
+          @options[:environment] = e
+        end
+        opts.on('--cert-path=NAME', '--certificate-path=NAME', 'Path to directory containing apn .pem certificates.') do |path|
+          @options[:cert_path] = path
+        end
+        opts.on('-n', '--number_of_workers=workers', "Number of unique workers to spawn") do |worker_count|
+          @worker_count = worker_count.to_i rescue 1
+        end
+      end
+      @args = opts.parse!(args)
+    end
+  
+    def daemonize
+      worker_count.times do |worker_index|
+        process_name = worker_count == 1 ? "apn_sender" : "apn_sender.#{worker_index}"
+        Daemons.run_proc(process_name, :dir => "#{::RAILS_ROOT}/tmp/pids", :dir_mode => :normal, :ARGV => @args) do |*args|
+          run process_name
+        end
+      end
+    end
+    
+    def run(worker_name = nil)
+      Dir.chdir(::RAILS_ROOT)
+      require File.join(::RAILS_ROOT, 'config', 'environment')
+      
+      # Replace the default logger
+      logger = Logger.new(File.join(::RAILS_ROOT, 'log', 'apn_sender.log'))
+      logger.level = ActiveRecord::Base.logger.level
+      ActiveRecord::Base.logger = logger
+      ActiveRecord::Base.clear_active_connections!
+      APN::Sender.logger = logger
+      
+      worker = APN::Sender.new(@options)
+      worker.verbose = @options[:verbose]
+      worker.very_verbose = @options[:very_verbose]
+      worker.work(@options[:delay] || 5)
+    rescue => e
+      logger.fatal e
+      STDERR.puts e.message
+      exit 1
+    end
+    
+  end
+end

data/lib/apn/tasks.rb

@@ -0,0 +1,39 @@
+# Slight modifications from the default Resque tasks
+namespace :apn do
+  task :setup
+  task :sender => :work
+  task :senders => :workers  
+
+  desc "Start an APN worker"
+  task :work => :setup do
+    require 'lib/apple_push_notification'
+
+    worker = nil
+
+    begin
+      worker = APN::Sender.new(:cert_path => ENV['CERT_PATH'], :environment => ENV['ENVIRONMENT'])
+      worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+      worker.very_verbose = ENV['VVERBOSE']
+    rescue Exception => e
+      raise e
+      # abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque:work"
+    end
+
+    puts "*** Starting worker to send apple notifications in the background from #{worker}"
+
+    worker.work(ENV['INTERVAL'] || 5) # interval, will block
+  end
+
+  desc "Start multiple APN workers. Should only be used in dev mode."
+  task :workers do
+    threads = []
+
+    ENV['COUNT'].to_i.times do
+      threads << Thread.new do
+        system "rake apn:work"
+      end
+    end
+
+    threads.each { |thread| thread.join }
+  end
+end

data/lib/apn.rb

@@ -0,0 +1,28 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'resque'
+require 'resque/plugins/access_worker_from_job'
+require 'resque/hooks/before_unregister_worker'
+
+begin
+  require 'yajl/json_gem'
+rescue LoadError
+  require 'json'
+end
+
+require 'apn/queue_manager'
+
+module APN
+  # Change this to modify the queue notification jobs are pushed to and pulled from
+  QUEUE_NAME = :apple_push_notifications
+  
+  # Enqueues a notification to be sent in the background via the persistent TCP socket, assuming apn_sender is running (or will be soon)
+  def self.notify(token, opts = {})
+    APN::QueueManager.enqueue(APN::NotificationJob, token, opts)
+  end  
+end
+
+require 'apn/notification'
+require 'apn/notification_job'
+require 'apn/sender'

data/lib/resque/hooks/before_unregister_worker.rb

@@ -0,0 +1,30 @@
+# Adding a +before_unregister_worker+ hook Resque::Worker. To be used, must be matched by a similar monkeypatch
+# for Resque class itself, or else a class that extends Resque. See apple_push_notification/queue_manager.rb for 
+# an implementation.
+module Resque
+  class Worker
+    alias_method :unregister_worker_without_before_hook, :unregister_worker
+
+    # Wrapper for original unregister_worker method which adds a before hook +before_unregister_worker+
+    # to be executed if present.
+    def unregister_worker
+      run_hook(:before_unregister_worker, self) 
+      unregister_worker_without_before_hook
+    end
+    
+    
+    # Unforunately have to override Resque::Worker's +run_hook+ method to call hook on 
+    # APN::QueueManager rather on Resque directly. Any suggestions on
+    # how to make this more flexible are more than welcome.
+    def run_hook(name, *args)
+      # return unless hook = Resque.send(name)
+      return unless hook = APN::QueueManager.send(name)
+      msg = "Running #{name} hook"
+      msg << " with #{args.inspect}" if args.any?
+      log msg
+
+      args.any? ? hook.call(*args) : hook.call
+    end
+    
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require "apn"

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'apple_push_notification'
+
+class Test::Unit::TestCase
+end

data/test/test_apple_push_notification.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestAPN < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: apn_sender
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kali Donovan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: resque
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: resque-access_worker_from_job
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Resque-based background worker to send Apple Push Notifications over a persistent TCP socket. Includes Resque tweaks to allow persistent sockets between jobs, helper methods for enqueueing APN notifications, and a background daemon to send them.
+email: kali.donovan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- apn_sender.gemspec
+- contrib/apn_sender.monitrc
+- generators/apple_push_notification_generator.rb
+- generators/templates/script
+- init.rb
+- lib/apn.rb
+- lib/apn/notification.rb
+- lib/apn/notification_job.rb
+- lib/apn/queue_manager.rb
+- lib/apn/sender.rb
+- lib/apn/sender_daemon.rb
+- lib/apn/tasks.rb
+- lib/resque/hooks/before_unregister_worker.rb
+- rails/init.rb
+- test/helper.rb
+- test/test_apple_push_notification.rb
+has_rdoc: true
+homepage: http://github.com/kdonovan/apple_push_notification
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Resque-based background worker to send Apple Push Notifications over a persistent TCP socket.
+test_files: 
+- test/helper.rb
+- test/test_apple_push_notification.rb