rpush 1.0.0

data/lib/rpush/daemon/apns.rb

@@ -0,0 +1,16 @@
+module Rpush
+  module Daemon
+    module Apns
+      extend ServiceConfigMethods
+
+      HOSTS = {
+        :production  => ['gateway.push.apple.com', 2195],
+        :development => ['gateway.sandbox.push.apple.com', 2195], # deprecated
+        :sandbox     => ['gateway.sandbox.push.apple.com', 2195]
+      }
+
+      dispatcher :tcp, :host => Proc.new { |app| HOSTS[app.environment.to_sym] }
+      loops Rpush::Daemon::Apns::FeedbackReceiver
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Rpush
+  module Apns
+    class CertificateExpiredError < StandardError
+      attr_reader :app, :time
+
+      def initialize(app, time)
+        @app = app
+        @time = time
+      end
+
+      def to_s
+        message
+      end
+
+      def message
+        "#{app.name} certificate expired at #{time}."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Rpush
+  module Daemon
+    module Apns
+      class Delivery < Rpush::Daemon::Delivery
+        SELECT_TIMEOUT = 0.2
+        ERROR_TUPLE_BYTES = 6
+        APN_ERRORS = {
+          1 => "Processing error",
+          2 => "Missing device token",
+          3 => "Missing topic",
+          4 => "Missing payload",
+          5 => "Missing token size",
+          6 => "Missing topic size",
+          7 => "Missing payload size",
+          8 => "Invalid token",
+          255 => "None (unknown error)"
+        }
+
+        def initialize(app, conneciton, notification, batch)
+          @app = app
+          @connection = conneciton
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          begin
+            @connection.write(@notification.to_binary)
+            check_for_error if Rpush.config.check_for_errors
+            mark_delivered
+            log_info("#{@notification.id} sent to #{@notification.device_token}")
+          rescue Rpush::DeliveryError, Rpush::Apns::DisconnectionError => error
+            mark_failed(error.code, error.description)
+            raise
+          end
+        end
+
+        protected
+
+        def check_for_error
+          if @connection.select(SELECT_TIMEOUT)
+            error = nil
+
+            if tuple = @connection.read(ERROR_TUPLE_BYTES)
+              _, code, notification_id = tuple.unpack("ccN")
+
+              description = APN_ERRORS[code.to_i] || "Unknown error. Possible Rpush bug?"
+              error = Rpush::DeliveryError.new(code, notification_id, description)
+            else
+              error = Rpush::Apns::DisconnectionError.new
+            end
+
+            begin
+              log_error("Error received, reconnecting...")
+              @connection.reconnect
+            ensure
+              raise error if error
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Rpush
+  module Apns
+    class DisconnectionError < StandardError
+      attr_reader :code, :description
+
+      def initialize
+        @code = nil
+        @description = "APNs disconnected without returning an error."
+      end
+
+      def to_s
+        message
+      end
+
+      def message
+        "The APNs disconnected without returning an error. This may indicate you are using an invalid certificate for the host."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Rpush
+  module Daemon
+    module Apns
+      class FeedbackReceiver
+        include Reflectable
+        include Loggable
+
+        TUPLE_BYTES = 38
+        HOSTS = {
+          :production  => ['feedback.push.apple.com', 2196],
+          :development => ['feedback.sandbox.push.apple.com', 2196], # deprecated
+          :sandbox     => ['feedback.sandbox.push.apple.com', 2196]
+        }
+
+        def initialize(app)
+          @app = app
+          @host, @port = HOSTS[@app.environment.to_sym]
+          @poll = Rpush.config.feedback_poll
+          @certificate = app.certificate
+          @password = app.password
+          @interruptible_sleep = InterruptibleSleep.new
+        end
+
+        def start
+          return if Rpush.config.push
+
+          @thread = Thread.new do
+            loop do
+              break if @stop
+              check_for_feedback
+              @interruptible_sleep.sleep @poll
+            end
+
+            Rpush::Daemon.store.release_connection
+          end
+        end
+
+        def stop
+          @stop = true
+          @interruptible_sleep.interrupt_sleep
+          @thread.join if @thread
+        end
+
+        def check_for_feedback
+          connection = nil
+          begin
+            connection = Rpush::Daemon::TcpConnection.new(@app, @host, @port)
+            connection.connect
+
+            while tuple = connection.read(TUPLE_BYTES)
+              timestamp, device_token = parse_tuple(tuple)
+              create_feedback(timestamp, device_token)
+            end
+          rescue StandardError => e
+            log_error(e)
+            reflect(:error, e)
+          ensure
+            connection.close if connection
+          end
+        end
+
+        protected
+
+        def parse_tuple(tuple)
+          failed_at, _, device_token = tuple.unpack("N1n1H*")
+          [Time.at(failed_at).utc, device_token]
+        end
+
+        def create_feedback(failed_at, device_token)
+          formatted_failed_at = failed_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+          log_info("[FeedbackReceiver] Delivery failed at #{formatted_failed_at} for #{device_token}.")
+
+          feedback = Rpush::Daemon.store.create_apns_feedback(failed_at, device_token, @app)
+          reflect(:apns_feedback, feedback)
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/app_runner.rb

