rpush 1.0.0-java → 2.0.0-java

data/lib/rpush/daemon/interruptible_sleep.rb

@@ -1,60 +1,41 @@
+require 'monitor'
+
 module Rpush
   module Daemon
     class InterruptibleSleep
-
-      def initialize
-        @sleep_reader, @wake_writer = IO.pipe
-        @udp_wakeup = nil
+      def initialize(duration)
+        @duration = duration
+        @obj = Object.new
+        @obj.extend(MonitorMixin)
+        @condition = @obj.new_cond
+        @stop = false
       end
 
-      # enable wake on receiving udp packets at the given address and port
-      # this returns the host,port used by bind in case an ephemeral port
-      # was indicated by specifying 0 as the port number.
-      # @return [String,Integer] host,port of bound UDP socket.
-      def enable_wake_on_udp(host, port)
-        @udp_wakeup = UDPSocket.new
-        @udp_wakeup.bind(host, port)
-        @udp_wakeup.addr.values_at(3,1)
+      def sleep
+        return if @stop
+        @obj.synchronize { @condition.wait(100_000) }
       end
 
-      # wait for the given timeout in seconds, or data was written to the pipe
-      # or the udp wakeup port if enabled.
-      # @return [boolean] true if the sleep was interrupted, or false
-      def sleep(timeout)
-        read_ports = [@sleep_reader]
-        read_ports << @udp_wakeup if @udp_wakeup
-        rs, = IO.select(read_ports, nil, nil, timeout) rescue nil
-
-        # consume all data on the readable io's so that our next call will wait for more data
-        perform_io(rs, @sleep_reader, :read_nonblock)
-        perform_io(rs, @udp_wakeup, :recv_nonblock)
-
-        !rs.nil? && rs.any?
-      end
+      def start
+        @stop = false
 
-      # writing to the pipe will wake the sleeping thread
-      def interrupt_sleep
-        @wake_writer.write('.')
+        @thread = Thread.new do
+          loop do
+            break if @stop
+            Kernel.sleep(@duration)
+            wakeup
+          end
+        end
       end
 
-      def close
-        @sleep_reader.close rescue nil
-        @wake_writer.close rescue nil
-        @udp_wakeup.close if @udp_wakeup rescue nil
+      def stop
+        @stop = true
+        wakeup
+        @thread.kill if @thread
       end
 
-      private
-
-      def perform_io(selected, io, meth)
-        if selected && selected.include?(io)
-          while true
-            begin
-              io.__send__(meth, 1)
-            rescue Errno::EAGAIN, IO::WaitReadable
-              break
-            end
-          end
-        end
+      def wakeup
+        @obj.synchronize { @condition.signal }
       end
     end
   end

data/lib/rpush/daemon/loggable.rb

@@ -20,10 +20,8 @@ module Rpush
       private
 
       def app_prefix(msg)
-        if app = instance_variable_get('@app')
-          msg = "[#{app.name}] #{msg}"
-        end
-
+        app = instance_variable_get('@app')
+        msg = "[#{app.name}] #{msg}" if app
         msg
       end
     end

data/lib/rpush/daemon/proc_title.rb

@@ -0,0 +1,16 @@
+module Rpush
+  module Daemon
+    class ProcTitle
+      def self.update
+        $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 | %s | %d queued | %d %s", Rpush.config.environment, total_queued, total_dispatchers, dispatchers_str)
+      end
+    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/reflectable.rb

@@ -2,11 +2,9 @@ module Rpush
   module Daemon
     module Reflectable
       def reflect(name, *args)
-        begin
-          Rpush.reflections.__dispatch(name, *args)
-        rescue StandardError => e
-          Rpush.logger.error(e)
-        end
+        Rpush.reflections.__dispatch(name, *args)
+      rescue StandardError => e
+        Rpush.logger.error(e)
       end
     end
   end

data/lib/rpush/daemon/retry_header_parser.rb

@@ -10,12 +10,12 @@ module Rpush
       end
 
       def parse
-        if @header
-          if @header.to_s =~ /^[0-9]+$/
-            Time.now + @header.to_i
-          else
-            Time.httpdate(@header)
-          end
+        return unless @header
+
+        if @header.to_s =~ /^[0-9]+$/
+          Time.now + @header.to_i
+        else
+          Time.httpdate(@header)
         end
       end
     end

data/lib/rpush/daemon/retryable_error.rb

@@ -17,4 +17,6 @@ module Rpush
       "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/service_config_methods.rb

@@ -2,17 +2,27 @@ module Rpush
   module Daemon
     module ServiceConfigMethods
       DISPATCHERS = {
-        :http => Rpush::Daemon::Dispatcher::Http,
-        :tcp => Rpush::Daemon::Dispatcher::Tcp
+        http: Rpush::Daemon::Dispatcher::Http,
+        tcp: Rpush::Daemon::Dispatcher::Tcp,
+        apns_tcp: Rpush::Daemon::Dispatcher::ApnsTcp
       }
 
