rpush 2.3.2 → 2.4.0

data/lib/rpush/daemon/adm/delivery.rb

@@ -151,7 +151,7 @@ module Rpush
         end
 
         def create_new_notification(response, registration_ids)
-          attrs = @notification.attributes.slice('app_id', 'collapse_key', 'delay_while_idle')
+          attrs = { 'app_id' => @notification.app_id, 'collapse_key' => @notification.collapse_key, 'delay_while_idle' => @notification.delay_while_idle }
           Rpush::Daemon.store.create_adm_notification(attrs, @notification.data, registration_ids, deliver_after_header(response), @notification.app)
         end
 

data/lib/rpush/daemon/apns.rb

@@ -11,7 +11,7 @@ module Rpush
 
       batch_deliveries true
       dispatcher :apns_tcp, host: proc { |app| HOSTS[app.environment.to_sym] }
-      loops Rpush::Daemon::Apns::FeedbackReceiver, if: -> { !Rpush.config.push }
+      loops Rpush::Daemon::Apns::FeedbackReceiver, if: -> { Rpush.config.apns.feedback_receiver.enabled && !Rpush.config.push }
     end
   end
 end

data/lib/rpush/daemon/apns/feedback_receiver.rb

@@ -19,19 +19,18 @@ module Rpush
           @host, @port = HOSTS[@app.environment.to_sym]
           @certificate = app.certificate
           @password = app.password
-          @interruptible_sleep = InterruptibleSleep.new(Rpush.config.feedback_poll)
+          @interruptible_sleep = InterruptibleSleep.new
         end
 
         def start
           return if Rpush.config.push
           Rpush.logger.info("[#{@app.name}] Starting feedback receiver... ", true)
-          @interruptible_sleep.start
 
           @thread = Thread.new do
             loop do
               break if @stop
               check_for_feedback
-              @interruptible_sleep.sleep
+              @interruptible_sleep.sleep(Rpush.config.apns.feedback_receiver.frequency)
             end
 
             Rpush::Daemon.store.release_connection

data/lib/rpush/daemon/dispatcher/apns_tcp.rb

@@ -63,7 +63,7 @@ module Rpush
             # On Linux, select returns nil from a dropped connection.
             # On OS X, Errno::EBADF is raised following a Errno::EADDRNOTAVAIL from the write call.
             return unless @connection.select(SELECT_TIMEOUT)
-          rescue SystemCallError
+          rescue SystemCallError, IOError
             # Connection closed.
             return
           end
@@ -93,6 +93,7 @@ module Rpush
         end
 
         def handle_error(code, notification_id)
+          notification_id = Rpush::Daemon.store.translate_integer_notification_id(notification_id)
           failed_pos = delivered_buffer.index(notification_id)
           description = APNS_ERRORS[code.to_i] || "Unknown error code #{code.inspect}. Possible Rpush bug?"
           log_error(description + " (#{code})")

data/lib/rpush/daemon/feeder.rb

@@ -21,7 +21,7 @@ module Rpush
       end
 
       def self.wakeup
-        interruptible_sleeper.wakeup
+        interruptible_sleeper.stop
       end
 
       class << self
@@ -35,8 +35,8 @@ module Rpush
       def self.feed_forever
         loop do
           enqueue_notifications
-          interruptible_sleeper.sleep
-          break if should_stop
+          interruptible_sleeper.sleep(Rpush.config.push_poll)
+          return if should_stop
         end
       end
 
@@ -51,10 +51,7 @@ module Rpush
       end
 
       def self.interruptible_sleeper
-        return @interruptible_sleeper if @interruptible_sleeper
-        @interruptible_sleeper = InterruptibleSleep.new(Rpush.config.push_poll)
-        @interruptible_sleeper.start
-        @interruptible_sleeper
+        @interruptible_sleeper ||= InterruptibleSleep.new
       end
     end
   end

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

