rapns 1.0.7 → 2.0.0rc1

data/lib/rapns/daemon/feeder.rb

@@ -1,20 +1,18 @@
 module Rapns
   module Daemon
     class Feeder
-      extend DatabaseReconnectable
       extend InterruptibleSleep
+      extend DatabaseReconnectable
 
       def self.name
-        "Feeder"
+        'Feeder'
       end
 
-      def self.start(foreground)
-        reconnect_database unless foreground
-
+      def self.start(poll)
         loop do
           break if @stop
           enqueue_notifications
-          interruptible_sleep Rapns::Daemon.configuration.push.poll
+          interruptible_sleep poll
         end
       end
 
@@ -28,10 +26,10 @@ module Rapns
       def self.enqueue_notifications
         begin
           with_database_reconnect_and_retry do
-            if Rapns::Daemon.delivery_queue.notifications_processed?
-              Rapns::Notification.ready_for_delivery.each do |notification|
-                Rapns::Daemon.delivery_queue.push(notification)
-              end
+            ready_apps = Rapns::Daemon::AppRunner.ready
+            batch_size = Rapns::Daemon.config.batch_size
+            Rapns::Notification.ready_for_delivery.find_each(:batch_size => batch_size) do |notification|
+              Rapns::Daemon::AppRunner.deliver(notification) if ready_apps.include?(notification.app)
             end
           end
         rescue StandardError => e

data/lib/rapns/daemon/logger.rb

@@ -3,8 +3,9 @@ module Rapns
     class Logger
       def initialize(options)
         @options = options
-        log_path = File.join(Rails.root, 'log', 'rapns.log')
-        @logger = ActiveSupport::BufferedLogger.new(log_path, Rails.logger.level)
+        log = File.open(File.join(Rails.root, 'log', 'rapns.log'), 'w')
+        log.sync = true
+        @logger = ActiveSupport::BufferedLogger.new(log, Rails.logger.level)
         @logger.auto_flushing = Rails.logger.respond_to?(:auto_flushing) ? Rails.logger.auto_flushing : true
       end
 
@@ -25,7 +26,8 @@ module Rapns
 
       def log(where, msg, prefix = nil)
         if msg.is_a?(Exception)
-          msg = "#{msg.class.name}, #{msg.message}"
+          formatted_backtrace = msg.backtrace.join("\n")
+          msg = "#{msg.class.name}, #{msg.message}\n#{formatted_backtrace}"
         end
 
         formatted_msg = "[#{Time.now.to_s(:db)}] "

data/lib/rapns/daemon.rb

@@ -3,64 +3,81 @@ 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/disconnection_error'
-require 'rapns/daemon/pool'
 require 'rapns/daemon/connection'
 require 'rapns/daemon/database_reconnectable'
 require 'rapns/daemon/delivery_queue'
 require 'rapns/daemon/delivery_handler'
 require 'rapns/daemon/delivery_handler_pool'
 require 'rapns/daemon/feedback_receiver'
+require 'rapns/daemon/app_runner'
 require 'rapns/daemon/feeder'
 require 'rapns/daemon/logger'
 
 module Rapns
   module Daemon
+    extend DatabaseReconnectable
+
     class << self
-      attr_accessor :logger, :configuration, :certificate,
-        :delivery_queue, :delivery_handler_pool, :foreground
-      alias_method  :foreground?, :foreground
+      attr_accessor :logger, :config
     end
 
-    def self.start(environment, foreground)
-      @foreground = foreground
+    def self.start(environment, config)
+      self.config = config
+      self.logger = Logger.new(:foreground => config.foreground, :airbrake_notify => config.airbrake_notify)
       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 = DeliveryQueue.new
-
-      daemonize unless foreground?
+      unless config.foreground
+        daemonize
+        reconnect_database
+      end
 
       write_pid_file
+      ensure_upgraded
+      AppRunner.sync
+      Feeder.start(config.push_poll)
+    end
+
+    protected
 