+      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] || (raise NotImplementedError)
+        DISPATCHERS[@dispatcher_name] || (fail NotImplementedError)
       end
 
       def delivery_class
@@ -23,10 +33,16 @@ module Rpush
         dispatcher_class.new(app, delivery_class, @dispatcher_options)
       end
 
-      def loops(*loops)
-        @loops ||= []
-        @loops = loops if loops.any?
-        @loops
+      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

data/lib/rpush/daemon/signal_handler.rb

@@ -0,0 +1,56 @@
+module Rpush
+  module Daemon
+    class SignalHandler
+      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
+      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'
+                Synchronizer.sync
+                Feeder.wakeup
+              when 'USR2'
+                AppRunner.debug
+              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 hndling signal '#{signal}'")
+              Rpush.logger.error(e)
+            end
+          end
+        end
+      end
+
+      def self.trap_signals?
+        !Rpush.config.embedded
+      end
+    end
+  end
+end

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

@@ -1,11 +1,15 @@
-class PGError < StandardError; end if !defined?(PGError)
-class Mysql; class Error < StandardError; end; end if !defined?(Mysql)
-module Mysql2; class Error < StandardError; end; end if !defined?(Mysql2)
-module ActiveRecord; end
-class ActiveRecord::JDBCError < StandardError; end if !defined?(::ActiveRecord::JDBCError)
+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:
-if !defined?(::SQLite3::Exception)
+unless defined?(::SQLite3::Exception)
   module SQLite3
     class Exception < StandardError; end
   end
@@ -16,19 +20,19 @@ module Rpush
     module Store
       class ActiveRecord
         module Reconnectable
-          ADAPTER_ERRORS = [::ActiveRecord::StatementInvalid, PGError, Mysql::Error,
-                            Mysql2::Error, ::ActiveRecord::JDBCError, SQLite3::Exception]
+          ADAPTER_ERRORS = [::ActiveRecord::StatementInvalid, PGError, PG::Error,
+                            Mysql::Error, Mysql2::Error, ::ActiveRecord::JDBCError,
+                            SQLite3::Exception, ::ActiveRecord::ConnectionTimeoutError]
 
           def with_database_reconnect_and_retry
-            begin
-              ::ActiveRecord::Base.connection_pool.with_connection do
-                yield
-              end
-            rescue *ADAPTER_ERRORS => e
-              Rpush.logger.error(e)
-              database_connection_lost
-              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
@@ -55,7 +59,7 @@ module Rpush
 
           def check_database_is_connected
             # Simply asking the adapter for the connection state is not sufficient.
-            Rpush::Notification.count
+            Rpush::Client::ActiveRecord::Notification.count
           end
 
           def sleep_to_avoid_thrashing

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

@@ -8,49 +8,66 @@ module Rpush
       class ActiveRecord
         include Reconnectable
 
-        DEFAULT_MARK_OPTIONS = {:persist => true}
+        DEFAULT_MARK_OPTIONS = { persist: true }
 
-        def deliverable_notifications(apps)
+        def app(id)
+          Rpush::Client::ActiveRecord::App.find(id)
+        end
+
+        def all_apps
+          Rpush::Client::ActiveRecord::App.all
+        end
+
+        def deliverable_notifications(limit)
           with_database_reconnect_and_retry do
-            batch_size = Rpush.config.batch_size
-            relation = Rpush::Notification.ready_for_delivery.for_apps(apps)
-            relation = relation.limit(batch_size) unless Rpush.config.push
-            relation.to_a
+            Rpush::Client::ActiveRecord::Notification.transaction do
+              relation = ready_for_delivery
+              relation = relation.limit(limit)
+              notifications = relation.lock(true).to_a
+              mark_processing(notifications)
+              notifications
+            end
           end
         end
 
         def mark_retryable(notification, deliver_after, opts = {})
           opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.processing = false
           notification.retries += 1
           notification.deliver_after = deliver_after
 
-          if opts[:persist]
-            with_database_reconnect_and_retry do
-              notification.save!(:validate => false)
-            end
+          return unless opts[:persist]
+
+          with_database_reconnect_and_retry do
+            notification.save!(validate: false)
           end
         end
 
         def mark_batch_retryable(notifications, deliver_after)
           ids = []
           notifications.each do |n|
-            mark_retryable(n, deliver_after, :persist => false)
+            mark_retryable(n, deliver_after, persist: false)
             ids << n.id
           end
+          mark_ids_retryable(ids, deliver_after)
+        end
+
+        def mark_ids_retryable(ids, deliver_after)
           with_database_reconnect_and_retry do
-            Rpush::Notification.where(:id => ids).update_all(['retries = retries + 1, deliver_after = ?', deliver_after])
+            Rpush::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?, delivered = ?, delivered_at = ?, failed = ?, failed_at = ?, retries = retries + 1, deliver_after = ?', false, false, nil, false, nil, deliver_after])
           end
         end
 
         def mark_delivered(notification, time, opts = {})
           opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.processing = false
           notification.delivered = true
           notification.delivered_at = time
 
