rapns 0.2.3 → 1.0.0

data/lib/rapns/daemon/interruptible_sleep.rb

@@ -0,0 +1,14 @@
+module Rapns
+  module Daemon
+    module InterruptibleSleep
+      def interruptible_sleep(seconds)
+        @_sleep_check, @_sleep_interrupt = IO.pipe
+        IO.select([@_sleep_check], nil, nil, seconds)
+      end
+
+      def interrupt_sleep
+        @_sleep_interrupt.close if @_sleep_interrupt
+      end
+    end
+  end
+end

data/lib/rapns/daemon/pool.rb

@@ -15,8 +15,6 @@ module Rapns
       end
 
       def drain
-        drain_started
-
         while !@queue.empty?
           object = @queue.pop
           object_removed_from_pool(object)
@@ -33,9 +31,6 @@ module Rapns
 
       def object_removed_from_pool(object)
       end
-
-      def drain_started
-      end
     end
   end
 end

data/lib/rapns/daemon.rb

@@ -2,23 +2,24 @@ require 'thread'
 require 'socket'
 require 'pathname'
 
+require 'rapns/daemon/interruptible_sleep'
 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_queue'
 require 'rapns/daemon/delivery_handler'
 require 'rapns/daemon/delivery_handler_pool'
+require 'rapns/daemon/feedback_receiver'
 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
+      attr_accessor :logger, :configuration, :certificate,
+        :delivery_queue, :delivery_handler_pool, :foreground
       alias_method  :foreground?, :foreground
     end
 
@@ -34,19 +35,18 @@ module Rapns
       self.certificate = Certificate.new(configuration.certificate)
       certificate.load
 
-      self.delivery_queue = DeliveryQueue.new(configuration.connections)
+      self.delivery_queue = DeliveryQueue.new
 
       daemonize unless foreground?
 
       write_pid_file
 
-      self.delivery_handler_pool = DeliveryHandlerPool.new(configuration.connections)
+      self.delivery_handler_pool = DeliveryHandlerPool.new(configuration.push.connections)
       delivery_handler_pool.populate
 
-      self.connection_pool = ConnectionPool.new(configuration.connections)
-      connection_pool.populate
-
       logger.info('Ready')
+
+      FeedbackReceiver.start
       Feeder.start(foreground?)
     end
 
@@ -70,9 +70,9 @@ module Rapns
 
     def self.shutdown
       puts "\nShutting down..."
+      Rapns::Daemon::FeedbackReceiver.stop
       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
       delete_pid_file
     end
 

data/lib/rapns/device_token_format_validator.rb

@@ -0,0 +1,10 @@
+module Rapns
+  class DeviceTokenFormatValidator < ActiveModel::Validator
+
+    def validate(record)
+      if record.device_token !~ /^[a-z0-9]{64}$/
+        record.errors[:device_token] << "is invalid"
+      end
+    end
+  end
+end

data/lib/rapns/feedback.rb

@@ -0,0 +1,10 @@
+module Rapns
+  class Feedback < ActiveRecord::Base
+    set_table_name 'rapns_feedback'
+
+    validates :device_token, :presence => true
+    validates :failed_at, :presence => true
+
+    validates_with Rapns::DeviceTokenFormatValidator
+  end
+end

data/lib/rapns/notification.rb

@@ -2,10 +2,11 @@ module Rapns
   class Notification < ActiveRecord::Base
     set_table_name "rapns_notifications"
 
-    validates :device_token, :presence => true, :format => { :with => /^[a-z0-9]{64}$/ }
+    validates :device_token, :presence => true
     validates :badge, :numericality => true, :allow_nil => true
     validates :expiry, :numericality => true, :presence => true
 
+    validates_with Rapns::DeviceTokenFormatValidator
     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)) }
@@ -14,6 +15,19 @@ module Rapns
       write_attribute(:device_token, token.delete(" <>")) if !token.nil?
     end
 
+    def alert=(alert)
+      if alert.is_a?(Hash)
+        write_attribute(:alert, ActiveSupport::JSON.encode(alert))
+      else
+        write_attribute(:alert, alert)
+      end
+    end
+
+    def alert
+      string_or_json = read_attribute(:alert)
+      ActiveSupport::JSON.decode(string_or_json) rescue string_or_json
+    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))

data/lib/rapns/version.rb

@@ -1,3 +1,3 @@
 module Rapns
-  VERSION = '0.2.3'
+  VERSION = '1.0.0'
 end

data/lib/rapns.rb

@@ -2,4 +2,6 @@ require 'active_record'
 
 require 'rapns/version'
 require 'rapns/binary_notification_validator'
-require 'rapns/notification'
+require 'rapns/device_token_format_validator'
+require 'rapns/notification'
+require 'rapns/feedback'

data/spec/rapns/daemon/certificate_spec.rb

@@ -1,6 +1,12 @@
 require "spec_helper"
 
 describe Rapns::Daemon::Certificate do
+  it 'reads the certificate from the given path' do
+    File.stub(:exists? => true)
+    File.should_receive(:read).with("/dir/development.pem")
+    cert = Rapns::Daemon::Certificate.new("/dir/development.pem")
+    cert.load
+  end
 
   it "should raise an error if the .pem file does not exist" do
     cert = Rapns::Daemon::Certificate.new("/tmp/rapns-missing.pem")

data/spec/rapns/daemon/configuration_spec.rb

@@ -4,9 +4,46 @@ describe Rapns::Daemon::Configuration do
   module Rails
   end
 
