rpush_extended 3.2.5

data/lib/rpush/daemon/apns2.rb

@@ -0,0 +1,10 @@
+module Rpush
+  module Daemon
+    module Apns2
+      extend ServiceConfigMethods
+
+      batch_deliveries true
+      dispatcher :apns_http2
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+module Rpush
+  module Daemon
+    module Apnsp8
+      # https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CommunicatingwithAPNs.html
+
+      HTTP2_HEADERS_KEY = 'headers'
+
+      class Delivery < Rpush::Daemon::Delivery
+        RETRYABLE_CODES = [ 429, 500, 503 ]
+
+        def initialize(app, http2_client, token_provider, batch)
+          @app = app
+          @client = http2_client
+          @batch = batch
+          @first_push = true
+          @token_provider = token_provider
+        end
+
+        def perform
+          @client.on(:error) { |err| mark_batch_retryable(Time.now + 10.seconds, err) }
+
+          @batch.each_notification do |notification|
+            prepare_async_post(notification)
+          end
+
+          # Send all preprocessed requests at once
+          @client.join
+        rescue Errno::ECONNREFUSED, SocketError, HTTP2::Error::StreamLimitExceeded => error
+          # TODO restart connection when StreamLimitExceeded
+          mark_batch_retryable(Time.now + 10.seconds, error)
+          raise
+        rescue StandardError => error
+          mark_batch_failed(error)
+          raise
+        ensure
+          @batch.all_processed
+        end
+
+        protected
+        ######################################################################
+
+        def prepare_async_post(notification)
+          response = {}
+
+          request = build_request(notification)
+          log_warn(request)
+          http_request = @client.prepare_request(:post, request[:path],
+            body:    request[:body],
+            headers: request[:headers]
+          )
+
+          http_request.on(:headers) do |hdrs|
+            response[:code] = hdrs[':status'].to_i
+          end
+
+          http_request.on(:body_chunk) do |body_chunk|
+            next unless body_chunk.present?
+
+            response[:failure_reason] = JSON.parse(body_chunk)['reason']
+          end
+
+          http_request.on(:close) { handle_response(notification, response) }
+
+          if @first_push
+            @first_push = false
+            @client.call_async(http_request)
+          else
+            delayed_push_async(http_request)
+          end
+        end
+
+        def delayed_push_async(http_request)
+          until streams_available? do
+            sleep 0.001
+          end
+          @client.call_async(http_request)
+        end
+
+        def streams_available?
+          remote_max_concurrent_streams - @client.stream_count > 0
+        end
+
+        def remote_max_concurrent_streams
+          # 0x7fffffff is the default value from http-2 gem (2^31)
+          if @client.remote_settings[:settings_max_concurrent_streams] == 0x7fffffff
+            0
+          else
+            @client.remote_settings[:settings_max_concurrent_streams]
+          end
+        end
+
+        def handle_response(notification, response)
+          code = response[:code]
+          case code
+          when 200
+            ok(notification)
+          when *RETRYABLE_CODES
+            service_unavailable(notification, response)
+          else
+            reflect(:notification_id_failed,
+              @app,
+              notification.id, code,
+              response[:failure_reason])
+            @batch.mark_failed(notification, response[:code], response[:failure_reason])
+            failed_message_to_log(notification, response)
+          end
+        end
+
+        def ok(notification)
+          log_info("#{notification.id} sent to #{notification.device_token}")
+          @batch.mark_delivered(notification)
+        end
+
+        def service_unavailable(notification, response)
+          @batch.mark_retryable(notification, Time.now + 10.seconds)
+          # Logs should go last as soon as we need to initialize
+          # retry time to display it in log
+          failed_message_to_log(notification, response)
+          retry_message_to_log(notification)
+        end
+
+        def build_request(notification)
+          {
+            path:    "/3/device/#{notification.device_token}",
+            headers: prepare_headers(notification),
+            body:    prepare_body(notification)
+          }
+        end
+
+        def prepare_body(notification)
+          hash = notification.as_json.except(HTTP2_HEADERS_KEY)
+          JSON.dump(hash).force_encoding(Encoding::BINARY)
+        end
+
+        def prepare_headers(notification)
+          jwt_token = @token_provider.token
+
+          headers = {}
+          
+          headers['content-type'] = 'application/json'
+          headers['apns-expiration'] = '0'
+          headers['apns-priority'] = '10'
+          headers['apns-topic'] = @app.bundle_id
+          headers['authorization'] = "bearer #{jwt_token}"
+
+          headers.merge notification_data(notification)[HTTP2_HEADERS_KEY] || {}
+        end
+
+        def notification_data(notification)
+          notification.data || {}
+        end
+
+        def retry_message_to_log(notification)
+          log_warn("Notification #{notification.id} will be retried after "\
+            "#{notification.deliver_after.strftime('%Y-%m-%d %H:%M:%S')} "\
+            "(retry #{notification.retries}).")
+        end
+
+        def failed_message_to_log(notification, response)
+          log_error("Notification #{notification.id} failed, "\
+            "#{response[:code]}/#{response[:failure_reason]}")
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/apnsp8/token.rb

