rpush 1.0.0 → 2.0.0.beta1

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,106 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class ApnsTcp < Rpush::Daemon::Dispatcher::Tcp
+        include Loggable
+
+        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.')
+          Rpush::Daemon.store.mark_ids_failed(delivered_buffer, nil, 'The APNs disconnected without returning an error. This may indicate you are using an invalid certificate.', Time.now)
+        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)
+
+          if failed_pos
+            retry_ids = delivered_buffer[(failed_pos + 1)..-1]
+            Rpush::Daemon.store.mark_ids_retryable(retry_ids, Time.now) if retry_ids.size > 0
+          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,15 +2,25 @@ module Rpush
   module Daemon
     class DispatcherLoop
       include Reflectable
+      include Loggable
+
+      attr_reader :started_at, :dispatch_count
 
       WAKEUP = :wakeup
 
       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
@@ -37,16 +47,15 @@ module Rpush
       protected
 
       def dispatch
-        notification, batch = @queue.pop
-        return if notification == WAKEUP
+        payload = @queue.pop
+        return if payload == WAKEUP
 
         begin
-          @dispatcher.dispatch(notification, batch)
+          @dispatch_count += 1
+          @dispatcher.dispatch(payload)
         rescue StandardError => e
-          Rpush.logger.error(e)
+          log_error(e)
           reflect(:error, e)
-        ensure
-          batch.notification_dispatched
         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.num_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