rpush 1.0.0-java

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

@@ -0,0 +1,222 @@
+module Rpush
+  module Daemon
+    module Gcm
+
+      # http://developer.android.com/guide/google/gcm/gcm.html#response
+      class Delivery < Rpush::Daemon::Delivery
+        include MultiJsonHelper
+
+        host = ENV["RPUSH_GCM_HOST"] || "https://android.googleapis.com"
+        GCM_URI = URI.parse("#{host}/gcm/send")
+        UNAVAILABLE_STATES = ['Unavailable', 'InternalServerError']
+        INVALID_REGISTRATION_ID_STATES = ['InvalidRegistration', 'MismatchSenderId', 'NotRegistered', 'InvalidPackageName']
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          begin
+            handle_response(do_post)
+          rescue Rpush::DeliveryError => error
+            mark_failed(error.code, error.description)
+            raise
+          end
+        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 503
+            service_unavailable(response)
+          else
+            raise Rpush::DeliveryError.new(response.code, @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])
+            if result.has_key?(:canonical_id)
+              reflect(:gcm_canonical_id, result[:registration_id], result[:canonical_id])
+            end
+          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)
+            raise 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 = @notification.attributes.slice('app_id', 'collapse_key', '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), @notification.app)
+        end
+
+        def bad_request
+          raise Rpush::DeliveryError.new(400, @notification.id, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
+        end
+
+        def unauthorized
+          raise 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 service_unavailable(response)
+          retry_delivery(@notification, response)
+          log_warn("GCM responded with an Service Unavailable Error. " + retry_message)
+        end
+
+        def deliver_after_header(response)
+          Rpush::Daemon::RetryHeaderParser.parse(response.header['retry-after'])
+        end
+
+        def retry_delivery(notification, response)
+          if time = deliver_after_header(response)
+            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(GCM_URI.path, initheader = {'Content-Type'  => 'application/json',
+                                                                 'Authorization' => "key=#{@notification.app.auth_key}"})
+          post.body = @notification.as_json.to_json
+          @http.request(GCM_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 = {})
+          @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.total_fail = failures.count == @registration_ids.count
+        end
+      end
+
+      class Failures < Hash
+        include Enumerable
+        attr_writer :total_fail, :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
+
+        private
+
+        def describe
+          if @total_fail
+            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

data/lib/rpush/daemon/interruptible_sleep.rb

@@ -0,0 +1,61 @@
+module Rpush
+  module Daemon
+    class InterruptibleSleep
+
+      def initialize
+        @sleep_reader, @wake_writer = IO.pipe
+        @udp_wakeup = nil
+      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)
+      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
+
+      # writing to the pipe will wake the sleeping thread
+      def interrupt_sleep
+        @wake_writer.write('.')
+      end
+
+      def close
+        @sleep_reader.close rescue nil
+        @wake_writer.close rescue nil
+        @udp_wakeup.close if @udp_wakeup rescue nil
+      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
+      end
+    end
+  end
+end

data/lib/rpush/daemon/loggable.rb

@@ -0,0 +1,31 @@
+module Rpush
+  module Daemon
+    module Loggable
+      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)
+        if app = instance_variable_get('@app')
+          msg = "[#{app.name}] #{msg}"
+        end
+
+        msg
+      end
+    end
+  end
+end

data/lib/rpush/daemon/reflectable.rb

@@ -0,0 +1,13 @@
+module Rpush
+  module Daemon
+    module Reflectable
+      def reflect(name, *args)
+        begin
+          Rpush.reflections.__dispatch(name, *args)
+        rescue StandardError => e
+          Rpush.logger.error(e)
+        end
+      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
+        if @header
+          if @header.to_s =~ /^[0-9]+$/
+            Time.now + @header.to_i
+          else
+            Time.httpdate(@header)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/retryable_error.rb

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

data/lib/rpush/daemon/service_config_methods.rb