@@ -0,0 +1,187 @@
+module Rpush
+  module Daemon
+    class AppRunner
+      extend Reflectable
+      include Reflectable
+      include Loggable
+
+      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
+            Rpush.logger.error("No such app '#{app_id}' for notifications #{batch.describe}.")
+          end
+        end
+      end
+
+      def self.sync
+        apps = Rpush::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(app)
+          begin
+            runner.start
+            runners[app.id] = runner
+          rescue StandardError => e
+            Rpush.logger.error("[#{app.name}] Exception raised during startup. Notifications will not be delivered for this app.")
+            Rpush.logger.error(e)
+            reflect(:error, e)
+          end
+        end
+      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
+        @loops = []
+      end
+
+      def start
+        app.connections.times { dispatchers.push(new_dispatcher_loop) }
+        start_loops
+        log_info("Started, #{dispatchers_str}.")
+      end
+
+      def stop
+        dispatchers.stop
+        stop_loops
+      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 = dispatchers.size - app.connections
+        return if diff == 0
+        if diff > 0
+          decrement_dispatchers(diff)
+          log_info("Stopped #{dispatchers_str(diff)}. #{dispatchers_str} running.")
+        else
+          increment_dispatchers(diff.abs)
+          log_info("Started #{dispatchers_str(diff)}. #{dispatchers_str} running.")
+        end
+      end
+
+      def decrement_dispatchers(num)
+        num.times { dispatchers.pop }
+      end
+
+      def increment_dispatchers(num)
+        num.times { dispatchers.push(new_dispatcher_loop) }
+      end
+
+      def debug
+        Rpush.logger.info <<-EOS
+
+#{@app.name}:
+  dispatchers: #{num_dispatchers}
+  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_dispatchers
+        dispatchers.size
+      end
+
+      protected
+
+      def start_loops
+        service_module.loops.each do |loop_class|
+          instance = loop_class.new(@app)
+          instance.start
+          @loops << instance
+        end
+      end
+
+      def stop_loops
+        @loops.map(&:stop)
+        @loops = []
+      end
+
+      def new_dispatcher_loop
+        dispatcher = service_module.new_dispatcher(@app)
+        dispatcher_loop = Rpush::Daemon::DispatcherLoop.new(queue, dispatcher)
+        dispatcher_loop.start
+        dispatcher_loop
+      end
+
+      def service_module
+        return @service_module if defined? @service_module
+        @service_module = "Rpush::Daemon::#{@app.service_name.camelize}".constantize
+      end
+
+      def queue
+        @queue ||= Queue.new
+      end
+
+      def dispatchers
+        @dispatchers ||= Rpush::Daemon::DispatcherLoopCollection.new
+      end
+
+      def dispatchers_str(count = app.connections)
+        count = count.abs
+        str = count == 1 ? 'dispatcher' : 'dispatchers'
+        "#{count} #{str}"
+      end
+    end
+  end
+end

data/lib/rpush/daemon/batch.rb

@@ -0,0 +1,115 @@
+module Rpush
+  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 Rpush.config.batch_storage_updates
+          retryable[deliver_after] ||= []
+          retryable[deliver_after] << notification
+          Rpush::Daemon.store.mark_retryable(notification, deliver_after, :persist => false)
+        else
+          Rpush::Daemon.store.mark_retryable(notification, deliver_after)
+          reflect(:notification_will_retry, notification)
+        end
+      end
+
+      def mark_delivered(notification)
+        if Rpush.config.batch_storage_updates
+          delivered << notification
+          Rpush::Daemon.store.mark_delivered(notification, Time.now, :persist => false)
+        else
+          Rpush::Daemon.store.mark_delivered(notification, Time.now)
+          reflect(:notification_delivered, notification)
+        end
+      end
+
+      def mark_failed(notification, code, description)
+        if Rpush.config.batch_storage_updates
+          key = [code, description]
+          failed[key] ||= []
+          failed[key] << notification
+          Rpush::Daemon.store.mark_failed(notification, code, description, Time.now, :persist => false)
+        else
+          Rpush::Daemon.store.mark_failed(notification, code, description, Time.now)
+          reflect(:notification_failed, notification)
+        end
+      end
+
+      def notification_dispatched
+        @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
+            Rpush.logger.error(e)
+            reflect(:error, e)
+          end
+        end
+
+        notifications.clear
+        @complete = true
+      end
+
+      def complete_delivered
+        Rpush::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|
+          Rpush::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|
+          Rpush::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