rapns 3.3.2-java → 3.4.0-java

data/lib/rapns/daemon/batch.rb

@@ -0,0 +1,100 @@
+module Rapns
+  module Daemon
+    class Batch
+      include Reflectable
+
+      attr_reader :num_processed, :notifications,
+        :delivered, :failed, :retryable
+
+      def initialize(notifications)
+        @notifications = notifications
+        @num_processed = 0
+        @delivered = []
+        @failed = {}
+        @retryable = {}
+        @mutex = Mutex.new
+      end
+
+      def num_notifications
+        @notifications.size
+      end
+
+      def mark_retryable(notification, deliver_after)
+        if Rapns.config.batch_storage_updates
+          @retryable[deliver_after] ||= []
+          @retryable[deliver_after] << notification
+        else
+          Rapns::Daemon.store.mark_retryable(notification, deliver_after)
+        end
+      end
+
+      def mark_delivered(notification)
+        if Rapns.config.batch_storage_updates
+          @delivered << notification
+        else
+          Rapns::Daemon.store.mark_delivered(notification)
+        end
+      end
+
+      def mark_failed(notification, code, description)
+        if Rapns.config.batch_storage_updates
+          key = [code, description]
+          @failed[key] ||= []
+          @failed[key] << notification
+        else
+          Rapns::Daemon.store.mark_failed(notification, code, description)
+        end
+      end
+
+      def notification_processed
+        @mutex.synchronize do
+          @num_processed += 1
+          complete if @num_processed >= @notifications.size
+        end
+      end
+
+      def complete?
+        @complete == true
+      end
+
+      def describe
+        @notifications.map(&:id).join(', ')
+      end
+
+      private
+
+      def complete
+        [:complete_delivered, :complete_failed, :complete_retried].each do |method|
+          begin
+            send(method)
+          rescue StandardError => e
+            Rapns.logger.error(e)
+            reflect(:error, e)
+          end
+        end
+
+        @notifications.clear
+        @complete = true
+      end
+
+      def complete_delivered
+        Rapns::Daemon.store.mark_batch_delivered(@delivered)
+        @delivered.clear
+      end
+
+      def complete_failed
+        @failed.each do |(code, description), notifications|
+          Rapns::Daemon.store.mark_batch_failed(notifications, code, description)
+        end
+        @failed.clear
+      end
+
+      def complete_retried
+        @retryable.each do |deliver_after, notifications|
+          Rapns::Daemon.store.mark_batch_retryable(notifications, deliver_after)
+        end
+        @retryable.clear
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery.rb

@@ -3,26 +3,22 @@ module Rapns
     class Delivery
       include Reflectable
 
-      def self.perform(*args)
-        new(*args).perform
-      end
-
-      def retry_after(notification, deliver_after)
-        Rapns::Daemon.store.retry_after(notification, deliver_after)
+      def mark_retryable(notification, deliver_after)
+        @batch.mark_retryable(notification, deliver_after)
         reflect(:notification_will_retry, notification)
       end
 
-      def retry_exponentially(notification)
-        retry_after(notification, Time.now + 2 ** (notification.retries + 1))
+      def mark_retryable_exponential(notification)
+        mark_retryable(notification, Time.now + 2 ** (notification.retries + 1))
       end
 
       def mark_delivered
-        Rapns::Daemon.store.mark_delivered(@notification)
+        @batch.mark_delivered(@notification)
         reflect(:notification_delivered, @notification)
       end
 
       def mark_failed(code, description)
-        Rapns::Daemon.store.mark_failed(@notification, code, description)
+        @batch.mark_failed(@notification, code, description)
         reflect(:notification_failed, @notification)
       end
     end

data/lib/rapns/daemon/delivery_handler.rb

@@ -3,6 +3,8 @@ module Rapns
     class DeliveryHandler
       include Reflectable
 
+      WAKEUP = :wakeup
+
       attr_accessor :queue
 
       def start
