racoon 0.3.1

data/README.mdown

@@ -0,0 +1,172 @@
+# Racoon push notification server
+
+This project started off as a fork of [apnserver](https://github.com/bpoweski/apnserver). It
+has since taken on a different path. How does it differ from apnserver? By a few key points:
+
+1. It implements the APNS feedback service;
+2. Uses Yajl for JSON encoding/decoding rather than ActiveSupport;
+3. Expects certificates as strings instead of paths to files;
+4. Does not assume there is only one certificate; and
+5. Receives packets containing notifications from beanstalkd instead of a listening socket.
+
+The above changes were made because of the need for an APNS provider to replace the current
+provider used by [Diligent Street](http://www.diligentstreet.com/) with something more robust. As such, it needs to be
+suitable for a hosted environment, where multiple—unrelated—users of the service will be
+using it.
+
+It should be noted that the development of this project is independent of the work bpoweski
+is doing on apnserver. If you're looking for that project, [go here](https://github.com/bpoweski/apnserver).
+
+## Description
+
+racoon is a server and a set of command line programs to send push notifications to iOS devices.
+Apple recommends to maintain an open connection to the push notification service, and refrain
+from opening up and tearing down SSL connections repeatedly. As such, a separate daemon is
+introduced that has messages queued up (beanstalkd) for consumption by this daemon. This
+decouples the APNS server from your backend system. Those notifications are sent over a
+persistent connection to Apple.
+
+## Remaining Tasks & Issues
+
+You can see progress by looking at the [issue tracker](https://www.pivotaltracker.com/projects/251991) page for fracas. Any labels related to
+*apnserver* or *racoon* are related to this subproject.
+
+## Preparing Certificates
+
+Certificates must be prepared before they can be used with racoon. Unfortunately, Apple
+gives us @.p12@ files instead of @.pem@ files. As such, we need to convert them. This
+can be accomplished by dropping to the command line and running this command:
+
+<pre>
+$ openssl pkcs12 -in cert.p12 -out cert.pem -nodes -clcerts
+</pre>
+
+This will generate a file suitable for use with this daemon, called @cert.pem@. If you're
+using frac.as, this is the file you would upload to the web service.
+
+If you're not using frac.as, then the contents of this file are what you need to use as
+your certificate, not the path to the file.
+
+## APN Server Daemon
+
+<pre>
+Usage: racoond [options]
+  --beanstalk <csv ip:port mappings>
+	The comma-separated list of ip:port for beanstalk servers
+
+  --pid <pid file path>
+	Path used for the PID file. Defaults to /var/run/racoon.pid
+
+  --log <log file path>
+	Path used for the log file. Defaults to /var/log/racoon.log
+
+  --help
+    usage message
+
+  --daemon
+    Runs process as daemon, not available on Windows
+</pre>
+
+## APN Server Client
+
+TODO: Document this
+
+## Sending Notifications from Ruby
+
+You need to set up a connection to the beanstalkd service. We can do this simply by defining
+the following method:
+
+```ruby
+def beanstalk
+  return @beanstalk if @beanstalk
+  @beanstalk = Beanstalk::Pool.new ["127.0.0.1:11300"]
+  @beanstalk.use "awesome-tube"
+  @beanstalk
+end
+```
+
+In this way, whenever we need access to beanstalk, we'll make the connection and set up to use
+the appropriate tube whether the connection is open yet or not.
+
+We will also need two pieces of information: A project, and a notification.
+
+### Project
+
+A project os comprised of a few pieces of information at a minimum (you may supply more if you
+wish, but racoond will ignore them):
+
+```ruby
+project = { :name => "Awesome project", :certificate => "contents of the generated .pem file" }
+```
+
+### Notification
+
+A notification is a ruby hash containing the things to be sent along, including the device token.
+An example notification may look like this:
+
+```ruby
+notification = { :device_token => "hex encoded device token",
+                 :aps => { :alert => "Some text",
+                           :sound => "Audio_file",
+                           :badge => 42,
+                           :custom => { :field => "lala",
+                                        :stuff => 42 }
+                         }
+               }
+```
+
+Finally within we can send a push notification using the following code:
+
+```ruby
+beanstalk.yput({ :project => project, :notification => notification, :sandbox => true })
+```
+
+Note that the `sandbox` parameter is used to indicate whether or not we're using a development
+certificate, and as such, should contact Apple's sandbox APN service instead of the production
+certificate. If left out, we assume production.
+
+This will schedule the push on beanstalkd. Racoon is constantly polling beanstalkd looking for
+ready jobs it can pop off and process (send to Apple). Using beanstalkd however allows us to
+queue up items, and during peak times, add another **N** more racoon servers to make up any
+backlog, to ensure our messages are sent fast, and that we can scale.
+
+## Installation
+
+Racoon is hosted on [rubygems](https://rubygems.org/gems/racoon)
+
+<pre>
+$ gem install racoon
+</pre>
+
+Adding racoon to your Rails application
+
+```ruby
+gem 'racoon'
+```
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2011 Jeremy Tregunna
+Copyright (c) 2011 Ben Poweski
+
+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/bin/apnsend

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'logger'
+require 'getoptlong'
+require 'rubygems'
+require 'apnserver'
+require 'base64'
+require 'socket'
+
+def usage
+  puts "Usage: apnsend [switches] (--b64-token | --hex-token) <token>"
+  puts " --server <localhost>                 the apn server defaults to a locally running apnserverd"
+  puts " --port <2195>                        the port of the apn server"
+  puts " --pem <path>                         the path to the pem file, if a pem is supplied the server defaults to gateway.push.apple.com:2195"
+  puts " --pem-passphrase <passphrase>        the pem passphrase"
+  puts " --alert <message>                    the message to send"
+  puts " --sound <default>                    the sound to play, defaults to 'default'"
+  puts " --badge <number>                     the badge number"
+  puts " --custom <json string>               a custom json string to be added to the main object"
+  puts " --b64-token <token>                  a base 64 encoded device token"
+  puts " --hex-token <token>                  a hex encoded device token"
+  puts " --help                               this message"
+end
+
+opts = GetoptLong.new(
+  ["--server", "-s", GetoptLong::REQUIRED_ARGUMENT],
+  ["--port", "-p", GetoptLong::REQUIRED_ARGUMENT],
+  ["--pem", "-c", GetoptLong::REQUIRED_ARGUMENT],
+  ["--pem-passphrase", "-C", GetoptLong::REQUIRED_ARGUMENT],
+  ["--alert", "-a", GetoptLong::REQUIRED_ARGUMENT],
+  ["--sound", "-S", GetoptLong::REQUIRED_ARGUMENT],
+  ["--badge", "-b", GetoptLong::REQUIRED_ARGUMENT],
+  ["--custom", "-j", GetoptLong::REQUIRED_ARGUMENT],
+  ["--b64-token", "-B", GetoptLong::REQUIRED_ARGUMENT],
+  ["--hex-token", "-H", GetoptLong::REQUIRED_ARGUMENT],
+  ["--help", "-h", GetoptLong::NO_ARGUMENT]
+)
+
+notification = ApnServer::Notification.new
+
+opts.each do |opt, arg|
+  case opt
+  when '--help'
+    usage
+    exit
+  when '--server'
+    ApnServer::Config.host = arg
+  when '--port'
+    ApnServer::Config.port = arg.to_i
+  when '--pem'
+    ApnServer::Config.pem = File.read(arg)
+  when '--pem-passphrase'
+    ApnServer::Config.password = arg
+  when '--alert'
+    notification.alert = arg
+  when '--sound'
+    notification.sound = arg
+  when '--badge'
+    notification.badge = arg.to_i
+  when '--custom'
+    notification.custom = ActiveSupport::JSON.decode(arg)
+  when '--b64-token'
+    notification.device_token = Base64::decode64(arg)
+  when '--hex-token'
+    notification.device_token  = arg.scan(/[0-9a-f][0-9a-f]/).map {|s| s.hex.chr}.join
+  end
+end
+
+if notification.device_token.nil?
+  usage
+  exit
+else
+  notification.push
+end

data/bin/apnserverd.fedora.init

@@ -0,0 +1,71 @@
+#!/bin/bash
+#
+#       /etc/rc.d/init.d/apnserverd
+# apnserverd    This shell script takes care of starting and stopping
+#               the APN Server Proxy
+#
+# chkconfig: 345 20 80
+# Author: Ben Poweski bpoweski@gmail.com
+#
+# Source function library.
+. /etc/init.d/functions
+
+NAME=apnserverd
+APNSERVERD=/usr/bin/$NAME
+PIDFILE=/var/run/$NAME.pid
+
+if [ -f /etc/sysconfig/$NAME ]; then
+        . /etc/sysconfig/$NAME
+fi
+
+
+start() {
+        echo -n "Starting APN Server:  "
+        if [ -f $PIDFILE ]; then
+                PID=`cat $PIDFILE`
+                echo $NAME already running: $PID
+                exit 2;
+        elif [ -f $PIDFILE ]; then
+                PID=`cat $PIDFILE`
+                echo $NAME already running: $PID
+                exit 2;
+        else
+                daemon $APNSERVERD $OPTIONS
+                RETVAL=$?
+		echo 
+                [ $RETVAL -eq 0 ] && touch /var/lock/subsys/$NAME
+                return $RETVAL
+        fi
+
+}
+
+stop() {
+        echo -n "Shutting down APN Server: "
+        echo
+        kill `cat $PIDFILE`
+        echo
+        rm -f /var/lock/subsys/$NAME
+		rm -f $PIDFILE
+        return 0
+}
+
+case "$1" in
+    start)
+        start
+        ;;
+    stop)
+        stop
+        ;;
+    status)
+        status $NAME
+        ;;
+    restart)
+        stop
+        start
+        ;;
+    *)
+        echo "Usage:  {start|stop|status|restart}"
+        exit 1
+        ;;
+esac
+exit $?

