rpush 1.0.0-java → 2.0.0-java

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

data/lib/rpush/daemon/delivery.rb

@@ -13,15 +13,25 @@ module Rpush
       end
 
       def mark_retryable_exponential(notification)
-        mark_retryable(notification, Time.now + 2 ** (notification.retries + 1))
+        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)
+      def mark_batch_delivered
+        @batch.mark_all_delivered
+      end
+
+      def mark_failed(error)
+        code = error.respond_to?(:code) ? error.code : nil
+        @batch.mark_failed(@notification, code, error.to_s)
+      end
+
+      def mark_batch_failed(error)
+        code = error.respond_to?(:code) ? error.code : nil
+        @batch.mark_all_failed(code, error.to_s)
       end
     end
   end

data/lib/rpush/daemon/delivery_error.rb

@@ -1,6 +1,6 @@
 module Rpush
   class DeliveryError < StandardError
-    attr_reader :code, :description
+    attr_reader :code, :notification_id
 
     def initialize(code, notification_id, description)
       @code = code
@@ -13,7 +13,15 @@ module Rpush
     end
 
     def message
-      "Unable to deliver notification #{@notification_id}, received error #{@code} (#{@description})"
+      error_str = [@code, "(#{@description})"].compact.join(' ')
+      "Unable to deliver notification #{@notification_id}, received error #{error_str}"
+    end
+
+    def ==(other)
+      other.is_a?(DeliveryError) && \
+      other.code == code && \
+      other.notification_id == notification_id && \
+      other.to_s == to_s
     end
   end
 end

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

