rpush 1.0.0

data/lib/rpush/daemon/interruptible_sleep.rb

@@ -0,0 +1,61 @@
+module Rpush
+  module Daemon
+    class InterruptibleSleep
+
+      def initialize
+        @sleep_reader, @wake_writer = IO.pipe
+        @udp_wakeup = nil
+      end
+
+      # enable wake on receiving udp packets at the given address and port
+      # this returns the host,port used by bind in case an ephemeral port
+      # was indicated by specifying 0 as the port number.
+      # @return [String,Integer] host,port of bound UDP socket.
+      def enable_wake_on_udp(host, port)
+        @udp_wakeup = UDPSocket.new
+        @udp_wakeup.bind(host, port)
+        @udp_wakeup.addr.values_at(3,1)
+      end
+
+      # wait for the given timeout in seconds, or data was written to the pipe
+      # or the udp wakeup port if enabled.
+      # @return [boolean] true if the sleep was interrupted, or false
+      def sleep(timeout)
+        read_ports = [@sleep_reader]
+        read_ports << @udp_wakeup if @udp_wakeup
+        rs, = IO.select(read_ports, nil, nil, timeout) rescue nil
+
+        # consume all data on the readable io's so that our next call will wait for more data
+        perform_io(rs, @sleep_reader, :read_nonblock)
+        perform_io(rs, @udp_wakeup, :recv_nonblock)
+
+        !rs.nil? && rs.any?
+      end
+
+      # writing to the pipe will wake the sleeping thread
+      def interrupt_sleep
+        @wake_writer.write('.')
+      end
+
+      def close
+        @sleep_reader.close rescue nil
+        @wake_writer.close rescue nil
+        @udp_wakeup.close if @udp_wakeup rescue nil
+      end
+
+      private
+
+      def perform_io(selected, io, meth)
+        if selected && selected.include?(io)
+          while true
+            begin
+              io.__send__(meth, 1)
+            rescue Errno::EAGAIN, IO::WaitReadable
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/loggable.rb

@@ -0,0 +1,31 @@
+module Rpush
+  module Daemon
+    module Loggable
+      def log_info(msg)
+        Rpush.logger.info(app_prefix(msg))
+      end
+
+      def log_warn(msg)
+        Rpush.logger.warn(app_prefix(msg))
+      end
+
+      def log_error(e)
+        if e.is_a?(Exception)
+          Rpush.logger.error(e)
+        else
+          Rpush.logger.error(app_prefix(e))
+        end
+      end
+
+      private
+
+      def app_prefix(msg)
+        if app = instance_variable_get('@app')
+          msg = "[#{app.name}] #{msg}"
+        end
+
+        msg
+      end
+    end
+  end
+end

data/lib/rpush/daemon/reflectable.rb

@@ -0,0 +1,13 @@
+module Rpush
+  module Daemon
+    module Reflectable
+      def reflect(name, *args)
+        begin
+          Rpush.reflections.__dispatch(name, *args)
+        rescue StandardError => e
+          Rpush.logger.error(e)
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/retry_header_parser.rb

@@ -0,0 +1,23 @@
+module Rpush
+  module Daemon
+    class RetryHeaderParser
+      def self.parse(header)
+        new(header).parse
+      end
+
+      def initialize(header)
+        @header = header
+      end
+
+      def parse
+        if @header
+          if @header.to_s =~ /^[0-9]+$/
+            Time.now + @header.to_i
+          else
+            Time.httpdate(@header)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/retryable_error.rb

@@ -0,0 +1,20 @@
+module Rpush
+  class RetryableError < StandardError
+    attr_reader :code, :description, :response
+
+    def initialize(code, notification_id, description, response)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+      @response = response
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      "Retryable error for #{@notification_id}, received error #{@code} (#{@description}) - retry after #{@response.header['retry-after']}"
+    end
+  end
+end

data/lib/rpush/daemon/service_config_methods.rb

@@ -0,0 +1,33 @@
+module Rpush
+  module Daemon
+    module ServiceConfigMethods
+      DISPATCHERS = {
+        :http => Rpush::Daemon::Dispatcher::Http,
+        :tcp => Rpush::Daemon::Dispatcher::Tcp
+      }
+
+      def dispatcher(name = nil, options = {})
+        @dispatcher_name = name
+        @dispatcher_options = options
+      end
+
+      def dispatcher_class
+        DISPATCHERS[@dispatcher_name] || (raise NotImplementedError)
+      end
+
+      def delivery_class
+        const_get('Delivery')
+      end
+
+      def new_dispatcher(app)
+        dispatcher_class.new(app, delivery_class, @dispatcher_options)
+      end
+
+      def loops(*loops)
+        @loops ||= []
+        @loops = loops if loops.any?
+        @loops
+      end
+    end
+  end
+end

data/lib/rpush/daemon/store/active_record.rb