data/bin/apnserverd.ubuntu.init

@@ -0,0 +1,116 @@
+#! /bin/sh
+### BEGIN INIT INFO
+# Provides:          apnserverd
+# Required-Start:    $remote_fs
+# Required-Stop:     $remote_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Apple Push Notification Server Daemon
+### END INIT INFO
+
+# Author: Philipp Schmid <philipp.schmid@openresearch.com>
+
+PATH=/sbin:/usr/sbin:/bin:/usr/bin
+DESC="Apple Push Notification Server Daemon"
+NAME=apnserverd
+DAEMON=/usr/bin/$NAME
+PEMPATH=""
+DAEMON_ARGS="--daemon --pem $PEMPATH"
+PIDFILE=/var/run/$NAME.pid
+SCRIPTNAME=/etc/init.d/$NAME
+
+# Exit if the package is not installed
+[ -x "$DAEMON" ] || exit 0
+
+# Load the VERBOSE setting and other rcS variables
+. /lib/init/vars.sh
+
+# Define LSB log_* functions.
+# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
+. /lib/lsb/init-functions
+
+#
+# Function that starts the daemon/service
+#
+do_start()
+{
+	# Return
+	#   0 if daemon has been started
+	#   1 if daemon was already running
+	#   2 if daemon could not be started
+	start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
+		|| return 1
+	start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON -- \
+		$DAEMON_ARGS \
+		|| return 2
+}
+
+#
+# Function that stops the daemon/service
+#
+do_stop()
+{
+	# Return
+	#   0 if daemon has been stopped
+	#   1 if daemon was already stopped
+	#   2 if daemon could not be stopped
+	#   other if a failure occurred
+	start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
+	RETVAL="$?"
+	[ "$RETVAL" = 2 ] && return 2
+	# Wait for children to finish too if this is a daemon that forks
+	# and if the daemon is only ever run from this initscript.
+	# If the above conditions are not satisfied then add some other code
+	# that waits for the process to drop all resources that could be
+	# needed by services started subsequently.  A last resort is to
+	# sleep for some time.
+	start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
+	[ "$?" = 2 ] && return 2
+	# Many daemons don't delete their pidfiles when they exit.
+	rm -f $PIDFILE
+	return "$RETVAL"
+}
+
+
+case "$1" in
+  start)
+	[ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
+	do_start
+	case "$?" in
+		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
+		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
+	esac
+	;;
+  stop)
+	[ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
+	do_stop
+	case "$?" in
+		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
+		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
+	esac
+	;;
+  restart|force-reload)
+	log_daemon_msg "Restarting $DESC" "$NAME"
+	do_stop
+	case "$?" in
+	  0|1)
+		do_start
+		case "$?" in
+			0) log_end_msg 0 ;;
+			1) log_end_msg 1 ;; # Old process is still running
+			*) log_end_msg 1 ;; # Failed to start
+		esac
+		;;
+	  *)
+	  	# Failed to stop
+		log_end_msg 1
+		;;
+	esac
+	;;
+  *)
+	echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
+	exit 3
+	;;
+esac
+
+:

