rapns 2.0.5 → 3.0.0.beta.1

data/lib/generators/rapns_generator.rb

@@ -15,6 +15,7 @@ class RapnsGenerator < Rails::Generators::Base
     add_rapns_migration('add_alert_is_json_to_rapns_notifications')
     add_rapns_migration('add_app_to_rapns')
     add_rapns_migration('create_rapns_apps')
+    add_rapns_migration('add_gcm')
   end
 
   protected

data/lib/generators/templates/add_gcm.rb

@@ -0,0 +1,86 @@
+class AddGcm < ActiveRecord::Migration
+  module Rapns
+    class App < ActiveRecord::Base
+      self.table_name = 'rapns_apps'
+    end
+
+    class Notification < ActiveRecord::Base
+      belongs_to :app
+      self.table_name = 'rapns_notifications'
+    end
+  end
+
+  def self.up
+    add_column :rapns_notifications, :type, :string, :null => true
+    add_column :rapns_apps, :type, :string, :null => true
+
+    AddGcm::Rapns::Notification.update_all :type => 'Rapns::Apns::Notification'
+    AddGcm::Rapns::App.update_all :type => 'Rapns::Apns::App'
+
+    change_column_null :rapns_notifications, :type, false
+    change_column_null :rapns_apps, :type, false
+    change_column_null :rapns_notifications, :device_token, true
+    change_column_null :rapns_notifications, :expiry, true
+    change_column_null :rapns_apps, :environment, true
+    change_column_null :rapns_apps, :certificate, true
+
+    change_column :rapns_notifications, :error_description, :text
+
+    rename_column :rapns_notifications, :attributes_for_device, :data
+    rename_column :rapns_apps, :key, :name
+
+    add_column :rapns_apps, :auth_key, :string, :null => true
+
+    add_column :rapns_notifications, :collapse_key, :string, :null => true
+    add_column :rapns_notifications, :delay_while_idle, :boolean, :null => false, :default => false
+    add_column :rapns_notifications, :registration_ids, :text, :null => true
+    add_column :rapns_notifications, :app_id, :integer, :null => true
+    add_column :rapns_notifications, :retries, :integer, :null => true, :default => 0
+
+    Rapns::Notification.reset_column_information
+    Rapns::App.reset_column_information
+
+    Rapns::App.all.each do |app|
+      Rapns::Notification.update_all(['app_id = ?', app.id], ['app = ?', app.name])
+    end
+
+    change_column_null :rapns_notifications, :app_id, false
+    remove_column :rapns_notifications, :app
+  end
+
+  def self.down
+    AddGcm::Rapns::Notification.where(:type => 'Rapns::Gcm::Notification').delete_all
+
+    remove_column :rapns_notifications, :type
+    remove_column :rapns_apps, :type
+
+    change_column_null :rapns_notifications, :device_token, false
+    change_column_null :rapns_notifications, :expiry, false
+    change_column_null :rapns_apps, :environment, false
+    change_column_null :rapns_apps, :certificate, false
+
+    change_column :rapns_notifications, :error_description, :string
+
+    rename_column :rapns_notifications, :data, :attributes_for_device
+    rename_column :rapns_apps, :name, :key
+
+    remove_column :rapns_apps, :auth_key
+
+    remove_column :rapns_notifications, :collapse_key
+    remove_column :rapns_notifications, :delay_while_idle
+    remove_column :rapns_notifications, :registration_ids
+    remove_column :rapns_notifications, :retries
+
+    add_column :rapns_notifications, :app, :string, :null => true
+
+    Rapns::Notification.reset_column_information
+    Rapns::App.reset_column_information
+
+    Rapns::App.all.each do |app|
+      Rapns::Notification.update_all(['app = ?', app.key], ['app_id = ?', app.id])
+    end
+
+    change_column_null :rapns_notifications, :key, false
+    remove_column :rapns_notifications, :app_id
+  end
+end

data/lib/generators/templates/create_rapns_notifications.rb

@@ -17,7 +17,7 @@ class CreateRapnsNotifications < ActiveRecord::Migration
       t.timestamps
     end
 
