rapns 0.1.0

data/lib/rapns/daemon.rb

@@ -0,0 +1,76 @@
+require "rapns/daemon/configuration"
+require "rapns/daemon/certificate"
+require "rapns/daemon/delivery_error"
+require "rapns/daemon/pool"
+require "rapns/daemon/connection_pool"
+require "rapns/daemon/connection"
+require "rapns/daemon/delivery_handler"
+require "rapns/daemon/delivery_handler_pool"
+require "rapns/daemon/feeder"
+require "rapns/daemon/logger"
+
+module Rapns
+  module Daemon
+    class << self
+      attr_accessor :logger, :configuration, :certificate, :connection_pool, :delivery_queue,
+        :delivery_handler_pool, :foreground
+      alias_method  :foreground?, :foreground
+    end
+
+    def self.start(environment, foreground)
+      @foreground = foreground
+      setup_signal_hooks
+
+      self.configuration = Configuration.new(environment, File.join(Rails.root, "config", "rapns", "rapns.yml"))
+      configuration.load
+
+      self.logger = Logger.new(:foreground => foreground, :airbrake_notify => configuration.airbrake_notify)
+
+      self.certificate = Certificate.new(configuration.certificate)
+      certificate.load
+
+      self.delivery_queue = Queue.new
+
+      self.delivery_handler_pool = DeliveryHandlerPool.new(configuration.connections)
+      delivery_handler_pool.populate
+
+      self.connection_pool = ConnectionPool.new(configuration.connections)
+      connection_pool.populate
+
+      daemonize unless foreground?
+
+      Feeder.start
+    end
+
+    protected
+
+    def self.setup_signal_hooks
+      @sigint_received = false
+      Signal.trap("SIGINT") do
+        exit 1 if @sigint_received
+        @sigint_received = true
+        shutdown
+      end
+    end
+
+    def self.shutdown
+      puts "\nShutting down..."
+      Rapns::Daemon::Feeder.stop
+      Rapns::Daemon.delivery_handler_pool.drain if Rapns::Daemon.delivery_handler_pool
+      Rapns::Daemon.connection_pool.drain if Rapns::Daemon.connection_pool
+    end
+
+    def self.daemonize
+      exit if pid = fork
+      Process.setsid
+      exit if pid = fork
+
+      Dir.chdir '/'
+      File.umask 0000
+
+      STDIN.reopen '/dev/null'
+      STDOUT.reopen '/dev/null', 'a'
+      STDERR.reopen STDOUT
+    end
+  end
+end

data/lib/rapns/notification.rb

@@ -0,0 +1,44 @@
+module Rapns
+  class Notification < ActiveRecord::Base
+    set_table_name "rapns_notifications"
+
+    validates :device_token, :presence => true, :format => { :with => /^[a-z0-9]{64}$/ }
+    validates :badge, :numericality => true, :allow_nil => true
+    validates :expiry, :numericality => true, :presence => true
+
+    validates_with Rapns::BinaryNotificationValidator
+
+    scope :ready_for_delivery, lambda { where(:delivered => false, :failed => false).merge(where("deliver_after IS NULL") | where("deliver_after < ?", Time.now)) }
+
+    def device_token=(token)
+      write_attribute(:device_token, token.delete(" <>")) if !token.nil?
+    end
+
+    def attributes_for_device=(attrs)
+      raise ArgumentError, "attributes_for_device must be a Hash" if !attrs.is_a?(Hash)
+      write_attribute(:attributes_for_device, ActiveSupport::JSON.encode(attrs))
+    end
+
+    def attributes_for_device
+      ActiveSupport::JSON.decode(read_attribute(:attributes_for_device)) if read_attribute(:attributes_for_device)
+    end
+
+    def as_json
+      json = ActiveSupport::OrderedHash.new
+      json['aps'] = ActiveSupport::OrderedHash.new
+      json['aps']['alert'] = alert if alert
+      json['aps']['badge'] = badge if badge
+      json['aps']['sound'] = sound if sound
+      attributes_for_device.each { |k, v| json[k.to_s] = v.to_s } if attributes_for_device
+      json
+    end
+
+    # This method conforms to the enhanced binary format.
+    # http://developer.apple.com/library/ios/#documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CommunicatingWIthAPS/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW4
+    def to_binary(options = {})
+      id_for_pack = options[:for_validation] ? 0 : id
+      json = as_json.to_json
+      [1, id_for_pack, expiry, 0, 32, device_token, 0, json.size, json].pack("cNNccH*cca*")
+    end
+  end
+end