data/bin/racoond

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'getoptlong'
+require 'rubygems'
+require 'daemons'
+require 'eventmachine'
+require 'racoon'
+require 'racoon/server'
+require 'csv'
+
+def usage
+  puts "Usage: racoond [switches] --beanstalk a.b.c.d:11300,...,w.x.y.z:11300"
+  puts " --beanstalk <127.0.0.1:11300>        csv list of ip:port for beanstalk servers"
+  puts " --pid </var/run/racoond.pid>         the path to store the pid"
+  puts " --log </var/log/racoond.log>         the path to store the log"
+  puts " --daemon                             to daemonize the server"
+  puts " --help                               this message"
+end
+
+def daemonize
+  Daemonize.daemonize(@log_file, 'racoond')
+  open(@pid_file,"w") { |f| f.write(Process.pid) }
+  open(@pid_file,"w") do |f|
+    f.write(Process.pid)
+    File.chmod(0644, @pid_file)
+  end
+end
+
+opts = GetoptLong.new(
+  ["--beanstalk", "-b", GetoptLong::REQUIRED_ARGUMENT],
+  ["--pid", "-i", GetoptLong::REQUIRED_ARGUMENT],
+  ["--log", "-l", GetoptLong::REQUIRED_ARGUMENT],
+  ["--help", "-h", GetoptLong::NO_ARGUMENT],
+  ["--daemon", "-d", GetoptLong::NO_ARGUMENT]
+)
+
+beanstalks = ["127.0.0.1:11300"]
+@pid_file = '/var/run/racoond.pid'
+@log_file = '/var/log/racoond.log'
+daemon = false
+
+opts.each do |opt, arg|
+  case opt
+  when '--help'
+    usage
+    exit 1
+  when '--beanstalk'
+    beanstalks = CSV.parse(arg)[0]
+  when '--pid'
+    @pid_file = arg
+  when '--log'
+    @log_file = arg
+  when '--daemon'
+    daemon = true
+  end
+end
+
+Racoon::Config.logger = Logger.new(@log_file)
+
+daemonize if daemon
+server = Racoon::Server.new(beanstalks) do |feedback_record|
+  Racoon::Config.logger.info "Received feedback at #{feedback_record[:feedback_at]} (length: #{feedback_record[:length]}): #{feedback_record[:device_token]}"
+end
+server.start!