@@ -0,0 +1,33 @@
+module Rpush
+  module Daemon
+    module ServiceConfigMethods
+      DISPATCHERS = {
+        :http => Rpush::Daemon::Dispatcher::Http,
+        :tcp => Rpush::Daemon::Dispatcher::Tcp
+      }
+
+      def dispatcher(name = nil, options = {})
+        @dispatcher_name = name
+        @dispatcher_options = options
+      end
+
+      def dispatcher_class
+        DISPATCHERS[@dispatcher_name] || (raise NotImplementedError)
+      end
+
+      def delivery_class
+        const_get('Delivery')
+      end
+
+      def new_dispatcher(app)
+        dispatcher_class.new(app, delivery_class, @dispatcher_options)
+      end
+
+      def loops(*loops)
+        @loops ||= []
+        @loops = loops if loops.any?
+        @loops
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+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)
+
+# :nocov:
+if !defined?(::SQLite3::Exception)
+  module SQLite3
+    class Exception < StandardError; end
+  end
+end
+
+module Rpush
+  module Daemon
+    module Store
+      class ActiveRecord
+        module Reconnectable
+          ADAPTER_ERRORS = [::ActiveRecord::StatementInvalid, PGError, Mysql::Error,
+                            Mysql2::Error, ::ActiveRecord::JDBCError, SQLite3::Exception]
+
+          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
+            end
+          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::Notification.count
+          end
+
+          def sleep_to_avoid_thrashing
+            sleep 2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+require 'active_record'
+
+require 'rpush/daemon/store/active_record/reconnectable'
+
+module Rpush
+  module Daemon
+    module Store
+      class ActiveRecord
+        include Reconnectable
+
+        DEFAULT_MARK_OPTIONS = {:persist => true}
+
+        def deliverable_notifications(apps)
+          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
+          end
+        end
+
+        def mark_retryable(notification, deliver_after, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.retries += 1
+          notification.deliver_after = deliver_after
+
+          if opts[:persist]
+            with_database_reconnect_and_retry do
+              notification.save!(:validate => false)
+            end
+          end
+        end
+
+        def mark_batch_retryable(notifications, deliver_after)
+          ids = []
+          notifications.each do |n|
+            mark_retryable(n, deliver_after, :persist => false)
+            ids << n.id
+          end
+          with_database_reconnect_and_retry do
+            Rpush::Notification.where(:id => ids).update_all(['retries = retries + 1, deliver_after = ?', deliver_after])
+          end
+        end
+
+        def mark_delivered(notification, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = true
+          notification.delivered_at = time
+
+          if opts[:persist]
+            with_database_reconnect_and_retry do
+              notification.save!(:validate => false)
+            end
+          end
+        end
+
+        def mark_batch_delivered(notifications)
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            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])
+          end
+        end
+
+        def mark_failed(notification, code, description, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = false
+          notification.delivered_at = nil
+          notification.failed = true
+          notification.failed_at = time
+          notification.error_code = code
+          notification.error_description = description
+
+          if opts[:persist]
+            with_database_reconnect_and_retry do
+              notification.save!(:validate => false)
+            end
+          end
+        end
+
+        def mark_batch_failed(notifications, code, description)
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            mark_failed(n, code, description, now, :persist => false)
+            ids << n.id
+          end
+          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])
+          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)
+          end
+        end
+
+        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
+          notification = Rpush::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
+          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        end
+
+        def update_app(app)
+          with_database_reconnect_and_retry do
+            app.save!
+          end
+        end
+
+        def update_notification(notification)
+          with_database_reconnect_and_retry do
+            notification.save!
+          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
+        end
+
+        private
+
+        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+          with_database_reconnect_and_retry do
+            notification.assign_attributes(attrs)
+            notification.data = data
+            notification.registration_ids = registration_ids
+            notification.deliver_after = deliver_after
+            notification.app = app
+            notification.save!
+            notification
+          end
+        end
+      end
+    end
+  end
+end