rpush 1.0.0-java

data/lib/rpush/apns/app.rb

@@ -0,0 +1,29 @@
+module Rpush
+  module Apns
+    class App < Rpush::App
+      validates :environment, :presence => true, :inclusion => { :in => %w(development production sandbox) }
+      validates :certificate, :presence => true
+      validate :certificate_has_matching_private_key
+
+      def service_name
+        'apns'
+      end
+
+      private
+
+      def certificate_has_matching_private_key
+        result = false
+        if certificate.present?
+          begin
+            x509 = OpenSSL::X509::Certificate.new(certificate)
+            pkey = OpenSSL::PKey::RSA.new(certificate, password)
+            result = !x509.nil? && !pkey.nil?
+          rescue OpenSSL::OpenSSLError
+            errors.add :certificate, 'Certificate value must contain a certificate and a private key.'
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rpush/apns/binary_notification_validator.rb

@@ -0,0 +1,12 @@
+module Rpush
+  module Apns
+    class BinaryNotificationValidator < ActiveModel::Validator
+
+      def validate(record)
+        if record.payload_size > 256
+          record.errors[:base] << "APN notification cannot be larger than 256 bytes. Try condensing your alert and device attributes."
+        end
+      end
+    end
+  end
+end

data/lib/rpush/apns/device_token_format_validator.rb

@@ -0,0 +1,12 @@
+module Rpush
+  module Apns
+    class DeviceTokenFormatValidator < ActiveModel::Validator
+
+      def validate(record)
+        if record.device_token !~ /^[a-z0-9]{64}$/i
+          record.errors[:device_token] << "is invalid"
+        end
+      end
+    end
+  end
+end

data/lib/rpush/apns/feedback.rb

@@ -0,0 +1,16 @@
+module Rpush
+  module Apns
+    class Feedback < ActiveRecord::Base
+      self.table_name = 'rpush_feedback'
+
+      if Rpush.attr_accessible_available?
+        attr_accessible :device_token, :failed_at, :app
+      end
+
+      validates :device_token, :presence => true
+      validates :failed_at, :presence => true
+
+      validates_with Rpush::Apns::DeviceTokenFormatValidator
+    end
+  end
+end

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/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

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/apns/certificate_expired_error.rb

@@ -0,0 +1,20 @@
+module Rpush
+  module Apns
+    class CertificateExpiredError < StandardError
+      attr_reader :app, :time
+
+      def initialize(app, time)
+        @app = app
+        @time = time
+      end
+
+      def to_s
+        message
+      end
+
+      def message
+        "#{app.name} certificate expired at #{time}."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Rpush
+  module Daemon
+    module Apns
+      class Delivery < Rpush::Daemon::Delivery
+        SELECT_TIMEOUT = 0.2
+        ERROR_TUPLE_BYTES = 6
+        APN_ERRORS = {
+          1 => "Processing error",
+          2 => "Missing device token",
+          3 => "Missing topic",
+          4 => "Missing payload",
+          5 => "Missing token size",
+          6 => "Missing topic size",
+          7 => "Missing payload size",
+          8 => "Invalid token",
+          255 => "None (unknown error)"
+        }
+
+        def initialize(app, conneciton, notification, batch)
+          @app = app
+          @connection = conneciton
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          begin
+            @connection.write(@notification.to_binary)
+            check_for_error if Rpush.config.check_for_errors
+            mark_delivered
+            log_info("#{@notification.id} sent to #{@notification.device_token}")
+          rescue Rpush::DeliveryError, Rpush::Apns::DisconnectionError => error
+            mark_failed(error.code, error.description)
+            raise
+          end
+        end
+
+        protected
+
+        def check_for_error
+          if @connection.select(SELECT_TIMEOUT)
+            error = nil
+
+            if tuple = @connection.read(ERROR_TUPLE_BYTES)
+              _, code, notification_id = tuple.unpack("ccN")
+
+              description = APN_ERRORS[code.to_i] || "Unknown error. Possible Rpush bug?"
+              error = Rpush::DeliveryError.new(code, notification_id, description)
+            else
+              error = Rpush::Apns::DisconnectionError.new
+            end
+
+            begin
+              log_error("Error received, reconnecting...")
+              @connection.reconnect
+            ensure
+              raise error if error
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/apns/disconnection_error.rb

@@ -0,0 +1,20 @@
+module Rpush
+  module Apns
+    class DisconnectionError < StandardError
+      attr_reader :code, :description
+
+      def initialize
+        @code = nil
+        @description = "APNs disconnected without returning an error."
+      end
+
+      def to_s
+        message
+      end
+
+      def message
+        "The APNs disconnected without returning an error. This may indicate you are using an invalid certificate for the host."
+      end
+    end
+  end
+end

data/lib/rpush/daemon/apns/feedback_receiver.rb

@@ -0,0 +1,79 @@
+module Rpush
+  module Daemon
+    module Apns
+      class FeedbackReceiver
+        include Reflectable
+        include Loggable
+
+        TUPLE_BYTES = 38
+        HOSTS = {
+          :production  => ['feedback.push.apple.com', 2196],
+          :development => ['feedback.sandbox.push.apple.com', 2196], # deprecated
+          :sandbox     => ['feedback.sandbox.push.apple.com', 2196]
+        }
+
+        def initialize(app)
+          @app = app
+          @host, @port = HOSTS[@app.environment.to_sym]
+          @poll = Rpush.config.feedback_poll
+          @certificate = app.certificate
+          @password = app.password
+          @interruptible_sleep = InterruptibleSleep.new
+        end
+
+        def start
+          return if Rpush.config.push
+
+          @thread = Thread.new do
+            loop do
+              break if @stop
+              check_for_feedback
+              @interruptible_sleep.sleep @poll
+            end
+
+            Rpush::Daemon.store.release_connection
+          end
+        end
+
+        def stop
+          @stop = true
+          @interruptible_sleep.interrupt_sleep
+          @thread.join if @thread
+        end
+
+        def check_for_feedback
+          connection = nil
+          begin
+            connection = Rpush::Daemon::TcpConnection.new(@app, @host, @port)
+            connection.connect
+
+            while tuple = connection.read(TUPLE_BYTES)
+              timestamp, device_token = parse_tuple(tuple)
+              create_feedback(timestamp, device_token)
+            end
+          rescue StandardError => e
+            log_error(e)
+            reflect(:error, e)
+          ensure
+            connection.close if connection
+          end
+        end
+
+        protected
+
+        def parse_tuple(tuple)
+          failed_at, _, device_token = tuple.unpack("N1n1H*")
+          [Time.at(failed_at).utc, device_token]
+        end
+
+        def create_feedback(failed_at, device_token)
+          formatted_failed_at = failed_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+          log_info("[FeedbackReceiver] Delivery failed at #{formatted_failed_at} for #{device_token}.")
+
+          feedback = Rpush::Daemon.store.create_apns_feedback(failed_at, device_token, @app)
+          reflect(:apns_feedback, feedback)
+        end
+      end
+    end
+  end
+end