-          if opts[:persist]
-            with_database_reconnect_and_retry do
-              notification.save!(:validate => false)
-            end
+          return unless opts[:persist]
+
+          with_database_reconnect_and_retry do
+            notification.save!(validate: false)
           end
         end
 
@@ -58,16 +75,17 @@ module Rpush
           now = Time.now
           ids = []
           notifications.each do |n|
-            mark_delivered(n, now, :persist => false)
+            mark_delivered(n, now, persist: false)
             ids << n.id
           end
           with_database_reconnect_and_retry do
-            Rpush::Notification.where(:id => ids).update_all(['delivered = ?, delivered_at = ?', true, now])
+            Rpush::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?, delivered = ?, delivered_at = ?', false, true, now])
           end
         end
 
         def mark_failed(notification, code, description, time, opts = {})
           opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.processing = false
           notification.delivered = false
           notification.delivered_at = nil
           notification.failed = true
@@ -75,10 +93,10 @@ module Rpush
           notification.error_code = code
           notification.error_description = description
 
-          if opts[:persist]
-            with_database_reconnect_and_retry do
-              notification.save!(:validate => false)
-            end
+          return unless opts[:persist]
+
+          with_database_reconnect_and_retry do
+            notification.save!(validate: false)
           end
         end
 
@@ -86,28 +104,32 @@ module Rpush
           now = Time.now
           ids = []
           notifications.each do |n|
-            mark_failed(n, code, description, now, :persist => false)
+            mark_failed(n, code, description, now, persist: false)
             ids << n.id
           end
+          mark_ids_failed(ids, code, description, now)
+        end
+
+        def mark_ids_failed(ids, code, description, time)
           with_database_reconnect_and_retry do
-            Rpush::Notification.where(:id => ids).update_all(['delivered = ?, delivered_at = NULL, failed = ?, failed_at = ?, error_code = ?, error_description = ?', false, true, now, code, description])
+            Rpush::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?, delivered = ?, delivered_at = NULL, failed = ?, failed_at = ?, error_code = ?, error_description = ?', false, false, true, time, code, description])
           end
         end
 
         def create_apns_feedback(failed_at, device_token, app)
           with_database_reconnect_and_retry do
-            Rpush::Apns::Feedback.create!(:failed_at => failed_at,
-              :device_token => device_token, :app => app)
+            Rpush::Client::ActiveRecord::Apns::Feedback.create!(failed_at: failed_at,
+                                                                device_token: device_token, app_id: app.id)
           end
         end
 
         def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
-          notification = Rpush::Gcm::Notification.new
+          notification = Rpush::Client::ActiveRecord::Gcm::Notification.new
           create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
         end
 
         def create_adm_notification(attrs, data, registration_ids, deliver_after, app)
-          notification = Rpush::Adm::Notification.new
+          notification = Rpush::Client::ActiveRecord::Adm::Notification.new
           create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
         end
 
@@ -123,21 +145,15 @@ module Rpush
           end
         end
 
-        def after_daemonize
-          reconnect_database
-        end
-
         def release_connection
-          begin
-            ::ActiveRecord::Base.connection_pool.release_connection
-          rescue StandardError => e
-            Rpush.logger.error(e)
-          end
+          ::ActiveRecord::Base.connection.close
+        rescue StandardError => e
+          Rpush.logger.error(e)
         end
 
         private
 
-        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists
           with_database_reconnect_and_retry do
             notification.assign_attributes(attrs)
             notification.data = data
@@ -148,7 +164,24 @@ module Rpush
             notification
           end
         end
+
+        def ready_for_delivery
+          Rpush::Client::ActiveRecord::Notification.where('processing = ? AND delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)', false, false, false, Time.now)
+        end
+
+        def mark_processing(notifications)
+          return if notifications.empty?
+
+          ids = []
+          notifications.each do |n|
+            n.processing = true
+            ids << n.id
+          end
+          Rpush::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?', true])
+        end
       end
     end
   end
 end
+
+Rpush::Daemon::Store::Interface.check(Rpush::Daemon::Store::ActiveRecord)

data/lib/rpush/daemon/store/interface.rb

@@ -0,0 +1,19 @@
+module Rpush
+  module Daemon
+    module Store
+      class Interface
+        PUBLIC_METHODS = [:deliverable_notifications, :mark_retryable,
+                          :mark_batch_retryable, :mark_delivered, :mark_batch_delivered,
+                          :mark_failed, :mark_batch_failed, :create_apns_feedback,
+                          :create_gcm_notification, :create_adm_notification, :update_app,
+                          :update_notification, :release_connection,
+                          :all_apps, :app, :mark_ids_failed, :mark_ids_retryable]
+
+        def self.check(klass)
+          missing = PUBLIC_METHODS - klass.instance_methods.map(&:to_sym)
+          fail "#{klass} must implement #{missing.join(', ')}." if missing.any?
+        end
+      end
+    end
+  end
+end