data/lib/rapns/version.rb

@@ -0,0 +1,3 @@
+module Rapns
+  VERSION = "0.1.0"
+end

data/lib/rapns.rb

@@ -0,0 +1,5 @@
+require "active_record"
+
+require "rapns/version"
+require "rapns/binary_notification_validator"
+require "rapns/notification"

data/spec/rapns/daemon/certificate_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe Rapns::Daemon::Certificate do
+
+  it "should raise an error if the .pem file does not exist" do
+    cert = Rapns::Daemon::Certificate.new("/tmp/rapns-missing.pem")
+    expect { cert.load }.to raise_error(Rapns::CertificateError, "/tmp/rapns-missing.pem does not exist. The certificate location can be configured in config/rapns/rapns.yml.")
+  end
+
+  it "should set the certificate accessor" do
+    cert = Rapns::Daemon::Certificate.new("/dir/development.pem")
+    cert.stub(:read_certificate).and_return("certificate contents")
+    cert.load
+    cert.certificate.should == "certificate contents"
+  end
+end

data/spec/rapns/daemon/configuration_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+
+describe Rapns::Daemon::Configuration do
+  module Rails
+  end
+
+  before do
+    @config = {"port" => 123, "host" => "localhost", "certificate" => "production.pem", "certificate_password" => "abc123", "airbrake_notify" => false, "poll" => 4, "connections" => 6}
+  end
+
+  it "should raise an error if the configuration file does not exist" do
+    expect { Rapns::Daemon::Configuration.new("production", "/tmp/rapns-non-existant-file").load }.to raise_error(Rapns::ConfigurationError, "/tmp/rapns-non-existant-file does not exist. Have you run 'rails g rapns'?")
+  end
+
+  it "should raise an error if the environment is not configured" do
+    configuration = Rapns::Daemon::Configuration.new("development", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => {}})
+    expect { configuration.load  }.to raise_error(Rapns::ConfigurationError, "Configuration for environment 'development' not defined in /some/config.yml")
+  end
+
+  it "should raise an error if the host is not configured" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config.except("host")})
+    expect { configuration.load }.to raise_error(Rapns::ConfigurationError, "'host' not defined for environment 'production' in /some/config.yml")
+  end
+
+  it "should raise an error if the port is not configured" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config.except("port")})
+    expect { configuration.load }.to raise_error(Rapns::ConfigurationError, "'port' not defined for environment 'production' in /some/config.yml")
+  end
+
+  it "should raise an error if the certificate is not configured" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config.except("certificate")})
+    expect { configuration.load }.to raise_error(Rapns::ConfigurationError, "'certificate' not defined for environment 'production' in /some/config.yml")
+  end
+
+  it "should set the host" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.host.should == "localhost"
+  end
+
+  it "should set the port" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.port.should == 123
+  end
+
+  it "should set the airbrake notify flag" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.airbrake_notify?.should == false
+  end
+
+  it "should default the airbrake notify flag to true if not set" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config.except("airbrake_notify")})
+    configuration.load
+    configuration.airbrake_notify?.should == true
+  end
+
+  it "should set the poll frequency" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.poll.should == 4
+  end
+
+  it "should default the poll frequency to 2 if not set" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config.except("poll")})
+    configuration.load
+    configuration.poll.should == 2
+  end
+
+  it "should set the number of connections" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.connections.should == 6
+  end
+
+  it "should default the number of connections to 3 if not set" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config.except("connections")})
+    configuration.load
+    configuration.connections.should == 3
+  end
+
+  it "should set the certificate password" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.certificate_password.should == "abc123"
+  end
+
+  it "should set the certificate password to a blank string if it is not configured" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config.except("certificate_password")})
+    configuration.load
+    configuration.certificate_password.should == ""
+  end
+
+  it "should set the certificate, with absolute path" do
+    Rails.stub(:root).and_return("/rails_root")
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.certificate.should == "/rails_root/config/rapns/production.pem"
+  end
+
+  it "should keep the absolute path of the certificate if it has one" do
+    Rails.stub(:root).and_return("/rails_root")
+    @config["certificate"] = "/different_path/to/production.pem"
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.load
+    configuration.certificate.should == "/different_path/to/production.pem"
+  end
+end

