rpush_extended 3.2.5

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

@@ -0,0 +1,214 @@
+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 initialize
+          reopen_log unless Rpush.config.embedded
+        end
+
+        def reopen_log
+          ::ActiveRecord::Base.logger = Rpush.logger.internal_logger
+        end
+
+        def app(id)
+          Rpush::Client::ActiveRecord::App.find(id)
+        end
+
+        def all_apps
+          Rpush::Client::ActiveRecord::App.all
+        end
+
+        def deliverable_notifications(limit)
+          with_database_reconnect_and_retry do
+            notifications = Rpush::Client::ActiveRecord::Notification.transaction do
+              relation = ready_for_delivery
+              relation = relation.limit(limit)
+              ids = relation.lock(true).ids
+              unless ids.empty?
+                relation = Rpush::Client::ActiveRecord::Notification.where(id: ids)
+                # mark processing
+                relation.update_all(processing: true, updated_at: Time.now)
+                relation
+              else
+                []
+              end
+            end
+
+            notifications.to_a
+          end
+        end
+
+        def mark_retryable(notification, deliver_after, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.processing = false
+          notification.retries += 1
+          notification.deliver_after = deliver_after
+
+          return unless opts[:persist]
+
+          with_database_reconnect_and_retry do
+            notification.save!(validate: false)
+          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
+          mark_ids_retryable(ids, deliver_after)
+        end
+
+        def mark_ids_retryable(ids, deliver_after)
+          return if ids.empty?
+
+          with_database_reconnect_and_retry do
+            Rpush::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?, delivered = ?, delivered_at = ?, failed = ?, failed_at = ?, retries = retries + 1, deliver_after = ?', false, false, nil, false, nil, deliver_after])
+          end
+        end
+
+        def mark_delivered(notification, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.processing = false
+          notification.delivered = true
+          notification.delivered_at = time
+
+          return unless opts[:persist]
+
+          with_database_reconnect_and_retry do
+            notification.save!(validate: false)
+          end
+        end
+
+        def mark_batch_delivered(notifications)
+          return if notifications.empty?
+
+          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::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?, delivered = ?, delivered_at = ?', false, true, now])
+          end
+        end
+
+        def mark_failed(notification, code, description, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.processing = false
+          notification.delivered = false
+          notification.delivered_at = nil
+          notification.failed = true
+          notification.failed_at = time
+          notification.error_code = code
+          notification.error_description = description
+
+          return unless opts[:persist]
+
+          with_database_reconnect_and_retry do
+            notification.save!(validate: false)
+          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
+          mark_ids_failed(ids, code, description, now)
+        end
+
+        def mark_ids_failed(ids, code, description, time)
+          return if ids.empty?
+
+          with_database_reconnect_and_retry do
+            Rpush::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?, delivered = ?, delivered_at = NULL, failed = ?, failed_at = ?, error_code = ?, error_description = ?', false, false, true, time, code, description])
+          end
+        end
+
+        def create_apns_feedback(failed_at, device_token, app)
+          with_database_reconnect_and_retry do
+            Rpush::Client::ActiveRecord::Apns::Feedback.create!(failed_at: failed_at,
+                                                                device_token: device_token, app_id: app.id)
+          end
+        end
+
+        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
+          notification = Rpush::Client::ActiveRecord::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::Client::ActiveRecord::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 release_connection
+          ::ActiveRecord::Base.connection.close
+        rescue StandardError => e
+          Rpush.logger.error(e)
+        end
+
+        def pending_delivery_count
+          ready_for_delivery.count
+        end
+
+        def translate_integer_notification_id(id)
+          id
+        end
+
+        private
+
+        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists
+          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
+
+        def ready_for_delivery
+          relation = Rpush::Client::ActiveRecord::Notification.where('processing = ? AND delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)', false, false, false, Time.now)
+          relation.order('deliver_after ASC, created_at ASC')
+        end
+
+        def adapter_name
+          env = (defined?(Rails) && Rails.env) ? Rails.env : 'development'
+          config = ::ActiveRecord::Base.configurations[env]
+          return '' unless config
+          Hash[config.map { |k, v| [k.to_sym, v] }][:adapter]
+        end
+      end
+    end
+  end
+end
+
+Rpush::Daemon::Store::Interface.check(Rpush::Daemon::Store::ActiveRecord)

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

@@ -0,0 +1,20 @@
+module Rpush
+  module Daemon
+    module Store
+      class Interface
+        PUBLIC_METHODS = [:deliverable_notifications, :mark_retryable,
+                          :mark_batch_retryable, :mark_delivered, :mark_batch_delivered,
+                          :mark_failed, :mark_batch_failed, :create_apns_feedback,
+                          :create_gcm_notification, :create_adm_notification, :update_app,
+                          :update_notification, :release_connection,
+                          :all_apps, :app, :mark_ids_failed, :mark_ids_retryable,
+                          :reopen_log, :pending_delivery_count, :translate_integer_notification_id]
+
+        def self.check(klass)
+          missing = PUBLIC_METHODS - klass.instance_methods.map(&:to_sym)
+          fail "#{klass} must implement #{missing.join(', ')}." if missing.any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+module Rpush
+  module Daemon
+    module Store
+      class Redis
+        DEFAULT_MARK_OPTIONS = { persist: true }
+
+        def app(app_id)
+          Rpush::Client::Redis::App.find(app_id)
+        end
+
+        def all_apps
+          Rpush::Client::Redis::App.all
+        end
+
+        def deliverable_notifications(limit)
+          retryable_ids = retryable_notification_ids
+          limit -= retryable_ids.size
+          pending_ids = limit > 0 ? pending_notification_ids(limit) : []
+          ids = retryable_ids + pending_ids
+          ids.map { |id| Rpush::Client::Redis::Notification.find(id) }
+        end
+
+        def mark_delivered(notification, time, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = true
+          notification.delivered_at = time
+          notification.save!(validate: false) if opts[:persist]
+        end
+
+        def mark_batch_delivered(notifications)
+          now = Time.now
+          notifications.each { |n| mark_delivered(n, now) }
+        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
+          notification.save!(validate: false) if opts[:persist]
+        end
+
+        def mark_batch_failed(notifications, code, description)
+          now = Time.now
+          notifications.each { |n| mark_failed(n, code, description, now) }
+        end
+
+        def mark_ids_failed(ids, code, description, time)
+          ids.each { |id| mark_failed(Rpush::Client::Redis::Notification.find(id), code, description, time) }
+        end
+
+        def mark_retryable(notification, deliver_after, opts = {})
+          opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
+          notification.delivered = false
+          notification.delivered_at = nil
+          notification.failed = false
+          notification.failed_at = nil
+          notification.retries += 1
+          notification.deliver_after = deliver_after
+
+          return unless opts[:persist]
+
+          notification.save!(validate: false)
+          namespace = Rpush::Client::Redis::Notification.absolute_retryable_namespace
+          Modis.with_connection do |redis|
+            redis.zadd(namespace, deliver_after.to_i, notification.id)
+          end
+        end
+
+        def mark_batch_retryable(notifications, deliver_after)
+          notifications.each { |n| mark_retryable(n, deliver_after) }
+        end
+
+        def mark_ids_retryable(ids, deliver_after)
+          ids.each { |id| mark_retryable(Rpush::Client::Redis::Notification.find(id), deliver_after) }
+        end
+
+        def create_apns_feedback(failed_at, device_token, app)
+          Rpush::Client::Redis::Apns::Feedback.create!(failed_at: failed_at, device_token: device_token, app_id: app.id)
+        end
+
+        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
+          notification = Rpush::Client::Redis::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::Client::Redis::Adm::Notification.new
+          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        end
+
+        def update_app(app)
+          app.save!
+        end
+
+        def update_notification(notification)
+          notification.save!
+        end
+
+        def release_connection
+        end
+
+        def reopen_log
+        end
+
+        def pending_delivery_count
+          Modis.with_connection do |redis|
+            pending = redis.zrange(Rpush::Client::Redis::Notification.absolute_pending_namespace, 0, -1)
+            retryable = redis.zrangebyscore(Rpush::Client::Redis::Notification.absolute_retryable_namespace, 0, Time.now.to_i)
+
+            pending.count + retryable.count
+          end
+        end
+
+        def translate_integer_notification_id(id)
+          id
+        end
+
+        private
+
+        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists
+          notification.assign_attributes(attrs)
+          notification.data = data
+          notification.registration_ids = registration_ids
+          notification.deliver_after = deliver_after
+          notification.app = app
+          notification.save!
+          notification
+        end
+
+        def retryable_notification_ids
+          retryable_ns = Rpush::Client::Redis::Notification.absolute_retryable_namespace
+
+          Modis.with_connection do |redis|
+            retryable_results = redis.multi do
+              now = Time.now.to_i
+              redis.zrangebyscore(retryable_ns, 0, now)
+              redis.zremrangebyscore(retryable_ns, 0, now)
+            end
+
+            retryable_results.first
+          end
+        end
+
+        def pending_notification_ids(limit)
+          limit = [0, limit - 1].max # 'zrange key 0 1' will return 2 values, not 1.
+          pending_ns = Rpush::Client::Redis::Notification.absolute_pending_namespace
+
+          Modis.with_connection do |redis|
+            pending_results = redis.multi do
+              redis.zrange(pending_ns, 0, limit)
+              redis.zremrangebyrank(pending_ns, 0, limit)
+            end
+
+            pending_results.first
+          end
+        end
+      end
+    end
+  end
+end
+
+Rpush::Daemon::Store::Interface.check(Rpush::Daemon::Store::Redis)

data/lib/rpush/daemon/string_helpers.rb

@@ -0,0 +1,15 @@
+module Rpush
+  module Daemon
+    module StringHelpers
+      def pluralize(count, singular, plural = nil)
+        if count == 1 || count =~ /^1(\.0+)?$/
+          word = singular
+        else
+          word = plural || singular.pluralize
+        end
+
+        "#{count || 0} #{word}"
+      end
+    end
+  end
+end

data/lib/rpush/daemon/synchronizer.rb

@@ -0,0 +1,62 @@
+module Rpush
+  module Daemon
+    class Synchronizer
+      extend Loggable
+      extend StringHelpers
+
+      APP_ATTRIBUTES_TO_CHECK = [:certificate, :environment, :auth_key, :client_id, :client_secret].freeze
+
+      def self.sync
+        apps = Rpush::Daemon.store.all_apps
+        apps.each { |app| sync_app(app) }
+        removed = AppRunner.app_ids - apps.map(&:id)
+        removed.each { |app_id| AppRunner.stop_app(app_id) }
+
+        ProcTitle.update
+      end
+
+      def self.sync_app(app)
+        if !AppRunner.app_running?(app)
+          AppRunner.start_app(app)
+        elsif (changed_attrs = changed_attributes(app)).count > 0
+          changed_attrs_str = changed_attrs.map(&:to_s).join(", ")
+          log_info("[#{app.name}] #{changed_attrs_str} changed, restarting...")
+          AppRunner.stop_app(app.id)
+          AppRunner.start_app(app)
+        else
+          sync_dispatcher_count(app)
+        end
+      end
+
+      def self.sync_dispatcher_count(app)
+        num_dispatchers = AppRunner.num_dispatchers_for_app(app)
+        diff = num_dispatchers - app.connections
+        return if diff == 0
+
+        if diff > 0
+          AppRunner.decrement_dispatchers(app, diff)
+          start_stop_str = "Stopped"
+        else
+          AppRunner.increment_dispatchers(app, diff.abs)
+          start_stop_str = "Started"
+        end
+
+        num_dispatchers = AppRunner.num_dispatchers_for_app(app)
+        log_info("[#{app.name}] #{start_stop_str} #{pluralize(diff.abs, 'dispatcher')}. #{num_dispatchers} running.")
+      end
+
+      def self.changed_attributes(app)
+        APP_ATTRIBUTES_TO_CHECK.select { |attr| attribute_changed?(app, attr) }
+      end
+
+      def self.attribute_changed?(app, attr)
+        if app.respond_to?(attr)
+          old_app = AppRunner.app_with_id(app.id)
+          app.send(attr) != old_app.send(attr)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/tcp_connection.rb

@@ -0,0 +1,190 @@
+module Rpush
+  module Daemon
+    class TcpConnectionError < StandardError; end
+
+    class TcpConnection
+      include Reflectable
+      include Loggable
+
+      OSX_TCP_KEEPALIVE = 0x10 # Defined in <netinet/tcp.h>
+      KEEPALIVE_INTERVAL = 5
+      KEEPALIVE_IDLE = 5
+      KEEPALIVE_MAX_FAIL_PROBES = 1
+      TCP_ERRORS = [SystemCallError, OpenSSL::OpenSSLError, IOError]
+
+      attr_accessor :last_touch
+      attr_reader :host, :port
+
+      def self.idle_period
+        30.minutes
+      end
+
+      def initialize(app, host, port)
+        @app = app
+        @host = host
+        @port = port
+        @certificate = app.certificate
+        @password = app.password
+        @connected = false
+        @connection_callbacks = []
+        touch
+      end
+
+      def on_connect(&blk)
+        raise 'already connected' if @connected
+        @connection_callbacks << blk
+      end
+
+      def connect
+        @ssl_context = setup_ssl_context
+        @tcp_socket, @ssl_socket = connect_socket
+        @connected = true
+
+        @connection_callbacks.each do |blk|
+          begin
+            blk.call
+          rescue StandardError => e
+            log_error(e)
+          end
+        end
+
+        @connection_callbacks.clear
+      end
+
+      def close
+        @ssl_socket.close if @ssl_socket
+        @tcp_socket.close if @tcp_socket
+      rescue IOError # rubocop:disable HandleExceptions
+      end
+
+      def read(num_bytes)
+        @ssl_socket.read(num_bytes) if @ssl_socket
+      end
+
+      def select(timeout)
+        IO.select([@ssl_socket], nil, nil, timeout) if @ssl_socket
+      end
+
+      def write(data)
+        connect unless @connected
+        reconnect_idle if idle_period_exceeded?
+
+        retry_count = 0
+
+        begin
+          write_data(data)
+        rescue *TCP_ERRORS => e
+          retry_count += 1
+
+          if retry_count == 1
+            log_error("Lost connection to #{@host}:#{@port} (#{e.class.name}, #{e.message}), reconnecting...")
+            reflect(:tcp_connection_lost, @app, e)
+          end
+
+          if retry_count <= 3
+            reconnect_with_rescue
+            sleep 1
+            retry
+          else
+            raise TcpConnectionError, "#{@app.name} tried #{retry_count - 1} times to reconnect but failed (#{e.class.name}, #{e.message})."
+          end
+        end
+      end
+
+      def reconnect_with_rescue
+        reconnect
+      rescue StandardError => e
+        log_error(e)
+      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_touch > self.class.idle_period
+      end
+
+      def write_data(data)
+        @ssl_socket.write(data)
+        @ssl_socket.flush
+        touch
+      end
+
+      def touch
+        self.last_touch = 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
+        touch
+        check_certificate_expiration
+
+        tcp_socket = TCPSocket.new(@host, @port)
+        tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+
+        # Linux
+        if [:SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all? { |c| Socket.const_defined?(c) }
+          tcp_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, KEEPALIVE_IDLE)
+          tcp_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, KEEPALIVE_INTERVAL)
+          tcp_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, KEEPALIVE_MAX_FAIL_PROBES)
+        end
+
+        # OSX
+        if RUBY_PLATFORM =~ /darwin/
+          tcp_socket.setsockopt(Socket::IPPROTO_TCP, OSX_TCP_KEEPALIVE, KEEPALIVE_IDLE)
+        end
+
+        ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, @ssl_context)
+        ssl_socket.sync = true
+        ssl_socket.connect
+        [tcp_socket, ssl_socket]
+      rescue *TCP_ERRORS => error
+        if error.message =~ /certificate revoked/i
+          log_error('Certificate has been revoked.')
+          reflect(:ssl_certificate_revoked, @app, error)
+        end
+        raise TcpConnectionError, "#{error.class.name}, #{error.message}"
+      end
+
+      def check_certificate_expiration
+        cert = @ssl_context.cert
+        if certificate_expired?
+          log_error(certificate_msg('expired'))
+          raise Rpush::CertificateExpiredError.new(@app, cert.not_after)
+        elsif certificate_expires_soon?
+          log_warn(certificate_msg('will expire'))
+          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

data/lib/rpush/daemon/wns/badge_request.rb

@@ -0,0 +1,32 @@
+module Rpush
+  module Daemon
+    module Wns
+      class BadgeRequest
+        def self.create(notification, access_token)
+          body = BadgeRequestPayload.new(notification).to_xml
+          uri  = URI.parse(notification.uri)
+          post = Net::HTTP::Post.new(
+            uri.request_uri,
+            "Content-Length" => body.length.to_s,
+            "Content-Type" => "text/xml",
+            "X-WNS-Type" => "wns/badge",
+            "X-WNS-RequestForStatus" => "true",
+            "Authorization" => "Bearer #{access_token}"
+          )
+          post.body = body
+          post
+        end
+      end
+
+      class BadgeRequestPayload
+        def initialize(notification)
+          @badge = notification.badge || 0
+        end
+
+        def to_xml
+          "<badge value=\"#{@badge}\"/>"
+        end
+      end
+    end
+  end
+end