@@ -100,7 +100,7 @@ module Rpush
         end
 
         def create_new_notification(response, unavailable_idxs)
-          attrs = @notification.attributes.slice('app_id', 'collapse_key', 'delay_while_idle')
+          attrs = { 'app_id' => @notification.app_id, 'collapse_key' => @notification.collapse_key, 'delay_while_idle' => @notification.delay_while_idle }
           registration_ids = @notification.registration_ids.values_at(*unavailable_idxs)
           Rpush::Daemon.store.create_gcm_notification(attrs, @notification.data,
                                                       registration_ids, deliver_after_header(response), @notification.app)

data/lib/rpush/daemon/interruptible_sleep.rb

@@ -3,60 +3,15 @@ require 'monitor'
 module Rpush
   module Daemon
     class InterruptibleSleep
-      def initialize(duration)
-        @duration = duration
-        @stop = false
-
-        @wakeup_obj = Object.new
-        @wakeup_obj.extend(MonitorMixin)
-        @wakeup_condition = @wakeup_obj.new_cond
-
-        @sleep_obj = Object.new
-        @sleep_obj.extend(MonitorMixin)
-        @sleep_condition = @sleep_obj.new_cond
-      end
-
-      def sleep
-        return if @stop
-        goto_sleep
-        wait_for_wakeup
-      end
-
-      def start
-        @stop = false
-
-        @thread = Thread.new do
-          loop do
-            wait_for_sleeper
-            break if @stop
-            Kernel.sleep(@duration)
-            wakeup
-          end
-        end
+      def sleep(duration)
+        @thread = Thread.new { Kernel.sleep duration }
+        Thread.pass
+        @thread.join
       end
 
       def stop
-        @stop = true
-        wakeup
         @thread.kill if @thread
-      end
-
-      def wakeup
-        @wakeup_obj.synchronize { @wakeup_condition.signal }
-      end
-
-      private
-
-      def goto_sleep
-        @sleep_obj.synchronize { @sleep_condition.signal }
-      end
-
-      def wait_for_wakeup
-        @wakeup_obj.synchronize { @wakeup_condition.wait(@duration * 2) }
-      end
-
-      def wait_for_sleeper
-        @sleep_obj.synchronize { @sleep_condition.wait }
+      rescue StandardError # rubocop:disable Lint/HandleExceptions
       end
     end
   end

data/lib/rpush/daemon/proc_title.rb

@@ -2,7 +2,8 @@ module Rpush
   module Daemon
     class ProcTitle
       def self.update
-        $0 = proc_title
+        return if Rpush.config.embedded || Rpush.config.push
+        Process.respond_to?(:setproctitle) ? Process.setproctitle(proc_title) : $0 = proc_title
       end
 
       def self.proc_title

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

@@ -169,6 +169,10 @@ module Rpush
           ready_for_delivery.count
         end
 
+        def translate_integer_notification_id(id)
+          id
+        end
+
         private
 
         def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists

data/lib/rpush/daemon/store/interface.rb

@@ -8,7 +8,7 @@ module Rpush
                           :create_gcm_notification, :create_adm_notification, :update_app,
                           :update_notification, :release_connection,
                           :all_apps, :app, :mark_ids_failed, :mark_ids_retryable,
-                          :reopen_log, :pending_delivery_count]
+                          :reopen_log, :pending_delivery_count, :translate_integer_notification_id]
 
         def self.check(klass)
           missing = PUBLIC_METHODS - klass.instance_methods.map(&:to_sym)

data/lib/rpush/daemon/store/mongoid.rb