data/spec/rapns/daemon/connection_pool_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Rapns::Daemon::ConnectionPool do
+  before do
+    @connection = mock("Connection", :connect => nil)
+    Rapns::Daemon::Connection.stub(:new).and_return(@connection)
+    @pool = Rapns::Daemon::ConnectionPool.new(3)
+  end
+
+  it "should populate the pool" do
+    Rapns::Daemon::Connection.should_receive(:new).exactly(3).times
+    @pool.populate
+  end
+
+  it "should tell each connection to close when drained" do
+    @pool.populate
+    @connection.should_receive(:close).exactly(3).times
+    @pool.drain
+  end
+end
+
+describe Rapns::Daemon::ConnectionPool, "when claiming a connection" do
+  before do
+    @connection = mock("Connection", :connect => nil)
+    Rapns::Daemon::Connection.stub(:new).and_return(@connection)
+    @pool = Rapns::Daemon::ConnectionPool.new(3)
+  end
+
+  it "should pop the connection from the pool" do
+    @pool.instance_variable_get("@queue").should_receive(:pop)
+    @pool.claim_connection {}
+  end
+
+  it "shuld push the connection into the pool after use" do
+    @pool.instance_variable_get("@queue").stub(:pop).and_return(@connection)
+    @pool.instance_variable_get("@queue").should_receive(:push).with(@connection)
+    @pool.claim_connection {}
+  end
+end
+

data/spec/rapns/daemon/connection_spec.rb