+  let(:config) do
+    {
+      "airbrake_notify" => false,
+      "certificate" => "production.pem",
+      "certificate_password" => "abc123",
+      "pid_file" => "rapns.pid",
+      "push" => {
+        "port" => 123,
+        "host" => "localhost",
+        "poll" => 4,
+        "connections" => 6
+      },
+      "feedback" => {
+        "port" => 123,
+        "host" => "localhost",
+        "poll" => 30,
+      }
+    }
+  end
+
   before do
     Rails.stub(:root).and_return("/rails_root")
-    @config = {"port" => 123, "host" => "localhost", "certificate" => "production.pem", "certificate_password" => "abc123", "airbrake_notify" => false, "poll" => 4, "connections" => 6, "pid_file" => "rapns.pid"}
+  end
+
+  it 'opens the config from the given path' do
+    YAML.stub(:load => {"production" => config})
+    fd = stub(:read => nil)
+    File.should_receive(:open).with("/tmp/rapns-non-existant-file").and_yield(fd)
+    config = Rapns::Daemon::Configuration.new("production", "/tmp/rapns-non-existant-file")
+    config.stub(:ensure_config_exists)
+    config.load
+  end
+
+  it 'reads the config as YAML' do
+    YAML.should_receive(:load).and_return({"production" => config})
+    fd = stub(:read => nil)
+    File.stub(:open).and_yield(fd)
+    config = Rapns::Daemon::Configuration.new("production", "/tmp/rapns-non-existant-file")
+    config.stub(:ensure_config_exists)
+    config.load
   end
 
   it "should raise an error if the configuration file does not exist" do
@@ -16,131 +53,178 @@ describe Rapns::Daemon::Configuration do
   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")
+    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 push host is not configured" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    config["push"]["host"] = nil
+    configuration.stub(:read_config).and_return({"production" => config})
+    expect { configuration.load }.to raise_error(Rapns::ConfigurationError, "'push.host' not defined for environment 'production' in /some/config.yml. You may need to run 'rails g rapns' after updating.")
   end
 
-  it "should raise an error if the host is not configured" do
+  it "should raise an error if the push port 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")
+    config["push"]["port"] = nil
+    configuration.stub(:read_config).and_return({"production" => config})
+    expect { configuration.load }.to raise_error(Rapns::ConfigurationError, "'push.port' not defined for environment 'production' in /some/config.yml. You may need to run 'rails g rapns' after updating.")
   end
 
-  it "should raise an error if the port is not configured" do
+  it "should raise an error if the feedback host 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")
+    config["feedback"]["host"] = nil
+    configuration.stub(:read_config).and_return({"production" => config})
+    expect { configuration.load }.to raise_error(Rapns::ConfigurationError, "'feedback.host' not defined for environment 'production' in /some/config.yml. You may need to run 'rails g rapns' after updating.")
+  end
+
+  it "should raise an error if the feedback port is not configured" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    config["feedback"]["port"] = nil
+    configuration.stub(:read_config).and_return({"production" => config})
+    expect { configuration.load }.to raise_error(Rapns::ConfigurationError, "'feedback.port' not defined for environment 'production' in /some/config.yml. You may need to run 'rails g rapns' after updating.")
   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")
+    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. You may need to run 'rails g rapns' after updating.")
+  end
+
+  it "should set the push host" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => config})
+    configuration.load
+    configuration.push.host.should == "localhost"
   end
 
-  it "should set the host" do
+  it "should set the push port" do
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
-    configuration.host.should == "localhost"
+    configuration.push.port.should == 123
   end
 
-  it "should set the port" do
+  it "should set the feedback port" do
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
-    configuration.port.should == 123
+    configuration.feedback.port.should == 123
+  end
+
+  it "should set the feedback host" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => config})
+    configuration.load
+    configuration.feedback.host.should == "localhost"
   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.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.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
+  it "should set the push poll frequency" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => config})
+    configuration.load
+    configuration.push.poll.should == 4
+  end
+
+  it "should set the feedback poll frequency" do
+    configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
+    configuration.stub(:read_config).and_return({"production" => config})
+    configuration.load
+    configuration.feedback.poll.should == 30
+  end
+
+  it "should default the push 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})
+    config["push"]["poll"] = nil
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
-    configuration.poll.should == 4
+    configuration.push.poll.should == 2
   end
 
-  it "should default the poll frequency to 2 if not set" do
+  it "should default the feedback poll frequency to 60 if not set" do
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config.except("poll")})
+    config["feedback"]["poll"] = nil
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
-    configuration.poll.should == 2
+    configuration.feedback.poll.should == 60
   end
 
-  it "should set the number of connections" do
+  it "should set the number of push connections" do
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
-    configuration.connections.should == 6
+    configuration.push.connections.should == 6
   end
 
-  it "should default the number of connections to 3 if not set" do
+  it "should default the number of push 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")})
+    config["push"]["connections"] = nil
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
-    configuration.connections.should == 3
+    configuration.push.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.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.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
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config})
+    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
-    @config["certificate"] = "/different_path/to/production.pem"
+    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.stub(:read_config).and_return({"production" => config})
     configuration.load
     configuration.certificate.should == "/different_path/to/production.pem"
   end
 
   it "should set the PID file path" do
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
     configuration.pid_file.should == "/rails_root/rapns.pid"
   end
 
   it "should keep the absolute path of the PID file if it has one" do
-    @config["pid_file"] = "/some/absolue/path/rapns.pid"
+    config["pid_file"] = "/some/absolue/path/rapns.pid"
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
     configuration.pid_file.should == "/some/absolue/path/rapns.pid"
   end
 
   it "should return nil if no PID file was set" do
-    @config["pid_file"] = ""
+    config["pid_file"] = ""
     configuration = Rapns::Daemon::Configuration.new("production", "/some/config.yml")
-    configuration.stub(:read_config).and_return({"production" => @config})
+    configuration.stub(:read_config).and_return({"production" => config})
     configuration.load
     configuration.pid_file.should be_nil
   end