rapns_rails_2 3.4.3

data/lib/rapns/daemon/app_runner.rb

@@ -0,0 +1,179 @@
+module Rapns
+  module Daemon
+    class AppRunner
+      extend Reflectable
+      include Reflectable
+
+      class << self
+        attr_reader :runners
+      end
+
+      @runners = {}
+
+      def self.enqueue(notifications)
+        notifications.group_by(&:app_id).each do |app_id, group|
+          batch = Batch.new(group)
+          if app = runners[app_id]
+            app.enqueue(batch)
+          else
+            Rapns.logger.error("No such app '#{app_id}' for notifications #{batch.describe}.")
+          end
+        end
+      end
+
+      def self.sync
+        apps = Rapns::App.all
+        apps.each { |app| sync_app(app) }
+        removed = runners.keys - apps.map(&:id)
+        removed.each { |app_id| runners.delete(app_id).stop }
+      end
+
+      def self.sync_app(app)
+        if runners[app.id]
+          runners[app.id].sync(app)
+        else
+          runner = new_runner(app)
+          begin
+            runner.start
+            runners[app.id] = runner
+          rescue StandardError => e
+            Rapns.logger.error("[#{app.name}] Exception raised during startup. Notifications will not be delivered for this app.")
+            Rapns.logger.error(e)
+            reflect(:error, e)
+          end
+        end
+      end
+
+      def self.new_runner(app)
+        type = app.class.parent.name.demodulize
+        "Rapns::Daemon::#{type}::AppRunner".constantize.new(app)
+      end
+
+      def self.stop
+        runners.values.map(&:stop)
+        runners.clear
+      end
+
+      def self.debug
+        runners.values.map(&:debug)
+      end
+
+      def self.idle
+        runners.values.select(&:idle?)
+      end
+
+      def self.wait
+        sleep 0.1 while !runners.values.all?(&:idle?)
+      end
+
+      attr_reader :app
+      attr_accessor :batch
+
+      def initialize(app)
+        @app = app
+      end
+
+      def before_start; end
+      def after_start; end
+      def before_stop; end
+      def after_stop; end
+
+      def start
+        before_start
+        app.connections.times { handlers.push(start_handler) }
+        after_start
+        Rapns.logger.info("[#{app.name}] Started, #{handlers_str}.")
+      end
+
+      def stop
+        before_stop
+        handlers.stop
+        after_stop
+      end
+
+      def enqueue(batch)
+        self.batch = batch
+        batch.notifications.each do |notification|
+          queue.push([notification, batch])
+          reflect(:notification_enqueued, notification)
+        end
+      end
+
+      def sync(app)
+        @app = app
+        diff = handlers.size - app.connections
+        return if diff == 0
+        if diff > 0
+          decrement_handlers(diff)
+          Rapns.logger.info("[#{app.name}] Stopped #{handlers_str(diff)}. #{handlers_str} running.")
+        else
+          increment_handlers(diff.abs)
+          Rapns.logger.info("[#{app.name}] Started #{handlers_str(diff)}. #{handlers_str} running.")
+        end
+      end
+
+      def decrement_handlers(num)
+        num.times { handlers.pop }
+      end
+
+      def increment_handlers(num)
+        num.times { handlers.push(start_handler) }
+      end
+
+      def debug
+        Rapns.logger.info <<-EOS
+
+#{@app.name}:
+  handlers: #{num_handlers}
+  queued: #{queue_size}
+  batch size: #{batch_size}
+  batch processed: #{batch_processed}
+  idle: #{idle?}
+        EOS
+      end
+
+      def idle?
+        batch ? batch.complete? : true
+      end
+
+      def queue_size
+        queue.size
+      end
+
+      def batch_size
+        batch ? batch.num_notifications : 0
+      end
+
+      def batch_processed
+        batch ? batch.num_processed : 0
+      end
+
+      def num_handlers
+        handlers.size
+      end
+
+      protected
+
+      def start_handler
+        handler = new_delivery_handler
+        handler.queue = queue
+        handler.start
+        handler
+      end
+
+      def queue
+        @queue ||= Queue.new
+      end
+
+      def handlers
+        @handlers ||= Rapns::Daemon::DeliveryHandlerCollection.new
+      end
+
+      def handlers_str(count = app.connections)
+        count = count.abs
+        str = count == 1 ? 'handler' : 'handlers'
+        "#{count} #{str}"
+      end
+    end
+  end
+end

data/lib/rapns/daemon/batch.rb

