rpush 1.0.0

data/lib/rpush/apns/notification.rb

@@ -0,0 +1,84 @@
+module Rpush
+  module Apns
+    class Notification < Rpush::Notification
+      class MultipleAppAssignmentError < StandardError; end
+
+      validates :device_token, :presence => true
+      validates :badge, :numericality => true, :allow_nil => true
+
+      validates_with Rpush::Apns::DeviceTokenFormatValidator
+      validates_with Rpush::Apns::BinaryNotificationValidator
+
+      alias_method :attributes_for_device=, :data=
+      alias_method :attributes_for_device, :data
+
+      def device_token=(token)
+        write_attribute(:device_token, token.delete(" <>")) if !token.nil?
+      end
+
+      def alert=(alert)
+        if alert.is_a?(Hash)
+          write_attribute(:alert, multi_json_dump(alert))
+          self.alert_is_json = true if has_attribute?(:alert_is_json)
+        else
+          write_attribute(:alert, alert)
+          self.alert_is_json = false if has_attribute?(:alert_is_json)
+        end
+      end
+
+      def alert
+        string_or_json = read_attribute(:alert)
+
+        if has_attribute?(:alert_is_json)
+          if alert_is_json?
+            multi_json_load(string_or_json)
+          else
+            string_or_json
+          end
+        else
+          multi_json_load(string_or_json) rescue string_or_json
+        end
+      end
+
+      MDM_KEY = '__rpush_mdm__'
+      def mdm=(magic)
+        self.attributes_for_device = (attributes_for_device || {}).merge({ MDM_KEY => magic })
+      end
+
+      CONTENT_AVAILABLE_KEY = '__rpush_content_available__'
+      def content_available=(bool)
+        return unless bool
+        self.attributes_for_device = (attributes_for_device || {}).merge({ CONTENT_AVAILABLE_KEY => true })
+      end
+
+      def as_json
+        json = ActiveSupport::OrderedHash.new
+
+        if attributes_for_device && attributes_for_device.key?(MDM_KEY)
+          json['mdm'] = attributes_for_device[MDM_KEY]
+        else
+          json['aps'] = ActiveSupport::OrderedHash.new
+          json['aps']['alert'] = alert if alert
+          json['aps']['badge'] = badge if badge
+          json['aps']['sound'] = sound if sound
+
+          if attributes_for_device && attributes_for_device[CONTENT_AVAILABLE_KEY]
+            json['aps']['content-available'] = 1
+          end
+
+          if attributes_for_device
+            non_aps_attributes = attributes_for_device.reject { |k, v| k == CONTENT_AVAILABLE_KEY }
+            non_aps_attributes.each { |k, v| json[k.to_s] = v }
+          end
+        end
+
+        json
+      end
+
+      def to_binary(options = {})
+        id_for_pack = options[:for_validation] ? 0 : id
+        [1, id_for_pack, expiry, 0, 32, device_token, payload_size, payload].pack("cNNccH*na*")
+      end
+    end
+  end
+end

data/lib/rpush/apns_feedback.rb

@@ -0,0 +1,13 @@
+module Rpush
+  def self.apns_feedback
+    Rpush.require_for_daemon
+    Rpush::Daemon.initialize_store
+
+    Rpush::Apns::App.all.each do |app|
+      receiver = Rpush::Daemon::Apns::FeedbackReceiver.new(app)
+      receiver.check_for_feedback
+    end
+
+    nil
+  end
+end

data/lib/rpush/app.rb

@@ -0,0 +1,18 @@
+module Rpush
+  class App < ActiveRecord::Base
+    self.table_name = 'rpush_apps'
+
+    if Rpush.attr_accessible_available?
+      attr_accessible :name, :environment, :certificate, :password, :connections, :auth_key, :client_id, :client_secret
+    end
+
+    has_many :notifications, :class_name => 'Rpush::Notification', :dependent => :destroy
+
+    validates :name, :presence => true, :uniqueness => { :scope => [:type, :environment] }
+    validates_numericality_of :connections, :greater_than => 0, :only_integer => true
+
+    def service_name
+      raise NotImplementedError
+    end
+  end
+end