-    add_index :rapns_notifications, [:delivered, :failed, :deliver_after], :name => "index_rapns_notifications_on_delivered_failed_deliver_after"
+    add_index :rapns_notifications, [:delivered, :failed, :deliver_after], :name => "index_rapns_notifications_multi"
   end
 
   def self.down

data/lib/rapns/apns/app.rb

@@ -0,0 +1,8 @@
+module Rapns
+  module Apns
+    class App < Rapns::App
+      validates :environment, :presence => true, :inclusion => { :in => %w(development production) }
+      validates :certificate, :presence => true
+    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[: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[:device_token] << "is invalid"
+        end
+      end
+    end
+  end
+end

data/lib/rapns/apns/feedback.rb

@@ -0,0 +1,14 @@
+module Rapns
+  module Apns
+    class Feedback < ActiveRecord::Base
+      self.table_name = 'rapns_feedback'
+
+      attr_accessible :device_token, :failed_at, :app
+
+      validates :device_token, :presence => true
+      validates :failed_at, :presence => true
+
+      validates_with Rapns::Apns::DeviceTokenFormatValidator
+    end
+  end
+end

data/lib/rapns/apns/notification.rb

@@ -0,0 +1,84 @@
+module Rapns
+  module Apns
+    class Notification < Rapns::Notification
+      class MultipleAppAssignmentError < StandardError; end
+
+      validates :device_token, :presence => true
+      validates :badge, :numericality => true, :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 = { MDM_KEY => magic }
+      end
+
+      CONTENT_AVAILABLE_KEY = '__rapns_content_available__'
+      def content_available=(bool)
+        return unless bool
+        self.attributes_for_device = { 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.to_s }
+          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/rapns/app.rb

@@ -2,11 +2,11 @@ module Rapns
   class App < ActiveRecord::Base
     self.table_name = 'rapns_apps'
 
-    attr_accessible :key, :environment, :certificate, :password, :connections
+    attr_accessible :name, :environment, :certificate, :password, :connections, :auth_key
 
-    validates :key, :presence => true, :uniqueness => true
-    validates :environment, :presence => true, :inclusion => { :in => %w(development production) }
-    validates :certificate, :presence => true
+    has_many :notifications
+
+    validates :name, :presence => true, :uniqueness => { :scope => [:type, :environment] }
     validates_numericality_of :connections, :greater_than => 0, :only_integer => true
 
     validate :certificate_has_matching_private_key
@@ -20,11 +20,10 @@ module Rapns
         pkey = OpenSSL::PKey::RSA.new certificate rescue nil
         result = !x509.nil? && !pkey.nil?
         unless result
-          errors.add :certificate, "Certificate value must contain a certificate and a private key"
+          errors.add :certificate, 'Certificate value must contain a certificate and a private key.'
         end
       end
       result
     end
   end
 end
-

data/lib/rapns/{config.rb → configuration.rb}

@@ -1,11 +1,11 @@
 module Rapns
 
-  # A globally accessible instance of Rapns::Config
+  # A globally accessible instance of Rapns::Configuration
   def self.configuration
-    @configuration ||= Rapns::Config.new
+    @configuration ||= Rapns::Configuration.new
   end
 
-  # Call the given block yielding to it the global Rapns::Config instance for setting
+  # Call the given block yielding to it the global Rapns::Configuration instance for setting
   # configuration values / callbacks.
   #
   # Typically this would be used in your Rails application's config/initializers/rapns.rb file
@@ -14,7 +14,7 @@ module Rapns
   end
 
   # A class to hold Rapns configuration settings and callbacks.
-  class Config < Struct.new(:foreground, :push_poll, :feedback_poll, :airbrake_notify, :check_for_errors, :pid_file, :batch_size)
+  class Configuration < Struct.new(:foreground, :push_poll, :feedback_poll, :airbrake_notify, :check_for_errors, :pid_file, :batch_size)
 
     attr_accessor :feedback_callback
 
@@ -52,4 +52,4 @@ module Rapns
       self.feedback_callback = block
     end
   end
-end
+end

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

@@ -0,0 +1,36 @@
+module Rapns
+  module Daemon
+    module Apns
+      class AppRunner < Rapns::Daemon::AppRunner
+        ENVIRONMENTS = {
+          :production => {
+            :push     => ['gateway.push.apple.com', 2195],
+            :feedback => ['feedback.push.apple.com', 2196]
+          },
+          :development => {
+            :push      => ['gateway.sandbox.push.apple.com', 2195],
+            :feedback  => ['feedback.sandbox.push.apple.com', 2196]
+          }
+        }
+
+        protected
+
+        def started
+          poll = Rapns::Daemon.config[:feedback_poll]
+          host, port = ENVIRONMENTS[app.environment.to_sym][:feedback]
+          @feedback_receiver = FeedbackReceiver.new(app, host, port, poll)
+          @feedback_receiver.start
+        end
+
+        def stopped
+          @feedback_receiver.stop if @feedback_receiver
+        end
+
+        def new_delivery_handler
+          push_host, push_port = ENVIRONMENTS[app.environment.to_sym][:push]
+          DeliveryHandler.new(app, push_host, push_port)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+module Rapns
+  module Daemon
+    module Apns
+      class ConnectionError < StandardError; end
+
+      class Connection
+        attr_accessor :last_write
+
+        def self.idle_period
+          30.minutes
+        end
+
+        def initialize(name, host, port, certificate, password)
+          @name = name
+          @host = host
+          @port = port
+          @certificate = certificate
+          @password = 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 => e
+            retry_count += 1;
+
+            if retry_count == 1
+              Rapns::Daemon.logger.error("[#{@name}] Lost connection to #{@host}:#{@port} (#{e.class.name}), reconnecting...")
+            end
+
+            if retry_count <= 3
+              reconnect
+              sleep 1
+              retry
+            else
+              raise ConnectionError, "#{@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::Daemon.logger.info("[#{@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
+          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::Daemon.logger.info("[#{@name}] Connected to #{@host}:#{@port}")
+          [tcp_socket, ssl_socket]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+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)
+          @app = app
+          @connection = conneciton
+          @notification = notification
+        end
+
+        def perform
+          begin
+            @connection.write(@notification.to_binary)
+            check_for_error if Rapns::Daemon.config.check_for_errors
+            mark_delivered
+            Rapns::Daemon.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::Daemon.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,21 @@
+module Rapns
+  module Daemon
+    module Apns
+      class DeliveryHandler < Rapns::Daemon::DeliveryHandler
+        def initialize(app, host, port)
+          @app = app
+          @connection = Connection.new(@app.name, host, port, @app.certificate, @app.password)
+          @connection.connect
+        end
+
+        def deliver(notification)
+          Rapns::Daemon::Apns::Delivery.perform(@app, @connection, notification)
+        end
+
+        def stopped
+          @connection.close
+        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,74 @@
+module Rapns
+  module Daemon
+    module Apns
+      class FeedbackReceiver
+        include InterruptibleSleep
+        include DatabaseReconnectable
+
+        FEEDBACK_TUPLE_BYTES = 38
+
+        def initialize(app, host, port, poll)
+          @app = app
+          @host = host
+          @port = port
+          @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 @poll
+            end
+          end
+        end
+
+        def stop
+          @stop = true
+          interrupt_sleep
+          @thread.join if @thread
+        end
+
+        def check_for_feedback
+          connection = nil
+          begin
+            connection = Connection.new("FeedbackReceiver:#{@app.name}", @host, @port, @certificate, @password)
+            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::Daemon.logger.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")
+          with_database_reconnect_and_retry do
+            Rapns::Daemon.logger.info("[FeedbackReceiver:#{@app.name}] Delivery failed at #{formatted_failed_at} for #{device_token}")
+            feedback = Rapns::Apns::Feedback.create!(:failed_at => failed_at, :device_token => device_token, :app => @app)
+            begin
+              Rapns.configuration.feedback_callback.call(feedback) if Rapns.configuration.feedback_callback
+            rescue StandardError => e
+              Rapns::Daemon.logger.error(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end