rpush 1.0.0 → 2.0.0.beta1

data/lib/rpush/daemon/apns.rb

@@ -4,13 +4,14 @@ module Rpush
       extend ServiceConfigMethods
 
       HOSTS = {
-        :production  => ['gateway.push.apple.com', 2195],
-        :development => ['gateway.sandbox.push.apple.com', 2195], # deprecated
-        :sandbox     => ['gateway.sandbox.push.apple.com', 2195]
+        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
+      batch_deliveries true
+      dispatcher :apns_tcp, host: proc { |app| HOSTS[app.environment.to_sym] }
+      loops Rpush::Daemon::Apns::FeedbackReceiver, if: -> { !Rpush.config.push }
     end
   end
 end

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

@@ -2,60 +2,36 @@ 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)
+        def initialize(app, connection, batch)
           @app = app
-          @connection = conneciton
-          @notification = notification
+          @connection = connection
           @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
+          @connection.write(batch_to_binary)
+          mark_batch_delivered
+          describe_deliveries
+        rescue StandardError => error
+          mark_batch_failed(error)
+          raise
+        ensure
+          @batch.all_processed
         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
+        def batch_to_binary
+          payload = ""
+          @batch.each_notification do |notification|
+            payload << notification.to_binary
+          end
+          payload
+        end
 
-            begin
-              log_error("Error received, reconnecting...")
-              @connection.reconnect
-            ensure
-              raise error if error
-            end
+        def describe_deliveries
+          @batch.each_notification do |notification|
+            log_info("#{notification.id} sent to #{notification.device_token}")
           end
         end
       end

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

@@ -7,28 +7,29 @@ module Rpush
 
         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]
+          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
+          @interruptible_sleep = InterruptibleSleep.new(Rpush.config.feedback_poll)
         end
 
         def start
           return if Rpush.config.push
+          log_info("APNs Feedback Receiver started.")
+          @interruptible_sleep.start
 
           @thread = Thread.new do
             loop do
               break if @stop
               check_for_feedback
-              @interruptible_sleep.sleep @poll
+              @interruptible_sleep.sleep
             end
 
             Rpush::Daemon.store.release_connection
@@ -37,7 +38,7 @@ module Rpush
 
         def stop
           @stop = true
-          @interruptible_sleep.interrupt_sleep
+          @interruptible_sleep.stop
           @thread.join if @thread
         end
 
@@ -46,10 +47,12 @@ module Rpush
           begin
             connection = Rpush::Daemon::TcpConnection.new(@app, @host, @port)
             connection.connect
+            tuple = connection.read(TUPLE_BYTES)
 
-            while tuple = connection.read(TUPLE_BYTES)
+            while tuple
               timestamp, device_token = parse_tuple(tuple)
               create_feedback(timestamp, device_token)
+              tuple = connection.read(TUPLE_BYTES)
             end
           rescue StandardError => e
             log_error(e)

data/lib/rpush/daemon/app_runner.rb

@@ -13,20 +13,18 @@ module Rpush
 
       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
+          sync_app_with_id(app_id) unless runners[app_id]
+          runners[app_id].enqueue(group) if runners[app_id]
         end
+        ProcTitle.update
       end
 
       def self.sync
-        apps = Rpush::App.all
+        apps = Rpush::Daemon.store.all_apps
         apps.each { |app| sync_app(app) }
         removed = runners.keys - apps.map(&:id)
         removed.each { |app_id| runners.delete(app_id).stop }
+        ProcTitle.update
       end
 
       def self.sync_app(app)
@@ -35,8 +33,8 @@ module Rpush
         else
           runner = new(app)
           begin
-            runner.start
             runners[app.id] = runner
+            runner.start
           rescue StandardError => e
             Rpush.logger.error("[#{app.name}] Exception raised during startup. Notifications will not be delivered for this app.")
             Rpush.logger.error(e)
@@ -45,25 +43,28 @@ module Rpush
         end
       end
 
+      def self.sync_app_with_id(app_id)
+        sync_app(Rpush::Daemon.store.app(app_id))
+      end
+
       def self.stop
         runners.values.map(&:stop)
         runners.clear
       end
 
-      def self.debug
-        runners.values.map(&:debug)
+      def self.num_dispatchers
+        runners.values.sum(&:num_dispatcher_loops)
       end
 
-      def self.idle
-        runners.values.select(&:idle?)
+      def self.num_queued
+        runners.values.sum(&:queue_size)
       end
 
-      def self.wait
-        sleep 0.1 while !runners.values.all?(&:idle?)
+      def self.debug
+        runners.values.map(&:debug)
       end
 
       attr_reader :app
-      attr_accessor :batch
 
       def initialize(app)
         @app = app
@@ -71,27 +72,40 @@ module Rpush
       end
 
       def start
-        app.connections.times { dispatchers.push(new_dispatcher_loop) }
+        app.connections.times { dispatcher_loops.push(new_dispatcher_loop) }
         start_loops
         log_info("Started, #{dispatchers_str}.")
       end
 
       def stop
-        dispatchers.stop
+        wait_until_idle
+        stop_dispatcher_loops
         stop_loops
       end
 
-      def enqueue(batch)
-        self.batch = batch
-        batch.notifications.each do |notification|
-          queue.push([notification, batch])
-          reflect(:notification_enqueued, notification)
+      def wait_until_idle
+        sleep 0.5 while queue.size > 0
+      end
+
+      def enqueue(notifications)
+        if service.batch_deliveries?
+          batch_size = (notifications.size / num_dispatcher_loops).ceil
+          notifications.in_groups_of(batch_size, false).each do |batch_notifications|
+            batch = Batch.new(batch_notifications)
+            queue.push(QueuePayload.new(batch))
+          end
+        else
+          batch = Batch.new(notifications)
+          notifications.each do |notification|
+            queue.push(QueuePayload.new(batch, notification))
+            reflect(:notification_enqueued, notification)
+          end
         end
       end
 
       def sync(app)
         @app = app