data/lib/rpush/configuration.rb

@@ -0,0 +1,75 @@
+module Rpush
+  def self.config
+    @config ||= Rpush::Configuration.new
+  end
+
+  def self.configure
+    yield config if block_given?
+  end
+
+  CONFIG_ATTRS = [:foreground, :push_poll, :feedback_poll, :embedded,
+    :check_for_errors, :pid_file, :batch_size, :push, :store, :logger,
+    :batch_storage_updates, :wakeup]
+
+  class ConfigurationWithoutDefaults < Struct.new(*CONFIG_ATTRS)
+  end
+
+  class Configuration < Struct.new(*CONFIG_ATTRS)
+    include Deprecatable
+
+    def initialize
+      super
+      set_defaults
+    end
+
+    def update(other)
+      CONFIG_ATTRS.each do |attr|
+        other_value = other.send(attr)
+        send("#{attr}=", other_value) unless other_value.nil?
+      end
+    end
+
+    def pid_file=(path)
+      if path && !Pathname.new(path).absolute?
+        super(File.join(Rails.root, path))
+      else
+        super
+      end
+    end
+
+    def logger=(logger)
+      super(logger)
+    end
+
+    def foreground=(bool)
+      if Rpush.jruby?
+        # The JVM does not support fork().
+        super(true)
+      else
+        super
+      end
+    end
+
+    def set_defaults
+      if Rpush.jruby?
+        # The JVM does not support fork().
+        self.foreground = true
+      else
+        self.foreground = false
+      end
+
+      self.push_poll = 2
+      self.feedback_poll = 60
+      self.check_for_errors = true
+      self.batch_size = 100
+      self.pid_file = nil
+      self.store = :active_record
+      self.logger = nil
+      self.batch_storage_updates = true
+
+      # Internal options.
+      self.embedded = false
+      self.push = false
+    end
+  end
+end

data/lib/rpush/daemon.rb

@@ -0,0 +1,140 @@
+require 'thread'
+require 'socket'
+require 'pathname'
+require 'openssl'
+
+require 'net/http/persistent'
+
+require 'rpush/daemon/constants'
+require 'rpush/daemon/reflectable'
+require 'rpush/daemon/loggable'
+require 'rpush/daemon/interruptible_sleep'
+require 'rpush/daemon/delivery_error'
+require 'rpush/daemon/retryable_error'
+require 'rpush/daemon/too_many_requests_error'
+require 'rpush/daemon/delivery'
+require 'rpush/daemon/feeder'
+require 'rpush/daemon/batch'
+require 'rpush/daemon/app_runner'
+require 'rpush/daemon/tcp_connection'
+require 'rpush/daemon/dispatcher_loop'
+require 'rpush/daemon/dispatcher_loop_collection'
+require 'rpush/daemon/dispatcher/http'
+require 'rpush/daemon/dispatcher/tcp'
+require 'rpush/daemon/service_config_methods'
+require 'rpush/daemon/retry_header_parser'
+
+require 'rpush/daemon/apns/delivery'
+require 'rpush/daemon/apns/disconnection_error'
+require 'rpush/daemon/apns/certificate_expired_error'
+require 'rpush/daemon/apns/feedback_receiver'
+require 'rpush/daemon/apns'
+
+require 'rpush/daemon/gcm/delivery'
+require 'rpush/daemon/gcm'
+
+require 'rpush/daemon/wpns/delivery'
+require 'rpush/daemon/wpns'
+
+require 'rpush/daemon/adm/delivery'
+require 'rpush/daemon/adm'
+
+module Rpush
+  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
+      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
+        name = Rpush.config.store.to_s
+        require "rpush/daemon/store/#{name}"
+        self.store = Rpush::Daemon::Store.const_get(name.camelcase).new
+      rescue StandardError, LoadError => e
+        Rpush.logger.error("Failed to load '#{Rpush.config.store}' storage backend.")
+        Rpush.logger.error(e)
+      end
+    end
+
+    protected
+
+    def self.daemonize?
+      !(Rpush.config.foreground || Rpush.config.embedded || Rpush.jruby?)
+    end
+
+    def self.trap_signals?
+      !Rpush.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 !Rpush.config.pid_file.blank?
+        begin
+          File.open(Rpush.config.pid_file, 'w') { |f| f.puts Process.pid }
+        rescue SystemCallError => e
+          Rpush.logger.error("Failed to write PID to '#{Rpush.config.pid_file}': #{e.inspect}")
+        end
+      end
+    end
+
+    def self.delete_pid_file
+      pid_file = Rpush.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/rpush/daemon/adm.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Daemon
+    module Adm
+      extend ServiceConfigMethods
+
+      dispatcher :http
+    end
+  end
+end

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

