rapns 2.0.5 → 3.0.0.beta.1

data/lib/rapns/daemon/app_runner.rb

@@ -1,130 +1,129 @@
 module Rapns
-	module Daemon
+  module Daemon
     class AppRunner
-      HOSTS = {
-        :production => {
-          :push => ['gateway.push.apple.com', 2195],
-          :feedback => ['feedback.push.apple.com', 2196]
-        },
-        :development => {
-          :push => ['gateway.sandbox.push.apple.com', 2195],
-          :feedback => ['feedback.sandbox.push.apple.com', 2196]
-        }
-      }
-
       class << self
-        attr_reader :all
+        attr_reader :runners # TODO: Needed?
       end
 
-      @all = {}
-
-      def self.ready
-        ready = []
-        @all.each { |app, runner| ready << app if runner.ready? }
-        ready
-      end
+      @runners = {}
 
-      def self.deliver(notification)
-        if app = @all[notification.app]
-          app.deliver(notification)
+      def self.enqueue(notification)
+        if app = @runners[notification.app_id]
+          app.enqueue(notification)
         else
-          Rapns::Daemon.logger.error("No such app '#{notification.app}' for notification #{notification.id}.")
+          Rapns::Daemon.logger.error("No such app '#{notification.app_id}' for notification #{notification.id}.")
         end
       end
 
       def self.sync
         apps = Rapns::App.all
-        apps.each do |app|
-          if @all[app.key]
-            @all[app.key].sync(app)
-          else
-            push_host, push_port = HOSTS[app.environment.to_sym][:push]
-            feedback_host, feedback_port = HOSTS[app.environment.to_sym][:feedback]
-            feedback_poll = Rapns::Daemon.config.feedback_poll
-            runner = AppRunner.new(app, push_host, push_port, feedback_host, feedback_port, feedback_poll)
-            begin
-              runner.start
-              @all[app.key] = runner
-            rescue
-              Rapns::Daemon.logger.info("[App:#{app.key}] failed to start. No notifications will be sent.")
-            end
+        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::Daemon.logger.error("[#{app.name}] Exception raised during startup. Notifications will not be delivered for this app.")
+            Rapns::Daemon.logger.error(e)
           end
         end
+      end
 
-        removed = @all.keys - apps.map(&:key)
-        removed.each { |key| @all.delete(key).stop }
+      def self.new_runner(app)
+        type = app.class.parent.name.demodulize
+        "Rapns::Daemon::#{type}::AppRunner".constantize.new(app)
       end
 
       def self.stop
-        @all.values.map(&:stop)
+        @runners.values.map(&:stop)
       end
 
       def self.debug
-        @all.values.map(&:debug)
+        @runners.values.map(&:debug)
+      end
+
+      def self.idle
+        runners.values.select { |runner| runner.idle? }
       end
 
-      def initialize(app, push_host, push_port, feedback_host, feedback_port, feedback_poll)
+      attr_reader :app
+
+      def initialize(app)
         @app = app
-        @push_host = push_host
-        @push_port = push_port
-        @feedback_host = feedback_host
-        @feedback_port = feedback_port
-        @feedback_poll = feedback_poll
+      end
+
+      def new_delivery_handler
+        raise NotImplementedError
+      end
 
-        @queue = DeliveryQueue.new
-        @feedback_receiver = nil
-        @handlers = []
+      def started
       end
 
+      def stopped
+      end
 
       def start
-        begin
-          @feedback_receiver = FeedbackReceiver.new(@app.key, @feedback_host, @feedback_port, @feedback_poll, @app.certificate, @app.password)
-          @feedback_receiver.start
-
-          @app.connections.times { @handlers << start_handler }
-        rescue OpenSSL::SSL::SSLError
-          # these errors mean that a connection is not possible, raise back to caller
-          raise
-        rescue StandardError => e
-          Rapns::Daemon.logger.error(e)
-        end
+        app.connections.times { handlers << start_handler }
+        started
       end
 
-      def deliver(notification)
-        @queue.push(notification)
+      def stop
+        handlers.map(&:stop)
+        stopped
       end
 
-      def stop
-        @handlers.map(&:stop)
-        @feedback_receiver.stop if @feedback_receiver
+      def enqueue(notification)
+        queue.push(notification)
       end
 
       def sync(app)
         @app = app
-        diff = @handlers.size - app.connections
+        diff = handlers.size - app.connections
         if diff > 0