-      self.delivery_handler_pool = DeliveryHandlerPool.new(configuration.push.connections)
-      delivery_handler_pool.populate
+    def self.ensure_upgraded
+      count = 0
+
+      begin
+        count = Rapns::App.count
+      rescue ActiveRecord::StatementInvalid
+        puts "!!!! RAPNS NOT STARTED !!!!"
+        puts
+        puts "As of version v2.0.0 apps are configured in the database instead of rapns.yml."
+        puts "Please run 'rails g rapns' to generate the new migrations and create your apps with Rapns::App."
+        puts "See https://github.com/ileitch/rapns for further instructions."
+        puts
+        exit 1
+      end
 
-      logger.info('Ready')
+      if count == 0
+        puts "!!!! RAPNS NOT STARTED !!!!"
+        puts
+        puts "You must create an Rapns::App."
+        puts "See https://github.com/ileitch/rapns for instructions."
+        puts
+        exit 1
+      end
 
-      FeedbackReceiver.start
-      Feeder.start(foreground?)
+      if File.exists?(File.join(Rails.root, 'config', 'rapns', 'rapns.yml'))
+        logger.warn("Since 2.0.0 rapns uses command-line options instead of a configuration file. Please remove config/rapns/rapns.yml.")
+      end
     end
 
-    protected
-
     def self.setup_signal_hooks
       @shutting_down = false
 
+      Signal.trap('SIGHUP') { AppRunner.sync }
+      Signal.trap('SIGUSR1') { AppRunner.debug }
+
       ['SIGINT', 'SIGTERM'].each do |signal|
-        Signal.trap(signal) do
-          handle_shutdown_signal
-        end
+        Signal.trap(signal) { handle_shutdown_signal }
       end
     end
 
@@ -72,9 +89,8 @@ 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
+      Feeder.stop
+      AppRunner.stop
       delete_pid_file
     end
 
@@ -92,19 +108,17 @@ module Rapns
     end
 
     def self.write_pid_file
-      if !configuration.pid_file.blank?
+      if !config.pid_file.blank?
         begin
-          File.open(configuration.pid_file, 'w') do |f|
-            f.puts $$
-          end
+          File.open(config.pid_file, 'w') { |f| f.puts Process.pid }
         rescue SystemCallError => e
-          logger.error("Failed to write PID to '#{configuration.pid_file}': #{e.inspect}")
+          logger.error("Failed to write PID to '#{config.pid_file}': #{e.inspect}")
         end
       end
     end
 
     def self.delete_pid_file
-      pid_file = configuration.pid_file
+      pid_file = config.pid_file
       File.delete(pid_file) if !pid_file.blank? && File.exists?(pid_file)
     end
   end

data/lib/rapns/notification.rb

@@ -48,13 +48,24 @@ module Rapns
       ActiveSupport::JSON.decode(read_attribute(:attributes_for_device)) if read_attribute(:attributes_for_device)
     end
 
+    MDM_OVERIDE_KEY = '__rapns_mdm__'
+    def mdm=(magic)
+      self.attributes_for_device = {MDM_OVERIDE_KEY => magic}
+    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
+
+      if attributes_for_device && attributes_for_device.key?(MDM_OVERIDE_KEY)
+        json['mdm'] = attributes_for_device[MDM_OVERIDE_KEY]
+      else
+        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
+      end
+
       json
     end
 

data/lib/rapns/patches.rb

@@ -1,5 +1,5 @@
-if ActiveRecord::Base.configurations[Rails.env]['adapter'] == 'postgresql'
-  if Rails::VERSION::STRING == '3.1.0' || Rails::VERSION::STRING == '3.1.1'
+if Rails::VERSION::STRING == '3.1.0' || Rails::VERSION::STRING == '3.1.1'
+  if ActiveRecord::Base.configurations[Rails.env]['adapter'] == 'postgresql'
     STDERR.puts "[WARNING] Detected Rails #{Rails::VERSION::STRING}, patching PostgreSQLAdapter to fix reconnection bug: https://github.com/rails/rails/issues/3160"
     require "rapns/patches/rails/#{Rails::VERSION::STRING}/postgresql_adapter.rb"
   end