@@ -0,0 +1,114 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class ApnsTcp < Rpush::Daemon::Dispatcher::Tcp
+        include Loggable
+        include Reflectable
+
+        SELECT_TIMEOUT = 10
+        ERROR_TUPLE_BYTES = 6
+        APNS_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(*args)
+          super
+          @dispatch_mutex = Mutex.new
+          @stop_error_receiver = false
+          start_error_receiver
+        end
+
+        def dispatch(payload)
+          @dispatch_mutex.synchronize do
+            @delivery_class.new(@app, connection, payload.batch).perform
+            record_batch(payload.batch)
+          end
+        end
+
+        def cleanup
+          @stop_error_receiver = true
+          super
+          @error_receiver_thread.join if @error_receiver_thread
+        end
+
+        private
+
+        def start_error_receiver
+          @error_receiver_thread = Thread.new do
+            check_for_error until @stop_error_receiver
+            Rpush::Daemon.store.release_connection
+          end
+        end
+
+        def delivered_buffer
+          @delivered_buffer ||= RingBuffer.new(Rpush.config.batch_size * 10)
+        end
+
+        def record_batch(batch)
+          batch.each_delivered do |notification|
+            delivered_buffer << notification.id
+          end
+        end
+
+        def check_for_error
+          begin
+            return unless connection.select(SELECT_TIMEOUT)
+          rescue Errno::EBADF
+            # Connection closed, daemon is shutting down.
+            return
+          end
+
+          tuple = connection.read(ERROR_TUPLE_BYTES)
+          @dispatch_mutex.synchronize { handle_error_response(tuple) }
+        end
+
+        def handle_error_response(tuple)
+          if tuple
+            _, code, notification_id = tuple.unpack('ccN')
+            handle_error(code, notification_id)
+          else
+            handle_disconnect
+          end
+
+          log_error('Error received, reconnecting...')
+          connection.reconnect
+        ensure
+          delivered_buffer.clear
+        end
+
+        def handle_disconnect
+          log_error('The APNs disconnected without returning an error. Marking all notifications delivered via this connection as failed.')
+          reason = 'The APNs disconnected without returning an error. This may indicate you are using an invalid certificate.'
+          Rpush::Daemon.store.mark_ids_failed(delivered_buffer, nil, reason, Time.now)
+          delivered_buffer.each { |id| reflect(:notification_id_failed, @app, id, nil, reason) }
+        end
+
+        def handle_error(code, notification_id)
+          failed_pos = delivered_buffer.index(notification_id)
+          description = APNS_ERRORS[code.to_i] || "Unknown error code #{code.inspect}. Possible Rpush bug?"
+          Rpush::Daemon.store.mark_ids_failed([notification_id], code, description, Time.now)
+          reflect(:notification_id_failed, @app, notification_id, code, description)
+
+          if failed_pos
+            retry_ids = delivered_buffer[(failed_pos + 1)..-1]
+            if retry_ids.size > 0
+              now = Time.now
+              Rpush::Daemon.store.mark_ids_retryable(retry_ids, now)
+              retry_ids.each { |id| reflect(:notification_id_will_retry, @app, id, now) }
+            end
+          elsif delivered_buffer.size > 0
+            log_error("Delivery sequence unknown for notifications following #{notification_id}.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,14 +2,14 @@ module Rpush
   module Daemon
     module Dispatcher
       class Http
-        def initialize(app, delivery_class, options = {})
+        def initialize(app, delivery_class, _options = {})
           @app = app
           @delivery_class = delivery_class
           @http = Net::HTTP::Persistent.new('rpush')
         end
 
-        def dispatch(notification, batch)
-          @delivery_class.new(@app, @http, notification, batch).perform
+        def dispatch(payload)
+          @delivery_class.new(@app, @http, payload.notification, payload.batch).perform
         end
 
         def cleanup

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

@@ -8,15 +8,15 @@ module Rpush
           @host, @port = options[:host].call(@app)
         end
 
-        def dispatch(notification, batch)
-          @delivery_class.new(@app, connection, notification, batch).perform
+        def dispatch(payload)
+          @delivery_class.new(@app, connection, payload.notification, payload.batch).perform
         end
 
         def cleanup
           @connection.close if @connection
         end
 
-        private
+        protected
 
         def connection
           return @connection if defined? @connection

data/lib/rpush/daemon/dispatcher_loop.rb

@@ -2,19 +2,38 @@ module Rpush
   module Daemon
     class DispatcherLoop
       include Reflectable
+      include Loggable
 
-      WAKEUP = :wakeup
+      attr_reader :started_at, :dispatch_count
+
+      STOP = :stop
 
       def initialize(queue, dispatcher)
         @queue = queue
         @dispatcher = dispatcher
+        @dispatch_count = 0
+      end
+
+      def thread_status
+        @thread ? @thread.status : 'not started'
       end
 
       def start
+        @started_at = Time.now
+
         @thread = Thread.new do
           loop do
-            dispatch
-            break if @stop
+            payload = @queue.pop
+            if stop_payload?(payload)
+              break if should_stop?(payload)
+
+              # Intended for another dispatcher loop.
+              @queue.push(payload)
+              Thread.pass
+              sleep 0.1
+            else
+              dispatch(payload)
+            end
           end
 
           Rpush::Daemon.store.release_connection
@@ -22,32 +41,27 @@ module Rpush
       end
 
       def stop
-        @stop = true
-      end
-
-      def wakeup
-        @queue.push(WAKEUP) if @thread
-      end
-
-      def wait
+        @queue.push([STOP, object_id]) if @thread
         @thread.join if @thread
         @dispatcher.cleanup
       end
 
-      protected
+      private
+
+      def stop_payload?(payload)
+        payload.is_a?(Array) && payload.first == STOP
+      end
 
-      def dispatch
-        notification, batch = @queue.pop
-        return if notification == WAKEUP
+      def should_stop?(payload)
+        payload.last == object_id
+      end
 
-        begin
-          @dispatcher.dispatch(notification, batch)
-        rescue StandardError => e
-          Rpush.logger.error(e)
-          reflect(:error, e)
-        ensure
-          batch.notification_dispatched
-        end
+      def dispatch(payload)
+        @dispatch_count += 1
+        @dispatcher.dispatch(payload)
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
       end
     end
   end

data/lib/rpush/daemon/errors.rb

@@ -0,0 +1,18 @@
+module Rpush
+  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

data/lib/rpush/daemon/feeder.rb

@@ -4,63 +4,52 @@ module Rpush
       extend Reflectable
 
       def self.start
-        @stop = false
-
-        if Rpush.config.embedded
-          Thread.new { feed_forever }
-        elsif Rpush.config.push
-          enqueue_notifications
-        else
-          feed_forever
-        end
+        self.should_stop = false
+        Rpush.config.push ? enqueue_notifications : feed_forever
       end
 
       def self.stop
-        @stop = true
-        interrupt_sleep
+        self.should_stop = true
+        interruptible_sleeper.stop
+        @thread.join if @thread
       end
 
-      def self.interrupt_sleep
-        interruptible_sleeper.interrupt_sleep
+      def self.wakeup
+        interruptible_sleeper.wakeup
       end
 
-      protected
+      class << self
+        attr_accessor :should_stop
+      end
 
       def self.feed_forever
-        loop do
-          enqueue_notifications
-          interruptible_sleeper.sleep(Rpush.config.push_poll)
-          break if stop?
+        @thread = Thread.new do
+          loop do
+            enqueue_notifications
+            interruptible_sleeper.sleep
+            break if should_stop
+          end
+
+          Rpush::Daemon.store.release_connection
         end
 
-        Rpush::Daemon.store.release_connection
-      end
-
-      # :nocov:
-      def self.stop?
-        @stop
+        @thread.join
       end
 
       def self.enqueue_notifications
-        begin
-          idle = Rpush::Daemon::AppRunner.idle.map(&:app)
-          return if idle.empty?
-          notifications = Rpush::Daemon.store.deliverable_notifications(idle)
-          Rpush::Daemon::AppRunner.enqueue(notifications)
-        rescue StandardError => e
-          Rpush.logger.error(e)
-          reflect(:error, e)
-        end
+        batch_size = Rpush.config.batch_size - Rpush::Daemon::AppRunner.total_queued
+        return if batch_size <= 0
+        notifications = Rpush::Daemon.store.deliverable_notifications(batch_size)
+        Rpush::Daemon::AppRunner.enqueue(notifications)
+      rescue StandardError => e
+        Rpush.logger.error(e)
+        reflect(:error, e)
       end
 
       def self.interruptible_sleeper
         return @interruptible_sleeper if @interruptible_sleeper
-
-        @interruptible_sleeper = InterruptibleSleep.new
-        if Rpush.config.wakeup
-          @interruptible_sleeper.enable_wake_on_udp Rpush.config.wakeup[:bind], Rpush.config.wakeup[:port]
-        end
-
+        @interruptible_sleeper = InterruptibleSleep.new(Rpush.config.push_poll)
+        @interruptible_sleeper.start
         @interruptible_sleeper
       end
     end

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

@@ -1,15 +1,14 @@
 module Rpush
   module Daemon
     module Gcm
-
       # http://developer.android.com/guide/google/gcm/gcm.html#response
       class Delivery < Rpush::Daemon::Delivery
         include MultiJsonHelper
 
         host = ENV["RPUSH_GCM_HOST"] || "https://android.googleapis.com"
         GCM_URI = URI.parse("#{host}/gcm/send")
-        UNAVAILABLE_STATES = ['Unavailable', 'InternalServerError']
-        INVALID_REGISTRATION_ID_STATES = ['InvalidRegistration', 'MismatchSenderId', 'NotRegistered', 'InvalidPackageName']
+        UNAVAILABLE_STATES = %w(Unavailable InternalServerError)
+        INVALID_REGISTRATION_ID_STATES = %w(InvalidRegistration MismatchSenderId NotRegistered InvalidPackageName)
 
         def initialize(app, http, notification, batch)
           @app = app
@@ -19,12 +18,12 @@ module Rpush
         end
 
         def perform
-          begin
-            handle_response(do_post)
-          rescue Rpush::DeliveryError => error
-            mark_failed(error.code, error.description)
-            raise
-          end
+          handle_response(do_post)
+        rescue StandardError => error
+          mark_failed(error)
+          raise
+        ensure
+          @batch.notification_processed
         end
 
         protected
@@ -42,7 +41,7 @@ module Rpush
           when 503
             service_unavailable(response)
           else
-            raise Rpush::DeliveryError.new(response.code, @notification.id, Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i])
+            fail Rpush::DeliveryError.new(response.code, @notification.id, Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i])
           end
         end
 
