rpush 1.0.0-java → 2.0.0-java

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

@@ -12,7 +12,7 @@ module Rpush
         AMAZON_ADM_URL = 'https://api.amazon.com/messaging/registrations/%s/messages'
 
         # Data used to request authorization tokens.
-        ACCESS_TOKEN_REQUEST_DATA = {"grant_type" => "client_credentials", "scope" => "messaging:push"}
+        ACCESS_TOKEN_REQUEST_DATA = { "grant_type" => "client_credentials", "scope" => "messaging:push" }
 
         def initialize(app, http, notification, batch)
           @app = app
@@ -24,29 +24,27 @@ module Rpush
         end
 
         def perform
-          begin
-            @notification.registration_ids.each do |registration_id|
-              handle_response(do_post(registration_id), registration_id)
-            end
-
-            if(@sent_registration_ids.empty?)
-              raise Rpush::DeliveryError.new(nil, @notification.id, describe_errors)
-            else
-              unless(@failed_registration_ids.empty?)
-                @notification.error_description = describe_errors
-                Rpush::Daemon.store.update_notification(@notification)
-              end
-
-              mark_delivered
+          @notification.registration_ids.each do |registration_id|
+            handle_response(do_post(registration_id), registration_id)
+          end
+          if @sent_registration_ids.empty?
+            fail Rpush::DeliveryError.new(nil, @notification.id, describe_errors)
+          else
+            unless @failed_registration_ids.empty?
+              @notification.error_description = describe_errors
+              Rpush::Daemon.store.update_notification(@notification)
             end
-          rescue Rpush::RetryableError => error
-            handle_retryable(error)
-          rescue Rpush::TooManyRequestsError => error
-            handle_too_many_requests(error)
-          rescue Rpush::DeliveryError => error
-            mark_failed(error.code, error.description)
-            raise
+            mark_delivered
           end
+        rescue Rpush::RateLimitError => error
+          handle_rate_limited(error)
+        rescue Rpush::RetryableError => error
+          handle_retryable(error)
+        rescue StandardError => error
+          mark_failed(error)
+          raise
+        ensure
+          @batch.notification_processed
         end
 
         protected
@@ -60,27 +58,27 @@ module Rpush
           when 401
             unauthorized(response)
           when 429
-            too_many_requests(response)
+            rate_limited(response)
           when 500
-            internal_server_error(response, current_registration_id)
+            internal_server_error(current_registration_id)
           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
 
         def ok(response, current_registration_id)
           response_body = multi_json_load(response.body)
 
-          if(response_body.has_key?('registrationID'))
+          if response_body.key?('registrationID')
             @sent_registration_ids << response_body['registrationID']
             log_info("#{@notification.id} sent to #{response_body['registrationID']}")
           end
 
-          if(current_registration_id != response_body['registrationID'])
-            reflect(:adm_canonical_id, current_registration_id, response_body['registrationID'])
-          end
+          return if current_registration_id == response_body['registrationID']
+
+          reflect(:adm_canonical_id, current_registration_id, response_body['registrationID'])
         end
 
         def handle_retryable(error)
@@ -88,7 +86,7 @@ module Rpush
           when 401
             # clear app access_token so a new one is fetched
             @notification.app.access_token = nil
-            get_access_token
+            access_token
             mark_retryable(@notification, Time.now) if @notification.app.access_token
           when 503
             retry_delivery(@notification, error.response)
@@ -96,8 +94,8 @@ module Rpush
           end
         end
 
-        def handle_too_many_requests(error)
-          if(@sent_registration_ids.empty?)
+        def handle_rate_limited(error)
+          if @sent_registration_ids.empty?
             # none sent yet, just resend after the specified retry-after response.header
             retry_delivery(@notification, error.response)
           else
@@ -120,30 +118,33 @@ module Rpush
         def bad_request(response, current_registration_id)
           response_body = multi_json_load(response.body)
 