data/lib/racoon/client.rb

@@ -0,0 +1,42 @@
+require 'openssl'
+require 'socket'
+
+module Racoon
+  class Client
+    attr_accessor :pem, :host, :port, :password
+
+    def initialize(pem, host = 'gateway.push.apple.com', port = 2195, pass = nil)
+      @pem, @host, @port, @password = pem, host, port, pass
+    end
+
+    def connect!
+      raise "Your certificate is not set." unless self.pem
+
+      @context      = OpenSSL::SSL::SSLContext.new
+      @context.cert = OpenSSL::X509::Certificate.new(self.pem)
+      @context.key  = OpenSSL::PKey::RSA.new(self.pem, self.password)
+
+      @sock         = TCPSocket.new(self.host, self.port.to_i)
+      @ssl          = OpenSSL::SSL::SSLSocket.new(@sock, @context)
+      @ssl.connect
+
+      return @sock, @ssl
+    end
+
+    def disconnect!
+      @ssl.close
+      @sock.close
+      @ssl = nil
+      @sock = nil
+    end
+
+    def write(notification)
+      Config.logger.debug "#{Time.now} [#{host}:#{port}] Device: #{notification.device_token.unpack('H*')} sending #{notification.json_payload}"
+      @ssl.write(notification.to_bytes)
+    end
+
+    def connected?
+      @ssl
+    end
+  end
+end

data/lib/racoon/config.rb

@@ -0,0 +1,9 @@
+module Racoon
+  class Config
+    class << self
+      attr_accessor :logger
+    end
+  end
+
+  Config.logger = Logger.new("/dev/null")
+end

data/lib/racoon/feedback_client.rb