@@ -16,10 +18,14 @@ module Rapns
 
       def stop
         @stop = true
-        if @thread
-          queue.wakeup(@thread)
-          @thread.join
-        end
+      end
+
+      def wakeup
+        queue.push(WAKEUP) if @thread
+      end
+
+      def wait
+        @thread.join if @thread
         stopped
       end
 
@@ -29,20 +35,16 @@ module Rapns
       end
 
       def handle_next_notification
-        begin
-          notification = queue.pop
-        rescue DeliveryQueue::WakeupError
-          return
-        end
+        notification, batch = queue.pop
+        return if notification == WAKEUP
 
         begin
-          deliver(notification)
-          reflect(:notification_delivered, notification)
+          deliver(notification, batch)
         rescue StandardError => e
           Rapns.logger.error(e)
           reflect(:error, e)
         ensure
-          queue.notification_processed
+          batch.notification_processed
         end
       end
     end

data/lib/rapns/daemon/delivery_handler_collection.rb

@@ -0,0 +1,33 @@
+module Rapns
+  module Daemon
+    class DeliveryHandlerCollection
+      attr_reader :handlers
+
+      def initialize
+        @handlers = []
+      end
+
+      def push(handler)
+        @handlers << handler
+      end
+
+      def pop
+        handler = @handlers.pop
+        handler.stop
+        handler.wakeup
+        @handlers.map(&:wakeup)
+        handler.wait
+      end
+
+      def size
+        @handlers.size
+      end
+
+      def stop
+        @handlers.map(&:stop)
+        @handlers.map(&:wakeup)
+        @handlers.map(&:wait)
+      end
+    end
+  end
+end

data/lib/rapns/daemon/feeder.rb

@@ -38,11 +38,9 @@ module Rapns
       def self.enqueue_notifications
         begin
           idle = Rapns::Daemon::AppRunner.idle.map(&:app)
-
-          Rapns::Daemon.store.deliverable_notifications(idle).each do |notification|
-            Rapns::Daemon::AppRunner.enqueue(notification)
-            reflect(:notification_enqueued, notification)
-          end
+          return if idle.empty?
+          notifications = Rapns::Daemon.store.deliverable_notifications(idle)
+          Rapns::Daemon::AppRunner.enqueue(notifications)
         rescue StandardError => e
           Rapns.logger.error(e)
           reflect(:error, e)

data/lib/rapns/daemon/gcm/delivery.rb

@@ -8,10 +8,11 @@ module Rapns
         GCM_URI = URI.parse('https://android.googleapis.com/gcm/send')
         UNAVAILABLE_STATES = ['Unavailable', 'InternalServerError']
 
-        def initialize(app, http, notification)
+        def initialize(app, http, notification, batch)
           @app = app
           @http = http
           @notification = notification
+          @batch = batch
         end
 
         def perform
@@ -121,7 +122,7 @@ module Rapns
 
         def deliver_after_header(response)
           if response.header['retry-after']
-            retry_after = if response.header['retry-after'].to_s =~ /^[0-9]+$/
+            if response.header['retry-after'].to_s =~ /^[0-9]+$/
               Time.now + response.header['retry-after'].to_i
             else
               Time.httpdate(response.header['retry-after'])
@@ -131,9 +132,9 @@ module Rapns
 
         def retry_delivery(notification, response)
           if time = deliver_after_header(response)
-            retry_after(notification, time)
+            mark_retryable(notification, time)
           else
-            retry_exponentially(notification)
+            mark_retryable_exponential(notification)
           end
         end
 

data/lib/rapns/daemon/gcm/delivery_handler.rb

@@ -7,8 +7,8 @@ module Rapns
           @http = Net::HTTP::Persistent.new('rapns')
         end
 
-        def deliver(notification)
-          Rapns::Daemon::Gcm::Delivery.perform(@app, @http, notification)
+        def deliver(notification, batch)
+          Rapns::Daemon::Gcm::Delivery.new(@app, @http, notification, batch).perform
         end
 
         def stopped