-          if(response_body.has_key?('reason'))
-            log_warn("bad_request: #{current_registration_id} (#{response_body['reason']})")
-            @failed_registration_ids[current_registration_id] = response_body['reason']
-          end
+          return unless response_body.key?('reason')
+
+          reason = response_body['reason']
+          log_warn("bad_request: #{current_registration_id} (#{reason})")
+          @failed_registration_ids[current_registration_id] = reason
+
+          reflect(:adm_failed_to_recipient, @notification, current_registration_id, reason)
         end
 
         def unauthorized(response)
           # Indicate a notification is retryable. Because ADM requires separate request for each push token, this will safely mark the entire notification to retry delivery.
-          raise Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Unauthorized Error.', response)
+          fail Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Unauthorized Error.', response)
         end
 
-        def too_many_requests(response)
+        def rate_limited(response)
           # raise error so the current notification stops sending messages to remaining reg ids
-          raise Rpush::TooManyRequestsError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
+          fail Rpush::RateLimitError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
         end
 
-        def internal_server_error(response, current_registration_id)
+        def internal_server_error(current_registration_id)
           @failed_registration_ids[current_registration_id] = "Internal Server Error"
           log_warn("internal_server_error: #{current_registration_id} (Internal Server Error)")
         end
 
         def service_unavailable(response)
           # Indicate a notification is retryable. Because ADM requires separate request for each push token, this will safely mark the entire notification to retry delivery.
-          raise Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Service Unavailable Error.', response)
+          fail Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Service Unavailable Error.', response)
         end
 
         def create_new_notification(response, registration_ids)
@@ -156,7 +157,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)
@@ -178,23 +180,22 @@ module Rpush
         end
 
         def do_post(registration_id)
-          adm_uri = URI.parse(AMAZON_ADM_URL % [registration_id])
-          post = Net::HTTP::Post.new(adm_uri.path, initheader = {
-            'Content-Type' => 'application/json',
-            'Accept' => 'application/json',
-            'x-amzn-type-version' => 'com.amazon.device.messaging.ADMMessage@1.0',
-            'x-amzn-accept-type' => 'com.amazon.device.messaging.ADMSendResult@1.0',
-            'Authorization' => "Bearer #{get_access_token}"
-          })
+          adm_uri = URI.parse(format(AMAZON_ADM_URL, registration_id))
+          post = Net::HTTP::Post.new(adm_uri.path,
+                                     'Content-Type' => 'application/json',
+                                     'Accept' => 'application/json',
+                                     'x-amzn-type-version' => 'com.amazon.device.messaging.ADMMessage@1.0',
+                                     'x-amzn-accept-type' => 'com.amazon.device.messaging.ADMSendResult@1.0',
+                                     'Authorization' => "Bearer #{access_token}")
           post.body = @notification.as_json.to_json
 
           @http.request(adm_uri, post)
         end
 
-        def get_access_token
-          if(@notification.app.access_token.nil? || @notification.app.access_token_expired?)
-            post = Net::HTTP::Post.new(AMAZON_TOKEN_URI.path, initheader = {'Content-Type' => 'application/x-www-form-urlencoded'})
-            post.set_form_data(ACCESS_TOKEN_REQUEST_DATA.merge({'client_id' => @notification.app.client_id, 'client_secret' => @notification.app.client_secret}))
+        def access_token
+          if @notification.app.access_token.nil? || @notification.app.access_token_expired?
+            post = Net::HTTP::Post.new(AMAZON_TOKEN_URI.path, 'Content-Type' => 'application/x-www-form-urlencoded')
+            post.set_form_data(ACCESS_TOKEN_REQUEST_DATA.merge('client_id' => @notification.app.client_id, 'client_secret' => @notification.app.client_secret))
 
             handle_access_token(@http.request(AMAZON_TOKEN_URI, post))
           end
@@ -203,7 +204,7 @@ module Rpush
         end
 
         def handle_access_token(response)