@@ -0,0 +1,24 @@
+# Feedback service
+
+module Racoon
+  class FeedbackClient < Client
+    def initialize(pem, host = 'feedback.push.apple.com', port = 2196, pass = nil)
+      @pem, @host, @port, @pass = pem, host, port, pass
+    end
+
+    def read
+      records ||= []
+      while record = @ssl.read(38)
+        records << parse_tuple(record)
+      end
+      records
+    end
+
+    private
+
+    def parse_tuple(data)
+      feedback = data.unpack("N1n1H*")
+      { :feedback_at => Time.at(feedback[0]), :length => feedback[1], :device_token => feedback[2] }
+    end
+  end
+end

data/lib/racoon/notification.rb

@@ -0,0 +1,87 @@
+require 'racoon/payload'
+require 'base64'
+require 'yajl'
+
+module Racoon
+  class Notification
+    include Racoon::Payload
+
+    attr_accessor :device_token, :alert, :badge, :sound, :custom
+
+    def payload
+      p = Hash.new
+      [:badge, :alert, :sound, :custom].each do |k|
+        r = send(k)
+        p[k] = r if r
+      end
+      create_payload(p)
+    end
+
+    def json_payload
+      j = Yajl::Encoder.encode(payload)
+      raise PayloadInvalid.new("The payload is larger than allowed: #{j.length}") if j.size > 256
+      j
+    end
+
+=begin
+    def push
+      if Config.pem.nil?
+        socket = TCPSocket.new(Config.host || 'localhost', Config.port.to_i || 22195)
+        socket.write(to_bytes)
+        socket.close
+      else
+        client = Racoon::Client.new(Config.pem, Config.host || 'gateway.push.apple.com', Config.port.to_i || 2195)
+        client.connect!
+        client.write(self)
+        client.disconnect!
+      end
+    end
+=end
+
+    def to_bytes
+      j = json_payload
+      [0, 0, device_token.size, device_token, 0, j.size, j].pack("ccca*cca*")
+    end
+
+    def self.valid?(p)
+      begin
+        Notification.parse(p)
+      rescue PayloadInvalid => p
+        Config.logger.error "PayloadInvalid: #{p}"
+        false
+      rescue RuntimeError => r
+        Config.logger.error "Runtime error: #{r}"
+        false
+      rescue Exception => e
+        Config.logger.error "Unknown error: #{e}"
+        false
+      end
+    end
+
+    def self.parse(p)
+      buffer = p.dup
+      notification = Notification.new
+
+      header = buffer.slice!(0, 3).unpack('ccc')
+      if header[0] != 0
+        raise RuntimeError.new("Header of notification is invalid: #{header.inspect}")
+      end
+
+      # parse token
+      notification.device_token = buffer.slice!(0, 32).unpack('a*').first
+
+      # parse json payload
+      payload_len = buffer.slice!(0, 2).unpack('CC')
+      j = buffer.slice!(0, payload_len.last)
+      result = Yajl::Parser.parse(j)
+
+      ['alert', 'badge', 'sound'].each do |k|
+        notification.send("#{k}=", result['aps'][k]) if result['aps'] && result['aps'][k]
+      end
+      result.delete('aps')
+      notification.custom = result
+
+      notification
+    end
+  end
+end

data/lib/racoon/payload.rb

@@ -0,0 +1,19 @@
+module Racoon
+  module Payload
+    PayloadInvalid = Class.new(RuntimeError)
+
+    def create_payload(payload)
+      case payload
+        when String then { :aps => { :alert =>  payload } }
+        when Hash then create_payload_from_hash(payload)
+      end
+    end
+
+    def create_payload_from_hash(payload)
+      custom = payload.delete(:custom)
+      aps = {:aps => payload }
+      aps.merge!(custom) if custom
+      aps
+    end
+  end
+end

data/lib/racoon/server.rb

