rpush_extended 3.2.5

data/lib/rpush/client/redis/wpns/notification.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Wpns
+        class Notification < Rpush::Client::Redis::Notification
+          include Rpush::Client::ActiveModel::Wpns::Notification
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis.rb

@@ -0,0 +1,56 @@
+
+# :nocov:
+begin
+  require 'modis'
+  require 'redis'
+rescue LoadError
+  puts
+  str = "* Please add 'rpush-redis' to your Gemfile to use the Redis client. *"
+  puts "*" * str.size
+  puts str
+  puts "*" * str.size
+  puts
+end
+
+require 'rpush/client/active_model'
+
+require 'rpush/client/redis/app'
+require 'rpush/client/redis/notification'
+
+require 'rpush/client/redis/apns/app'
+require 'rpush/client/redis/apns/notification'
+require 'rpush/client/redis/apns/feedback'
+
+require 'rpush/client/redis/apns2/app'
+require 'rpush/client/redis/apns2/notification'
+
+require 'rpush/client/redis/apnsp8/app'
+require 'rpush/client/redis/apnsp8/notification'
+
+require 'rpush/client/redis/gcm/app'
+require 'rpush/client/redis/gcm/notification'
+
+require 'rpush/client/redis/adm/app'
+require 'rpush/client/redis/adm/notification'
+
+require 'rpush/client/redis/wpns/app'
+require 'rpush/client/redis/wpns/notification'
+
+require 'rpush/client/redis/wns/app'
+require 'rpush/client/redis/wns/notification'
+require 'rpush/client/redis/wns/raw_notification'
+require 'rpush/client/redis/wns/badge_notification'
+
+require 'rpush/client/redis/pushy/app'
+require 'rpush/client/redis/pushy/notification'
+
+Modis.configure do |config|
+  config.namespace = :rpush
+end
+
+# Prevent diverging Redis namespaces for subclasses as introduced by Modis 1.4.2
+Rpush::Client::Redis::Notification.subclasses.each do |notification_class|
+  notification_class.class_eval do
+    self.namespace = Rpush::Client::Redis::Notification.namespace
+  end
+end

data/lib/rpush/configuration.rb