data/lib/rapns/daemon/store/active_record.rb

@@ -13,11 +13,11 @@ module Rapns
             batch_size = Rapns.config.batch_size
             relation = Rapns::Notification.ready_for_delivery.for_apps(apps)
             relation = relation.limit(batch_size) unless Rapns.config.push
-            relation.all
+            relation.to_a
           end
         end
 
-        def retry_after(notification, deliver_after)
+        def mark_retryable(notification, deliver_after)
           with_database_reconnect_and_retry do
             notification.retries += 1
             notification.deliver_after = deliver_after
@@ -25,6 +25,13 @@ module Rapns
           end
         end
 
+        def mark_batch_retryable(notifications, deliver_after)
+          ids = notifications.map(&:id)
+          with_database_reconnect_and_retry do
+            Rapns::Notification.where(:id => ids).update_all(['retries = retries + 1, deliver_after = ?', deliver_after])
+          end
+        end
+
         def mark_delivered(notification)
           with_database_reconnect_and_retry do
             notification.delivered = true
@@ -33,6 +40,13 @@ module Rapns
           end
         end
 
+        def mark_batch_delivered(notifications)
+          ids = notifications.map(&:id)
+          with_database_reconnect_and_retry do
+            Rapns::Notification.where(:id => ids).update_all(['delivered = true, delivered_at = ?', Time.now])
+          end
+        end
+
         def mark_failed(notification, code, description)
           with_database_reconnect_and_retry do
             notification.delivered = false
@@ -45,6 +59,13 @@ module Rapns
           end
         end
 
+        def mark_batch_failed(notifications, code, description)
+          ids = notifications.map(&:id)
+          with_database_reconnect_and_retry do
+            Rapns::Notification.where(:id => ids).update_all(['delivered = false, delivered_at = NULL, failed = true, failed_at = ?, error_code = ?, error_description = ?', Time.now, code, description])
+          end
+        end
+
         def create_apns_feedback(failed_at, device_token, app)
           with_database_reconnect_and_retry do
             Rapns::Apns::Feedback.create!(:failed_at => failed_at,

data/lib/rapns/deprecation.rb

@@ -1,20 +1,21 @@
 module Rapns
   class Deprecation
-    def self.silenced
+    def self.muted
       begin
-        Thread.current[:rapns_silence_deprecations] = true
+        orig_val = Thread.current[:rapns_mute_deprecations]
+        Thread.current[:rapns_mute_deprecations] = true
         yield
       ensure
-        Thread.current[:rapns_silence_deprecations] = false
+        Thread.current[:rapns_mute_deprecations] = orig_val
       end
     end
 
-    def self.silenced?
-      Thread.current[:rapns_silence_deprecations]
+    def self.muted?
+      Thread.current[:rapns_mute_deprecations] == true
     end
 
     def self.warn(msg)
-      unless Rapns::Deprecation.silenced?
+      unless Rapns::Deprecation.muted?
         STDERR.puts "DEPRECATION WARNING: #{msg}"
       end
     end

data/lib/rapns/logger.rb

@@ -32,7 +32,7 @@ module Rapns
     def setup_logger(log)
       if Rapns.config.logger
         @logger = Rapns.config.logger
-      elsif defined?(ActiveSupport::BufferedLogger)
+      elsif ActiveSupport.const_defined?('BufferedLogger')
         @logger = ActiveSupport::BufferedLogger.new(log, Rails.logger.level)
         @logger.auto_flushing = Rails.logger.respond_to?(:auto_flushing) ? Rails.logger.auto_flushing : true
       else

data/lib/rapns/notification.rb

@@ -9,9 +9,11 @@ module Rapns
 
     belongs_to :app, :class_name => 'Rapns::App'
 
-    attr_accessible :badge, :device_token, :sound, :alert, :data, :expiry,:delivered,
-      :delivered_at, :failed, :failed_at, :error_code, :error_description, :deliver_after,
-      :alert_is_json, :app, :app_id, :collapse_key, :delay_while_idle, :registration_ids
+    if Rapns.attr_accessible_available?
+      attr_accessible :badge, :device_token, :sound, :alert, :data, :expiry,:delivered,
+        :delivered_at, :failed, :failed_at, :error_code, :error_description, :deliver_after,
+        :alert_is_json, :app, :app_id, :collapse_key, :delay_while_idle, :registration_ids
+    end
 
     validates :expiry, :numericality => true, :allow_nil => true
     validates :app, :presence => true

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,
-      :gcm_canonical_id, :error
+      :gcm_canonical_id, :error, :apns_certificate_will_expire
     ]
 
     REFLECTIONS.each do |reflection|