@@ -0,0 +1,160 @@
+require 'beanstalk-client'
+
+module Racoon
+  class Server
+    attr_accessor :beanstalkd_uris, :feedback_callback
+
+    def initialize(beanstalkd_uris = ["127.0.0.1:11300"], &feedback_blk)
+      @beanstalks = {}
+      @clients = {}
+      @feedback_callback = feedback_blk
+      @beanstalkd_uris = beanstalkd_uris
+    end
+
+    def beanstalk(arg)
+      tube = "racoon-#{arg}"
+      return @beanstalks[tube] if @beanstalks[tube]
+      @beanstalks[tube] = Beanstalk::Pool.new @beanstalkd_uris
+      %w{watch use}.each { |s| @beanstalks[tube].send(s, "racoon-#{tube}") }
+      @beanstalks[tube].ignore('default')
+      @beanstalks[tube]
+    end
+
+    def start!
+      EventMachine::run do
+        EventMachine::PeriodicTimer.new(3600) do
+          begin
+            if beanstalk('feedback').peek_ready
+              item = beanstalk('feedback').reserve(1)
+              handle_feedback(item)
+            end
+          rescue Beanstalk::TimedOut
+            Config.logger.info "(Beanstalkd) Unable to secure a job, operation timed out."
+          end
+        end
+
+        EventMachine::PeriodicTimer.new(60) do
+          begin
+            if beanstalk('killer').peek_ready
+              item = beanstalk('killer').reserve(1)
+              purge_client(item)
+            end
+          rescue Beanstalk::TimedOut
+            Config.logger.info "(Beanstalkd) Unable to secure a job, operation timed out."
+          end
+        end
+
+        EventMachine::PeriodicTimer.new(1) do
+          begin
+            if beanstalk('apns').peek_ready
+              item = beanstalk('apns').reserve(1)
+              handle_job item
+            end
+          rescue Beanstalk::TimedOut
+            Config.logger.info "(Beanstalkd) Unable to secure a job, operation timed out."
+          end
+        end
+      end
+    end
+
+    private
+
+    # Received a notification. job is YAML encoded hash in the following format:
+    # job = {
+    #   :project => {
+    #     :name => "Foo",
+    #     :certificate => "contents of a certificate.pem"
+    #   },
+    #   :device_token => "0f21ab...def",
+    #   :notification => notification.json_payload,
+    #   :sandbox => true # Development environment?
+    # }
+    def handle_job(job)
+      packet = job.ybody
+      project = packet[:project]
+
+      aps = packet[:notification][:aps]
+
+      notification = Notification.new
+      notification.device_token = packet[:device_token]
+      notification.badge = aps[:badge] if aps.has_key? :badge
+      notification.alert = aps[:alert] if aps.has_key? :alert
+      notification.sound = aps[:sound] if aps.has_key? :sound
+      notification.custom = aps[:custom] if aps.has_key? :custom
+
+      if notification
+        client = get_client(project[:name], project[:certificate], packet[:sandbox])
+        begin
+          client.connect! unless client.connected?
+          client.write(notification)
+
+          job.delete
+        rescue Errno::EPIPE, OpenSSL::SSL::SSLError, Errno::ECONNRESET
+          Config.logger.error "Caught Error, closing connecting and adding notification back to queue"
+
+          client.disconnect!
+
+          # Queue back up the notification
+          job.release
+        rescue RuntimeError => e
+          Config.logger.error "Unable to handle: #{e}"
+
+          job.delete
+        end
+      end
+    end
+
+    # Will be a hash with two keys:
+    # :certificate and :sandbox.
+    def handle_feedback(job)
+      begin
+        packet = job.ybody
+        uri = "feedback.#{packet[:sandbox] ? 'sandbox.' : ''}push.apple.com"
+        feedback_client = Racoon::FeedbackClient.new(packet[:certificate], uri)
+        feedback_client.connect!
+        feedback_client.read.each do |record|
+          feedback_callback.call record
+        end
+        feedback_client.disconnect!
+        job.delete
+      rescue Errno::EPIPE, OpenSSL::SSL::SSLError, Errno::ECONNRESET
+        Config.logger.error "(Feedback) Caught Error, closing connection"
+        feedback_client.disconnect!
+        job.release
+      rescue RuntimeError => e
+        Config.logger.error "(Feedback) Unable to handle: #{e}"
+        job.delete
+      end
+    end
+
+    def get_client(project_name, certificate, sandbox = false)
+      uri = "gateway.#{sandbox ? 'sandbox.' : ''}push.apple.com"
+      unless @clients[project_name]
+        @clients[project_name] = Racoon::Client.new(certificate, uri)
+        # in 18 hours (64800 seconds) we need to schedule this socket to be killed. Long opened
+        # sockets don't work.
+        beanstalk('killer').yput({:certificate => certificate, :sandbox => sandbox}, 65536, 64800)
+      end
+      @clients[project_name] ||= Racoon::Client.new(certificate, uri)
+      client = @clients[project_name]
+
+      # If the certificate has changed, but we still are connected using the old certificate,
+      # disconnect and reconnect.
+      unless client.pem.eql?(certificate)
+        client.disconnect! if client.connected?
+        @clients[project_name] = Racoon::Client.new(certificate, uri)
+        client = @clients[project_name]
+      end
+
+      client
+    end
+
+    def purge_client(job)
+      project_name = job.ybody
+      client = @clients[project_name]
+      client.disconnect! if client
+      @clients[project_name] = nil
+      job.delete
+    end
+  end
+end