@@ -0,0 +1,115 @@
+require 'pathname'
+require 'ostruct'
+
+module Rpush
+  class << self
+    attr_writer :config
+
+    def config
+      @config ||= Rpush::Configuration.new
+    end
+
+    def configure
+      return unless block_given?
+      yield config
+      config.initialize_client
+    end
+  end
+
+  CURRENT_ATTRS = [:push_poll, :embedded, :pid_file, :batch_size, :push, :client, :logger, :log_file, :foreground, :log_level, :plugin, :apns]
+  DEPRECATED_ATTRS = []
+  CONFIG_ATTRS = CURRENT_ATTRS + DEPRECATED_ATTRS
+
+  class ConfigurationError < StandardError; end
+
+  class ApnsFeedbackReceiverConfiguration < Struct.new(:frequency, :enabled) # rubocop:disable Style/StructInheritance
+    def initialize
+      super
+      self.enabled = true
+      self.frequency = 60
+    end
+  end
+
+  class ApnsConfiguration < Struct.new(:feedback_receiver) # rubocop:disable Style/StructInheritance
+    def initialize
+      super
+      self.feedback_receiver = ApnsFeedbackReceiverConfiguration.new
+    end
+  end
+
+  class Configuration < Struct.new(*CONFIG_ATTRS) # rubocop:disable Style/StructInheritance
+    include Deprecatable
+
+    delegate :redis_options, to: '::Modis'
+
+    def initialize
+      super
+
+      self.push_poll = 2
+      self.batch_size = 100
+      self.logger = nil
+      self.log_file = 'log/rpush.log'
+      self.pid_file = 'tmp/rpush.pid'
+      self.log_level = (defined?(Rails) && Rails.logger) ? Rails.logger.level : ::Logger::Severity::DEBUG
+      self.plugin = OpenStruct.new
+      self.foreground = false
+
+      self.apns = ApnsConfiguration.new
+
+      # Internal options.
+      self.embedded = false
+      self.push = false
+    end
+
+    def update(other)
+      CONFIG_ATTRS.each do |attr|
+        other_value = other.send(attr)
+        send("#{attr}=", other_value) unless other_value.nil?
+      end
+    end
+
+    def pid_file=(path)
+      if path && !Pathname.new(path).absolute?
+        super(File.join(Rpush.root, path))
+      else
+        super
+      end
+    end
+
+    def log_file=(path)
+      if path && !Pathname.new(path).absolute?
+        super(File.join(Rpush.root, path))
+      else
+        super
+      end
+    end
+
+    def logger=(logger)
+      super(logger)
+    end
+
+    def client=(client)
+      super
+      initialize_client
+    end
+
+    def redis_options=(options)
+      Modis.redis_options = options if client == :redis
+    end
+
+    def initialize_client
+      return if @client_initialized
+      raise ConfigurationError, 'Rpush.config.client is not set.' unless client
+      require "rpush/client/#{client}"
+
+      client_module = Rpush::Client.const_get(client.to_s.camelize)
+      Rpush.send(:include, client_module) unless Rpush.ancestors.include?(client_module)
+
+      [:Apns, :Gcm, :Wpns, :Wns, :Adm, :Pushy].each do |service|
+        Rpush.const_set(service, client_module.const_get(service)) unless Rpush.const_defined?(service)
+      end
+
+      @client_initialized = true
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+module Rpush
+  module Daemon
+    module Adm
+      # https://developer.amazon.com/sdk/adm/sending-message.html
+      class Delivery < Rpush::Daemon::Delivery
+        include MultiJsonHelper
+
+        # Oauth2.0 token endpoint. This endpoint is used to request authorization tokens.
+        AMAZON_TOKEN_URI = URI.parse('https://api.amazon.com/auth/O2/token')
+
+        # ADM services endpoint. This endpoint is used to perform ADM requests.
+        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" }
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+          @sent_registration_ids = []
+          @failed_registration_ids = {}
+        end
+
+        def perform
+          @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
+            mark_delivered
+          end
+        rescue Rpush::RateLimitError => error
+          handle_rate_limited(error)
+        rescue Rpush::RetryableError => error
+          handle_retryable(error)
+        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, current_registration_id)
+          case response.code.to_i
+          when 200
+            ok(response, current_registration_id)
+          when 400
+            bad_request(response, current_registration_id)
+          when 401
+            unauthorized(response)
+          when 429
+            rate_limited(response)
+          when 500
+            internal_server_error(current_registration_id)
+          when 503
+            service_unavailable(response)
+          else
+            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.key?('registrationID')
+            @sent_registration_ids << response_body['registrationID']
+            log_info("#{@notification.id} sent to #{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)
+          case error.code
+          when 401
+            # clear app access_token so a new one is fetched
+            @notification.app.access_token = nil
+            access_token
+            mark_retryable(@notification, Time.now) if @notification.app.access_token
+          when 503
+            retry_delivery(@notification, error.response)
+            log_warn("ADM responded with an Service Unavailable Error. " + retry_message)
+          end
+        end
+
+        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
+            # save unsent registration ids
+            unsent_registration_ids = @notification.registration_ids.select { |reg_id| !@sent_registration_ids.include?(reg_id) }
+
+            # update the current notification so it only contains the sent reg ids
+            @notification.registration_ids.reject! { |reg_id| !@sent_registration_ids.include?(reg_id) }
+
+            Rpush::Daemon.store.update_notification(@notification)
+
+            # create a new notification with the remaining unsent reg ids
+            create_new_notification(error.response, unsent_registration_ids)
+
+            # mark the current notification as sent
+            mark_delivered
+          end
+        end
+
+        def bad_request(response, current_registration_id)
+          response_body = multi_json_load(response.body)
+
+          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.
+          fail Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Unauthorized Error.', response)
+        end
+
+        def rate_limited(response)
+          # raise error so the current notification stops sending messages to remaining reg ids
+          fail Rpush::RateLimitError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
+        end
+
+        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.
+          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)
+          attrs = { 'app_id' => @notification.app_id, 'collapse_key' => @notification.collapse_key, 'delay_while_idle' => @notification.delay_while_idle }
+          Rpush::Daemon.store.create_adm_notification(attrs, @notification.data, registration_ids, deliver_after_header(response), @notification.app)
+        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 describe_errors
+          if @failed_registration_ids.size == @notification.registration_ids.size
+            "Failed to deliver to all recipients."
+          else
+            error_msgs = []
+            @failed_registration_ids.each_pair { |regId, reason| error_msgs.push("#{regId}: #{reason}") }
+            "Failed to deliver to recipients: \n#{error_msgs.join("\n")}"
+          end
+        end
+
+        def retry_message
+          "Notification #{@notification.id} will be retired after #{@notification.deliver_after.strftime('%Y-%m-%d %H:%M:%S')} (retry #{@notification.retries})."
+        end
+
+        def do_post(registration_id)
+          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 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
+
+          @notification.app.access_token
+        end
+
+        def handle_access_token(response)
+          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}")
+          else
+            log_warn("Could not retrieve access token from ADM: #{response.body}")
+          end
+        end
+
+        def update_access_token(data)
+          @notification.app.access_token = data['access_token']
+          @notification.app.access_token_expiration = Time.now + data['expires_in'].to_i
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/adm.rb

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

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

