rpush_extended 3.2.5

data/lib/rpush/daemon/interruptible_sleep.rb

@@ -0,0 +1,24 @@
+module Rpush
+  module Daemon
+    class InterruptibleSleep
+      def sleep(duration)
+        @thread = Thread.new { Kernel.sleep duration }
+        Thread.pass
+
+        begin
+          @thread.join
+        rescue StandardError # rubocop:disable Lint/HandleExceptions
+        ensure
+          @thread = nil
+        end
+      end
+
+      def stop
+        @thread.kill if @thread
+      rescue StandardError # rubocop:disable Lint/HandleExceptions
+      ensure
+        @thread = nil
+      end
+    end
+  end
+end

data/lib/rpush/daemon/loggable.rb

@@ -0,0 +1,33 @@
+module Rpush
+  module Daemon
+    module Loggable
+      def log_debug(msg)
+        Rpush.logger.debug(app_prefix(msg))
+      end
+
+      def log_info(msg)
+        Rpush.logger.info(app_prefix(msg))
+      end
+
+      def log_warn(msg)
+        Rpush.logger.warn(app_prefix(msg))
+      end
+
+      def log_error(e)
+        if e.is_a?(Exception)
+          Rpush.logger.error(e)
+        else
+          Rpush.logger.error(app_prefix(e))
+        end
+      end
+
+      private
+
+      def app_prefix(msg)
+        app = instance_variable_get('@app')
+        msg = "[#{app.name}] #{msg}" if app
+        msg
+      end
+    end
+  end
+end

data/lib/rpush/daemon/proc_title.rb

@@ -0,0 +1,17 @@
+module Rpush
+  module Daemon
+    class ProcTitle
+      def self.update
+        return if Rpush.config.embedded || Rpush.config.push
+        Process.respond_to?(:setproctitle) ? Process.setproctitle(proc_title) : $0 = proc_title
+      end
+
+      def self.proc_title
+        total_dispatchers = AppRunner.total_dispatchers
+        dispatchers_str = total_dispatchers == 1 ? 'dispatcher' : 'dispatchers'
+        total_queued = AppRunner.total_queued
+        format("rpush | %d queued | %d %s", total_queued, total_dispatchers, dispatchers_str)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Rpush
+  module Daemon
+    module Pushy
+      class Delivery < Rpush::Daemon::Delivery
+        include MultiJsonHelper
+
+        attr_reader :http, :notification, :batch, :pushy_uri
+
+        def initialize(app, http, notification, batch)
+          @http = http
+          @notification = notification
+          @batch = batch
+          @pushy_uri = URI.parse("https://api.pushy.me/push?api_key=#{app.api_key}")
+        end
+
+        def perform
+          response = send_request
+          process_response(response)
+        rescue SocketError => error
+          mark_retryable(notification, Time.now + 10.seconds, error)
+          raise
+        rescue StandardError => error
+          mark_failed(error)
+          raise
+        ensure
+          batch.notification_processed
+        end
+
+        private
+
+        def send_request
+          post = Net::HTTP::Post.new(pushy_uri)
+          post.content_type = 'application/json'
+          post.body = notification.to_json
+          http.request(pushy_uri, post)
+        end
+
+        def process_response(response)
+          case response.code.to_i
+          when 200
+            process_delivery(response)
+          when 429, 500, 502, 503, 504
+            retry_delivery(response)
+          else
+            fail_delivery(response)
+          end
+        end
+
+        def process_delivery(response)
+          mark_delivered
+          body = multi_json_load(response.body)
+          external_device_id = body['id']
+          notification.external_device_id = external_device_id
+          Rpush::Daemon.store.update_notification(notification)
+          log_info("#{notification.id} received an external id=#{external_device_id}")
+        end
+
+        def retry_delivery(response)
+          time = deliver_after_header(response)
+          if time
+            mark_retryable(notification, time)
+          else
+            mark_retryable_exponential(notification)
+          end
+          log_warn("Pushy responded with a #{response.code} error. #{retry_message}")
+        end
+
+        def deliver_after_header(response)
+          Rpush::Daemon::RetryHeaderParser.parse(response.header['retry-after'])
+        end
+
+        def retry_message
+          deliver_after = notification.deliver_after.strftime('%Y-%m-%d %H:%M:%S')
+          "Notification #{notification.id} will be retried after #{deliver_after} (retry #{notification.retries})."
+        end
+
+        def fail_delivery(response)
+          fail_message = fail_message(response)
+          log_error("#{notification.id} failed: #{fail_message}")
+          fail Rpush::DeliveryError.new(response.code.to_i, notification.id, fail_message)
+        end
+
+        def fail_message(response)
+          body = multi_json_load(response.body)
+          body['error'] || Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i]
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/pushy.rb

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

data/lib/rpush/daemon/queue_payload.rb

@@ -0,0 +1,12 @@
+module Rpush
+  module Daemon
+    class QueuePayload
+      attr_reader :batch, :notification
+
+      def initialize(batch, notification = nil)
+        @batch = batch
+        @notification = notification
+      end
+    end
+  end
+end