data/lib/racoon.rb

@@ -0,0 +1,6 @@
+require 'logger'
+require 'racoon/config'
+require 'racoon/payload'
+require 'racoon/notification'
+require 'racoon/client'
+require 'racoon/feedback_client'

data/spec/models/client_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module ApnServer
+  describe Client do
+    describe "#new" do
+      let(:client) { ApnServer::Client.new('cert.pem', 'gateway.sandbox.push.apple.com', 2196) }
+
+      it "sets the pem path" do
+        client.pem.should == 'cert.pem'
+      end
+
+      it "sets the host" do
+        client.host.should == 'gateway.sandbox.push.apple.com'
+      end
+
+      it "sets the port" do
+        client.port.should == 2196
+      end
+    end
+  end
+end

data/spec/models/feedback_client_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module ApnServer
+  describe FeedbackClient do
+    describe "#new" do
+      let(:feedback_client) { ApnServer::FeedbackClient.new('cert.pem', 'feedback.sandbox.push.apple.com', 2196) }
+
+      it "sets the pem path" do
+        feedback_client.pem.should == 'cert.pem'
+      end
+
+      it "sets the host" do
+        feedback_client.host.should == 'feedback.sandbox.push.apple.com'
+      end
+
+      it "sets the port" do
+        feedback_client.port.should == 2196
+      end
+    end
+  end
+end

data/spec/models/notification_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module ApnServer
+  describe Notification do
+    let(:notification) { Notification.new }
+
+    describe "#to_bytes" do
+      it "generates a byte array" do
+        payload = '{"aps":{"alert":"You have not mail!"}}'
+        device_token = "12345678123456781234567812345678"
+        notification.device_token = device_token
+        notification.alert = "You have not mail!"
+        expected = [0, 0, device_token.size, device_token, 0, payload.size, payload]
+        notification.to_bytes.should == expected.pack("ccca*CCa*")
+      end
+    end
+
+    describe "#payload" do
+      it "generates the badge element" do
+        expected = { :aps => { :badge => 1 }}
+        notification.badge = 1
+        notification.payload.should == expected
+      end
+
+      it "generates the alert alement" do
+        expected = { :aps => { :alert => 'Hi' }}
+        notification.alert = 'Hi'
+        notification.payload.should == expected
+      end
+    end
+
+    describe "#json_payload" do
+      it "converts payload to json" do
+        expected = '{"aps":{"alert":"Hi"}}'
+        notification.alert = 'Hi'
+        notification.json_payload.should == expected
+      end
+
+      it "does not allow payloads larger than 256 chars" do
+        lambda {
+          alert = []
+          256.times { alert << 'Hi' }
+          notification.alert = alert.join
+          notification.json_payload
+        }.should raise_error(Payload::PayloadInvalid)
+      end
+    end
+
+    describe "#valid?" do
+      it "recognizes a valid request" do
+        device_token = '12345678123456781234567812345678'
+        payload = '{"aps":{"alert":"You have not mail!"}}'
+        request = [0, 0, device_token.size, device_token, 0, payload.size, payload].pack("CCCa*CCa*")
+        Notification.valid?(request).should be_true
+        notification = Notification.parse(request)
+        notification.device_token.should == device_token
+        notification.alert.should == "You have not mail!"
+      end
+
+      it "recognizes an invalid request" do
+        device_token = '123456781234567812345678'
+        payload = '{"aps":{"alert":"You have not mail!"}}'
+        request = [0, 0, 32, device_token, 0, payload.size, payload].pack("CCCa*CCa*")
+        Notification.valid?(request).should be_false
+      end
+    end
+
+    describe "#parse" do
+      it "reads a byte array and constructs a notification" do
+        device_token = '12345678123456781234567812345678'
+        notification.device_token = device_token
+        notification.badge = 10
+        notification.alert = 'Hi'
+        notification.sound = 'default'
+        notification.custom = { 'acme1' => "bar", 'acme2' => 42}
+
+        parsed = Notification.parse(notification.to_bytes)
+        [:device_token, :badge, :alert, :sound, :custom].each do |k|
+          expected = notification.send(k)
+          parsed.send(k).should == expected
+        end
+      end
+    end
+  end
+end

