rapns 3.0.0-java

data/lib/rapns/daemon/delivery_handler.rb

@@ -0,0 +1,46 @@
+module Rapns
+  module Daemon
+    class DeliveryHandler
+      attr_accessor :queue
+
+      def start
+        @thread = Thread.new do
+          loop do
+            handle_next_notification
+            break if @stop
+          end
+        end
+      end
+
+      def stop
+        @stop = true
+        if @thread
+          queue.wakeup(@thread)
+          @thread.join
+        end
+        stopped
+      end
+
+      protected
+
+      def stopped
+      end
+
+      def handle_next_notification
+        begin
+          notification = queue.pop
+        rescue DeliveryQueue::WakeupError
+          return
+        end
+
+        begin
+          deliver(notification)
+        rescue StandardError => e
+          Rapns::Daemon.logger.error(e)
+        ensure
+          queue.notification_processed
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery_queue.rb

@@ -0,0 +1,42 @@
+module Rapns
+  module Daemon
+    if RUBY_VERSION < '1.9'
+      require 'rapns/daemon/delivery_queue_18'
+      ancestor_class = DeliveryQueue18
+    else
+      require 'rapns/daemon/delivery_queue_19'
+      ancestor_class = DeliveryQueue19
+    end
+
+    class DeliveryQueue < ancestor_class
+      class WakeupError < StandardError; end
+
+      def initialize
+        @num_notifications = 0
+        @queue = []
+        @waiting = []
+
+        super
+      end
+
+      def wakeup(thread)
+        synchronize do
+          t = @waiting.delete(thread)
+          t.raise WakeupError if t
+        end
+      end
+
+      def size
+        synchronize { @queue.size }
+      end
+
+      def notification_processed
+        synchronize { @num_notifications -= 1 }
+      end
+
+      def notifications_processed?
+        synchronize { @num_notifications == 0 }
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery_queue_18.rb

@@ -0,0 +1,44 @@
+module Rapns
+  module Daemon
+    class DeliveryQueue18
+      def push(obj)
+        Thread.critical = true
+        @queue.push obj
+        @num_notifications += 1
+        begin
+          t = @waiting.shift
+          t.wakeup if t
+        rescue ThreadError
+          retry
+        ensure
+          Thread.critical = false
+        end
+        begin
+          t.run if t
+        rescue ThreadError
+        end
+      end
+
+      def pop
+        while (Thread.critical = true; @queue.empty?)
+          @waiting.push Thread.current
+          Thread.stop
+        end
+        @queue.shift
+      ensure
+        Thread.critical = false
+      end
+
+      protected
+
+      def synchronize
+        Thread.critical = true
+        begin
+          yield
+        ensure
+          Thread.critical = false
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery_queue_19.rb

@@ -0,0 +1,42 @@
+module Rapns
+  module Daemon
+    class DeliveryQueue19
+      def initialize
+        @mutex = Mutex.new
+      end
+
+      def push(notification)
+        @mutex.synchronize do
+          @num_notifications += 1
+          @queue.push(notification)
+
+          begin
+            t = @waiting.shift
+            t.wakeup if t
+          rescue ThreadError
+            retry
+          end
+        end
+      end
+
+      def pop
+        @mutex.synchronize do
+          while true
+            if @queue.empty?
+              @waiting.push Thread.current
+              @mutex.sleep
+            else
+              return @queue.shift
+            end
+          end
+        end
+      end
+
+      protected
+
+      def synchronize(&blk)
+        @mutex.synchronize(&blk)
+      end
+    end
+  end
+end

data/lib/rapns/daemon/feeder.rb