@@ -0,0 +1,157 @@
+module Rpush
+  module Daemon
+    module Store
+      class Mongoid
+        DEFAULT_MARK_OPTIONS = { persist: true }
+
+        def app(app_id)
+          Rpush::Client::Mongoid::App.find(app_id)
+        end
+
+        def all_apps
+          Rpush::Client::Mongoid::App.all
+        end
+
+        def deliverable_notifications(limit)
+          relation = ready_for_delivery.limit(limit)
+          claim_notifications(relation)
+        end
+
+        def mark_delivered(notification, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = true
+          notification.delivered_at = time
+          notification.save!(validate: false) if opts[:persist]
+        end
+
+        def mark_batch_delivered(notifications)
+          return if notifications.empty?
+
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            mark_delivered(n, now, persist: false)
+            ids << n.id
+          end
+          Rpush::Client::Mongoid::Notification.in(id: ids).update_all(processing: false, delivered: true, delivered_at: now)
+        end
+
+        def mark_failed(notification, code, description, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = false
+          notification.delivered_at = nil
+          notification.failed = true
+          notification.failed_at = time
+          notification.error_code = code
+          notification.error_description = description
+          notification.save!(validate: false) if opts[:persist]
+        end
+
+        def mark_batch_failed(notifications, code, description)
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            mark_failed(n, code, description, now, persist: false)
+            ids << n.id
+          end
+          mark_ids_failed(ids, code, description, now)
+        end
+
+        def mark_ids_failed(ids, code, description, time)
+          return if ids.empty?
+
+          Rpush::Client::Mongoid::Notification.in(id: ids).update_all(processing: false, delivered: false, delivered_at: nil, failed: true, failed_at: time, error_code: code, error_description: description)
+        end
+
+        def mark_retryable(notification, deliver_after, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = false
+          notification.delivered_at = nil
+          notification.failed = false
+          notification.failed_at = nil
+          notification.retries += 1
+          notification.deliver_after = deliver_after
+
+          return unless opts[:persist]
+
+          notification.save!(validate: false)
+        end
+
+        def mark_batch_retryable(notifications, deliver_after)
+          ids = []
+          notifications.each do |n|
+            mark_retryable(n, deliver_after, persist: false)
+            ids << n.id
+          end
+          mark_ids_retryable(ids, deliver_after)
+        end
+
+        def mark_ids_retryable(ids, deliver_after)
+          return if ids.empty?
+
+          Rpush::Client::Mongoid::Notification.in(id: ids).update_all(processing: false, delivered: false, delivered_at: nil, failed: false, failed_at: nil, deliver_after: deliver_after, '$inc' => { retries: 1 })
+        end
+
+        def create_apns_feedback(failed_at, device_token, app)
+          Rpush::Client::Mongoid::Apns::Feedback.create!(failed_at: failed_at, device_token: device_token, app: app)
+        end
+
+        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists
+          notification = Rpush::Client::Mongoid::Gcm::Notification.new
+          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        end
+
+        def create_adm_notification(attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists
+          notification = Rpush::Client::Mongoid::Adm::Notification.new
+          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        end
+
+        def update_app(app)
+          app.save!
+        end
+
+        def update_notification(notification)
+          notification.save!
+        end
+
+        def release_connection
+        end
+
+        def reopen_log
+        end
+
+        def pending_delivery_count
+          ready_for_delivery.count
+        end
+
+        def translate_integer_notification_id(id)
+          Rpush::Client::Mongoid::Notification.find_by(integer_id: id).id
+        end
+
+        private
+
+        def ready_for_delivery
+          Rpush::Client::Mongoid::Notification.where(processing: false, delivered: false, failed: false).or({ deliver_after: nil }, :deliver_after.lt => Time.now)
+        end
+
+        def claim_notifications(relation)
+          ids = relation.map(:id)
+          relation.where('$isolated' => 1).in(id: ids).update_all(processing: true, processing_pid: Process.pid)
+          Rpush::Client::Mongoid::Notification.where(processing: true, processing_pid: Process.pid).in(id: ids).asc('created_at')
+        end
+
+        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists
+          notification.assign_attributes(attrs)
+          notification.data = data
+          notification.registration_ids = registration_ids
+          notification.deliver_after = deliver_after
+          notification.app = app
+          notification.save!
+          notification
+        end
+      end
+    end
+  end
+end
+
+Rpush::Daemon::Store::Interface.check(Rpush::Daemon::Store::Mongoid)

data/lib/rpush/daemon/store/redis.rb

@@ -49,7 +49,7 @@ module Rpush
         end
 
         def mark_ids_failed(ids, code, description, time)
-          ids.each { |id| mark_failed(Rpush::Client::Redis::Apns::Notification.find(id), code, description, time) }
+          ids.each { |id| mark_failed(Rpush::Client::Redis::Notification.find(id), code, description, time) }
         end
 
         def mark_retryable(notification, deliver_after, opts = {})
@@ -75,7 +75,7 @@ module Rpush
         end
 
         def mark_ids_retryable(ids, deliver_after)
-          ids.each { |id| mark_retryable(Rpush::Client::Redis::Apns::Notification.find(id), deliver_after) }
+          ids.each { |id| mark_retryable(Rpush::Client::Redis::Notification.find(id), deliver_after) }
         end
 
         def create_apns_feedback(failed_at, device_token, app)
@@ -115,6 +115,10 @@ module Rpush
           end
         end
 
+        def translate_integer_notification_id(id)
+          id
+        end
+
         private
 
         def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists

data/lib/rpush/deprecatable.rb

@@ -14,8 +14,7 @@ module Rpush
         warning << " #{msg}" if msg
         class_eval(<<-RUBY, __FILE__, __LINE__)
           def #{method_name}(*args, &blk)
-            trace = "\n\nCALLED FROM:\n" + caller.join("\n")
-            Rpush::Deprecation.warn(#{warning.inspect} + trace)
+            Rpush::Deprecation.warn_with_backtrace(#{warning.inspect})
             #{method_name_as_var}_without_warning(*args, &blk)
           end
         RUBY

data/lib/rpush/deprecation.rb

@@ -16,5 +16,11 @@ module Rpush
       return if Rpush::Deprecation.muted?
       STDERR.puts "DEPRECATION WARNING: #{msg}"
     end
+
+    def self.warn_with_backtrace(msg)
+      return if Rpush::Deprecation.muted?
+      trace = "\n\nCALLED FROM:\n" + caller.join("\n")
+      warn(msg + trace)
+    end
   end
 end

data/lib/rpush/embed.rb

@@ -2,6 +2,11 @@ module Rpush
   def self.embed(options = {})
     require 'rpush/daemon'
 
+    unless options.empty?
+      warning = "Passing configuration options directly to Rpush.embed is deprecated and will be removed from Rpush 2.5.0. Please setup configuration using Rpush.configure { |config| ... } before calling embed."
+      Rpush::Deprecation.warn_with_backtrace(warning)
+    end
+
     if @embed_thread
       STDERR.puts 'Rpush.embed can only be run once inside this process.'
     end

data/lib/rpush/logger.rb

@@ -3,12 +3,9 @@ module Rpush
     attr_reader :internal_logger
 
     def initialize
-      if Rpush.config.logger
-        @internal_logger = Rpush.config.logger
-      else
-        @internal_logger = setup_logger(open_logfile)
-      end
-    rescue Errno::ENOENT, Errno::EPERM => e
+      @internal_logger = Rpush.config.logger || setup_logger(open_logfile)
+      @internal_logger.level = Rpush.config.log_level
+    rescue SystemCallError => e
       @internal_logger = nil
       error(e)
       error('Logging disabled.')
@@ -46,11 +43,11 @@ module Rpush
 
     def setup_logger(log)
       if ActiveSupport.const_defined?('BufferedLogger')
-        logger = ActiveSupport::BufferedLogger.new(log, Rpush.config.log_level)
+        logger = ActiveSupport::BufferedLogger.new(log)
         logger.auto_flushing = auto_flushing
         logger
       else
-        ActiveSupport::Logger.new(log, Rpush.config.log_level)
+        ActiveSupport::Logger.new(log)
       end
     end