rapns_rails_2 3.4.3

data/lib/rapns/apns/app.rb

@@ -0,0 +1,25 @@
+module Rapns
+  module Apns
+    class App < Rapns::App
+      validates_presence_of :environment
+      validates_inclusion_of :environment, :in => %w(development production sandbox)
+      validates_presence_of :certificate
+      validate :certificate_has_matching_private_key
+
+      private
+
+      def certificate_has_matching_private_key
+        result = false
+        if certificate.present?
+          x509 = OpenSSL::X509::Certificate.new(certificate) rescue nil
+          pkey = OpenSSL::PKey::RSA.new(certificate, password) rescue nil
+          result = !x509.nil? && !pkey.nil?
+          unless result
+            errors.add :certificate, 'Certificate value must contain a certificate and a private key.'
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rapns/apns/binary_notification_validator.rb

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

data/lib/rapns/apns/device_token_format_validator.rb

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

data/lib/rapns/apns/feedback.rb

@@ -0,0 +1,16 @@
+module Rapns
+  module Apns
+    class Feedback < ActiveRecord::Base
+      self.table_name = 'rapns_feedback'
+
+      if Rapns.attr_accessible_available?
+        attr_accessible :device_token, :failed_at, :app
+      end
+
+      validates_presence_of :device_token
+      validates_presence_of :failed_at
+
+      validates_with Rapns::Apns::DeviceTokenFormatValidator
+    end
+  end
+end

data/lib/rapns/apns/notification.rb

@@ -0,0 +1,91 @@
+module Rapns
+  module Apns
+    class Notification < Rapns::Notification
+      class MultipleAppAssignmentError < StandardError; end
+
+      validates_presence_of :device_token
+      validates_numericality_of :badge, :allow_nil => true
+
+      validates_with Rapns::Apns::DeviceTokenFormatValidator
+      validates_with Rapns::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 = '__rapns_mdm__'
+      def mdm=(magic)
+        self.attributes_for_device = (attributes_for_device || {}).merge({ MDM_KEY => magic })
+      end
+
+      CONTENT_AVAILABLE_KEY = '__rapns_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
+
+      def data=(attrs)
+        return unless attrs
+        raise ArgumentError, "must be a Hash" if !attrs.is_a?(Hash)
+        super attrs.merge(data || {})
+      end
+
+    end
+  end
+end

data/lib/rapns/apns_feedback.rb

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

data/lib/rapns/app.rb

@@ -0,0 +1,16 @@
+module Rapns
+  class App < ActiveRecord::Base
+    self.table_name = 'rapns_apps'
+    self.store_full_sti_class = true
+
+    if Rapns.attr_accessible_available?
+      attr_accessible :name, :environment, :certificate, :password, :connections, :auth_key
+    end
+
+    has_many :notifications, :class_name => 'Rapns::Notification', :dependent => :destroy
+
+    validates_presence_of :name
+    validates_uniqueness_of :name, :scope => [:type, :environment]
+    validates_numericality_of :connections, :greater_than => 0, :only_integer => true
+  end
+end

data/lib/rapns/configuration.rb

@@ -0,0 +1,89 @@
+module Rapns
+  def self.config
+    @config ||= Rapns::Configuration.new
+  end
+
+  def self.configure
+    yield config if block_given?
+  end
+
+  CONFIG_ATTRS = [:foreground, :push_poll, :feedback_poll, :embedded,
+    :airbrake_notify, :check_for_errors, :pid_file, :batch_size,
+    :push, :store, :logger, :batch_storage_updates, :udp_wake_host, :udp_wake_port]
+
+  class ConfigurationWithoutDefaults < Struct.new(*CONFIG_ATTRS)
+  end
+
+  class Configuration < Struct.new(*CONFIG_ATTRS)
+    include Deprecatable
+
+    attr_accessor :apns_feedback_callback
+
+    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 airbrake_notify=(bool)
+      Rapns::Deprecation.warn("airbrake_notify is deprecated. Please use the Rapns.reflect API instead.")
+      super(bool)
+    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 Rapns.jruby?
+        # The JVM does not support fork().
+        super(true)
+      else
+        super
+      end
+    end
+
+    def on_apns_feedback(&block)
+      self.apns_feedback_callback = block
+    end
+    deprecated(:on_apns_feedback, 3.2, "Please use the Rapns.reflect API instead.")
+
+    def set_defaults
+      if Rapns.jruby?
+        # The JVM does not support fork().
+        self.foreground = true
+      else
+        self.foreground = false
+      end
+
+      self.push_poll = 2
+      self.feedback_poll = 60
+      Rapns::Deprecation.muted { self.airbrake_notify = true }
+      self.check_for_errors = true
+      self.batch_size = 5000
+      self.pid_file = nil
+      self.apns_feedback_callback = 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/rapns/daemon/apns/app_runner.rb

