rpush_extended 3.2.5

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

@@ -0,0 +1,51 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class ApnsHttp2
+
+        URLS = {
+          production: 'https://api.push.apple.com:443',
+          development: 'https://api.development.push.apple.com:443',
+          sandbox: 'https://api.development.push.apple.com:443'
+        }
+
+        DEFAULT_TIMEOUT = 60
+
+        def initialize(app, delivery_class, _options = {})
+          @app = app
+          @delivery_class = delivery_class
+
+          url = URLS[app.environment.to_sym]
+          @client = NetHttp2::Client.new(url,
+            ssl_context:     prepare_ssl_context,
+            connect_timeout: DEFAULT_TIMEOUT)
+        end
+
+        def dispatch(payload)
+          @delivery_class.new(@app, @client, payload.batch).perform
+        end
+
+        def cleanup
+          @client.close
+        end
+
+        private
+
+        def prepare_ssl_context
+          @ssl_context ||= begin
+            ctx = OpenSSL::SSL::SSLContext.new
+            begin
+              p12      = OpenSSL::PKCS12.new(@app.certificate, @app.password)
+              ctx.key  = p12.key
+              ctx.cert = p12.certificate
+            rescue OpenSSL::PKCS12::PKCS12Error
+              ctx.key  = OpenSSL::PKey::RSA.new(@app.certificate, @app.password)
+              ctx.cert = OpenSSL::X509::Certificate.new(@app.certificate)
+            end
+            ctx
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+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 device token',
+          10 => 'APNs closed connection (possible maintenance)',
+          255 => 'None (unknown error)'
+        }
+
+        def initialize(*args)
+          super
+          @dispatch_mutex = Mutex.new
+          @stop_error_receiver = false
+          @connection.on_connect { 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
+          if Rpush.config.push
+            # In push mode only a single batch is sent, followed by immediate shutdown.
+            # Allow the error receiver time to handle any errors.
+            @reconnect_disabled = true
+            sleep 1
+          end
+
+          @stop_error_receiver = true
+          super
+          @error_receiver_thread.join if @error_receiver_thread
+        rescue StandardError => e
+          log_error(e)
+          reflect(:error, e)
+        ensure
+          @error_receiver_thread = nil
+        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
+            # On Linux, select returns nil from a dropped connection.
+            # On OS X, Errno::EBADF is raised following a Errno::EADDRNOTAVAIL from the write call.
+            return unless @connection.select(SELECT_TIMEOUT)
+            tuple = @connection.read(ERROR_TUPLE_BYTES)
+          rescue *TcpConnection::TCP_ERRORS
+            reconnect unless @stop_error_receiver
+            return
+          end
+
+          @dispatch_mutex.synchronize { handle_error_response(tuple) }
+        rescue StandardError => e
+          log_error(e)
+        end
+
+        def handle_error_response(tuple)
+          if tuple
+            _, code, notification_id = tuple.unpack('ccN')
+            handle_error(code, notification_id)
+          else
+            handle_disconnect
+          end
+
+          if Rpush.config.push
+            # Only attempt to handle a single error in Push mode.
+            @stop_error_receiver = true
+            return
+          end
+
+          reconnect
+        ensure
+          delivered_buffer.clear
+        end
+
+        def reconnect
+          return if @reconnect_disabled
+          log_error("Lost connection to #{@connection.host}:#{@connection.port}, reconnecting...")
+          @connection.reconnect_with_rescue
+        end
+
+        def handle_disconnect
+          log_error("The APNs disconnected before any notifications could be delivered. This usually indicates you are using an invalid certificate.") if delivered_buffer.size == 0
+        end
+
+        def handle_error(code, notification_id)
+          notification_id = Rpush::Daemon.store.translate_integer_notification_id(notification_id)
+          failed_pos = delivered_buffer.index(notification_id)
+          description = description_for_code(code)
+          log_error("Notification #{notification_id} failed with error: " + description)
+          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]
+            retry_notification_ids(retry_ids, notification_id)
+          elsif delivered_buffer.size > 0
+            log_error("Delivery sequence unknown for notifications following #{notification_id}.")
+          end
+        end
+
+        def description_for_code(code)
+          APNS_ERRORS[code.to_i] ? "#{APNS_ERRORS[code.to_i]} (#{code})" : "Unknown error code #{code.inspect}. Possible Rpush bug?"
+        end
+
+        def retry_notification_ids(ids, notification_id)
+          return if ids.size == 0
+
+          now = Time.now
+          Rpush::Daemon.store.mark_ids_retryable(ids, now)
+          notifications_str = 'Notification'
+          notifications_str += 's' if ids.size > 1
+          log_warn("#{notifications_str} #{ids.join(', ')} will be retried due to the failure of notification #{notification_id}.")
+          ids.each { |id| reflect(:notification_id_will_retry, @app, id, now) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class Apnsp8Http2
+
+        URLS = {
+          production: 'https://api.push.apple.com',
+          development: 'https://api.development.push.apple.com'
+        }
+
+        DEFAULT_TIMEOUT = 60
+
+        def initialize(app, delivery_class, _options = {})
+          @app = app
+          @delivery_class = delivery_class
+
+          url = URLS[app.environment.to_sym]
+          @client = NetHttp2::Client.new(url, connect_timeout: DEFAULT_TIMEOUT)
+          @token_provider = Rpush::Daemon::Apnsp8::Token.new(@app)
+        end
+
+        def dispatch(payload)
+
+          @delivery_class.new(@app, @client, @token_provider, payload.batch).perform
+        end
+
+        def cleanup
+          @client.close
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class Tcp
+        def initialize(app, delivery_class, options = {})
+          @app = app
+          @delivery_class = delivery_class
+          @host, @port = options[:host].call(@app)
+          @connection = Rpush::Daemon::TcpConnection.new(@app, @host, @port)
+        end
+
+        def dispatch(payload)
+          @delivery_class.new(@app, @connection, payload.notification, payload.batch).perform
+        end
+
+        def cleanup
+          @connection.close if @connection
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/dispatcher_loop.rb

@@ -0,0 +1,73 @@
+module Rpush
+  module Daemon
+    class DispatcherLoop
+      include Reflectable
+      include Loggable
+
+      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
+            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
+        end
+      end
+
+      def stop
+        @queue.push([STOP, object_id]) if @thread
+        @thread.join if @thread
+        @dispatcher.cleanup
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
+      end
+
+      private
+
+      def stop_payload?(payload)
+        payload.is_a?(Array) && payload.first == STOP
+      end
+
+      def should_stop?(payload)
+        payload.last == object_id
+      end
+
+      def dispatch(payload)
+        @dispatch_count += 1
+        @dispatcher.dispatch(payload)
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      end
+    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

@@ -0,0 +1,69 @@
+module Rpush
+  module Daemon
+    class Feeder
+      extend Reflectable
+      extend Loggable
+
+      def self.start(push_mode = false)
+        self.should_stop = false
+
+        @thread = Thread.new do
+          push_mode ? feed_all : feed_forever
+          Rpush::Daemon.store.release_connection
+        end
+
+        @thread.join
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
+      end
+
+      def self.stop
+        self.should_stop = true
+        interruptible_sleeper.stop
+        @thread.join if @thread
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
+      end
+
+      def self.wakeup
+        interruptible_sleeper.stop
+      end
+
+      class << self
+        attr_accessor :should_stop
+      end
+
+      def self.feed_all
+        enqueue_notifications until Rpush::Daemon.store.pending_delivery_count == 0
+      end
+
+      def self.feed_forever
+        loop do
+          enqueue_notifications
+          interruptible_sleeper.sleep(Rpush.config.push_poll)
+          return if should_stop
+        end
+      end
+
+      def self.enqueue_notifications
+        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
+        @interruptible_sleeper ||= InterruptibleSleep.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,241 @@
+module Rpush
+  module Daemon
+    module Gcm
+      # https://firebase.google.com/docs/cloud-messaging/server
+      class Delivery < Rpush::Daemon::Delivery
+        include MultiJsonHelper
+
+        host = 'https://fcm.googleapis.com'
+        FCM_URI = URI.parse("#{host}/fcm/send")
+        UNAVAILABLE_STATES = %w(Unavailable BadGateway InternalServerError)
+        INVALID_REGISTRATION_ID_STATES = %w(InvalidRegistration MismatchSenderId NotRegistered InvalidPackageName)
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          handle_response(do_post)
+        rescue SocketError => error
+          mark_retryable(@notification, Time.now + 10.seconds, error)
+          raise
+        rescue StandardError => error
+          mark_failed(error)
+          raise
+        ensure
+          @batch.notification_processed
+        end
+
+        protected
+
+        def handle_response(response)
+          case response.code.to_i
+          when 200
+            ok(response)
+          when 400
+            bad_request
+          when 401
+            unauthorized
+          when 500
+            internal_server_error(response)
+          when 502
+            bad_gateway(response)
+          when 503
+            service_unavailable(response)
+          when 500..599
+            other_5xx_error(response)
+          else
+            fail Rpush::DeliveryError.new(response.code.to_i, @notification.id, Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i])
+          end
+        end
+
+        def ok(response)
+          results = process_response(response)
+          handle_successes(results.successes)
+
+          if results.failures.any?
+            handle_failures(results.failures, response)
+          else
+            mark_delivered
+            log_info("#{@notification.id} sent to #{@notification.registration_ids.join(', ')}")
+          end
+        end
+
+        def process_response(response)
+          body = multi_json_load(response.body)
+          results = Results.new(body['results'], @notification.registration_ids)
+          results.process(invalid: INVALID_REGISTRATION_ID_STATES, unavailable: UNAVAILABLE_STATES)
+          results
+        end
+
+        def handle_successes(successes)
+          successes.each do |result|
+            reflect(:gcm_delivered_to_recipient, @notification, result[:registration_id])
+            next unless result.key?(:canonical_id)
+            reflect(:gcm_canonical_id, result[:registration_id], result[:canonical_id])
+          end
+        end
+
+        def handle_failures(failures, response)
+          if failures[:unavailable].count == @notification.registration_ids.count
+            retry_delivery(@notification, response)
+            log_warn("All recipients unavailable. #{retry_message}")
+          else
+            if failures[:unavailable].any?
+              unavailable_idxs = failures[:unavailable].map { |result| result[:index] }
+              new_notification = create_new_notification(response, unavailable_idxs)
+              failures.description += " #{unavailable_idxs.join(', ')} will be retried as notification #{new_notification.id}."
+            end
+            handle_errors(failures)
+            fail Rpush::DeliveryError.new(nil, @notification.id, failures.description)
+          end
+        end
+
+        def handle_errors(failures)
+          failures.each do |result|
+            reflect(:gcm_failed_to_recipient, @notification, result[:error], result[:registration_id])
+          end
+          failures[:invalid].each do |result|
+            reflect(:gcm_invalid_registration_id, @app, result[:error], result[:registration_id])
+          end
+        end
+
+        def create_new_notification(response, unavailable_idxs)
+          attrs = { 'app_id' => @notification.app_id, 'collapse_key' => @notification.collapse_key, 'delay_while_idle' => @notification.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), @app)
+        end
+
+        def bad_request
+          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
+          fail Rpush::DeliveryError.new(401, @notification.id, 'Unauthorized, check your App auth_key.')
+        end
+
+        def internal_server_error(response)
+          retry_delivery(@notification, response)
+          log_warn("GCM responded with an Internal Error. " + retry_message)
+        end
+
+        def bad_gateway(response)
+          retry_delivery(@notification, response)
+          log_warn("GCM responded with a Bad Gateway Error. " + retry_message)
+        end
+
+        def service_unavailable(response)
+          retry_delivery(@notification, response)
+          log_warn("GCM responded with an Service Unavailable Error. " + retry_message)
+        end
+
+        def other_5xx_error(response)
+          retry_delivery(@notification, response)
+          log_warn("GCM responded with a 5xx Error. " + retry_message)
+        end
+
+        def deliver_after_header(response)
+          Rpush::Daemon::RetryHeaderParser.parse(response.header['retry-after'])
+        end
+
+        def retry_delivery(notification, response)
+          time = deliver_after_header(response)
+          if time
+            mark_retryable(notification, time)
+          else
+            mark_retryable_exponential(notification)
+          end
+        end
+
+        def retry_message
+          "Notification #{@notification.id} will be retried after #{@notification.deliver_after.strftime('%Y-%m-%d %H:%M:%S')} (retry #{@notification.retries})."
+        end
+
+        def do_post
+          post = Net::HTTP::Post.new(FCM_URI.path, 'Content-Type'  => 'application/json',
+                                                   'Authorization' => "key=#{@app.auth_key}")
+          post.body = @notification.as_json.to_json
+          @http.request(FCM_URI, post)
+        end
+      end
+
+      class Results
+        attr_reader :successes, :failures
+
+        def initialize(results_data, registration_ids)
+          @results_data = results_data
+          @registration_ids = registration_ids
+        end
+
+        def process(failure_partitions = {}) # rubocop:disable Metrics/AbcSize
+          @successes = []
+          @failures = Failures.new
+          failure_partitions.each_key do |category|
+            failures[category] = []
+          end
+
+          @results_data.each_with_index do |result, index|
+            entry = {
+              registration_id: @registration_ids[index],
+              index: index
+            }
+            if result['message_id']
+              entry[:canonical_id] = result['registration_id'] if result['registration_id'].present?
+              successes << entry
+            elsif result['error']
+              entry[:error] = result['error']
+              failures << entry
+              failure_partitions.each do |category, error_states|
+                failures[category] << entry if error_states.include?(result['error'])
+              end
+            end
+          end
+          failures.all_failed = failures.count == @registration_ids.count
+        end
+      end
+
+      class Failures < Hash
+        include Enumerable
+        attr_writer :all_failed, :description
+
+        def initialize
+          super[:all] = []
+        end
+
+        def each
+          self[:all].each { |x| yield x }
+        end
+
+        def <<(item)
+          self[:all] << item
+        end
+
+        def description
+          @description ||= describe
+        end
+
+        def any?
+          self[:all].any?
+        end
+
+        private
+
+        def describe
+          if @all_failed
+            error_description = "Failed to deliver to all recipients."
+          else
+            index_list = map { |item| item[:index] }
+            error_description = "Failed to deliver to recipients #{index_list.join(', ')}."
+          end
+
+          error_list = map { |item| item[:error] }
+          error_description + " Errors: #{error_list.join(', ')}."
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/gcm.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Daemon
+    module Gcm
+      extend ServiceConfigMethods
+
+      dispatcher :http
+    end
+  end
+end