@@ -69,9 +68,8 @@ module Rpush
         def handle_successes(successes)
           successes.each do |result|
             reflect(:gcm_delivered_to_recipient, @notification, result[:registration_id])
-            if result.has_key?(:canonical_id)
-              reflect(:gcm_canonical_id, result[:registration_id], result[:canonical_id])
-            end
+            next unless result.key?(:canonical_id)
+            reflect(:gcm_canonical_id, result[:registration_id], result[:canonical_id])
           end
         end
 
@@ -86,7 +84,7 @@ module Rpush
               failures.description += " #{unavailable_idxs.join(', ')} will be retried as notification #{new_notification.id}."
             end
             handle_errors(failures)
-            raise Rpush::DeliveryError.new(nil, @notification.id, failures.description)
+            fail Rpush::DeliveryError.new(nil, @notification.id, failures.description)
           end
         end
 
@@ -103,15 +101,15 @@ module Rpush
           attrs = @notification.attributes.slice('app_id', 'collapse_key', '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)
+                                                      registration_ids, deliver_after_header(response), @notification.app)
         end
 
         def bad_request
-          raise Rpush::DeliveryError.new(400, @notification.id, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
+          fail Rpush::DeliveryError.new(400, @notification.id, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
         end
 
         def unauthorized
-          raise Rpush::DeliveryError.new(401, @notification.id, 'Unauthorized, check your App auth_key.')
+          fail Rpush::DeliveryError.new(401, @notification.id, 'Unauthorized, check your App auth_key.')
         end
 
         def internal_server_error(response)
@@ -129,7 +127,8 @@ module Rpush
         end
 
         def retry_delivery(notification, response)
-          if time = deliver_after_header(response)
+          time = deliver_after_header(response)
+          if time
             mark_retryable(notification, time)
           else
             mark_retryable_exponential(notification)
@@ -141,8 +140,8 @@ module Rpush
         end
 
         def do_post
-          post = Net::HTTP::Post.new(GCM_URI.path, initheader = {'Content-Type'  => 'application/json',
-                                                                 'Authorization' => "key=#{@notification.app.auth_key}"})
+          post = Net::HTTP::Post.new(GCM_URI.path, 'Content-Type'  => 'application/json',
+                                                   'Authorization' => "key=#{@notification.app.auth_key}")
           post.body = @notification.as_json.to_json
           @http.request(GCM_URI, post)
         end