@@ -0,0 +1,26 @@
+module Rapns
+  module Daemon
+    module Apns
+      class AppRunner < Rapns::Daemon::AppRunner
+
+        protected
+
+        def after_start
+          unless Rapns.config.push
+            poll = Rapns.config.feedback_poll
+            @feedback_receiver = FeedbackReceiver.new(app, poll)
+            @feedback_receiver.start
+          end
+        end
+
+        def after_stop
+          @feedback_receiver.stop if @feedback_receiver
+        end
+
+        def new_delivery_handler
+          DeliveryHandler.new(app)
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/apns/certificate_expired_error.rb

@@ -0,0 +1,20 @@
+module Rapns
+  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/rapns/daemon/apns/connection.rb

@@ -0,0 +1,142 @@
+module Rapns
+  module Daemon
+    module Apns
+      class ConnectionError < StandardError; end
+
+      class Connection
+        include Reflectable
+
+        attr_accessor :last_write
+
+        def self.idle_period
+          30.minutes
+        end
+
+        def initialize(app, host, port)
+          @app = app
+          @host = host
+          @port = port
+          @certificate = app.certificate
+          @password = app.password
+          written
+        end
+
+        def connect
+          @ssl_context = setup_ssl_context
+          @tcp_socket, @ssl_socket = connect_socket
+        end
+
+        def close
+          begin
+            @ssl_socket.close if @ssl_socket
+            @tcp_socket.close if @tcp_socket
+          rescue IOError
+          end
+        end
+
+        def read(num_bytes)
+          @ssl_socket.read(num_bytes)
+        end
+
+        def select(timeout)
+          IO.select([@ssl_socket], nil, nil, timeout)
+        end
+
+        def write(data)
+          reconnect_idle if idle_period_exceeded?
+
+          retry_count = 0
+
+          begin
+            write_data(data)
+          rescue Errno::EPIPE, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError, IOError => e
+            retry_count += 1;
+
+            if retry_count == 1
+              Rapns.logger.error("[#{@app.name}] Lost connection to #{@host}:#{@port} (#{e.class.name}), reconnecting...")
+              reflect(:apns_connection_lost, @app, e)
+            end
+
+            if retry_count <= 3
+              reconnect
+              sleep 1
+              retry
+            else
+              raise ConnectionError, "#{@app.name} tried #{retry_count-1} times to reconnect but failed (#{e.class.name})."
+            end
+          end
+        end
+
+        def reconnect
+          close
+          @tcp_socket, @ssl_socket = connect_socket
+        end
+
+        protected
+
+        def reconnect_idle
+          Rapns.logger.info("[#{@app.name}] Idle period exceeded, reconnecting...")
+          reconnect
+        end
+
+        def idle_period_exceeded?
+          Time.now - last_write > self.class.idle_period
+        end
+
+        def write_data(data)
+          @ssl_socket.write(data)
+          @ssl_socket.flush
+          written
+        end
+
+        def written
+          self.last_write = Time.now
+        end
+
+        def setup_ssl_context
+          ssl_context = OpenSSL::SSL::SSLContext.new
+          ssl_context.key = OpenSSL::PKey::RSA.new(@certificate, @password)
+          ssl_context.cert = OpenSSL::X509::Certificate.new(@certificate)
+          ssl_context
+        end
+
+        def connect_socket
+          check_certificate_expiration
+
+          tcp_socket = TCPSocket.new(@host, @port)
+          tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1)
+          tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+          ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, @ssl_context)
+          ssl_socket.sync = true
+          ssl_socket.connect
+          Rapns.logger.info("[#{@app.name}] Connected to #{@host}:#{@port}")
+          [tcp_socket, ssl_socket]
+        end
+
+        def check_certificate_expiration
+          cert = @ssl_context.cert
+          if certificate_expired?
+            Rapns.logger.error(certificate_msg('expired'))
+            raise Rapns::Apns::CertificateExpiredError.new(@app, cert.not_after)
+          elsif certificate_expires_soon?
+            Rapns.logger.warn(certificate_msg('will expire'))
+            reflect(:apns_certificate_will_expire, @app, cert.not_after)
+          end
+        end
+
+        def certificate_msg(msg)
+          time = @ssl_context.cert.not_after.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+          "[#{@app.name}] Certificate #{msg} at #{time}."
+        end
+
+        def certificate_expired?
+          @ssl_context.cert.not_after && @ssl_context.cert.not_after.utc < Time.now.utc
+        end
+
+        def certificate_expires_soon?
+          @ssl_context.cert.not_after && @ssl_context.cert.not_after.utc < (Time.now + 1.month).utc
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Rapns
+  module Daemon
+    module Apns
+      class Delivery < Rapns::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 Rapns.config.check_for_errors
+            mark_delivered
+            Rapns.logger.info("[#{@app.name}] #{@notification.id} sent to #{@notification.device_token}")
+          rescue Rapns::DeliveryError, Rapns::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)
+              cmd, code, notification_id = tuple.unpack("ccN")
+
+              description = APN_ERRORS[code.to_i] || "Unknown error. Possible rapns bug?"
+              error = Rapns::DeliveryError.new(code, notification_id, description)
+            else
+              error = Rapns::Apns::DisconnectionError.new
+            end
+
+            begin
+              Rapns.logger.error("[#{@app.name}] Error received, reconnecting...")
+              @connection.reconnect
+            ensure
+              raise error if error
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Rapns
+  module Daemon
+    module Apns
+      class DeliveryHandler < Rapns::Daemon::DeliveryHandler
+        HOSTS = {
+          :production  => ['gateway.push.apple.com', 2195],
+          :development => ['gateway.sandbox.push.apple.com', 2195], # deprecated
+          :sandbox     => ['gateway.sandbox.push.apple.com', 2195]
+        }
+
+        def initialize(app)
+          @app = app
+          @host, @port = HOSTS[@app.environment.to_sym]
+        end
+
+        def deliver(notification, batch)
+          Rapns::Daemon::Apns::Delivery.new(@app, connection, notification, batch).perform
+        end
+
+        def stopped
+          @connection.close if @connection
+        end
+
+        protected
+
+        def connection
+          return @connection if defined? @connection
+          connection = Connection.new(@app, @host, @port)
+          connection.connect
+          @connection = connection
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Rapns
+  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/rapns/daemon/apns/feedback_receiver.rb

