rapns 3.2.0 → 3.3.0

data/lib/rapns/gcm/notification.rb

@@ -19,10 +19,11 @@ module Rapns
         }
 
         if collapse_key
-          json.merge!({
-            'collapse_key' => collapse_key,
-            'time_to_live' => expiry
-          })
+          json['collapse_key'] = collapse_key
+        end
+
+        if expiry
+          json['time_to_live'] = expiry
         end
 
         json

data/lib/rapns/gcm/registration_ids_count_validator.rb

@@ -5,7 +5,7 @@ module Rapns
 
       def validate(record)
         if record.registration_ids && record.registration_ids.size > LIMIT
-          record.errors[:base] << "GCM notification num of registration_ids cannot be larger than #{LIMIT}."
+          record.errors[:base] << "GCM notification number of registration_ids cannot be larger than #{LIMIT}."
         end
       end
     end

data/lib/rapns/logger.rb

@@ -6,8 +6,12 @@ module Rapns
       begin
         log = File.open(File.join(Rails.root, 'log', 'rapns.log'), 'a')
         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
+        if defined?(ActiveSupport::BufferedLogger)
+          @logger = ActiveSupport::BufferedLogger.new(log, Rails.logger.level)
+          @logger.auto_flushing = Rails.logger.respond_to?(:auto_flushing) ? Rails.logger.auto_flushing : true
+        else
+          @logger = ActiveSupport::Logger.new(log, Rails.logger.level)
+        end
       rescue Errno::ENOENT, Errno::EPERM => e
         @logger = nil
         error(e)

data/lib/rapns/push.rb

@@ -8,6 +8,7 @@ module Rapns
     Rapns.config.update(config)
 
     Upgraded.check(:exit => false)
+    Rapns::Daemon.initialize_store
     Rapns::Daemon::AppRunner.sync
     Rapns::Daemon::Feeder.start
     Rapns::Daemon::AppRunner.wait

data/lib/rapns/reflection.rb

@@ -13,7 +13,7 @@ module Rapns
     REFLECTIONS = [
       :apns_feedback, :notification_enqueued, :notification_delivered,
       :notification_failed, :notification_will_retry, :apns_connection_lost,
-      :error
+      :gcm_canonical_id, :error
     ]
 
     REFLECTIONS.each do |reflection|

data/lib/rapns/version.rb

@@ -1,3 +1,3 @@
 module Rapns
-  VERSION = '3.2.0'
+  VERSION = '3.3.0'
 end

data/spec/unit/apns/notification_spec.rb

@@ -1,3 +1,5 @@
+# encoding: US-ASCII
+
 require "unit_spec_helper"
 require 'unit/notification_shared.rb'
 

data/spec/unit/apns_feedback_spec.rb

@@ -8,6 +8,11 @@ describe Rapns, 'apns_feedback' do
     Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => receiver)
   end
 
+  it 'initializes the store' do
+    Rapns::Daemon.should_receive(:initialize_store)
+    Rapns.apns_feedback
+  end
+
   it 'checks feedback for each app' do
     Rapns::Daemon::Apns::FeedbackReceiver.should_receive(:new).with(app, 0).and_return(receiver)
     receiver.should_receive(:check_for_feedback)

data/spec/unit/configuration_spec.rb

@@ -40,7 +40,7 @@ describe Rapns::Configuration do
 
   it 'does not allow foreground to be set to false if the platform is JRuby' do
     config.foreground = true
-    stub_const('Rapns::Configuration::JRUBY_VERSION', '1.7.1')
+    Rapns.stub(:jruby? => true)
     config.foreground = false
     config.foreground.should be_true
   end

data/spec/unit/daemon/apns/delivery_spec.rb