@@ -0,0 +1,247 @@
+require "spec_helper"
+
+describe Rapns::Daemon::Connection, "when setting up the SSL context" do
+  before do
+    @ssl_context = mock("SSLContext", :key= => nil, :cert= => nil)
+    OpenSSL::SSL::SSLContext.should_receive(:new).and_return(@ssl_context)
+    @rsa_key = mock("RSA public key")
+    OpenSSL::PKey::RSA.stub(:new).and_return(@rsa_key)
+    @certificate = mock("Certificate", :certificate => "certificate contents")
+    Rapns::Daemon.stub(:certificate).and_return(@certificate)
+    @x509_certificate = mock("X509 Certificate")
+    OpenSSL::X509::Certificate.stub(:new).and_return(@x509_certificate)
+    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @connection.stub(:connect_socket)
+    @connection.stub(:setup_at_exit_hook)
+    configuration = mock("Configuration", :host => "localhost", :port => 123, :certificate_password => "abc123")
+    Rapns::Daemon.stub(:configuration).and_return(configuration)
+  end
+
+  it "should set the key on the context" do
+    OpenSSL::PKey::RSA.should_receive(:new).with("certificate contents", "abc123").and_return(@rsa_key)
+    @ssl_context.should_receive(:key=).with(@rsa_key)
+    @connection.connect
+  end
+
+  it "should set the cert on the context" do
+    OpenSSL::X509::Certificate.should_receive(:new).with("certificate contents").and_return(@x509_certificate)
+    @ssl_context.should_receive(:cert=).with(@x509_certificate)
+    @connection.connect
+  end
+end
+
+describe Rapns::Daemon::Connection, "when connecting the socket" do
+  before do
+    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @connection.stub(:setup_at_exit_hook)
+    @ssl_context = mock("SSLContext")
+    @connection.stub(:setup_ssl_context).and_return(@ssl_context)
+    @tcp_socket = mock("TCPSocket", :close => nil)
+    TCPSocket.stub(:new).and_return(@tcp_socket)
+    Rapns::Daemon::Configuration.stub(:host).and_return("localhost")
+    Rapns::Daemon::Configuration.stub(:port).and_return(123)
+    @ssl_socket = mock("SSLSocket", :sync= => nil, :connect => nil, :close => nil)
+    OpenSSL::SSL::SSLSocket.stub(:new).and_return(@ssl_socket)
+    configuration = mock("Configuration", :host => "localhost", :port => 123)
+    Rapns::Daemon.stub(:configuration).and_return(configuration)
+    @logger = mock("Logger", :info => nil)
+    Rapns::Daemon.stub(:logger).and_return(@logger)
+  end
+
+  it "should create a TCP socket using the configured host and port" do
+    TCPSocket.should_receive(:new).with("localhost", 123).and_return(@tcp_socket)
+    @connection.connect
+  end
+
+  it "should create a new SSL socket using the TCP socket and SSL context" do
+    OpenSSL::SSL::SSLSocket.should_receive(:new).with(@tcp_socket, @ssl_context).and_return(@ssl_socket)
+    @connection.connect
+  end
+
+  it "should set the sync option on the SSL socket" do
+    @ssl_socket.should_receive(:sync=).with(true)
+    @connection.connect
+  end
+
+  it "should connect the SSL socket" do
+    @ssl_socket.should_receive(:connect)
+    @connection.connect
+  end
+end
+
+describe Rapns::Daemon::Connection, "when shuting down the connection" do
+  before do
+    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @connection.stub(:setup_ssl_context)
+    @ssl_socket = mock("SSLSocket", :close => nil)
+    @tcp_socket = mock("TCPSocket", :close => nil)
+    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
+  end
+
+  it "should close the TCP socket" do
+    @connection.connect
+    @tcp_socket.should_receive(:close)
+    @connection.close
+  end
+
+  it "should attempt to close the TCP socket if it does not exist" do
+    @connection.connect
+    @tcp_socket.should_not_receive(:close)
+    @connection.instance_variable_set("@tcp_socket", nil)
+    @connection.close
+  end
+
+  it "should close the SSL socket" do
+    @connection.connect
+    @ssl_socket.should_receive(:close)
+    @connection.close
+  end
+
+  it "should attempt to close the SSL socket if it does not exist" do
+    @connection.connect
+    @ssl_socket.should_not_receive(:close)
+    @connection.instance_variable_set("@ssl_socket", nil)
+    @connection.close
+  end
+end
+
+describe Rapns::Daemon::Connection, "when the connection is lost" do
+  before do
+    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @ssl_socket = mock("SSLSocket")
+    @connection.instance_variable_set("@ssl_socket", @ssl_socket)
+    @connection.stub(:connect_socket).and_return([mock("TCPSocket"), @ssl_socket])
+    @ssl_socket.stub(:write).and_raise(Errno::EPIPE)
+    @logger = mock("Logger", :warn => nil)
+    Rapns::Daemon.stub(:logger).and_return(@logger)
+    @connection.stub(:sleep)
+    configuration = mock("Configuration", :host => "localhost", :port => 123)
+    Rapns::Daemon.stub(:configuration).and_return(configuration)
+  end
+
+  it "should log a warning" do
+    Rapns::Daemon.logger.should_receive(:warn).with("[Connection 1] Lost connection to localhost:123, reconnecting...")
+    begin
+      @connection.write(nil)
+    rescue Rapns::Daemon::ConnectionError
+    end
+  end
+
+  it "should retry to make a connection 3 times" do
+    @connection.should_receive(:connect_socket).exactly(3).times
+    begin
+      @connection.write(nil)
+    rescue Rapns::Daemon::ConnectionError
+    end
+  end
+
+  it "should raise a ConnectionError after 3 attempts at reconnecting" do
+    expect do
+      @connection.write(nil)
+    end.to raise_error(Rapns::Daemon::ConnectionError, "Connection 1 tried 3 times to reconnect but failed: #<Errno::EPIPE: Broken pipe>")
+  end
+
+  it "should sleep 1 second before retrying the connection" do
+    @connection.should_receive(:sleep).with(1)
+    begin
+      @connection.write(nil)
+    rescue Rapns::Daemon::ConnectionError
+    end
+  end
+end
+
+describe Rapns::Daemon::Connection, "when sending a notification" do
+  before do
+    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @ssl_socket = mock("SSLSocket", :write => nil, :flush => nil, :close => nil)
+    @tcp_socket = mock("TCPSocket", :close => nil)
+    @connection.stub(:setup_ssl_context)
+    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
+    @connection.stub(:check_for_error)
+    @connection.connect
+  end
+
+  it "should write the data to the SSL socket" do
+    @ssl_socket.should_receive(:write).with("blah")
+    @connection.write("blah")
+  end
+
+  it "should flush the SSL socket" do
+    @ssl_socket.should_receive(:flush)
+    @connection.write("blah")
+  end
+
+  it "should select check for an error packet" do
+    @connection.should_receive(:check_for_error)
+    @connection.write("blah")
+  end
+end
+
+describe Rapns::Daemon::Connection, "when receiving an error packet" do
+  before do
+    @notification = Rapns::Notification.create!(:device_token => "a" * 64)
+    @notification.stub(:save!)
+    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @ssl_socket = mock("SSLSocket", :write => nil, :flush => nil, :close => nil, :read => [8, 4, @notification.id].pack("ccN"))
+    @connection.stub(:setup_ssl_context)
+    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
+    IO.stub(:select).and_return([@ssl_socket, [], []])
+    logger = mock("Logger", :error => nil, :warn => nil)
+    Rapns::Daemon.stub(:logger).and_return(logger)
+    @connection.connect
+  end
+
+  it "should raise a DeliveryError when an error is received" do
+    expect { @connection.write("msg with an error") }.should raise_error(Rapns::DeliveryError)
+  end
+
+  it "should not raise a DeliveryError if the packet cmd value is not 8" do
+    @ssl_socket.stub(:read).and_return([6, 4, 12].pack("ccN"))
+    expect { @connection.write("msg with an error") }.should_not raise_error(Rapns::DeliveryError)
+  end
+
+  it "should not raise a DeliveryError if the status code is 0 (no error)" do
+    @ssl_socket.stub(:read).and_return([8, 0, 12].pack("ccN"))
+    expect { @connection.write("msg with an error") }.should_not raise_error(Rapns::DeliveryError)
+  end
+
+  it "should read 6 bytes from the socket" do
+    @ssl_socket.should_receive(:read).with(6).and_return(nil)
+    @connection.write("msg with an error")
+  end
+
+  it "should not attempt to read from the socket if the socket was not selected for reading after the timeout" do
+    IO.stub(:select).and_return(nil)
+    @ssl_socket.should_not_receive(:read)
+    @connection.write("msg with an error")
+  end
+
+  it "should not raise a DeliveryError if the socket read returns nothing" do
+    @ssl_socket.stub(:read).with(6).and_return(nil)
+    expect { @connection.write("msg with an error") }.should_not raise_error(Rapns::DeliveryError)
+  end
+
+  it "should close the socket after handling the error" do
+    @connection.should_receive(:close)
+    begin
+      @connection.write("msg with an error")
+    rescue Rapns::DeliveryError
+    end
+  end
+
+  it "should reconnect the socket" do
+    @connection.should_receive(:connect_socket)
+    begin
+      @connection.write("msg with an error")
+    rescue Rapns::DeliveryError
+    end
+  end
+
+  it "should log that the connection is being reconnected" do
+    Rapns::Daemon.logger.should_receive(:warn).with("[Connection 1] Error received, reconnecting...")
+    begin
+      @connection.write("msg with an error")
+    rescue Rapns::DeliveryError
+    end
+  end
+end