@@ -0,0 +1,89 @@
+module Rapns
+  module Daemon
+    module Apns
+      class FeedbackReceiver
+        include Reflectable
+
+        FEEDBACK_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, poll)
+          @app = app
+          @host, @port = HOSTS[@app.environment.to_sym]
+          @poll = poll
+          @certificate = app.certificate
+          @password = app.password
+        end
+
+        def start
+          @thread = Thread.new do
+            loop do
+              break if @stop
+              check_for_feedback
+              interruptible_sleep.sleep @poll
+            end
+          end
+        end
+
+        def stop
+          @stop = true
+          interruptible_sleep.interrupt_sleep
+          @thread.join if @thread
+        end
+
+        def check_for_feedback
+          connection = nil
+          begin
+            connection = Connection.new(@app, @host, @port)
+            connection.connect
+
+            while tuple = connection.read(FEEDBACK_TUPLE_BYTES)
+              timestamp, device_token = parse_tuple(tuple)
+              create_feedback(timestamp, device_token)
+            end
+          rescue StandardError => e
+            Rapns.logger.error(e)
+          ensure
+            connection.close if connection
+          end
+        end
+
+        def interrupt_sleep
+          interruptible_sleep.interrupt_sleep
+        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")
+          Rapns.logger.info("[#{@app.name}] [FeedbackReceiver] Delivery failed at #{formatted_failed_at} for #{device_token}.")
+
+          feedback = Rapns::Daemon.store.create_apns_feedback(failed_at, device_token, @app)
+          reflect(:apns_feedback, feedback)
+
+          # Deprecated.
+          begin
+            Rapns.config.apns_feedback_callback.call(feedback) if Rapns.config.apns_feedback_callback
+          rescue StandardError => e
+            Rapns.logger.error(e)
+          end
+        end
+
+        def interruptible_sleep
+          @interruptible_sleep ||= InterruptibleSleep.new
+        end
+
+
+      end
+    end
+  end
+end