@@ -7,6 +7,7 @@ describe Rapns::Daemon::Apns::Delivery do
   let(:config) { stub(:check_for_errors => true) }
   let(:connection) { stub(:select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
   let(:delivery) { Rapns::Daemon::Apns::Delivery.new(app, connection, notification) }
+  let(:store) { stub(:mark_failed => nil, :mark_delivered => nil) }
 
   def perform
     begin
@@ -16,6 +17,7 @@ describe Rapns::Daemon::Apns::Delivery do
   end
 
   before do
+    Rapns::Daemon.stub(:store => store)
     Rapns.stub(:config => config, :logger => logger)
   end
 
@@ -32,7 +34,7 @@ describe Rapns::Daemon::Apns::Delivery do
   end
 
   it "marks the notification as delivered" do
-    notification.should_receive(:delivered=).with(true)
+    store.should_receive(:mark_delivered).with(notification)
     perform
   end
 
@@ -41,23 +43,6 @@ describe Rapns::Daemon::Apns::Delivery do
     perform
   end
 
-  it "sets the time the notification was delivered" do
-    now = Time.now
-    Time.stub(:now).and_return(now)
-    notification.should_receive(:delivered_at=).with(now)
-    perform
-  end
-
-  it "does not trigger validations when saving the notification" do
-    notification.should_receive(:save!).with(:validate => false)
-    perform
-  end
-
-  it "updates notification with the ability to reconnect the database" do
-    delivery.should_receive(:with_database_reconnect_and_retry)
-    perform
-  end
-
   it 'does not check for errors if check_for_errors config option is false' do
     config.stub(:check_for_errors => false)
     delivery.should_not_receive(:check_for_error)
@@ -67,23 +52,8 @@ describe Rapns::Daemon::Apns::Delivery do
   describe "when delivery fails" do
     before { connection.stub(:select => true, :read => [8, 4, 69].pack("ccN")) }
 
-    it "updates notification with the ability to reconnect the database" do
-      delivery.should_receive(:with_database_reconnect_and_retry)
-      perform
-    end
-
-    it "sets the notification as not delivered" do
-      notification.should_receive(:delivered=).with(false)
-      perform
-    end
-
-    it "sets the notification delivered_at timestamp to nil" do
-      notification.should_receive(:delivered_at=).with(nil)
-      perform
-    end
-
-    it "sets the notification as failed" do
-      notification.should_receive(:failed=).with(true)
+    it "marks the notification as failed" do
+      store.should_receive(:mark_failed).with(notification, 4, "Missing payload")
       perform
     end
 
@@ -92,18 +62,6 @@ describe Rapns::Daemon::Apns::Delivery do
       perform
     end
 
-    it "sets the notification failed_at timestamp" do
-      now = Time.now
-      Time.stub(:now).and_return(now)
-      notification.should_receive(:failed_at=).with(now)
-      perform
-    end
-
-    it "sets the notification error code" do
-      notification.should_receive(:error_code=).with(4)
-      perform
-    end
-
     it "logs the delivery error" do
       # checking for the stubbed error doesn't work in jruby, but checking
       # for the exception by class does.
@@ -115,16 +73,6 @@ describe Rapns::Daemon::Apns::Delivery do
       expect { delivery.perform }.to raise_error(Rapns::DeliveryError)
     end
 
-    it "sets the notification error description" do
-      notification.should_receive(:error_description=).with("Missing payload")
-      perform
-    end
-
-    it "skips validation when saving the notification" do
-      notification.should_receive(:save!).with(:validate => false)
-      perform
-    end
-
     it "reads 6 bytes from the socket" do
       connection.should_receive(:read).with(6).and_return(nil)
       perform
@@ -155,13 +103,8 @@ describe Rapns::Daemon::Apns::Delivery do
         expect { delivery.perform }.to raise_error(Rapns::Apns::DisconnectionError)
       end
 
-      it 'does not set the error code on the notification' do
-        notification.should_receive(:error_code=).with(nil)
-        perform
-      end
-
-      it 'sets the error description on the notification' do
-        notification.should_receive(:error_description=).with("APNs disconnected without returning an error.")
+      it 'marks the notification as failed' do
+        store.should_receive(:mark_failed).with(notification, nil, "APNs disconnected without returning an error.")
         perform
       end
     end

data/spec/unit/daemon/apns/feedback_receiver_spec.rb

@@ -16,8 +16,8 @@ describe Rapns::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
     receiver.stub(:interruptible_sleep)
     Rapns.stub(:logger => logger)
     Rapns::Daemon::Apns::Connection.stub(:new => connection)
-    Rapns::Apns::Feedback.stub(:create! => feedback)
     receiver.instance_variable_set("@stop", false)
+    Rapns::Daemon.stub(:store => stub(:create_apns_feedback => feedback))
   end
 
   def stub_connection_read_with_tuple
@@ -58,8 +58,8 @@ describe Rapns::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   end
 
   it 'creates the feedback' do
+    Rapns::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1323533325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
     stub_connection_read_with_tuple
-    Rapns::Apns::Feedback.should_receive(:create!).with(:failed_at => Time.at(1323533325), :device_token => '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', :app => app)
     receiver.check_for_feedback
   end
 

data/spec/unit/daemon/feeder_spec.rb

@@ -8,10 +8,10 @@ describe Rapns::Daemon::Feeder do
   let(:logger) { stub }
 
   before do
-    Rapns.stub(:config => config)
+    Rapns.stub(:config => config,:logger => logger)
+    Rapns::Daemon.stub(:store => stub(:deliverable_notifications => [notification]))
     Rapns::Daemon::Feeder.stub(:stop? => true)
-    Rapns::Daemon::AppRunner.stub(:idle => [stub(:app => app)])
-    Rapns.stub(:logger => logger)
+    Rapns::Daemon::AppRunner.stub(:enqueue => nil, :idle => [stub(:app => app)])
   end
 
   def start
@@ -25,8 +25,8 @@ describe Rapns::Daemon::Feeder do
     start
   end
 
-  it "checks for new notifications with the ability to reconnect the database" do
-    Rapns::Daemon::Feeder.should_receive(:with_database_reconnect_and_retry)
+  it 'loads deliverable notifications' do
+    Rapns::Daemon.store.should_receive(:deliverable_notifications).with([app])
     start
   end
 
@@ -37,72 +37,20 @@ describe Rapns::Daemon::Feeder do
     start
   end
 
-  it 'loads notifications in batches' do
-    relation = stub.as_null_object
-    relation.should_receive(:limit).with(5000)
-    Rapns::Notification.stub(:ready_for_delivery => relation)
-    start
-  end
-
-  it 'does not load notification in batches if in push mode' do
-    config.stub(:push => true)
-    relation = stub.as_null_object
-    relation.should_not_receive(:limit)
-    Rapns::Notification.stub(:ready_for_delivery => relation)
-    start
-  end
-
   it "enqueues the notification" do
-    notification.update_attributes!(:delivered => false)
     Rapns::Daemon::AppRunner.should_receive(:enqueue).with(notification)
     start
   end
 
   it 'reflects the notification has been enqueued' do
-    notification.update_attributes!(:delivered => false)
     Rapns::Daemon::AppRunner.stub(:enqueue)
     Rapns::Daemon::Feeder.should_receive(:reflect).with(:notification_enqueued, notification)
     start
   end
 
-  it 'does not enqueue the notification if the app runner is still processing the previous batch' do
-    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
-    start
-  end
-
-  it "enqueues an undelivered notification without deliver_after set" do
-    notification.update_attributes!(:delivered => false, :deliver_after => nil)
-    Rapns::Daemon::AppRunner.should_receive(:enqueue).with(notification)
-    start
-  end
-
-  it "enqueues a notification with a deliver_after time in the past" do
-    notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.ago)
-    Rapns::Daemon::AppRunner.should_receive(:enqueue).with(notification)
-    start
-  end
-
-  it "does not enqueue a notification with a deliver_after time in the future" do
-    notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.from_now)
-    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
-    start
-  end
-
-  it "does not enqueue a previously delivered notification" do
-    notification.update_attributes!(:delivered => true, :delivered_at => Time.now)
-    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
-    start
-  end
-
-  it "does not enqueue a notification that has previously failed delivery" do
-    notification.update_attributes!(:delivered => false, :failed => true)
-    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
-    start
-  end
-
   it "logs errors" do
     e = StandardError.new("bork")
