rpush 8.0.0 → 9.1.0

data/lib/rpush/apns_feedback.rb

@@ -1,18 +0,0 @@
-module Rpush
-  def self.apns_feedback
-    require 'rpush/daemon'
-    Rpush::Daemon.common_init
-
-    Rpush::Apns::App.all.each do |app|
-      # Redis stores every App type on the same namespace, hence the
-      # additional filtering
-      next unless app.service_name == 'apns'
-      next unless app.feedback_enabled
-
-      receiver = Rpush::Daemon::Apns::FeedbackReceiver.new(app)
-      receiver.check_for_feedback
-    end
-
-    nil
-  end
-end

data/lib/rpush/client/active_model/gcm/app.rb

@@ -1,19 +0,0 @@
-module Rpush
-  module Client
-    module ActiveModel
-      module Gcm
-        module App
-          def self.included(base)
-            base.instance_eval do
-              validates :auth_key, presence: true
-            end
-          end
-
-          def service_name
-            'gcm'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rpush/client/active_model/gcm/expiry_collapse_key_mutual_inclusion_validator.rb

@@ -1,14 +0,0 @@
-module Rpush
-  module Client
-    module ActiveModel
-      module Gcm
-        class ExpiryCollapseKeyMutualInclusionValidator < ::ActiveModel::Validator
-          def validate(record)
-            return unless record.collapse_key && !record.expiry
-            record.errors.add :expiry, 'must be set when using a collapse_key'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rpush/client/active_model/gcm/notification.rb

@@ -1,62 +0,0 @@
-module Rpush
-  module Client
-    module ActiveModel
-      module Gcm
-        module Notification
-          GCM_PRIORITY_HIGH = Rpush::Client::ActiveModel::Apns::Notification::APNS_PRIORITY_IMMEDIATE
-          GCM_PRIORITY_NORMAL = Rpush::Client::ActiveModel::Apns::Notification::APNS_PRIORITY_CONSERVE_POWER
-          GCM_PRIORITIES = [GCM_PRIORITY_HIGH, GCM_PRIORITY_NORMAL]
-
-          def self.included(base)
-            base.instance_eval do
-              validates :registration_ids, presence: true
-              validates :priority, inclusion: { in: GCM_PRIORITIES }, allow_nil: true
-              validates :dry_run, inclusion: { in: [true, false] }
-
-              validates_with Rpush::Client::ActiveModel::PayloadDataSizeValidator, limit: 4096
-              validates_with Rpush::Client::ActiveModel::RegistrationIdsCountValidator, limit: 1000
-
-              validates_with Rpush::Client::ActiveModel::Gcm::ExpiryCollapseKeyMutualInclusionValidator
-            end
-          end
-
-          # This is a hack. The schema defines `priority` to be an integer, but GCM expects a string.
-          # But for users of rpush to have an API they might expect (setting priority to `high`, not 10)
-          # we do a little conversion here.
-          # I'm not happy about it, but this will have to do until I can take a further look.
-          def priority=(priority)
-            case priority
-              when 'high', GCM_PRIORITY_HIGH
-                super(GCM_PRIORITY_HIGH)
-              when 'normal', GCM_PRIORITY_NORMAL
-                super(GCM_PRIORITY_NORMAL)
-              else
-                errors.add(:priority, 'must be one of either "normal" or "high"')
-            end
-          end
-
-          def as_json(options = nil) # rubocop:disable Metrics/PerceivedComplexity
-            json = {
-                'registration_ids' => registration_ids,
-                'delay_while_idle' => delay_while_idle,
-                'data' => data
-            }
-            json['collapse_key'] = collapse_key if collapse_key
-            json['content_available'] = content_available if content_available
-            json['mutable_content'] = mutable_content if mutable_content
-            json['dry_run'] = dry_run if dry_run
-            json['notification'] = notification if notification
-            json['priority'] = priority_for_notification if priority
-            json['time_to_live'] = expiry if expiry
-            json
-          end
-
-          def priority_for_notification
-            return 'high' if priority == GCM_PRIORITY_HIGH
-            'normal' if priority == GCM_PRIORITY_NORMAL
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rpush/client/active_record/gcm/app.rb

@@ -1,11 +0,0 @@
-module Rpush
-  module Client
-    module ActiveRecord
-      module Gcm
-        class App < Rpush::Client::ActiveRecord::App
-          include Rpush::Client::ActiveModel::Gcm::App
-        end
-      end
-    end
-  end
-end

data/lib/rpush/client/active_record/gcm/notification.rb

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

data/lib/rpush/client/redis/gcm/app.rb

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

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

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

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

@@ -1,43 +0,0 @@
-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

@@ -1,91 +0,0 @@
-# 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
-          return unless @app.feedback_enabled
-          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 Rainbow('✔').green if Rpush.config.foreground && Rpush.config.foreground_logging
-        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

@@ -1,17 +0,0 @@
-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/dispatcher/apns_tcp.rb

@@ -1,152 +0,0 @@
-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/tcp.rb

@@ -1,22 +0,0 @@
-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