rpush 1.0.0

data/lib/rpush/daemon/constants.rb

@@ -0,0 +1,59 @@
+module Rpush
+  module Daemon
+    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',
+      429  => 'Too Many Requests',
+      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

data/lib/rpush/daemon/delivery.rb

@@ -0,0 +1,28 @@
+module Rpush
+  module Daemon
+    class Delivery
+      include Reflectable
+      include Loggable
+
+      def mark_retryable(notification, deliver_after)
+        if notification.fail_after && notification.fail_after < Time.now
+          @batch.mark_failed(notification, nil, "Notification failed to be delivered before #{notification.fail_after.strftime("%Y-%m-%d %H:%M:%S")}.")
+        else
+          @batch.mark_retryable(notification, deliver_after)
+        end
+      end
+
+      def mark_retryable_exponential(notification)
+        mark_retryable(notification, Time.now + 2 ** (notification.retries + 1))
+      end
+
+      def mark_delivered
+        @batch.mark_delivered(@notification)
+      end
+
+      def mark_failed(code, description)
+        @batch.mark_failed(@notification, code, description)
+      end
+    end
+  end
+end

data/lib/rpush/daemon/delivery_error.rb

@@ -0,0 +1,19 @@
+module Rpush
+  class DeliveryError < StandardError
+    attr_reader :code, :description
+
+    def initialize(code, notification_id, description)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      "Unable to deliver notification #{@notification_id}, received error #{@code} (#{@description})"
+    end
+  end
+end

data/lib/rpush/daemon/dispatcher/http.rb

@@ -0,0 +1,21 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class Http
+        def initialize(app, delivery_class, options = {})
+          @app = app
+          @delivery_class = delivery_class
+          @http = Net::HTTP::Persistent.new('rpush')
+        end
+
+        def dispatch(notification, batch)
+          @delivery_class.new(@app, @http, notification, batch).perform
+        end
+
+        def cleanup
+          @http.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/dispatcher/tcp.rb

@@ -0,0 +1,30 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class Tcp
+        def initialize(app, delivery_class, options = {})
+          @app = app
+          @delivery_class = delivery_class
+          @host, @port = options[:host].call(@app)
+        end
+
+        def dispatch(notification, batch)
+          @delivery_class.new(@app, connection, notification, batch).perform
+        end
+
+        def cleanup
+          @connection.close if @connection
+        end
+
+        private
+
+        def connection
+          return @connection if defined? @connection
+          connection = Rpush::Daemon::TcpConnection.new(@app, @host, @port)
+          connection.connect
+          @connection = connection
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/dispatcher_loop.rb

@@ -0,0 +1,54 @@
+module Rpush
+  module Daemon
+    class DispatcherLoop
+      include Reflectable
+
+      WAKEUP = :wakeup
+
+      def initialize(queue, dispatcher)
+        @queue = queue
+        @dispatcher = dispatcher
+      end
+
+      def start
+        @thread = Thread.new do
+          loop do
+            dispatch
+            break if @stop
+          end
+
+          Rpush::Daemon.store.release_connection
+        end
+      end
+
+      def stop
+        @stop = true
+      end
+
+      def wakeup
+        @queue.push(WAKEUP) if @thread
+      end
+
+      def wait
+        @thread.join if @thread
+        @dispatcher.cleanup
+      end
+
+      protected
+
+      def dispatch
+        notification, batch = @queue.pop
+        return if notification == WAKEUP
+
+        begin
+          @dispatcher.dispatch(notification, batch)
+        rescue StandardError => e
+          Rpush.logger.error(e)
+          reflect(:error, e)
+        ensure
+          batch.notification_dispatched
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/dispatcher_loop_collection.rb

@@ -0,0 +1,33 @@
+module Rpush
+  module Daemon
+    class DispatcherLoopCollection
+      attr_reader :loops
+
+      def initialize
+        @loops = []
+      end
+
+      def push(dispatcher_loop)
+        @loops << dispatcher_loop
+      end
+
+      def pop
+        dispatcher_loop = @loops.pop
+        dispatcher_loop.stop
+        dispatcher_loop.wakeup
+        @loops.map(&:wakeup)
+        dispatcher_loop.wait
+      end
+
+      def size
+        @loops.size
+      end
+
+      def stop
+        @loops.map(&:stop)
+        @loops.map(&:wakeup)
+        @loops.map(&:wait)
+      end
+    end
+  end
+end

data/lib/rpush/daemon/feeder.rb

@@ -0,0 +1,68 @@
+module Rpush
+  module Daemon
+    class Feeder
+      extend Reflectable
+
+      def self.start
+        @stop = false
+
+        if Rpush.config.embedded
+          Thread.new { feed_forever }
+        elsif Rpush.config.push
+          enqueue_notifications
+        else
+          feed_forever
+        end
+      end
+
+      def self.stop
+        @stop = true
+        interrupt_sleep
+      end
+
+      def self.interrupt_sleep
+        interruptible_sleeper.interrupt_sleep
+      end
+
+      protected
+
+      def self.feed_forever
+        loop do
+          enqueue_notifications
+          interruptible_sleeper.sleep(Rpush.config.push_poll)
+          break if stop?
+        end
+
+        Rpush::Daemon.store.release_connection
+      end
+
+      # :nocov:
+      def self.stop?
+        @stop
+      end
+
+      def self.enqueue_notifications
+        begin
+          idle = Rpush::Daemon::AppRunner.idle.map(&:app)
+          return if idle.empty?
+          notifications = Rpush::Daemon.store.deliverable_notifications(idle)
+          Rpush::Daemon::AppRunner.enqueue(notifications)
+        rescue StandardError => e
+          Rpush.logger.error(e)
+          reflect(:error, e)
+        end
+      end
+
+      def self.interruptible_sleeper
+        return @interruptible_sleeper if @interruptible_sleeper
+
+        @interruptible_sleeper = InterruptibleSleep.new
+        if Rpush.config.wakeup
+          @interruptible_sleeper.enable_wake_on_udp Rpush.config.wakeup[:bind], Rpush.config.wakeup[:port]
+        end
+
+        @interruptible_sleeper
+      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/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