-    Rapns::Notification.stub(:ready_for_delivery).and_raise(e)
+    Rapns::Daemon.store.stub(:deliverable_notifications).and_raise(e)
     Rapns.logger.should_receive(:error).with(e)
     start
   end

data/spec/unit/daemon/gcm/delivery_spec.rb

@@ -2,18 +2,21 @@ require 'unit_spec_helper'
 
 describe Rapns::Daemon::Gcm::Delivery do
   let(:app) { Rapns::Gcm::App.new(:name => 'MyApp', :auth_key => 'abc123') }
-  let(:notification) { Rapns::Gcm::Notification.create!(:app => app, :registration_ids => ['xyz']) }
+  let(:notification) { Rapns::Gcm::Notification.create!(:app => app, :registration_ids => ['xyz'], :deliver_after => Time.now) }
   let(:logger) { stub(:error => nil, :info => nil, :warn => nil) }
   let(:response) { stub(:code => 200, :header => {}) }
   let(:http) { stub(:shutdown => nil, :request => response)}
   let(:now) { Time.parse('2012-10-14 00:00:00') }
   let(:delivery) { Rapns::Daemon::Gcm::Delivery.new(app, http, notification) }
+  let(:store) { stub(:mark_failed => nil, :mark_delivered => nil, :retry_after => nil, :create_gcm_notification => stub(:id => 2)) }
 
   def perform
     delivery.perform
   end
 
   before do