@@ -0,0 +1,222 @@
+module Rpush
+  module Daemon
+    module Adm
+      # https://developer.amazon.com/sdk/adm/sending-message.html
+      class Delivery < Rpush::Daemon::Delivery
+        include MultiJsonHelper
+
+        # Oauth2.0 token endpoint. This endpoint is used to request authorization tokens.
+        AMAZON_TOKEN_URI = URI.parse('https://api.amazon.com/auth/O2/token')
+
+        # ADM services endpoint. This endpoint is used to perform ADM requests.
+        AMAZON_ADM_URL = 'https://api.amazon.com/messaging/registrations/%s/messages'
+
+        # Data used to request authorization tokens.
+        ACCESS_TOKEN_REQUEST_DATA = {"grant_type" => "client_credentials", "scope" => "messaging:push"}
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+          @sent_registration_ids = []
+          @failed_registration_ids = {}
+        end
+
+        def perform
+          begin
+            @notification.registration_ids.each do |registration_id|
+              handle_response(do_post(registration_id), registration_id)
+            end
+
+            if(@sent_registration_ids.empty?)
+              raise Rpush::DeliveryError.new(nil, @notification.id, describe_errors)
+            else
+              unless(@failed_registration_ids.empty?)
+                @notification.error_description = describe_errors
+                Rpush::Daemon.store.update_notification(@notification)
+              end
+
+              mark_delivered
+            end
+          rescue Rpush::RetryableError => error
+            handle_retryable(error)
+          rescue Rpush::TooManyRequestsError => error
+            handle_too_many_requests(error)
+          rescue Rpush::DeliveryError => error
+            mark_failed(error.code, error.description)
+            raise
+          end
+        end
+
+        protected
+
+        def handle_response(response, current_registration_id)
+          case response.code.to_i
+          when 200
+            ok(response, current_registration_id)
+          when 400
+            bad_request(response, current_registration_id)
+          when 401
+            unauthorized(response)
+          when 429
+            too_many_requests(response)
+          when 500
+            internal_server_error(response, current_registration_id)
+          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, current_registration_id)
+          response_body = multi_json_load(response.body)
+
+          if(response_body.has_key?('registrationID'))
+            @sent_registration_ids << response_body['registrationID']
+            log_info("#{@notification.id} sent to #{response_body['registrationID']}")
+          end
+
+          if(current_registration_id != response_body['registrationID'])
+            reflect(:adm_canonical_id, current_registration_id, response_body['registrationID'])
+          end
+        end
+
+        def handle_retryable(error)
+          case error.code
+          when 401
+            # clear app access_token so a new one is fetched
+            @notification.app.access_token = nil
+            get_access_token
+            mark_retryable(@notification, Time.now) if @notification.app.access_token
+          when 503
+            retry_delivery(@notification, error.response)
+            log_warn("ADM responded with an Service Unavailable Error. " + retry_message)
+          end
+        end
+
+        def handle_too_many_requests(error)
+          if(@sent_registration_ids.empty?)
+            # none sent yet, just resend after the specified retry-after response.header
+            retry_delivery(@notification, error.response)
+          else
+            # save unsent registration ids
+            unsent_registration_ids = @notification.registration_ids.select { |reg_id| !@sent_registration_ids.include?(reg_id) }
+
+            # update the current notification so it only contains the sent reg ids
+            @notification.registration_ids.reject! { |reg_id| !@sent_registration_ids.include?(reg_id) }
+
+            Rpush::Daemon.store.update_notification(@notification)
+
+            # create a new notification with the remaining unsent reg ids
+            create_new_notification(error.response, unsent_registration_ids)
+
+            # mark the current notification as sent
+            mark_delivered
+          end
+        end
+
+        def bad_request(response, current_registration_id)
+          response_body = multi_json_load(response.body)
+
+          if(response_body.has_key?('reason'))
+            log_warn("bad_request: #{current_registration_id} (#{response_body['reason']})")
+            @failed_registration_ids[current_registration_id] = response_body['reason']
+          end
+        end
+
+        def unauthorized(response)
+          # Indicate a notification is retryable. Because ADM requires separate request for each push token, this will safely mark the entire notification to retry delivery.
+          raise Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Unauthorized Error.', response)
+        end
+
+        def too_many_requests(response)
+          # raise error so the current notification stops sending messages to remaining reg ids
+          raise Rpush::TooManyRequestsError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
+        end
+
+        def internal_server_error(response, current_registration_id)
+          @failed_registration_ids[current_registration_id] = "Internal Server Error"
+          log_warn("internal_server_error: #{current_registration_id} (Internal Server Error)")
+        end
+
+        def service_unavailable(response)
+          # Indicate a notification is retryable. Because ADM requires separate request for each push token, this will safely mark the entire notification to retry delivery.
+          raise Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Service Unavailable Error.', response)
+        end
+
+        def create_new_notification(response, registration_ids)
+          attrs = @notification.attributes.slice('app_id', 'collapse_key', 'delay_while_idle')
+          Rpush::Daemon.store.create_adm_notification(attrs, @notification.data, registration_ids, deliver_after_header(response), @notification.app)
+        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 describe_errors
+          if @failed_registration_ids.size == @notification.registration_ids.size
+            "Failed to deliver to all recipients."
+          else
+            error_msgs = []
+            @failed_registration_ids.each_pair { |regId, reason| error_msgs.push("#{regId}: #{reason}") }
+            "Failed to deliver to recipients: \n#{error_msgs.join("\n")}"
+          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(registration_id)
+          adm_uri = URI.parse(AMAZON_ADM_URL % [registration_id])
+          post = Net::HTTP::Post.new(adm_uri.path, initheader = {
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json',
+            'x-amzn-type-version' => 'com.amazon.device.messaging.ADMMessage@1.0',
+            'x-amzn-accept-type' => 'com.amazon.device.messaging.ADMSendResult@1.0',
+            'Authorization' => "Bearer #{get_access_token}"
+          })
+          post.body = @notification.as_json.to_json
+
+          @http.request(adm_uri, post)
+        end
+
+        def get_access_token
+          if(@notification.app.access_token.nil? || @notification.app.access_token_expired?)
+            post = Net::HTTP::Post.new(AMAZON_TOKEN_URI.path, initheader = {'Content-Type' => 'application/x-www-form-urlencoded'})
+            post.set_form_data(ACCESS_TOKEN_REQUEST_DATA.merge({'client_id' => @notification.app.client_id, 'client_secret' => @notification.app.client_secret}))
+
+            handle_access_token(@http.request(AMAZON_TOKEN_URI, post))
+          end
+
+          @notification.app.access_token
+        end
+
+        def handle_access_token(response)
+          if(response.code.to_i == 200)
+            update_access_token(JSON.parse(response.body))
+            Rpush::Daemon.store.update_app(@notification.app)
+            log_info("ADM access token updated: token = #{@notification.app.access_token}, expires = #{@notification.app.access_token_expiration}")
+          else
+            log_warn("Could not retrieve access token from ADM: #{response.body}")
+          end
+        end
+
+        def update_access_token(data)
+          @notification.app.access_token = data['access_token']
+          @notification.app.access_token_expiration = Time.now + data['expires_in'].to_i
+        end
+      end
+    end
+  end
+end