-          if(response.code.to_i == 200)
+          if response.code.to_i == 200
             update_access_token(JSON.parse(response.body))
             Rpush::Daemon.store.update_app(@notification.app)
             log_info("ADM access token updated: token = #{@notification.app.access_token}, expires = #{@notification.app.access_token_expiration}")

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/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/app_runner.rb

@@ -4,152 +4,161 @@ module Rpush
       extend Reflectable
       include Reflectable
       include Loggable
-
-      class << self
-        attr_reader :runners
-      end
+      extend Loggable
+      include StringHelpers
+      extend StringHelpers
 
       @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
+          start_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.each { |app| sync_app(app) }
-        removed = runners.keys - apps.map(&:id)
-        removed.each { |app_id| runners.delete(app_id).stop }
+      def self.start_app_with_id(app_id)
+        start_app(Rpush::Daemon.store.app(app_id))
       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
+      def self.start_app(app)
+        @runners[app.id] = new(app)
+        @runners[app.id].start
+        log_info("[#{app.name}] Started, #{pluralize(app.connections, 'dispatcher')}.")
+      rescue StandardError => e
+        @runners.delete(app.id)
+        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
+
+      def self.stop_app(app_id)
+        runner = @runners.delete(app_id)
+        if runner
+          runner.stop
+          log_info("[#{runner.app.name}] Stopped.")
         end
       end
 
+      def self.app_with_id(app_id)
+        @runners[app_id].app
+      end
+
+      def self.app_running?(app)
+        @runners.key?(app.id)
+      end
+
+      def self.app_ids
+        @runners.keys
+      end
+
       def self.stop
-        runners.values.map(&:stop)
-        runners.clear
+        @runners.values.map(&:stop)
+        @runners.clear
       end
 
-      def self.debug
-        runners.values.map(&:debug)
+      def self.total_dispatchers
+        @runners.values.sum(&:num_dispatcher_loops)
+      end
+
+      def self.total_queued
+        @runners.values.sum(&:queue_size)
+      end
+
+      def self.num_dispatchers_for_app(app)
+        runner = @runners[app.id]
+        runner ? runner.num_dispatcher_loops : 0
+      end
+
+      def self.decrement_dispatchers(app, num)
+        @runners[app.id].decrement_dispatchers(num)
       end
 
-      def self.idle
-        runners.values.select(&:idle?)
+      def self.increment_dispatchers(app, num)
+        @runners[app.id].increment_dispatchers(num)
       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
         @loops = []
+        @dispatcher_loops = []
       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)
-        end
+      def wait_until_idle
+        sleep 0.5 while queue.size > 0
       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.")
+      def enqueue(notifications)
+        if service.batch_deliveries?
+          batch_size = (notifications.size / num_dispatcher_loops.to_f).ceil
+          notifications.in_groups_of(batch_size, false).each do |batch_notifications|
+            batch = Batch.new(batch_notifications)
+            queue.push(QueuePayload.new(batch))
+          end
         else
-          increment_dispatchers(diff.abs)
-          log_info("Started #{dispatchers_str(diff)}. #{dispatchers_str} running.")
+          batch = Batch.new(notifications)
+          notifications.each do |notification|
+            queue.push(QueuePayload.new(batch, notification))
+            reflect(:notification_enqueued, notification)
+          end
         end
       end
 
       def decrement_dispatchers(num)
-        num.times { dispatchers.pop }
+        num.times { @dispatcher_loops.pop.stop }
       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.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,31 +166,26 @@ module Rpush
         @loops = []
       end
 
+      def stop_dispatcher_loops
+        @dispatcher_loops.map(&:stop)
+        @dispatcher_loops.clear
+      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
-      end
-
-      def dispatchers_str(count = app.connections)
-        count = count.abs
-        str = count == 1 ? 'dispatcher' : 'dispatchers'
-        "#{count} #{str}"
-      end
     end
   end
 end