data/lib/rpush/daemon/retry_header_parser.rb

@@ -0,0 +1,23 @@
+module Rpush
+  module Daemon
+    class RetryHeaderParser
+      def self.parse(header)
+        new(header).parse
+      end
+
+      def initialize(header)
+        @header = header
+      end
+
+      def parse
+        return unless @header
+
+        if @header.to_s =~ /^[0-9]+$/
+          Time.now + @header.to_i
+        else
+          Time.httpdate(@header)
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/retryable_error.rb

@@ -0,0 +1,22 @@
+module Rpush
+  class RetryableError < StandardError
+    attr_reader :code, :description, :response
+
+    def initialize(code, notification_id, description, response)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+      @response = response
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      "Retryable error for #{@notification_id}, received error #{@code} (#{@description}) - retry after #{@response.header['retry-after']}"
+    end
+  end
+
+  class RateLimitError < RetryableError; end
+end

data/lib/rpush/daemon/ring_buffer.rb

@@ -0,0 +1,16 @@
+module Rpush
+  module Daemon
+    class RingBuffer < Array
+      def initialize(max_size)
+        @max_size = max_size
+      end
+
+      def <<(obj)
+        shift if size >= @max_size
+        super
+      end
+
+      alias_method :push, :<<
+    end
+  end
+end

data/lib/rpush/daemon/rpc/client.rb

@@ -0,0 +1,27 @@
+module Rpush
+  module Daemon
+    module Rpc
+      class Client
+        def initialize(pid)
+          @socket = UNIXSocket.open(Rpc.socket_path(pid))
+        end
+
+        def status
+          call(:status)
+        end
+
+        def close
+          @socket.close
+        rescue StandardError # rubocop:disable Lint/HandleExceptions
+        end
+
+        private
+
+        def call(cmd, args = {})
+          @socket.puts(JSON.dump([cmd, args]))
+          JSON.parse(@socket.gets)
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/rpc/server.rb

@@ -0,0 +1,82 @@
+require 'socket'
+require 'singleton'
+
+module Rpush
+  module Daemon
+    module Rpc
+      class Server
+        include Singleton
+        include Loggable
+        include Reflectable
+
+        def self.start
+          instance.start
+        end
+
+        def self.stop
+          instance.stop
+        end
+
+        def start
+          @stop = false
+
+          @thread = Thread.new(UNIXServer.open(Rpc.socket_path)) do |server|
+            begin
+              loop do
+                socket = server.accept
+                break if @stop
+                read_loop(socket)
+              end
+
+              server.close
+            rescue StandardError => e
+              log_error(e)
+            ensure
+              File.unlink(Rpc.socket_path) if File.exist?(Rpc.socket_path)
+            end
+          end
+        end
+
+        def stop
+          @stop = true
+          UNIXSocket.new(Rpc.socket_path)
+          @thread.join if @thread
+        rescue StandardError => e
+          log_error(e)
+        end
+
+        private
+
+        def read_loop(socket)
+          loop do
+            line = socket.gets
+            break unless line
+
+            begin
+              cmd, args = JSON.load(line)
+              log_debug("[rpc:server] #{cmd.to_sym.inspect}, args: #{args.inspect}")
+              response = process(cmd, args)
+              socket.puts(JSON.dump(response))
+            rescue StandardError => e
+              log_error(e)
+              reflect(:error, e)
+            end
+          end
+
+          socket.close
+        end
+
+        def process(cmd, args) # rubocop:disable Lint/UnusedMethodArgument
+          case cmd
+          when 'status'
+            status
+          end
+        end
+
+        def status
+          Rpush::Daemon::AppRunner.status
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/rpc.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Daemon
+    module Rpc
+      def self.socket_path(pid = Process.pid)
+        "/tmp/rpush.#{pid}.sock"
+      end
+    end
+  end
+end

data/lib/rpush/daemon/service_config_methods.rb

@@ -0,0 +1,51 @@
+module Rpush
+  module Daemon
+    module ServiceConfigMethods
+      DISPATCHERS = {
+        http:       Rpush::Daemon::Dispatcher::Http,
+        tcp:        Rpush::Daemon::Dispatcher::Tcp,
+        apns_tcp:   Rpush::Daemon::Dispatcher::ApnsTcp,
+        apns_http2: Rpush::Daemon::Dispatcher::ApnsHttp2,
+        apnsp8_http2: Rpush::Daemon::Dispatcher::Apnsp8Http2
+      }
+
+      def batch_deliveries(value = nil)
+        return batch_deliveries? if value.nil?
+        @batch_deliveries = value
+      end
+
+      def batch_deliveries?
+        @batch_deliveries == true
+      end
+
+      def dispatcher(name = nil, options = {})
+        @dispatcher_name = name
+        @dispatcher_options = options
+      end
+
+      def dispatcher_class
+        DISPATCHERS[@dispatcher_name] || (fail NotImplementedError)
+      end
+
+      def delivery_class
+        const_get('Delivery')
+      end
+
+      def new_dispatcher(app)
+        dispatcher_class.new(app, delivery_class, @dispatcher_options)
+      end
+
+      def loops(classes, options = {})
+        classes = Array[*classes]
+        @loops = classes.map { |cls| [cls, options] }
+      end
+
+      def loop_instances(app)
+        (@loops || []).map do |cls, options|
+          next unless options.key?(:if) ? options[:if].call : true
+          cls.new(app)
+        end.compact
+      end
+    end
+  end
+end