-          diff.times { @handlers.pop.stop }
+          diff.times { handlers.pop.stop }
         else
-          diff.abs.times { @handlers << start_handler }
+          diff.abs.times { handlers << start_handler }
         end
       end
 
-      def ready?
-        @queue.notifications_processed?
+      def debug
+        Rapns::Daemon.logger.info <<-EOS
+
+#{@app.name}:
+  handlers: #{handlers.size}
+  queued: #{queue.size}
+  idle: #{idle?}
+        EOS
       end
 
-      def debug
-        Rapns::Daemon.logger.info("\nAppRunner State:\n#{@app.key}:\n  handlers: #{@handlers.size}\n  backlog: #{@queue.size}\n  ready: #{ready?}")
+      def idle?
+        queue.notifications_processed?
       end
 
       protected
 
       def start_handler
-        handler = DeliveryHandler.new(@queue, @app.key, @push_host, @push_port, @app.certificate, @app.password)
+        handler = new_delivery_handler
+        handler.queue = queue
         handler.start
         handler
       end
+
+      def queue
+        @queue ||= Rapns::Daemon::DeliveryQueue.new
+      end
+
+      def handlers
+        @handler ||= []
+      end
     end
-	end
-end
+  end
+end

data/lib/rapns/daemon/database_reconnectable.rb

@@ -23,11 +23,11 @@ module Rapns
       end
 
       def database_connection_lost
-        Rapns::Daemon.logger.warn("[#{name}] Lost connection to database, reconnecting...")
+        Rapns::Daemon.logger.warn("Lost connection to database, reconnecting...")
         attempts = 0
         loop do
           begin
-            Rapns::Daemon.logger.warn("[#{name}] Attempt #{attempts += 1}")
+            Rapns::Daemon.logger.warn("Attempt #{attempts += 1}")
             reconnect_database
             check_database_is_connected
             break
@@ -36,7 +36,7 @@ module Rapns
             sleep_to_avoid_thrashing
           end
         end
-        Rapns::Daemon.logger.warn("[#{name}] Database reconnected")
+        Rapns::Daemon.logger.warn("Database reconnected")
       end
 
       def reconnect_database

data/lib/rapns/daemon/delivery.rb

@@ -0,0 +1,43 @@
+module Rapns
+  module Daemon
+    class Delivery
+      include DatabaseReconnectable
+
+      def self.perform(*args)
+        new(*args).perform
+      end
+
+      def retry_after(notification, deliver_after)
+        with_database_reconnect_and_retry do
+          notification.retries += 1
+          notification.deliver_after = deliver_after
+          notification.save!(:validate => false)
+        end
+      end
+
+      def retry_exponentially(notification)
+        retry_after(notification, Time.now + 2 ** (notification.retries + 1))
+      end
+
+      def mark_delivered
+        with_database_reconnect_and_retry do
+          @notification.delivered = true
+          @notification.delivered_at = Time.now
+          @notification.save!(:validate => false)
+        end
+      end
+
+      def mark_failed(code, description)
+        with_database_reconnect_and_retry do
+          @notification.delivered = false
+          @notification.delivered_at = nil
+          @notification.failed = true
+          @notification.failed_at = Time.now
+          @notification.error_code = code
+          @notification.error_description = description
+          @notification.save!(:validate => false)
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery_error.rb

@@ -8,8 +8,12 @@ module Rapns
       @description = description
     end
 
+    def to_s
+      message
+    end
+
     def message
-      "Unable to deliver notification #{@notification_id}, received APN error #{@code} (#{@description})"
+      "Unable to deliver notification #{@notification_id}, received error #{@code} (#{@description})"
     end
   end
-end
+end

data/lib/rapns/daemon/delivery_handler.rb

@@ -1,105 +1,39 @@
 module Rapns
   module Daemon
     class DeliveryHandler
-      include DatabaseReconnectable
+      attr_accessor :queue
 
-      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)"
-      }
-
-      attr_reader :name
-
-      def initialize(queue, name, host, port, certificate, password)
-        @queue = queue
-        @name = "DeliveryHandler:#{name}"
-        @connection = Connection.new(@name, host, port, certificate, password)
+      def deliver(notification)
+        raise NotImplementedError
       end
 
       def start
-        @connection.connect
-
         @thread = Thread.new do
           loop do