@@ -0,0 +1,112 @@
+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)
+          reflect(:notification_will_retry, notification)
+        end
+      end
+
+      def mark_delivered(notification)
+        if Rapns.config.batch_storage_updates
+          delivered << notification
+        else
+          Rapns::Daemon.store.mark_delivered(notification)
+          reflect(:notification_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)
+          reflect(:notification_failed, notification)
+        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.each do |notification|
+          reflect(:notification_delivered, notification)
+        end
+        delivered.clear
+      end
+
+      def complete_failed
+        failed.each do |(code, description), notifications|
+          Rapns::Daemon.store.mark_batch_failed(notifications, code, description)
+          notifications.each do |notification|
+            reflect(:notification_failed, notification)
+          end
+        end
+        failed.clear
+      end
+
+      def complete_retried
+        retryable.each do |deliver_after, notifications|
+          Rapns::Daemon.store.mark_batch_retryable(notifications, deliver_after)
+          notifications.each do |notification|
+            reflect(:notification_will_retry, notification)
+          end
+        end
+        retryable.clear
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery.rb

@@ -0,0 +1,23 @@
+module Rapns
+  module Daemon
+    class Delivery
+      include Reflectable
+
+      def mark_retryable(notification, deliver_after)
+        @batch.mark_retryable(notification, deliver_after)
+      end
+
+      def mark_retryable_exponential(notification)
+        mark_retryable(notification, Time.now + 2 ** (notification.retries + 1))
+      end
+
+      def mark_delivered
+        @batch.mark_delivered(@notification)
+      end
+
+      def mark_failed(code, description)
+        @batch.mark_failed(@notification, code, description)
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery_error.rb

@@ -0,0 +1,19 @@
+module Rapns
+  class DeliveryError < StandardError
+    attr_reader :code, :description
+
+    def initialize(code, notification_id, description)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      "Unable to deliver notification #{@notification_id}, received error #{@code} (#{@description})"
+    end
+  end
+end

data/lib/rapns/daemon/delivery_handler.rb

@@ -0,0 +1,52 @@
+module Rapns
+  module Daemon
+    class DeliveryHandler
+      include Reflectable
+
+      WAKEUP = :wakeup
+
+      attr_accessor :queue
+
+      def start
+        @thread = Thread.new do
+          loop do
+            handle_next_notification
+            break if @stop
+          end
+        end
+      end
+
+      def stop
+        @stop = true
+      end
+
+      def wakeup
+        queue.push(WAKEUP) if @thread
+      end
+
+      def wait
+        @thread.join if @thread
+        stopped
+      end
+
+      protected
+
+      def stopped
+      end
+
+      def handle_next_notification
+        notification, batch = queue.pop
+        return if notification == WAKEUP
+
+        begin
+          deliver(notification, batch)
+        rescue StandardError => e
+          Rapns.logger.error(e)
+          reflect(:error, e)
+        ensure
+          batch.notification_processed
+        end
+      end
+    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

@@ -0,0 +1,65 @@
+module Rapns
+  module Daemon
+    class Feeder
+      extend Reflectable
+
+      def self.start
+        @stop = false
+
+        if Rapns.config.embedded
+          Thread.new { feed_forever }
+        elsif Rapns.config.push
+          enqueue_notifications
+        else
+          feed_forever
+        end
+      end
+
+      def self.stop
+        @stop = true
+        interrupt_sleep
+      end
+
+      def self.interrupt_sleep
+        interruptible_sleeper.interrupt_sleep
+      end
+
+      protected
+
+      def self.feed_forever
+        loop do
+          enqueue_notifications
+          interruptible_sleeper.sleep(Rapns.config.push_poll)
+          break if stop?
+        end
+      end
+
+      def self.stop?
+        @stop
+      end
+
+      def self.enqueue_notifications
+        begin
+          idle = Rapns::Daemon::AppRunner.idle.map(&:app)
+          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)
+        end
+      end
+
+      def self.interruptible_sleeper
+        unless @interruptible_sleeper
+          @interruptible_sleeper = InterruptibleSleep.new
+          if Rapns.config.udp_wake_host && Rapns.config.udp_wake_port
+            @interruptible_sleeper.enable_wake_on_udp Rapns.config.udp_wake_host, Rapns.config.udp_wake_port
+          end
+        end
+        @interruptible_sleeper
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Rapns
+  module Daemon
+    module Gcm
+      class AppRunner < Rapns::Daemon::AppRunner
+        protected
+
+        def new_delivery_handler
+          DeliveryHandler.new(app)
+        end
+      end
+    end
+  end
+end