@@ -0,0 +1,154 @@
+require 'active_record'
+
+require 'rpush/daemon/store/active_record/reconnectable'
+
+module Rpush
+  module Daemon
+    module Store
+      class ActiveRecord
+        include Reconnectable
+
+        DEFAULT_MARK_OPTIONS = {:persist => true}
+
+        def deliverable_notifications(apps)
+          with_database_reconnect_and_retry do
+            batch_size = Rpush.config.batch_size
+            relation = Rpush::Notification.ready_for_delivery.for_apps(apps)
+            relation = relation.limit(batch_size) unless Rpush.config.push
+            relation.to_a
+          end
+        end
+
+        def mark_retryable(notification, deliver_after, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.retries += 1
+          notification.deliver_after = deliver_after
+
+          if opts[:persist]
+            with_database_reconnect_and_retry do
+              notification.save!(:validate => false)
+            end
+          end
+        end
+
+        def mark_batch_retryable(notifications, deliver_after)
+          ids = []
+          notifications.each do |n|
+            mark_retryable(n, deliver_after, :persist => false)
+            ids << n.id
+          end
+          with_database_reconnect_and_retry do
+            Rpush::Notification.where(:id => ids).update_all(['retries = retries + 1, deliver_after = ?', deliver_after])
+          end
+        end
+
+        def mark_delivered(notification, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = true
+          notification.delivered_at = time
+
+          if opts[:persist]
+            with_database_reconnect_and_retry do
+              notification.save!(:validate => false)
+            end
+          end
+        end
+
+        def mark_batch_delivered(notifications)
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            mark_delivered(n, now, :persist => false)
+            ids << n.id
+          end
+          with_database_reconnect_and_retry do
+            Rpush::Notification.where(:id => ids).update_all(['delivered = ?, delivered_at = ?', true, now])
+          end
+        end
+
+        def mark_failed(notification, code, description, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = false
+          notification.delivered_at = nil
+          notification.failed = true
+          notification.failed_at = time
+          notification.error_code = code
+          notification.error_description = description
+
+          if opts[:persist]
+            with_database_reconnect_and_retry do
+              notification.save!(:validate => false)
+            end
+          end
+        end
+
+        def mark_batch_failed(notifications, code, description)
+          now = Time.now
+          ids = []
+          notifications.each do |n|
+            mark_failed(n, code, description, now, :persist => false)
+            ids << n.id
+          end
+          with_database_reconnect_and_retry do
+            Rpush::Notification.where(:id => ids).update_all(['delivered = ?, delivered_at = NULL, failed = ?, failed_at = ?, error_code = ?, error_description = ?', false, true, now, code, description])
+          end
+        end
+
+        def create_apns_feedback(failed_at, device_token, app)
+          with_database_reconnect_and_retry do
+            Rpush::Apns::Feedback.create!(:failed_at => failed_at,
+              :device_token => device_token, :app => app)
+          end
+        end
+
+        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
+          notification = Rpush::Gcm::Notification.new
+          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        end
+
+        def create_adm_notification(attrs, data, registration_ids, deliver_after, app)
+          notification = Rpush::Adm::Notification.new
+          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        end
+
+        def update_app(app)
+          with_database_reconnect_and_retry do
+            app.save!
+          end
+        end
+
+        def update_notification(notification)
+          with_database_reconnect_and_retry do
+            notification.save!
+          end
+        end
+
+        def after_daemonize
+          reconnect_database
+        end
+
+        def release_connection
+          begin
+            ::ActiveRecord::Base.connection_pool.release_connection
+          rescue StandardError => e
+            Rpush.logger.error(e)
+          end
+        end
+
+        private
+
+        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+          with_database_reconnect_and_retry do
+            notification.assign_attributes(attrs)
+            notification.data = data
+            notification.registration_ids = registration_ids
+            notification.deliver_after = deliver_after
+            notification.app = app
+            notification.save!
+            notification
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/store/active_record/reconnectable.rb

@@ -0,0 +1,68 @@
+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)
+
+# :nocov:
+if !defined?(::SQLite3::Exception)
+  module SQLite3
+    class Exception < StandardError; end
+  end
+end
+
+module Rpush
+  module Daemon
+    module Store
+      class ActiveRecord
+        module Reconnectable
+          ADAPTER_ERRORS = [::ActiveRecord::StatementInvalid, PGError, Mysql::Error,
+                            Mysql2::Error, ::ActiveRecord::JDBCError, SQLite3::Exception]
+
+          def with_database_reconnect_and_retry
+            begin
+              ::ActiveRecord::Base.connection_pool.with_connection do
+                yield
+              end
+            rescue *ADAPTER_ERRORS => e
+              Rpush.logger.error(e)
+              database_connection_lost
+              retry
+            end
+          end
+
+          def database_connection_lost
+            Rpush.logger.warn("Lost connection to database, reconnecting...")
+            attempts = 0
+            loop do
+              begin
+                Rpush.logger.warn("Attempt #{attempts += 1}")
+                reconnect_database
+                check_database_is_connected
+                break
+              rescue *ADAPTER_ERRORS => e
+                Rpush.logger.error(e)
+                sleep_to_avoid_thrashing
+              end
+            end
+            Rpush.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.
+            Rpush::Notification.count
+          end
+
+          def sleep_to_avoid_thrashing
+            sleep 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/tcp_connection.rb

@@ -0,0 +1,143 @@
+module Rpush
+  module Daemon
+    class TcpConnectionError < StandardError; end
+
+    class TcpConnection
+      include Reflectable
+      include Loggable
+
+      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
+            log_error("Lost connection to #{@host}:#{@port} (#{e.class.name}), reconnecting...")
+            reflect(:apns_connection_lost, @app, e) # deprecated
+            reflect(:tcp_connection_lost, @app, e)
+          end
+
+          if retry_count <= 3
+            reconnect
+            sleep 1
+            retry
+          else
+            raise TcpConnectionError, "#{@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
+        log_info("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
+        log_info("Connected to #{@host}:#{@port}")
+        [tcp_socket, ssl_socket]
+      end
+
+      def check_certificate_expiration
+        cert = @ssl_context.cert
+        if certificate_expired?
+          log_error(certificate_msg('expired'))
+          raise Rpush::Apns::CertificateExpiredError.new(@app, cert.not_after)
+        elsif certificate_expires_soon?
+          log_warn(certificate_msg('will expire'))
+          reflect(:apns_certificate_will_expire, @app, cert.not_after) # deprecated
+          reflect(:ssl_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")
+        "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