+    delivery.stub(:reflect => nil)
+    Rapns::Daemon.stub(:store => store)
     Time.stub(:now => now)
     Rapns.stub(:logger => logger)
   end
@@ -25,9 +28,8 @@ describe Rapns::Daemon::Gcm::Delivery do
 
     it 'marks the notification as delivered if delivered successfully to all devices' do
       response.stub(:body => JSON.dump({ 'failure' => 0 }))
-      expect do
-        perform
-      end.to change(notification, :delivered).to(true)
+      store.should_receive(:mark_delivered).with(notification)
+      perform
     end
 
     it 'reflects the notification was delivered' do
@@ -51,11 +53,25 @@ describe Rapns::Daemon::Gcm::Delivery do
           { 'error' => 'NotRegistered' }
       ]}
       response.stub(:body => JSON.dump(body))
+      store.should_receive(:mark_failed).with(notification, nil, "Failed to deliver to all recipients. Errors: NotRegistered.")
       perform rescue Rapns::DeliveryError
-      notification.reload
-      notification.failed.should be_true
-      notification.error_code = nil
-      notification.error_description = "Weee"
+    end
+
+    it 'reflects on canonical IDs' do
+      body = {
+        'failure' => 0,
+        'success' => 3,
+        'canonical_ids' => 1,
+        'results' => [
+          { 'message_id' => '1:000' },
+          { 'message_id' => '1:000', 'registration_id' => 'canonical123' },
+          { 'message_id' => '1:000' },
+        ]}
+
+      response.stub(:body => JSON.dump(body))
+      notification.stub(:registration_ids => ['1', '2', '3'])
+      delivery.should_receive(:reflect).with(:gcm_canonical_id, '2', 'canonical123')
+      perform
     end
 
     describe 'all deliveries returned Unavailable or InternalServerError' do
@@ -71,28 +87,23 @@ describe Rapns::Daemon::Gcm::Delivery do
 
       it 'retries the notification respecting the Retry-After header' do
         response.stub(:header => { 'retry-after' => 10 })
+        store.should_receive(:retry_after).with(notification, now + 10.seconds)
         perform
-        notification.reload
-        notification.retries.should == 1
-        notification.deliver_after.should == now + 10.seconds
       end
 
       it 'retries the notification using exponential back-off if the Retry-After header is not present' do
-        notification.update_attribute(:retries, 8)
+        store.should_receive(:retry_after).with(notification, now + 2)
         perform
-        notification.reload
-        notification.retries.should == 9
-        notification.deliver_after.should == now + 2 ** 9
       end
 
       it 'does not mark the notification as failed' do
-        expect do
-          perform
-          notification.reload
-        end.to_not change(notification, :failed).to(true)
+        store.should_not_receive(:mark_failed)
+        perform
       end
 
       it 'logs that the notification will be retried' do
+        notification.retries = 1
+        notification.deliver_after = now + 2
         Rapns.logger.should_receive(:warn).with("All recipients unavailable. Notification #{notification.id} will be retired after 2012-10-14 00:00:02 (retry 1).")
         perform
       end
@@ -104,12 +115,8 @@ describe Rapns::Daemon::Gcm::Delivery do
       before { response.stub(:body => JSON.dump(body)) }
 
       it 'marks the original notification as failed' do
+        store.should_receive(:mark_failed).with(notification, nil, error_description)
         perform rescue Rapns::DeliveryError
-        notification.reload
-        notification.failed.should be_true
-        notification.failed_at = now
-        notification.error_code.should be_nil
-        notification.error_description.should == error_description
       end
 
       it 'reflects the notification delivery failed' do