data/lib/rapns/version.rb

@@ -1,3 +1,3 @@
 module Rapns
-  VERSION = '1.0.7'
+  VERSION = '2.0.0rc1'
 end

data/lib/rapns.rb

@@ -4,4 +4,5 @@ require 'rapns/version'
 require 'rapns/binary_notification_validator'
 require 'rapns/device_token_format_validator'
 require 'rapns/notification'
-require 'rapns/feedback'
+require 'rapns/feedback'
+require 'rapns/app'

data/spec/rapns/daemon/app_runner_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Rapns::Daemon::AppRunner do
+  let(:app) { stub(:key => 'app', :certificate => 'cert', :password => '', :connections => 1) }
+  let(:queue) { stub(:notifications_processed? => true, :push => nil) }
+  let(:receiver) { stub(:start => nil, :stop => nil) }
+  let(:handler) { stub(:start => nil, :stop => nil) }
+  let(:push_config) { stub(:host => 'gateway.push.apple.com', :port => 2195) }
+  let(:feedback_config) { stub(:host => 'feedback.push.apple.com', :port => 2196, :poll => 60) }
+  let(:runner) { Rapns::Daemon::AppRunner.new(app, push_config.host, push_config.port,
+    feedback_config.host, feedback_config.port, feedback_config.poll) }
+
+  before do
+    Rapns::Daemon::DeliveryQueue.stub(:new => queue)
+    Rapns::Daemon::FeedbackReceiver.stub(:new => receiver)
+    Rapns::Daemon::DeliveryHandler.stub(:new => handler)
+  end
+
+  after { Rapns::Daemon::AppRunner.all.clear }
+
+  describe 'start' do
+    it 'starts a feedback receiver' do
+      Rapns::Daemon::FeedbackReceiver.should_receive(:new).with(app.key, feedback_config.host, feedback_config.port, feedback_config.poll, app.certificate, app.password)
+      receiver.should_receive(:start)
+      runner.start
+    end
+
+    it 'starts a delivery handler for each connection' do
+      Rapns::Daemon::DeliveryHandler.should_receive(:new).with(queue, app.key, push_config.host,
+        push_config.port, app.certificate, app.password)
+      handler.should_receive(:start)
+      runner.start
+    end
+  end
+
+  describe 'deliver' do
+    let(:notification) { stub }
+
+    it 'enqueues the notification' do
+      queue.should_receive(:push).with(notification)
+      runner.deliver(notification)
+    end
+  end
+
+  describe 'stop' do
+    before { runner.start }
+
+    it 'stops the delivery handlers' do
+      handler.should_receive(:stop)
+      runner.stop
+    end
+
+    it 'stops the feedback receiver' do
+      receiver.should_receive(:stop)
+      runner.stop
+    end
+  end
+
+  describe 'ready?' do
+    it 'is ready if all notifications have been processed' do
+      queue.stub(:notifications_processed? => true)
+      runner.ready?.should be_true
+    end
+
+    it 'is not ready if not all notifications have been processed' do
+      queue.stub(:notifications_processed? => false)
+      runner.ready?.should be_false
+    end
+  end
+
+  describe 'sync' do
+    let(:new_app) { stub(:key => 'app', :certificate => 'cert', :password => '', :connections => 1) }
+    before { runner.start }
+
+    it 'reduces the number of handlers if needed' do
+      handler.should_receive(:stop)
+      new_app.stub(:connections => app.connections - 1)
+      runner.sync(new_app)
+    end
+
+    it 'increases the number of handlers if needed' do
+      new_handler = stub
+      Rapns::Daemon::DeliveryHandler.should_receive(:new).and_return(new_handler)
+      new_handler.should_receive(:start)
+      new_app.stub(:connections => app.connections + 1)
+      runner.sync(new_app)
+    end
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'stop' do
+  let(:runner) { stub }
+  before { Rapns::Daemon::AppRunner.all['app'] = runner }
+  after { Rapns::Daemon::AppRunner.all.clear }
+
+  it 'stops all runners' do
+    runner.should_receive(:stop)
+    Rapns::Daemon::AppRunner.stop
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'deliver' do
+  let(:runner) { stub }
+  let(:notification) { stub(:app => 'app') }
+  let(:logger) { stub(:error => nil) }
+
+  before do
+    Rapns::Daemon.stub(:logger => logger)
+    Rapns::Daemon::AppRunner.all['app'] = runner
+  end
+
+  after { Rapns::Daemon::AppRunner.all.clear }
+
+  it 'delivers the notification' do
+    runner.should_receive(:deliver).with(notification)
+    Rapns::Daemon::AppRunner.deliver(notification)
+  end
+
+  it 'logs an error if there is no runner to deliver the notification' do
+    notification.stub(:app => 'unknonw', :id => 123)
+    logger.should_receive(:error).with("No such app '#{notification.app}' for notification #{notification.id}.")
+    Rapns::Daemon::AppRunner.deliver(notification)
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'ready' do
+  let(:runner1) { stub(:ready? => true) }
+  let(:runner2) { stub(:ready? => false) }
+
+  before do
+    Rapns::Daemon::AppRunner.all['app1'] = runner1
+    Rapns::Daemon::AppRunner.all['app2'] = runner2
+  end
+
+  after { Rapns::Daemon::AppRunner.all.clear }
+
+  it 'returns apps that are ready for more notifications' do
+    Rapns::Daemon::AppRunner.ready.should == ['app1']
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'sync' do
+  let(:app) { stub(:key => 'app') }
+  let(:new_app) { stub(:key => 'new_app') }
+  let(:runner) { stub(:sync => nil, :stop => nil) }
+  let(:new_runner) { stub }
+  let(:logger) { stub(:error => nil) }
+  let(:config) { stub(:feedback_poll => 60) }
+
+  before do
+    Rapns::Daemon.stub(:config => config, :logger => logger)
+    Rapns::Daemon::AppRunner.all['app'] = runner
+    Rapns::App.stub(:all => [app])
+  end
+
+  after { Rapns::Daemon::AppRunner.all.clear }
+
+  it 'loads all apps' do
+    Rapns::App.should_receive(:all)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'instructs existing runners to sync' do
+    runner.should_receive(:sync).with(app)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+it 'starts a runner for a new app with a production certificate' do
+    new_app.stub(:certificate => 'Apple Production IOS Push Services')
+    Rapns::App.stub(:all => [new_app])
+    new_runner = stub 
+    Rapns::Daemon::AppRunner.should_receive(:new).with(new_app, 'gateway.push.apple.com', 2195,
+      'feedback.push.apple.com', 2196, config.feedback_poll).and_return(new_runner)
+    new_runner.should_receive(:start)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'starts a runner for a new app with a development certificate' do
+    new_app.stub(:certificate => 'Apple Development IOS Push Services')
+    Rapns::App.stub(:all => [new_app])
+    new_runner = stub 
+    Rapns::Daemon::AppRunner.should_receive(:new).with(new_app, 'gateway.sandbox.push.apple.com', 2195,
+      'feedback.sandbox.push.apple.com', 2196, config.feedback_poll).and_return(new_runner)
+    new_runner.should_receive(:start)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'logs an error if the environment cannot be determined from the certificate' do
+    new_app.stub(:certificate => 'wat')
+    Rapns::App.stub(:all => [new_app])
+    Rapns::Daemon.logger.should_receive(:error).with("Could not detect environment for app 'new_app'.")
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'does not attempt to start an AppRunner if the environment could not be detected' do
+    new_app.stub(:certificate => 'wat')
+    Rapns::App.stub(:all => [new_app])
+    Rapns::Daemon::AppRunner.should_not_receive(:new) 
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'deletes old apps' do
+    Rapns::App.stub(:all => [])
+    runner.should_receive(:stop)
+    Rapns::Daemon::AppRunner.sync
+  end
+end