-        diff = dispatchers.size - app.connections
+        diff = dispatcher_loops.size - app.connections
         return if diff == 0
         if diff > 0
           decrement_dispatchers(diff)
@@ -103,53 +117,41 @@ module Rpush
       end
 
       def decrement_dispatchers(num)
-        num.times { dispatchers.pop }
+        num.times { dispatcher_loops.pop }
       end
 
       def increment_dispatchers(num)
-        num.times { dispatchers.push(new_dispatcher_loop) }
+        num.times { dispatcher_loops.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
+        dispatcher_details = {}
+
+        dispatcher_loops.loops.each_with_index do |dispatcher_loop, i|
+          dispatcher_details[i] = {
+            started_at: dispatcher_loop.started_at.iso8601,
+            dispatched: dispatcher_loop.dispatch_count,
+            thread_status: dispatcher_loop.thread_status
+          }
+        end
 
-      def idle?
-        batch ? batch.complete? : true
+        runner_details = { dispatchers: dispatcher_details, queued: queue_size }
+        log_info(JSON.pretty_generate(runner_details))
       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
+      def num_dispatcher_loops
+        dispatcher_loops.size
       end
 
-      protected
+      private
 
       def start_loops
-        service_module.loops.each do |loop_class|
-          instance = loop_class.new(@app)
-          instance.start
-          @loops << instance
-        end
+        @loops = service.loop_instances(@app)
+        @loops.map(&:start)
       end
 
       def stop_loops
@@ -157,27 +159,32 @@ module Rpush
         @loops = []
       end
 
+      def stop_dispatcher_loops
+        dispatcher_loops.stop
+        @dispatcher_loops = nil
+      end
+
       def new_dispatcher_loop
-        dispatcher = service_module.new_dispatcher(@app)
+        dispatcher = service.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
+      def service
+        return @service if defined? @service
+        @service = "Rpush::Daemon::#{@app.service_name.camelize}".constantize
       end
 
       def queue
         @queue ||= Queue.new
       end
 
-      def dispatchers
-        @dispatchers ||= Rpush::Daemon::DispatcherLoopCollection.new
+      def dispatcher_loops
+        @dispatcher_loops ||= Rpush::Daemon::DispatcherLoopCollection.new
       end
 
-      def dispatchers_str(count = app.connections)
+      def dispatchers_str(count = num_dispatcher_loops)
         count = count.abs
         str = count == 1 ? 'dispatcher' : 'dispatchers'
         "#{count} #{str}"

data/lib/rpush/daemon/batch.rb

@@ -3,8 +3,7 @@ module Rpush
     class Batch
       include Reflectable
 
-      attr_reader :num_processed, :notifications,
-        :delivered, :failed, :retryable
+      attr_reader :num_processed, :notifications, :delivered, :failed, :retryable
 
       def initialize(notifications)
         @notifications = notifications
@@ -15,61 +14,80 @@ module Rpush
         @mutex = Mutex.new
       end
 
-      def num_notifications
-        @notifications.size
+      def complete?
+        @complete == true
+      end
+
+      def each_notification(&blk)
+        @notifications.each(&blk)
+      end
+
+      def each_delivered(&blk)
+        @delivered.each(&blk)
       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)
+        @mutex.synchronize do
+          @retryable[deliver_after] ||= []
+          @retryable[deliver_after] << notification
         end
+        Rpush::Daemon.store.mark_retryable(notification, deliver_after, persist: false)
       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)
+        @mutex.synchronize do
+          @delivered << notification
+        end
+        Rpush::Daemon.store.mark_delivered(notification, Time.now, persist: false)
+      end
+
+      def mark_all_delivered
+        @mutex.synchronize do
+          @delivered = @notifications
+        end
+        each_notification do |notification|
+          Rpush::Daemon.store.mark_delivered(notification, Time.now, persist: false)
         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)
+        key = [code, description]
+        @mutex.synchronize do
+          @failed[key] ||= []
+          @failed[key] << notification
         end
+        Rpush::Daemon.store.mark_failed(notification, code, description, Time.now, persist: false)
       end
 
-      def notification_dispatched
+      def mark_all_failed(code, message)
+        key = [code, message]
         @mutex.synchronize do
-          @num_processed += 1
-          complete if @num_processed >= @notifications.size
+          @failed[key] = @notifications
+        end
+        each_notification do |notification|
+          Rpush::Daemon.store.mark_failed(notification, code, message, Time.now, persist: false)
         end
       end
 
-      def complete?
-        @complete == true
+      def notification_processed
+        @mutex.synchronize do
+          @num_processed += 1
+          complete if @num_processed >= @notifications.size
+        end
       end
 
-      def describe
-        notifications.map(&:id).join(', ')
+      def all_processed
+        @mutex.synchronize do
+          @num_processed = @notifications.size
+          complete
+        end
       end
 
       private
 
       def complete
+        return if complete?
+
         [:complete_delivered, :complete_failed, :complete_retried].each do |method|
           begin
             send(method)
@@ -79,36 +97,32 @@ module Rpush
           end
         end
 
-        notifications.clear
         @complete = true
       end
 
       def complete_delivered
-        Rpush::Daemon.store.mark_batch_delivered(delivered)
-        delivered.each do |notification|
+        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|
+        @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|
+        @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