-            break if @stop
             handle_next_notification
+            break if @stop
           end
         end
       end
 
       def stop
         @stop = true
-        @queue.wakeup(@thread)
-      end
-
-      protected
-
-      def deliver(notification)
-        begin
-          @connection.write(notification.to_binary)
-          check_for_error if Rapns::Daemon.config.check_for_errors
-
-          with_database_reconnect_and_retry do
-            notification.delivered = true
-            notification.delivered_at = Time.now
-            notification.save!(:validate => false)
-          end
-
-          Rapns::Daemon.logger.info("[#{@name}] #{notification.id} sent to #{notification.device_token}")
-        rescue Rapns::DeliveryError, Rapns::DisconnectionError => error
-          handle_delivery_error(notification, error)
-          raise
-        end
-      end
-
-      def handle_delivery_error(notification, error)
-        with_database_reconnect_and_retry do
-          notification.delivered = false
-          notification.delivered_at = nil
-          notification.failed = true
-          notification.failed_at = Time.now
-          notification.error_code = error.code
-          notification.error_description = error.description
-          notification.save!(:validate => false)
+        if @thread
+          queue.wakeup(@thread)
+          @thread.join
         end
+        stopped
       end
 
-      def check_for_error
-        if @connection.select(SELECT_TIMEOUT)
-          error = nil
-
-          if tuple = @connection.read(ERROR_TUPLE_BYTES)
-            cmd, code, notification_id = tuple.unpack("ccN")
-
-            description = APN_ERRORS[code.to_i] || "Unknown error. Possible rapns bug?"
-            error = Rapns::DeliveryError.new(code, notification_id, description)
-          else
-            error = Rapns::DisconnectionError.new
-          end
+      protected
 
-          begin
-            Rapns::Daemon.logger.error("[#{@name}] Error received, reconnecting...")
-            @connection.reconnect
-          ensure
-            raise error if error
-          end
-        end
+      def stopped
       end
 
       def handle_next_notification
         begin
-          notification = @queue.pop
+          notification = queue.pop
         rescue DeliveryQueue::WakeupError
-          @connection.close
           return
         end
 
@@ -108,9 +42,9 @@ module Rapns
         rescue StandardError => e
           Rapns::Daemon.logger.error(e)
         ensure
-          @queue.notification_processed
+          queue.notification_processed
         end
       end
     end
   end
-end
+end

data/lib/rapns/daemon/delivery_queue_18.rb

@@ -1,6 +1,6 @@
 module Rapns
   module Daemon
-  	class DeliveryQueue18
+    class DeliveryQueue18
       def push(obj)
         Thread.critical = true
         @queue.push obj
@@ -39,6 +39,6 @@ module Rapns
           Thread.critical = false
         end
       end
-  	end
+    end
   end
 end

data/lib/rapns/daemon/delivery_queue_19.rb

@@ -1,6 +1,6 @@
 module Rapns
   module Daemon
-  	class DeliveryQueue19
+    class DeliveryQueue19
       def initialize
         @mutex = Mutex.new
       end
@@ -35,8 +35,8 @@ module Rapns
       protected
 
       def synchronize(&blk)
-      	@mutex.synchronize(&blk)
+        @mutex.synchronize(&blk)
       end
-  	end
+    end
   end
 end

data/lib/rapns/daemon/feeder.rb

@@ -10,9 +10,9 @@ module Rapns
 
       def self.start(poll)
         loop do
-          break if @stop
           enqueue_notifications
           interruptible_sleep poll
+          break if @stop
         end
       end
 
@@ -26,10 +26,10 @@ module Rapns
       def self.enqueue_notifications
         begin
           with_database_reconnect_and_retry do
-            ready_apps = Rapns::Daemon::AppRunner.ready
             batch_size = Rapns::Daemon.config.batch_size
-            Rapns::Notification.ready_for_delivery.find_each(:batch_size => batch_size) do |notification|
-              Rapns::Daemon::AppRunner.deliver(notification) if ready_apps.include?(notification.app)
+            idle = Rapns::Daemon::AppRunner.idle.map(&:app)
+            Rapns::Notification.ready_for_delivery.for_apps(idle).limit(batch_size).each do |notification|
+              Rapns::Daemon::AppRunner.enqueue(notification)
             end
           end
         rescue StandardError => e
@@ -38,4 +38,4 @@ module Rapns
       end
     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