data/lib/rpush/daemon/signal_handler.rb

@@ -0,0 +1,75 @@
+module Rpush
+  module Daemon
+    class SignalHandler
+      extend Loggable
+
+      class << self
+        attr_reader :thread
+      end
+
+      def self.start
+        return unless trap_signals?
+
+        read_io, @write_io = IO.pipe
+        start_handler(read_io)
+        %w(INT TERM HUP USR2).each do |signal|
+          Signal.trap(signal) { @write_io.puts(signal) }
+        end
+      end
+
+      def self.stop
+        @write_io.puts('break') if @write_io
+        @thread.join if @thread
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
+      end
+
+      def self.start_handler(read_io)
+        @thread = Thread.new do
+          while readable_io = IO.select([read_io]) # rubocop:disable AssignmentInCondition
+            signal = readable_io.first[0].gets.strip
+
+            begin
+              case signal
+              when 'HUP'
+                handle_hup
+              when 'USR2'
+                handle_usr2
+              when 'INT', 'TERM'
+                Thread.new { Rpush::Daemon.shutdown }
+                break
+              when 'break'
+                break
+              else
+                Rpush.logger.error("Unhandled signal: #{signal}")
+              end
+            rescue StandardError => e
+              Rpush.logger.error("Error raised when handling signal '#{signal}'")
+              Rpush.logger.error(e)
+            end
+          end
+        end
+      end
+
+      def self.handle_hup
+        Rpush.logger.reopen
+        Rpush.logger.info('Received HUP signal.')
+        Rpush::Daemon.store.reopen_log
+        Synchronizer.sync
+        Feeder.wakeup
+      end
+
+      def self.handle_usr2
+        Rpush.logger.info('Received USR2 signal.')
+        AppRunner.debug
+      end
+
+      def self.trap_signals?
+        !Rpush.config.embedded
+      end
+    end
+  end
+end

data/lib/rpush/daemon/store/active_record/reconnectable.rb

@@ -0,0 +1,80 @@
+class PGError < StandardError; end unless defined?(PGError)
+module PG
+  class Error < StandardError; end unless defined?(::PG::Error)
+end
+class Mysql; class Error < StandardError; end; end unless defined?(Mysql)
+module Mysql2; class Error < StandardError; end; end unless defined?(Mysql2)
+module ActiveRecord
+  class JDBCError < StandardError; end unless defined?(::ActiveRecord::JDBCError)
+end
+
+# :nocov:
+unless defined?(::SQLite3::Exception)
+  module SQLite3
+    class Exception < StandardError; end
+  end
+end
+
+module Rpush
+  module Daemon
+    module Store
+      class ActiveRecord
+        module Reconnectable
+          ADAPTER_ERRORS = [
+              ::ActiveRecord::ConnectionNotEstablished,
+              ::ActiveRecord::ConnectionTimeoutError,
+              ::ActiveRecord::JDBCError,
+              ::ActiveRecord::StatementInvalid,
+              Mysql::Error,
+              Mysql2::Error,
+              PG::Error,
+              PGError,
+              SQLite3::Exception
+          ]
+
+          def with_database_reconnect_and_retry
+            ::ActiveRecord::Base.connection_pool.with_connection do
+              yield
+            end
+          rescue *ADAPTER_ERRORS => e
+            Rpush.logger.error(e)
+            sleep_to_avoid_thrashing
+            database_connection_lost
+            retry
+          end
+
+          def database_connection_lost
+            Rpush.logger.warn("Lost connection to database, reconnecting...")
+            attempts = 0
+            loop do
+              begin
+                Rpush.logger.warn("Attempt #{attempts += 1}")
+                reconnect_database
+                check_database_is_connected
+                break
+              rescue *ADAPTER_ERRORS => e
+                Rpush.logger.error(e)
+                sleep_to_avoid_thrashing
+              end
+            end
+            Rpush.logger.warn("Database reconnected")
+          end
+
+          def reconnect_database
+            ::ActiveRecord::Base.clear_all_connections!
+            ::ActiveRecord::Base.establish_connection
+          end
+
+          def check_database_is_connected
+            # Simply asking the adapter for the connection state is not sufficient.
+            Rpush::Client::ActiveRecord::Notification.count
+          end
+
+          def sleep_to_avoid_thrashing
+            sleep 2
+          end
+        end
+      end
+    end
+  end
+end