@@ -0,0 +1,43 @@
+module Rpush
+  module Daemon
+    module Apnsp8
+      TOKEN_TTL = 30 * 60
+      class Token
+        def initialize(app)
+          @app = app
+        end
+
+        def token
+          if @cached_token && !expired_token?
+            @cached_token
+          else
+            new_token
+          end
+        end
+
+        private
+
+        def new_token
+          @cached_token_at = Time.now
+          ec_key = OpenSSL::PKey::EC.new(@app.apn_key)
+          @cached_token = JWT.encode(
+            {
+              iss: @app.team_id,
+              iat: Time.now.to_i
+            },
+            ec_key,
+            'ES256',
+            {
+              alg: 'ES256',
+              kid: @app.apn_key_id
+            }
+          )
+        end
+
+        def expired_token?
+          Time.now - @cached_token_at >= TOKEN_TTL
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/apnsp8.rb

@@ -0,0 +1,10 @@
+module Rpush
+  module Daemon
+    module Apnsp8
+      extend ServiceConfigMethods
+
+      batch_deliveries true
+      dispatcher :apnsp8_http2
+    end
+  end
+end

data/lib/rpush/daemon/app_runner.rb

@@ -0,0 +1,190 @@
+# encoding: UTF-8
+
+module Rpush
+  module Daemon
+    class AppRunner
+      extend Reflectable
+      include Reflectable
+      include Loggable
+      extend Loggable
+      include StringHelpers
+      extend StringHelpers
+
+      @runners = {}
+
+      def self.enqueue(notifications)
+        notifications.group_by(&:app_id).each do |app_id, group|
+          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.start_app_with_id(app_id)
+        start_app(Rpush::Daemon.store.app(app_id))
+      end
+
+      def self.start_app(app)
+        Rpush.logger.info("[#{app.name}] Starting #{pluralize(app.connections, 'dispatcher')}... ", true)
+        runner = @runners[app.id] = new(app)
+        runner.start_dispatchers
+        puts ANSI.green { '✔' } if Rpush.config.foreground
+        runner.start_loops
+      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
+      end
+
+      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.increment_dispatchers(app, num)
+        @runners[app.id].increment_dispatchers(num)
+      end
+
+      def self.status
+        { app_runners: @runners.values.map(&:status) }
+      end
+
+      attr_reader :app
+      delegate :size, to: :queue, prefix: true
+
+      def initialize(app)
+        @app = app
+        @loops = []
+        @dispatcher_loops = []
+      end
+
+      def start_dispatchers
+        app.connections.times { @dispatcher_loops.push(new_dispatcher_loop) }
+      end
+
+      def start_loops
+        @loops = service.loop_instances(@app)
+        @loops.map(&:start)
+      end
+
+      def stop
+        wait_until_idle
+        stop_dispatcher_loops
+        stop_loops
+      end
+
+      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.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
+          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 { @dispatcher_loops.pop.stop }
+      end
+
+      def increment_dispatchers(num)
+        num.times { @dispatcher_loops.push(new_dispatcher_loop) }
+      end
+
+      def status
+        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
+
+        { app_name: @app.name, dispatchers: dispatcher_details, queued: queue_size }
+      end
+
+      def num_dispatcher_loops
+        @dispatcher_loops.size
+      end
+
+      private
+
+      def stop_loops
+        @loops.map(&:stop)
+        @loops = []
+      end
+
+      def stop_dispatcher_loops
+        @dispatcher_loops.map(&:stop)
+        @dispatcher_loops.clear
+      end
+
+      def new_dispatcher_loop
+        dispatcher = service.new_dispatcher(@app)
+        dispatcher_loop = Rpush::Daemon::DispatcherLoop.new(queue, dispatcher)
+        dispatcher_loop.start
+        dispatcher_loop
+      end
+
+      def service
+        return @service if defined? @service
+        @service = "Rpush::Daemon::#{@app.service_name.camelize}".constantize
+      end
+
+      def queue
+        @queue ||= Queue.new
+      end
+    end
+  end
+end

data/lib/rpush/daemon/batch.rb

