rapns_rails_2 3.4.3

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

@@ -0,0 +1,228 @@
+module Rapns
+  module Daemon
+    module Gcm
+      # http://developer.android.com/guide/google/gcm/gcm.html#response
+      class Delivery < Rapns::Daemon::Delivery
+        include Rapns::MultiJsonHelper
+
+        GCM_URI = URI.parse('https://android.googleapis.com/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 Rapns::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(response)
+          when 401
+            unauthorized(response)
+          when 500
+            internal_server_error(response)
+          when 503
+            service_unavailable(response)
+          else
+            raise Rapns::DeliveryError.new(response.code, @notification.id, HTTP_STATUS_CODES[response.code.to_i])
+          end
+        end
+
+        def ok(response)
+          body = multi_json_load(response.body)
+          if body['failure'].to_i == 0
+            mark_delivered
+            Rapns.logger.info("[#{@app.name}] #{@notification.id} sent to #{@notification.registration_ids.join(', ')}")
+          else
+            handle_invalid_registration_ids(response, body)
+            handle_errors(response, body)
+          end
+
+          handle_canonical_ids(response, body)
+        end
+
+        def handle_errors(response, body)
+          errors = {}
+
+          body['results'].each_with_index do |result, i|
+            errors[i] = result['error'] if result['error'] && ! INVALID_REGISTRATION_ID_STATES.include?(result['error'])
+          end
+          return if errors.empty?
+
+          if body['success'].to_i == 0 && errors.values.all? { |error| UNAVAILABLE_STATES.include?(error) }
+            all_devices_unavailable(response)
+          elsif errors.values.any? { |error| UNAVAILABLE_STATES.include?(error) }
+            some_devices_unavailable(response, errors)
+          else
+            raise Rapns::DeliveryError.new(nil, @notification.id, describe_errors(errors))
+          end
+        end
+
+        def handle_invalid_registration_ids(response, body)
+          body['results'].each_with_index do |result, i|
+            next unless INVALID_REGISTRATION_ID_STATES.include?(result['error'])
+
+            registration_id = @notification.registration_ids[i]
+            reflect(:gcm_invalid_registration_id, @app, result['error'], registration_id)
+          end
+        end
+
+        def handle_canonical_ids(response, body)
+          if body['canonical_ids'] && body['canonical_ids'].to_i > 0
+            body['results'].each_with_index do |result, i|
+              if result['message_id'] && result['registration_id']
+                old_id = @notification.registration_ids[i]
+                reflect(:gcm_canonical_id, old_id, result['registration_id'])
+              end
+            end
+          end
+        end
+
+        def bad_request(response)
+          raise Rapns::DeliveryError.new(400, @notification.id, 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.')
+        end
+
+        def unauthorized(response)
+          raise Rapns::DeliveryError.new(401, @notification.id, 'Unauthorized, check your App auth_key.')
+        end
+
+        def internal_server_error(response)
+          retry_delivery(@notification, response)
+          Rapns.logger.warn("GCM responded with an Internal Error. " + retry_message)
+        end
+
+        def service_unavailable(response)
+          retry_delivery(@notification, response)
+          Rapns.logger.warn("GCM responded with an Service Unavailable Error. " + retry_message)
+        end
+
+        def all_devices_unavailable(response)
+          retry_delivery(@notification, response)
+          Rapns.logger.warn("All recipients unavailable. " + retry_message)
+        end
+
+        def some_devices_unavailable(response, errors)
+          unavailable_idxs = errors.find_all { |i, error| UNAVAILABLE_STATES.include?(error) }.map(&:first)
+          new_notification = create_new_notification(response, unavailable_idxs)
+          raise Rapns::DeliveryError.new(nil, @notification.id,
+            describe_errors(errors) + " #{unavailable_idxs.join(', ')} will be retried as notification #{new_notification.id}.")
+        end
+
+        def create_new_notification(response, unavailable_idxs)
+          attrs = @notification.attributes.slice('app_id', 'collapse_key', 'delay_while_idle')
+          registration_ids = unavailable_idxs.map { |i| @notification.registration_ids[i] }
+          Rapns::Daemon.store.create_gcm_notification(attrs, @notification.data,
+            registration_ids, deliver_after_header(response), @notification.app)
+        end
+
+        def deliver_after_header(response)
+          if response.header['retry-after']
+            if response.header['retry-after'].to_s =~ /^[0-9]+$/
+              Time.now + response.header['retry-after'].to_i
+            else
+              Time.httpdate(response.header['retry-after'])
+            end
+          end
+        end
+
+        def retry_delivery(notification, response)
+          if time = deliver_after_header(response)
+            mark_retryable(notification, time)
+          else
+            mark_retryable_exponential(notification)
+          end
+        end
+
+        def describe_errors(errors)
+          description = if errors.size == @notification.registration_ids.size
+            "Failed to deliver to all recipients. Errors: #{errors.values.join(', ')}."
+          else
+            "Failed to deliver to recipients #{errors.keys.join(', ')}. Errors: #{errors.values.join(', ')}."
+          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
+
+        HTTP_STATUS_CODES = {
+          100  => 'Continue',
+          101  => 'Switching Protocols',
+          102  => 'Processing',
+          200  => 'OK',
+          201  => 'Created',
+          202  => 'Accepted',
+          203  => 'Non-Authoritative Information',
+          204  => 'No Content',
+          205  => 'Reset Content',
+          206  => 'Partial Content',
+          207  => 'Multi-Status',
+          226  => 'IM Used',
+          300  => 'Multiple Choices',
+          301  => 'Moved Permanently',
+          302  => 'Found',
+          303  => 'See Other',
+          304  => 'Not Modified',
+          305  => 'Use Proxy',
+          306  => 'Reserved',
+          307  => 'Temporary Redirect',
+          400  => 'Bad Request',
+          401  => 'Unauthorized',
+          402  => 'Payment Required',
+          403  => 'Forbidden',
+          404  => 'Not Found',
+          405  => 'Method Not Allowed',
+          406  => 'Not Acceptable',
+          407  => 'Proxy Authentication Required',
+          408  => 'Request Timeout',
+          409  => 'Conflict',
+          410  => 'Gone',
+          411  => 'Length Required',
+          412  => 'Precondition Failed',
+          413  => 'Request Entity Too Large',
+          414  => 'Request-URI Too Long',
+          415  => 'Unsupported Media Type',
+          416  => 'Requested Range Not Satisfiable',
+          417  => 'Expectation Failed',
+          418  => "I'm a Teapot",
+          422  => 'Unprocessable Entity',
+          423  => 'Locked',
+          424  => 'Failed Dependency',
+          426  => 'Upgrade Required',
+          500  => 'Internal Server Error',
+          501  => 'Not Implemented',
+          502  => 'Bad Gateway',
+          503  => 'Service Unavailable',
+          504  => 'Gateway Timeout',
+          505  => 'HTTP Version Not Supported',
+          506  => 'Variant Also Negotiates',
+          507  => 'Insufficient Storage',
+          510  => 'Not Extended',
+        }
+      end
+    end
+  end
+end

data/lib/rapns/daemon/gcm/delivery_handler.rb

@@ -0,0 +1,20 @@
+module Rapns
+  module Daemon
+    module Gcm
+      class DeliveryHandler < Rapns::Daemon::DeliveryHandler
+        def initialize(app)
+          @app = app
+          @http = Net::HTTP::Persistent.new('rapns')
+        end
+
+        def deliver(notification, batch)
+          Rapns::Daemon::Gcm::Delivery.new(@app, @http, notification, batch).perform
+        end
+
+        def stopped
+          @http.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/interruptible_sleep.rb

@@ -0,0 +1,65 @@
+module Rapns
+  module Daemon
+    class InterruptibleSleep
+
+      def initialize
+        @sleep_reader, @wake_writer = IO.pipe
+      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
+        if rs && rs.include?(@sleep_reader)
+          while true
+            begin
+              @sleep_reader.read_nonblock(1)
+            rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+            # rescue IO::WaitReadable
+              break
+            end
+          end
+        end
+
+        if rs && rs.include?(@udp_wakeup)
+          while true
+            begin
+              @udp_wakeup.recv_nonblock(1)
+            rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+            # rescue IO::WaitReadable
+              break
+            end
+          end
+        end
+
+        !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
+    end
+  end
+end

data/lib/rapns/daemon/reflectable.rb

@@ -0,0 +1,13 @@
+module Rapns
+  module Daemon
+    module Reflectable
+      def reflect(name, *args)
+        begin
+          Rapns.reflections.__dispatch(name, *args)
+        rescue StandardError => e
+          Rapns.logger.error(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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)
+if !defined?(::SQLite3::Exception)
+  module SQLite3
+    class Exception < StandardError; end
+  end
+end
+
+module Rapns
+  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
+              Rapns.logger.error(e)
+              database_connection_lost
+              retry
+            end
+          end
+
+          def database_connection_lost
+            Rapns.logger.warn("Lost connection to database, reconnecting...")
+            attempts = 0
+            loop do
+              begin
+                Rapns.logger.warn("Attempt #{attempts += 1}")
+                reconnect_database
+                check_database_is_connected
+                break
+              rescue *ADAPTER_ERRORS => e
+                Rapns.logger.error(e, :airbrake_notify => false)
+                sleep_to_avoid_thrashing
+              end
+            end
+            Rapns.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.
+            Rapns::Notification.count
+          end
+
+          def sleep_to_avoid_thrashing
+            sleep 2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+require 'active_record'
+
+require 'rapns/daemon/store/active_record/reconnectable'
+
+module Rapns
+  module Daemon
+    module Store
+      class ActiveRecord
+        include Reconnectable
+
+        def deliverable_notifications(apps)
+          with_database_reconnect_and_retry do
+            batch_size = Rapns.config.batch_size
+            relation = Rapns::Notification.ready_for_delivery.for_apps(apps)
+            if Rapns.config.push
+              relation.all
+            else
+              relation.find(:all, :limit => batch_size)
+            end
+          end
+        end
+
+        def mark_retryable(notification, deliver_after)
+          with_database_reconnect_and_retry do
+            notification.retries += 1
+            notification.deliver_after = deliver_after
+            notification.save(false)
+          end
+        end
+
+        def mark_batch_retryable(notifications, deliver_after)
+          ids = []
+          notifications.each do |n|
+            # Update attrs for reflections, but don't save.
+            n.retries += 1
+            n.deliver_after = deliver_after
+            ids << n.id
+          end
+          with_database_reconnect_and_retry do
+            Rapns::Notification.find(ids).each { |n|
+              n.update_attributes(:retries => n.retries + 1, :deliver_after => deliver_after)
+            }
+          end
+        end
+
+        def mark_delivered(notification)
+          with_database_reconnect_and_retry do
+            notification.delivered = true
+            notification.delivered_at = Time.now
+            notification.save(false)
+          end
+        end
+
+        def mark_batch_delivered(notifications)
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            # Update attrs for reflections, but don't save.
+            n.delivered = true
+            n.delivered_at = now
+            ids << n.id
+          end
+          with_database_reconnect_and_retry do
+            Rapns::Notification.find(ids).each { |n|
+              n.update_attributes(:delivered => true, :delivered_at => now)
+            }
+          end
+        end
+
+        def mark_failed(notification, code, description)
+          with_database_reconnect_and_retry do
+            notification.delivered = false
+            notification.delivered_at = nil
+            notification.failed = true
+            notification.failed_at = Time.now
+            notification.error_code = code
+            notification.error_description = description
+            notification.save(false)
+          end
+        end
+
+        def mark_batch_failed(notifications, code, description)
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            # Update attrs for reflections, but don't save.
+            n.delivered = false
+            n.delivered_at = nil
+            n.failed = true
+            n.failed_at = now
+            n.error_code = code
+            n.error_description = description
+            ids << n.id
+          end
+          with_database_reconnect_and_retry do
+            Rapns::Notification.find(ids).each { |n|
+              n.update_attributes(:delivered => false, :delivered_at => nil, :failed => true, :failed_at => now, :error_code => code, :error_description => description)
+            }
+          end
+        end
+
+        def create_apns_feedback(failed_at, device_token, app)
+          with_database_reconnect_and_retry do
+            Rapns::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)
+          with_database_reconnect_and_retry do
+            notification = Rapns::Gcm::Notification.new
+            notification.attributes = attrs
+            notification.data = data
+            notification.registration_ids = registration_ids
+            notification.deliver_after = deliver_after
+            notification.app = app
+            notification.save!
+            notification
+          end
+        end
+
+        def after_daemonize
+          reconnect_database
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon.rb

@@ -0,0 +1,129 @@
+require 'thread'
+require 'socket'
+require 'pathname'
+require 'openssl'
+
+require 'net/http/persistent'
+
+require 'rapns/daemon/reflectable'
+require 'rapns/daemon/interruptible_sleep'
+require 'rapns/daemon/delivery_error'
+require 'rapns/daemon/delivery'
+require 'rapns/daemon/feeder'
+require 'rapns/daemon/batch'
+require 'rapns/daemon/app_runner'
+require 'rapns/daemon/delivery_handler'
+require 'rapns/daemon/delivery_handler_collection'
+
+require 'rapns/daemon/apns/delivery'
+require 'rapns/daemon/apns/disconnection_error'
+require 'rapns/daemon/apns/certificate_expired_error'
+require 'rapns/daemon/apns/connection'
+require 'rapns/daemon/apns/app_runner'
+require 'rapns/daemon/apns/delivery_handler'
+require 'rapns/daemon/apns/feedback_receiver'
+
+require 'rapns/daemon/gcm/delivery'
+require 'rapns/daemon/gcm/app_runner'
+require 'rapns/daemon/gcm/delivery_handler'
+
+module Rapns
+  module Daemon
+    class << self
+      attr_accessor :store
+    end
+
+    def self.start
+      setup_signal_traps if trap_signals?
+
+      initialize_store
+      return unless store
+
+      if daemonize?
+        daemonize
+        store.after_daemonize
+      end
+
+      write_pid_file
+      Upgraded.check(:exit => true)
+      AppRunner.sync
+      Feeder.start
+    end
+
+    def self.shutdown(quiet = false)
+      puts "\nShutting down..." unless quiet
+      Feeder.stop
+      AppRunner.stop
+      delete_pid_file
+    end
+
+    def self.initialize_store
+      return if store
+      begin
+        require "rapns/daemon/store/#{Rapns.config.store}"
+        klass = "Rapns::Daemon::Store::#{Rapns.config.store.to_s.camelcase}".constantize
+        self.store = klass.new
+      rescue StandardError, LoadError => e
+        Rapns.logger.error("Failed to load '#{Rapns.config.store}' storage backend.")
+        Rapns.logger.error(e)
+      end
+    end
+
+    protected
+
+    def self.daemonize?
+      !(Rapns.config.foreground || Rapns.config.embedded || Rapns.jruby?)
+    end
+
+    def self.trap_signals?
+      !Rapns.config.embedded
+    end
+
+    def self.setup_signal_traps
+      @shutting_down = false
+
+      Signal.trap('SIGHUP') { AppRunner.sync }
+      Signal.trap('SIGUSR2') { AppRunner.debug }
+
+      ['SIGINT', 'SIGTERM'].each do |signal|
+        Signal.trap(signal) { handle_shutdown_signal }
+      end
+    end
+
+    def self.handle_shutdown_signal
+      exit 1 if @shutting_down
+      @shutting_down = true
+      shutdown
+    end
+
+    def self.write_pid_file
+      if !Rapns.config.pid_file.blank?
+        begin
+          File.open(Rapns.config.pid_file, 'w') { |f| f.puts Process.pid }
+        rescue SystemCallError => e
+          Rapns.logger.error("Failed to write PID to '#{Rapns.config.pid_file}': #{e.inspect}")
+        end
+      end
+    end
+
+    def self.delete_pid_file
+      pid_file = Rapns.config.pid_file
+      File.delete(pid_file) if !pid_file.blank? && File.exists?(pid_file)
+    end
+
+    # :nocov:
+    def self.daemonize
+      if RUBY_VERSION < "1.9"
+        exit if fork
+        Process.setsid
+        exit if fork
+        Dir.chdir "/"
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen "/dev/null", "a"
+      else
+        Process.daemon
+      end
+    end
+  end
+end

data/lib/rapns/deprecatable.rb

@@ -0,0 +1,23 @@
+module Rapns
+  module Deprecatable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def deprecated(method_name, version, msg=nil)
+        instance_eval do
+          alias_method "#{method_name}_without_warning", method_name
+        end
+        warning = "#{method_name} is deprecated and will be removed from Rapns #{version}."
+        warning << " #{msg}" if msg
+        class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{method_name}(*args, &blk)
+            Rapns::Deprecation.warn(#{warning.inspect})
+            #{method_name}_without_warning(*args, &blk)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rapns/deprecation.rb

@@ -0,0 +1,23 @@
+module Rapns
+  class Deprecation
+    def self.muted
+      begin
+        orig_val = Thread.current[:rapns_mute_deprecations]
+        Thread.current[:rapns_mute_deprecations] = true
+        yield
+      ensure
+        Thread.current[:rapns_mute_deprecations] = orig_val
+      end
+    end
+
+    def self.muted?
+      Thread.current[:rapns_mute_deprecations] == true
+    end
+
+    def self.warn(msg)
+      unless Rapns::Deprecation.muted?
+        STDERR.puts "DEPRECATION WARNING: #{msg}"
+      end
+    end
+  end
+end