@@ -0,0 +1,37 @@
+module Rapns
+  module Daemon
+    class Feeder
+      extend InterruptibleSleep
+      extend DatabaseReconnectable
+
+      def self.start(poll)
+        loop do
+          enqueue_notifications
+          interruptible_sleep poll
+          break if @stop
+        end
+      end
+
+      def self.stop
+        @stop = true
+        interrupt_sleep
+      end
+
+      protected
+
+      def self.enqueue_notifications
+        begin
+          with_database_reconnect_and_retry do
+            batch_size = Rapns.config.batch_size
+            idle = Rapns::Daemon::AppRunner.idle.map(&:app)
+            Rapns::Notification.ready_for_delivery.for_apps(idle).limit(batch_size).each do |notification|
+              Rapns::Daemon::AppRunner.enqueue(notification)
+            end
+          end
+        rescue StandardError => e
+          Rapns::Daemon.logger.error(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Rapns
+  module Daemon
+    module Gcm
+      class AppRunner < Rapns::Daemon::AppRunner
+        protected
+
+        def new_delivery_handler
+          DeliveryHandler.new(app)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+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']
+
+        def initialize(app, http, notification)
+          @app = app
+          @http = http
+          @notification = notification
+        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::Daemon.logger.info("[#{@app.name}] #{@notification.id} sent to #{@notification.registration_ids.join(', ')}")
+          else
+            handle_errors(response, body)
+          end
+        end
+
+        def handle_errors(response, body)
+          errors = {}
+
+          body['results'].each_with_index do |result, i|
+            errors[i] = result['error'] if result['error']
+          end
+
+          if body['success'].to_i == 0 && errors.values.all? { |error| error.in?(UNAVAILABLE_STATES) }
+            all_devices_unavailable(response)
+          elsif errors.values.any? { |error| error.in?(UNAVAILABLE_STATES) }
+            some_devices_unavailable(response, errors)
+          else
+            raise Rapns::DeliveryError.new(nil, @notification.id, describe_errors(errors))
+          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::Daemon.logger.warn("GCM responded with an Internal Error. " + retry_message)
+        end
+
+        def service_unavailable(response)
+          retry_delivery(@notification, response)
+          Rapns::Daemon.logger.warn("GCM responded with an Service Unavailable Error. " + retry_message)
+        end
+
+        def all_devices_unavailable(response)
+          retry_delivery(@notification, response)
+          Rapns::Daemon.logger.warn("All recipients unavailable. " + retry_message)
+        end
+
+        def some_devices_unavailable(response, errors)
+          unavailable_idxs = errors.find_all { |i, error| error.in?(UNAVAILABLE_STATES) }.map(&:first)
+          new_notification = build_new_notification(response, unavailable_idxs)
+          with_database_reconnect_and_retry { new_notification.save! }
+          raise Rapns::DeliveryError.new(nil, @notification.id,
+            describe_errors(errors) + " #{unavailable_idxs.join(', ')} will be retried as notification #{new_notification.id}.")
+        end
+
+        def build_new_notification(response, idxs)
+          notification = Rapns::Gcm::Notification.new
+          notification.assign_attributes(@notification.attributes.slice('app_id', 'collapse_key', 'delay_while_idle'))
+          notification.data = @notification.data
+          notification.registration_ids = idxs.map { |i| @notification.registration_ids[i] }
+          notification.deliver_after = deliver_after_header(response)
+          notification
+        end
+
+        def deliver_after_header(response)
+          if response.header['retry-after']
+            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)
+            retry_after(notification, time)
+          else
+            retry_exponentially(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 retired 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)
+          Rapns::Daemon::Gcm::Delivery.perform(@app, @http, notification)
+        end
+
+        def stopped
+          @http.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/interruptible_sleep.rb

@@ -0,0 +1,18 @@
+module Rapns
+  module Daemon
+    module InterruptibleSleep
+      def interruptible_sleep(seconds)
+        @_sleep_check, @_sleep_interrupt = IO.pipe
+        IO.select([@_sleep_check], nil, nil, seconds)
+        @_sleep_check.close rescue IOError
+        @_sleep_interrupt.close rescue IOError
+      end
+
+      def interrupt_sleep
+        if @_sleep_interrupt
+          @_sleep_interrupt.close rescue IOError
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/logger.rb

@@ -0,0 +1,68 @@
+module Rapns
+  module Daemon
+    class Logger
+      def initialize(options)
+        @options = options
+
+        begin
+          log = File.open(File.join(Rails.root, 'log', 'rapns.log'), 'a')
+          log.sync = true
+          @logger = ActiveSupport::BufferedLogger.new(log, Rails.logger.level)
+          @logger.auto_flushing = Rails.logger.respond_to?(:auto_flushing) ? Rails.logger.auto_flushing : true
+        rescue Errno::ENOENT, Errno::EPERM => e
+          @logger = nil
+          error(e)
+          error('Logging disabled.')
+        end
+      end
+
+      def info(msg)
+        log(:info, msg)
+      end
+
+      def error(msg, options = {})
+        airbrake_notify(msg) if notify_via_airbrake?(msg, options)
+        log(:error, msg, 'ERROR', STDERR)
+      end
+
+      def warn(msg)
+        log(:warn, msg, 'WARNING', STDERR)
+      end
+
+      private
+
+      def log(where, msg, prefix = nil, io = STDOUT)
+        if msg.is_a?(Exception)
+          formatted_backtrace = msg.backtrace.join("\n")
+          msg = "#{msg.class.name}, #{msg.message}\n#{formatted_backtrace}"
+        end
+
+        formatted_msg = "[#{Time.now.to_s(:db)}] "
+        formatted_msg << "[#{prefix}] " if prefix
+        formatted_msg << msg
+
+        if io == STDERR
+          io.puts formatted_msg
+        elsif @options[:foreground]
+          io.puts formatted_msg
+        end
+
+        @logger.send(where, formatted_msg) if @logger
+      end
+
+      def airbrake_notify(e)
+        return unless @options[:airbrake_notify] == true
+
+        if defined?(Airbrake)
+          Airbrake.notify_or_ignore(e)
+        elsif defined?(HoptoadNotifier)
+          HoptoadNotifier.notify_or_ignore(e)
+        end
+      end
+
+      def notify_via_airbrake?(msg, options)
+        msg.is_a?(Exception) && options[:airbrake_notify] != false
+      end
+    end
+  end
+end