data/lib/rapns/version.rb

@@ -1,3 +1,3 @@
 module Rapns
-  VERSION = '3.3.2'
+  VERSION = '3.4.0'
 end

data/lib/tasks/cane.rake

@@ -3,7 +3,7 @@ begin
 
   desc "Run cane to check quality metrics"
   Cane::RakeTask.new(:quality) do |cane|
-    cane.add_threshold 'coverage/covered_percent', :>=, 99
+    cane.add_threshold 'coverage/covered_percent', :>=, 98
     cane.no_style = false
     cane.style_measure = 1000
     cane.no_doc = true

data/lib/tasks/test.rake

@@ -2,9 +2,13 @@ namespace :test do
   task :build_rails do
     require 'fileutils'
 
-    def cmd(str)
+    def cmd(str, clean_env = true)
       puts "* #{str}"
-      retval = Bundler.with_clean_env { `#{str}` }
+      retval = if clean_env
+        Bundler.with_clean_env { `#{str}` }
+      else
+        `#{str}`
+      end
       puts retval.strip
       retval
     end
@@ -15,7 +19,8 @@ namespace :test do
     FileUtils.mkdir_p(path)
     pwd = Dir.pwd
 
-    cmd("bundle exec rails new #{path} --skip-bundle")
+    cmd("bundle exec rails --version", false)
+    cmd("bundle exec rails new #{path} --skip-bundle", false)
 
     begin
       Dir.chdir(path)

data/spec/unit/apns/app_spec.rb

@@ -2,26 +2,26 @@ require 'unit_spec_helper'
 
 describe Rapns::App do
   it 'does not validate an app with an invalid certificate' do
-    app = Rapns::Apns::App.new(:key => 'test', :environment => 'development', :certificate => 'foo')
+    app = Rapns::Apns::App.new(:name => 'test', :environment => 'development', :certificate => 'foo')
     app.valid?
     app.errors[:certificate].should == ['Certificate value must contain a certificate and a private key.']
   end
 
   it 'validates a certificate without a password' do
-    app = Rapns::Apns::App.new :key => 'test', :environment => 'development', :certificate => TEST_CERT
+    app = Rapns::Apns::App.new :name => 'test', :environment => 'development', :certificate => TEST_CERT
     app.valid?
     app.errors[:certificate].should == []
   end
 
   it 'validates a certificate with a password' do
-    app = Rapns::Apns::App.new :key => 'test', :environment => 'development',
+    app = Rapns::Apns::App.new :name => 'test', :environment => 'development',
       :certificate => TEST_CERT_WITH_PASSWORD, :password => 'fubar'
     app.valid?
     app.errors[:certificate].should == []
   end
 
   it 'validates a certificate with an incorrect password' do
-    app = Rapns::Apns::App.new :key => 'test', :environment => 'development',
+    app = Rapns::Apns::App.new :name => 'test', :environment => 'development',
       :certificate => TEST_CERT_WITH_PASSWORD, :password => 'incorrect'
     app.valid?
     app.errors[:certificate].should == ["Certificate value must contain a certificate and a private key."]