@@ -0,0 +1,138 @@
+module Rpush
+  module Daemon
+    class Batch
+      include Reflectable
+
+      attr_reader :num_processed, :notifications, :delivered, :failed, :retryable
+
+      def initialize(notifications)
+        @notifications = notifications
+        @num_processed = 0
+        @delivered = []
+        @failed = {}
+        @retryable = {}
+        @mutex = Mutex.new
+      end
+
+      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)
+        @mutex.synchronize do
+          @retryable[deliver_after] ||= []
+          @retryable[deliver_after] << notification
+        end
+        Rpush::Daemon.store.mark_retryable(notification, deliver_after, persist: false)
+      end
+
+      def mark_all_retryable(deliver_after)
+        @mutex.synchronize do
+          @retryable[deliver_after] = @notifications
+        end
+        each_notification do |notification|
+          Rpush::Daemon.store.mark_retryable(notification, deliver_after, persist: false)
+        end
+      end
+
+      def mark_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)
+        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 mark_all_failed(code, message)
+        key = [code, message]
+        @mutex.synchronize do
+          @failed[key] = @notifications
+        end
+        each_notification do |notification|
+          Rpush::Daemon.store.mark_failed(notification, code, message, Time.now, persist: false)
+        end
+      end
+
+      def notification_processed
+        @mutex.synchronize do
+          @num_processed += 1
+          complete if @num_processed >= @notifications.size
+        end
+      end
+
+      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)
+          rescue StandardError => e
+            Rpush.logger.error(e)
+            reflect(:error, e)
+          end
+        end
+
+        @complete = true
+      end
+
+      def complete_delivered
+        Rpush::Daemon.store.mark_batch_delivered(@delivered)
+        @delivered.each do |notification|
+          reflect(:notification_delivered, notification)
+        end
+      end
+
+      def complete_failed
+        @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
+      end
+
+      def complete_retried
+        @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
+      end
+    end
+  end
+end

data/lib/rpush/daemon/constants.rb

@@ -0,0 +1,59 @@
+module Rpush
+  module Daemon
+    HTTP_STATUS_CODES = {
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      102  => 'Processing',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      207  => 'Multi-Status',
+      226  => 'IM Used',
+      300  => 'Multiple Choices',
+      301  => 'Moved Permanently',
+      302  => 'Found',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      306  => 'Reserved',
+      307  => 'Temporary Redirect',
+      400  => 'Bad Request',
+      401  => 'Unauthorized',
+      402  => 'Payment Required',
+      403  => 'Forbidden',
+      404  => 'Not Found',
+      405  => 'Method Not Allowed',
+      406  => 'Not Acceptable',
+      407  => 'Proxy Authentication Required',
+      408  => 'Request Timeout',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Long',
+      415  => 'Unsupported Media Type',
+      416  => 'Requested Range Not Satisfiable',
+      417  => 'Expectation Failed',
+      418  => "I'm a Teapot",
+      422  => 'Unprocessable Entity',
+      423  => 'Locked',
+      424  => 'Failed Dependency',
+      426  => 'Upgrade Required',
+      429  => 'Too Many Requests',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Timeout',
+      505  => 'HTTP Version Not Supported',
+      506  => 'Variant Also Negotiates',
+      507  => 'Insufficient Storage',
+      510  => 'Not Extended'
+    }
+  end
+end

data/lib/rpush/daemon/delivery.rb

@@ -0,0 +1,46 @@
+module Rpush
+  module Daemon
+    class Delivery
+      include Reflectable
+      include Loggable
+
+      def mark_retryable(notification, deliver_after, error = nil)
+        if notification.fail_after && notification.fail_after < Time.now
+          @batch.mark_failed(notification, nil, "Notification failed to be delivered before #{notification.fail_after.strftime('%Y-%m-%d %H:%M:%S')}.")
+        else
+          if error
+            log_warn("Will retry notification #{notification.id} after #{deliver_after.strftime('%Y-%m-%d %H:%M:%S')} due to error (#{error.class.name}, #{error.message})")
+          end
+          @batch.mark_retryable(notification, deliver_after)
+        end
+      end
+
+      def mark_retryable_exponential(notification)
+        mark_retryable(notification, Time.now + 2**(notification.retries + 1))
+      end
+
+      def mark_batch_retryable(deliver_after, error)
+        log_warn("Will retry #{@batch.notifications.size} notifications after #{deliver_after.strftime('%Y-%m-%d %H:%M:%S')} due to error (#{error.class.name}, #{error.message})")
+        @batch.mark_all_retryable(deliver_after)
+      end
+
+      def mark_delivered
+        @batch.mark_delivered(@notification)
+      end
+
+      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
+end

data/lib/rpush/daemon/delivery_error.rb

@@ -0,0 +1,27 @@
+module Rpush
+  class DeliveryError < StandardError
+    attr_reader :code, :notification_id
+
+    def initialize(code, notification_id, description)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      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