rapns 3.0.0-java

data/lib/rapns/app.rb

@@ -0,0 +1,29 @@
+module Rapns
+  class App < ActiveRecord::Base
+    self.table_name = 'rapns_apps'
+
+    attr_accessible :name, :environment, :certificate, :password, :connections, :auth_key
+
+    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
+
+    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 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

data/lib/rapns/configuration.rb

@@ -0,0 +1,46 @@
+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,
+    :airbrake_notify, :check_for_errors, :pid_file, :batch_size]
+
+  class Configuration < Struct.new(*CONFIG_ATTRS)
+    attr_accessor :apns_feedback_callback
+
+    def initialize
+      super
+
+      self.foreground = false
+      self.push_poll = 2
+      self.feedback_poll = 60
+      self.airbrake_notify = true
+      self.check_for_errors = true
+      self.batch_size = 5000
+    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 on_apns_feedback(&block)
+      self.apns_feedback_callback = block
+    end
+
+    def pid_file=(path)
+      if path && !Pathname.new(path).absolute?
+        super(File.join(Rails.root, path))
+      else
+        super
+      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.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.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.config.apns_feedback_callback.call(feedback) if Rapns.config.apns_feedback_callback
+            rescue StandardError => e
+              Rapns::Daemon.logger.error(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/app_runner.rb

@@ -0,0 +1,135 @@
+module Rapns
+  module Daemon
+    class AppRunner
+      class << self
+        attr_reader :runners # TODO: Needed?
+      end
+
+      @runners = {}
+
+      def self.enqueue(notification)
+        if app = runners[notification.app_id]
+          app.enqueue(notification)
+        else
+          Rapns::Daemon.logger.error("No such app '#{notification.app_id}' for notification #{notification.id}.")
+        end
+      end
+
+      def self.sync
+        apps = Rapns::App.all
+        apps.each { |app| sync_app(app) }
+        removed = runners.keys - apps.map(&:id)
+        removed.each { |app_id| runners.delete(app_id).stop }
+      end
+
+      def self.sync_app(app)
+        if runners[app.id]
+          runners[app.id].sync(app)
+        else
+          runner = new_runner(app)
+          begin
+            runner.start
+            runners[app.id] = runner
+          rescue StandardError => e
+            Rapns::Daemon.logger.error("[#{app.name}] Exception raised during startup. Notifications will not be delivered for this app.")
+            Rapns::Daemon.logger.error(e)
+          end
+        end
+      end
+
+      def self.new_runner(app)
+        type = app.class.parent.name.demodulize
+        "Rapns::Daemon::#{type}::AppRunner".constantize.new(app)
+      end
+
+      def self.stop
+        runners.values.map(&:stop)
+      end
+
+      def self.debug
+        runners.values.map(&:debug)
+      end
+
+      def self.idle
+        runners.values.select { |runner| runner.idle? }
+      end
+
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def started
+      end
+
+      def stopped
+      end
+
+      def start
+        app.connections.times { handlers << start_handler }
+        started
+        Rapns::Daemon.logger.info("[#{app.name}] Started, #{handlers_str}.")
+      end
+
+      def stop
+        handlers.map(&:stop)
+        stopped
+      end
+
+      def enqueue(notification)
+        queue.push(notification)
+      end
+
+      def sync(app)
+        @app = app
+        diff = handlers.size - app.connections
+        return if diff == 0
+        if diff > 0
+          diff.times { handlers.pop.stop }
+          Rapns::Daemon.logger.info("[#{app.name}] Terminated #{handlers_str(diff)}. #{handlers_str} remaining.")
+        else
+          diff.abs.times { handlers << start_handler }
+          Rapns::Daemon.logger.info("[#{app.name}] Added #{handlers_str(diff)}. #{handlers_str} remaining.")
+        end
+      end
+
+      def debug
+        Rapns::Daemon.logger.info <<-EOS
+
+#{@app.name}:
+  handlers: #{handlers.size}
+  queued: #{queue.size}
+  idle: #{idle?}
+        EOS
+      end
+
+      def idle?
+        queue.notifications_processed?
+      end
+
+      protected
+
+      def start_handler
+        handler = new_delivery_handler
+        handler.queue = queue
+        handler.start
+        handler
+      end
+
+      def queue
+        @queue ||= Rapns::Daemon::DeliveryQueue.new
+      end
+
+      def handlers
+        @handler ||= []
+      end
+
+      def handlers_str(count = app.connections)
+        count = count.abs
+        str = count == 1 ? 'handler' : 'handlers'
+        "#{count} #{str}"
+      end
+    end
+  end
+end

data/lib/rapns/daemon/database_reconnectable.rb

@@ -0,0 +1,57 @@
+class PGError < StandardError; end if !defined?(PGError)
+class Mysql; class Error < StandardError; end; end if !defined?(Mysql)
+module Mysql2; class Error < StandardError; end; end if !defined?(Mysql2)
+module ActiveRecord; end
+class ActiveRecord::JDBCError < StandardError; end if !defined?(ActiveRecord::JDBCError)
+
+module Rapns
+  module Daemon
+    module DatabaseReconnectable
+      ADAPTER_ERRORS = [ActiveRecord::StatementInvalid, PGError, Mysql::Error,
+                        Mysql2::Error, ActiveRecord::JDBCError]
+
+      def with_database_reconnect_and_retry
+        begin
+          ActiveRecord::Base.connection_pool.with_connection do
+            yield
+          end
+        rescue *ADAPTER_ERRORS => e
+          Rapns::Daemon.logger.error(e)
+          database_connection_lost
+          retry
+        end
+      end
+
+      def database_connection_lost
+        Rapns::Daemon.logger.warn("Lost connection to database, reconnecting...")
+        attempts = 0
+        loop do
+          begin
+            Rapns::Daemon.logger.warn("Attempt #{attempts += 1}")
+            reconnect_database
+            check_database_is_connected
+            break
+          rescue *ADAPTER_ERRORS => e
+            Rapns::Daemon.logger.error(e, :airbrake_notify => false)
+            sleep_to_avoid_thrashing
+          end
+        end
+        Rapns::Daemon.logger.warn("Database reconnected")
+      end
+
+      def reconnect_database
+        ActiveRecord::Base.clear_all_connections!
+        ActiveRecord::Base.establish_connection
+      end
+
+      def check_database_is_connected
+        # Simply asking the adapter for the connection state is not sufficient.
+        Rapns::Notification.count
+      end
+
+      def sleep_to_avoid_thrashing
+        sleep 2
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery.rb

@@ -0,0 +1,43 @@
+module Rapns
+  module Daemon
+    class Delivery
+      include DatabaseReconnectable
+
+      def self.perform(*args)
+        new(*args).perform
+      end
+
+      def retry_after(notification, deliver_after)
+        with_database_reconnect_and_retry do
+          notification.retries += 1
+          notification.deliver_after = deliver_after
+          notification.save!(:validate => false)
+        end
+      end
+
+      def retry_exponentially(notification)
+        retry_after(notification, Time.now + 2 ** (notification.retries + 1))
+      end
+
+      def mark_delivered
+        with_database_reconnect_and_retry do
+          @notification.delivered = true
+          @notification.delivered_at = Time.now
+          @notification.save!(:validate => false)
+        end
+      end
+
+      def mark_failed(code, description)
+        with_database_reconnect_and_retry do
+          @notification.delivered = false
+          @notification.delivered_at = nil
+          @notification.failed = true
+          @notification.failed_at = Time.now
+          @notification.error_code = code
+          @notification.error_description = description
+          @notification.save!(:validate => false)
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon/delivery_error.rb

@@ -0,0 +1,19 @@
+module Rapns
+  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