data/spec/rapns/daemon/delivery_error_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Rapns::DeliveryError do
+  before do
+    @error = Rapns::DeliveryError.new(4, "Missing payload", 12)
+  end
+
+  it "should give an informative message" do
+    @error.message.should == "Unable to deliver notification 12, received APN error 4 (Missing payload)"
+  end
+end

data/spec/rapns/daemon/delivery_handler_pool_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe Rapns::Daemon::DeliveryHandlerPool do
+  before do
+    @handler = mock("DeliveryHandler", :start => nil)
+    Rapns::Daemon::DeliveryHandler.stub(:new).and_return(@handler)
+    @pool = Rapns::Daemon::DeliveryHandlerPool.new(3)
+    Rapns::Daemon.stub(:delivery_queue).and_return(mock("Delivery queue", :push => nil))
+  end
+
+  it "should populate the pool" do
+    Rapns::Daemon::DeliveryHandler.should_receive(:new).exactly(3).times
+    @pool.populate
+  end
+
+  it "should tell each connection to close when drained" do
+    @pool.populate
+    @handler.should_receive(:stop).exactly(3).times
+    @pool.drain
+  end
+
+  it "should initiate the topping process for each DeliveryHandler before the pool is drained" do
+    Rapns::Daemon.delivery_queue.should_receive(:push).with(0x666).exactly(3).times
+    @pool.drain
+  end
+end