@@ -0,0 +1,43 @@
+module Rpush
+  module Daemon
+    module Apns
+      class Delivery < Rpush::Daemon::Delivery
+        def initialize(app, connection, batch)
+          @app = app
+          @connection = connection
+          @batch = batch
+        end
+
+        def perform
+          @connection.write(batch_to_binary)
+          mark_batch_delivered
+          describe_deliveries
+        rescue Rpush::Daemon::TcpConnectionError => error
+          mark_batch_retryable(Time.now + 10.seconds, error)
+          raise
+        rescue StandardError => error
+          mark_batch_failed(error)
+          raise
+        ensure
+          @batch.all_processed
+        end
+
+        protected
+
+        def batch_to_binary
+          payload = ""
+          @batch.each_notification do |notification|
+            payload << notification.to_binary
+          end
+          payload
+        end
+
+        def describe_deliveries
+          @batch.each_notification do |notification|
+            log_info("#{notification.id} sent to #{notification.device_token}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/apns/feedback_receiver.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+
+module Rpush
+  module Daemon
+    module Apns
+      class FeedbackReceiver
+        include Reflectable
+        include Loggable
+
+        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]
+        }
+
+        def initialize(app)
+          @app = app
+          @host, @port = HOSTS[@app.environment.to_sym]
+          @certificate = app.certificate
+          @password = app.password
+          @interruptible_sleep = InterruptibleSleep.new
+        end
+
+        def start
+          return if Rpush.config.push
+          Rpush.logger.info("[#{@app.name}] Starting feedback receiver... ", true)
+
+          @thread = Thread.new do
+            loop do
+              break if @stop
+              check_for_feedback
+              @interruptible_sleep.sleep(Rpush.config.apns.feedback_receiver.frequency)
+            end
+
+            Rpush::Daemon.store.release_connection
+          end
+
+          puts ANSI.green { '✔' } if Rpush.config.foreground
+        end
+
+        def stop
+          @stop = true
+          @interruptible_sleep.stop
+          @thread.join if @thread
+        rescue StandardError => e
+          log_error(e)
+          reflect(:error, e)
+        ensure
+          @thread = nil
+        end
+
+        def check_for_feedback
+          connection = nil
+          begin
+            connection = Rpush::Daemon::TcpConnection.new(@app, @host, @port)
+            connection.connect
+            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)
+            reflect(:error, e)
+          ensure
+            connection.close if connection
+          end
+        end
+
+        protected
+
+        def parse_tuple(tuple)
+          failed_at, _, device_token = tuple.unpack("N1n1H*")
+          [Time.at(failed_at).utc, device_token]
+        end
+
+        def create_feedback(failed_at, device_token)
+          formatted_failed_at = failed_at.strftime('%Y-%m-%d %H:%M:%S UTC')
+          log_info("[FeedbackReceiver] Delivery failed at #{formatted_failed_at} for #{device_token}.")
+
+          feedback = Rpush::Daemon.store.create_apns_feedback(failed_at, device_token, @app)
+          reflect(:apns_feedback, feedback)
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/apns.rb

@@ -0,0 +1,17 @@
+module Rpush
+  module Daemon
+    module Apns
+      extend ServiceConfigMethods
+
+      HOSTS = {
+        production: ['gateway.push.apple.com', 2195],
+        development: ['gateway.sandbox.push.apple.com', 2195], # deprecated
+        sandbox: ['gateway.sandbox.push.apple.com', 2195]
+      }
+
+      batch_deliveries true
+      dispatcher :apns_tcp, host: proc { |app| HOSTS[app.environment.to_sym] }
+      loops Rpush::Daemon::Apns::FeedbackReceiver, if: -> { Rpush.config.apns.feedback_receiver.enabled && !Rpush.config.push }
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module Rpush
+  module Daemon
+    module Apns2
+      # 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, batch)
+          @app = app
+          @client = http2_client
+          @batch = batch
+        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 => error
+          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)
+          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) }
+
+          @client.call_async(http_request)
+        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)
+          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