@@ -119,17 +126,11 @@ describe Rapns::Daemon::Gcm::Delivery do
 
       it 'creates a new notification for the unavailable devices' do
         notification.update_attributes(:registration_ids => ['id_0', 'id_1', 'id_2'], :data => {'one' => 1}, :collapse_key => 'thing', :delay_while_idle => true)
-        perform rescue Rapns::DeliveryError
-        new_notification.registration_ids.should == ['id_0', 'id_2']
-        new_notification.data.should == {'one' => 1}
-        new_notification.collapse_key.should == 'thing'
-        new_notification.delay_while_idle.should be_true
-      end
-
-      it 'sets the delivery time on the new notification to respect the Retry-After header' do
         response.stub(:header => { 'retry-after' => 10 })
+        attrs = { 'collapse_key' => 'thing', 'delay_while_idle' => true, 'app_id' => app.id }
+        store.should_receive(:create_gcm_notification).with(attrs, notification.data,
+            ['id_0', 'id_2'], now + 10.seconds, notification.app)
         perform rescue Rapns::DeliveryError
-        new_notification.deliver_after.should == now + 10.seconds
       end
 
       it 'raises a DeliveryError' do
@@ -168,28 +169,27 @@ describe Rapns::Daemon::Gcm::Delivery do
     before { response.stub(:code => 503) }
 
     it 'logs a warning that the notification will be retried.' do
+      notification.retries = 1
+      notification.deliver_after = now + 2
       logger.should_receive(:warn).with("GCM responded with an Service Unavailable Error. Notification #{notification.id} will be retired after 2012-10-14 00:00:02 (retry 1).")
       perform
     end
 
     it 'respects an integer Retry-After header' do
       response.stub(:header => { 'retry-after' => 10 })
-      expect do
-        perform
-      end.to change(notification, :deliver_after).to(now + 10)
+      store.should_receive(:retry_after).with(notification, now + 10.seconds)
+      perform
     end
 
     it 'respects a HTTP-date Retry-After header' do
       response.stub(:header => { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
-      expect do
-        perform
-      end.to change(notification, :deliver_after).to(Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
+      store.should_receive(:retry_after).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
+      perform
     end
 
     it 'defaults to exponential back-off if the Retry-After header is not present' do
-      expect do
-        perform
-      end.to change(notification, :deliver_after).to(now + 2 ** 1)
+      store.should_receive(:retry_after).with(notification, now + 2 ** 1)
+      perform
     end
 
     it 'reflects the notification will be retried' do
@@ -205,15 +205,15 @@ describe Rapns::Daemon::Gcm::Delivery do
     end
 
     it 'logs a warning that the notification has been re-queued.' do
+      notification.retries = 3
+      notification.deliver_after = now + 2 ** 3
       Rapns.logger.should_receive(:warn).with("GCM responded with an Internal Error. Notification #{notification.id} will be retired after #{(now + 2 ** 3).strftime("%Y-%m-%d %H:%M:%S")} (retry 3).")
       perform
     end
 
-    it 'sets deliver_after on the notification in accordance with the exponential back-off strategy.' do
-      expect do
-        perform
-        notification.reload
-      end.to change(notification, :deliver_after).to(now + 2 ** 3)
+    it 'retries the notification in accordance with the exponential back-off strategy.' do
+      store.should_receive(:retry_after).with(notification, now + 2 ** 3)
+      perform
     end
 
     it 'reflects the notification will be retried' do
@@ -234,12 +234,8 @@ describe Rapns::Daemon::Gcm::Delivery do
     before { response.stub(:code => 400) }
 
     it 'marks the notification as failed' do
+      store.should_receive(:mark_failed).with(notification, 400, 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.')
       perform rescue Rapns::DeliveryError
-      notification.reload
-      notification.failed.should be_true
-      notification.failed_at.should == now
-      notification.error_code.should == 400
-      notification.error_description.should == 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.'
     end
 
     it 'reflects the notification delivery failed' do
@@ -252,12 +248,8 @@ describe Rapns::Daemon::Gcm::Delivery do
     before { response.stub(:code => 418) }
 
     it 'marks the notification as failed' do
+      store.should_receive(:mark_failed).with(notification, 418, "I'm a Teapot")
       perform rescue Rapns::DeliveryError
-      notification.reload
-      notification.failed.should be_true
-      notification.failed_at.should == now
-      notification.error_code.should == 418
-      notification.error_description.should == "I'm a Teapot"
     end
 
     it 'reflects the notification delivery failed' do