data/spec/models/payload_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module ApnServer
+  describe Payload do
+    describe "#payload.create_payload" do
+      let(:payload) { Class.new.send(:include, Payload).new }
+
+      it "creates a payload_with_simple_string" do
+        payload.create_payload('Hi').should == { :aps => { :alert => 'Hi' }}
+      end
+
+      it "creates a payload_with_alert_key" do
+        payload.create_payload(:alert => 'Hi').should == { :aps => { :alert => 'Hi' }}
+      end
+
+      it "creates payload with badge_and_alert" do
+        payload.create_payload(:alert => 'Hi', :badge => 1).should == { :aps => { :alert => 'Hi', :badge => 1 }}
+      end
+
+      # example 1
+      it "test_should_payload.create_payload_with_custom_payload" do
+        alert = 'Message received from Bob'
+        payload.create_payload(:alert => alert, :custom => { :acme2 => ['bang', 'whiz']}).should == {
+          :aps => { :alert => alert },
+          :acme2 => [ "bang",  "whiz" ]
+        }
+      end
+
+      # example 3
+      it "test_should_payload.create_payload_with_sound_and_multiple_custom" do
+        expected = {
+          :aps => {
+            :alert => "You got your emails.",
+            :badge => 9,
+            :sound => "bingbong.aiff"
+          },
+          :acme1 => "bar",
+          :acme2 => 42
+        }
+        payload.create_payload({
+          :alert => "You got your emails.",
+          :badge => 9,
+          :sound => "bingbong.aiff",
+          :custom => { :acme1 => "bar", :acme2 => 42}
+        }).should == expected
+      end
+
+      # example 5
+      it "test_should_payload.create_payload_with_empty_aps" do
+        payload.create_payload(:custom => { :acme2 => [ 5,  8 ] }).should == {
+          :aps => {},
+          :acme2 => [ 5,  8 ]
+        }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+
+# Set up gems listed in the Gemfile.
+gemfile = File.expand_path('../Gemfile', File.dirname(__FILE__))
+begin
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+rescue Bundler::GemNotFound => e
+  STDERR.puts e.message
+  STDERR.puts "Try running `bundle install`."
+  exit!
+end
+
+Bundler.require(:spec)
+
+Rspec.configure do |config|
+  config.mock_with :rspec
+end
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+
+require "apnserver"
+require 'base64'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: racoon
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Tregunna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-04-23 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70118651237540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70118651237540
+- !ruby/object:Gem::Dependency
+  name: beanstalk-client
+  requirement: &70118651237080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70118651237080
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70118651236620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70118651236620
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70118651236160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.8
+  type: :development
+  prerelease: false
+  version_requirements: *70118651236160
+description: A toolkit for proxying and sending Apple Push Notifications prepared
+  for a hosted environment
+email: jeremy.tregunna@me.com
+executables:
+- racoond
+extensions: []
+extra_rdoc_files:
+- README.mdown
+files:
+- bin/apnsend
+- bin/apnserverd.fedora.init
+- bin/apnserverd.ubuntu.init
+- bin/racoond
+- lib/racoon/client.rb
+- lib/racoon/config.rb
+- lib/racoon/feedback_client.rb
+- lib/racoon/notification.rb
+- lib/racoon/payload.rb
+- lib/racoon/server.rb
+- lib/racoon.rb
+- README.mdown
+- spec/models/client_spec.rb
+- spec/models/feedback_client_spec.rb
+- spec/models/notification_spec.rb
+- spec/models/payload_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/jeremytregunna/racoon
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: racoon
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Apple Push Notification Toolkit for hosted environments
+test_files:
+- spec/models/client_spec.rb
+- spec/models/feedback_client_spec.rb
+- spec/models/notification_spec.rb
+- spec/models/payload_spec.rb
+- spec/spec_helper.rb