data/lib/rapns/daemon.rb

@@ -0,0 +1,136 @@
+require 'thread'
+require 'socket'
+require 'pathname'
+require 'openssl'
+
+require 'net/http/persistent'
+
+require 'rapns/daemon/interruptible_sleep'
+require 'rapns/daemon/delivery_error'
+require 'rapns/daemon/database_reconnectable'
+require 'rapns/daemon/delivery'
+require 'rapns/daemon/delivery_queue'
+require 'rapns/daemon/feeder'
+require 'rapns/daemon/logger'
+require 'rapns/daemon/app_runner'
+require 'rapns/daemon/delivery_handler'
+
+require 'rapns/daemon/apns/delivery'
+require 'rapns/daemon/apns/disconnection_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
+    extend DatabaseReconnectable
+
+    class << self
+      attr_accessor :logger
+    end
+
+    def self.start
+      self.logger = Logger.new(:foreground => Rapns.config.foreground,
+                               :airbrake_notify => Rapns.config.airbrake_notify)
+      setup_signal_hooks
+
+      unless Rapns.config.foreground
+        daemonize
+        reconnect_database
+      end
+
+      write_pid_file
+      ensure_upgraded
+      AppRunner.sync
+      Feeder.start(Rapns.config.push_poll)
+    end
+
+    protected
+
+    def self.ensure_upgraded
+      count = 0
+
+      begin
+        count = Rapns::App.count
+      rescue ActiveRecord::StatementInvalid
+        puts "!!!! RAPNS NOT STARTED !!!!"
+        puts
+        puts "As of version v2.0.0 apps are configured in the database instead of rapns.yml."
+        puts "Please run 'rails g rapns' to generate the new migrations and create your app."
+        puts "See https://github.com/ileitch/rapns for further instructions."
+        puts
+        exit 1
+      end
+
+      if count == 0
+        logger.warn("You have not created an app yet. See https://github.com/ileitch/rapns for instructions.")
+      end
+
+      if File.exists?(File.join(Rails.root, 'config', 'rapns', 'rapns.yml'))
+        logger.warn(<<-EOS)
+Since 2.0.0 rapns uses command-line options and a Ruby based configuration file.
+Please run 'rails g rapns' to generate a new configuration file into config/initializers.
+Remove config/rapns/rapns.yml to avoid this warning.
+        EOS
+      end
+    end
+
+    def self.setup_signal_hooks
+      @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.shutdown
+      puts "\nShutting down..."
+      Feeder.stop
+      AppRunner.stop
+      delete_pid_file
+    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
+          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
+      exit if pid = fork
+      Process.setsid
+      exit if pid = fork
+
+      Dir.chdir '/'
+      File.umask 0000
+
+      STDIN.reopen '/dev/null'
+      STDOUT.reopen '/dev/null', 'a'
+      STDERR.reopen STDOUT
+    end
+  end
+end

data/lib/rapns/gcm/app.rb

@@ -0,0 +1,7 @@
+module Rapns
+  module Gcm
+    class App < Rapns::App
+      validates :auth_key, :presence => true
+    end
+  end
+end

data/lib/rapns/gcm/expiry_collapse_key_mutual_inclusion_validator.rb

@@ -0,0 +1,11 @@
+module Rapns
+  module Gcm
+    class ExpiryCollapseKeyMutualInclusionValidator < ActiveModel::Validator
+      def validate(record)
+        if record.collapse_key && !record.expiry
+          record.errors[:expiry] << "must be set when using a collapse_key"
+        end
+      end
+    end
+  end
+end