rpush 1.0.0 → 2.0.0.beta1

data/lib/rpush/client/redis/adm/notification.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Adm
+        class Notification < Rpush::Client::Redis::Notification
+          include Rpush::Client::ActiveModel::Adm::Notification
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/apns/app.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Apns
+        class App < Rpush::Client::Redis::App
+          include Rpush::Client::ActiveModel::Apns::App
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/apns/feedback.rb

@@ -0,0 +1,20 @@
+module Rpush
+  module Client
+    module Redis
+      module Apns
+        class Feedback
+          include Modis::Model
+
+          attribute :app_id, :integer
+          attribute :device_token, :string
+          attribute :failed_at, :timestamp
+
+          validates :device_token, presence: true
+          validates :failed_at, presence: true
+
+          validates_with Rpush::Client::ActiveModel::Apns::DeviceTokenFormatValidator
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/apns/notification.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Apns
+        class Notification < Rpush::Client::Redis::Notification
+          include Rpush::Client::ActiveModel::Apns::Notification
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/app.rb

@@ -0,0 +1,22 @@
+module Rpush
+  module Client
+    module Redis
+      class App
+        include Modis::Model
+        self.namespace = 'apps'
+
+        attribute :name, :string
+        attribute :environment, :string
+        attribute :certificate, :string
+        attribute :password, :string
+        attribute :connections, :integer, default: 1
+        attribute :auth_key, :string
+        attribute :client_id, :string
+        attribute :client_secret, :string
+
+        validates :name, presence: true
+        validates_numericality_of :connections, greater_than: 0, only_integer: true
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/gcm/app.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Gcm
+        class App < Rpush::Client::Redis::App
+          include Rpush::Client::ActiveModel::Gcm::App
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/gcm/notification.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Gcm
+        class Notification < Rpush::Client::Redis::Notification
+          include Rpush::Client::ActiveModel::Gcm::Notification
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/notification.rb

@@ -0,0 +1,68 @@
+module Rpush
+  module Client
+    module Redis
+      class Notification
+        include Rpush::MultiJsonHelper
+        include Modis::Model
+        include Rpush::Client::ActiveModel::Notification
+
+        after_create :register_notification
+
+        self.namespace = 'notifications'
+
+        def self.absolute_pending_namespace
+          "#{absolute_namespace}:pending"
+        end
+
+        def self.absolute_retryable_namespace
+          "#{absolute_namespace}:retryable"
+        end
+
+        attribute :badge, :integer
+        attribute :device_token, :string
+        attribute :sound, :string, default: 'default'
+        attribute :alert, :hash, strict: false
+        attribute :data, :hash
+        attribute :expiry, :integer, default: 1.day.to_i
+        attribute :delivered, :boolean
+        attribute :delivered_at, :timestamp
+        attribute :failed, :boolean
+        attribute :failed_at, :timestamp
+        attribute :fail_after, :timestamp
+        attribute :retries, :integer, default: 0
+        attribute :error_code, :integer
+        attribute :error_description, :string
+        attribute :deliver_after, :timestamp
+        attribute :alert_is_json, :boolean
+        attribute :app_id, :integer
+        attribute :collapse_key, :string
+        attribute :delay_while_idle, :boolean
+        attribute :registration_ids, :array
+        attribute :uri, :string
+        attribute :priority, :integer
+
+        def app
+          return nil unless app_id
+          @app ||= Rpush::Client::Redis::App.find(app_id)
+        end
+
+        def app=(app)
+          @app = app
+          if app
+            self.app_id = app.id
+          else
+            self.app_id = nil
+          end
+        end
+
+        private
+
+        def register_notification
+          Modis.with_connection do |redis|
+            redis.zadd(self.class.absolute_pending_namespace, id, id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/wpns/app.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Wpns
+        class App < Rpush::Client::Redis::App
+          include Rpush::Client::ActiveModel::Wpns::App
+        end
+      end
+    end
+  end
+end

data/lib/rpush/client/redis/wpns/notification.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Client
+    module Redis
+      module Wpns
+        class Notification < Rpush::Client::Redis::Notification
+          include Rpush::Client::ActiveModel::Wpns::Notification
+        end
+      end
+    end
+  end
+end

data/lib/rpush/configuration.rb

@@ -4,12 +4,28 @@ module Rpush
   end
 
   def self.configure
-    yield config if block_given?
+    if block_given?
+      yield config
+      initialize_client
+    end
+  end
+
+  def self.initialize_client
+    return if @client_initialized
+    require "rpush/client/#{config.client}"
+    client_module = Rpush::Client.const_get(config.client.to_s.camelize)
+    Rpush.send(:include, client_module)
+
+    [:Apns, :Gcm, :Wpns, :Adm].each do |service|
+      Rpush.const_set(service, client_module.const_get(service))
+    end
+
+    @client_initialized = true
   end
 
   CONFIG_ATTRS = [:foreground, :push_poll, :feedback_poll, :embedded,
-    :check_for_errors, :pid_file, :batch_size, :push, :store, :logger,
-    :batch_storage_updates, :wakeup]
+                  :check_for_errors, :pid_file, :batch_size, :push, :client, :logger,
+                  :batch_storage_updates, :log_dir, :environment]
 
   class ConfigurationWithoutDefaults < Struct.new(*CONFIG_ATTRS)
   end
@@ -17,6 +33,11 @@ module Rpush
   class Configuration < Struct.new(*CONFIG_ATTRS)
     include Deprecatable
 
+    deprecated(:batch_storage_updates=, '2.1.0', 'Updates are now always batched by the storage backends.')
+    deprecated(:check_for_errors=, '2.1.0', 'APNs error detection is now performed asynchronously and does not require pauses.')
+
+    delegate :redis_options, :redis_options=, to: :Modis
+
     def initialize
       super
       set_defaults
@@ -60,16 +81,16 @@ module Rpush
 
       self.push_poll = 2
       self.feedback_poll = 60
-      self.check_for_errors = true
       self.batch_size = 100
       self.pid_file = nil
-      self.store = :active_record
+      self.client = :active_record
       self.logger = nil
-      self.batch_storage_updates = true
+      self.log_dir = Rails.root
 
       # Internal options.
       self.embedded = false
       self.push = false
+      self.environment = Rails.env
     end
   end
 end

data/lib/rpush/daemon.rb

@@ -2,9 +2,9 @@ require 'thread'
 require 'socket'
 require 'pathname'
 require 'openssl'
-
 require 'net/http/persistent'
 
+require 'rpush/daemon/errors'
 require 'rpush/daemon/constants'
 require 'rpush/daemon/reflectable'
 require 'rpush/daemon/loggable'
@@ -15,18 +15,23 @@ require 'rpush/daemon/too_many_requests_error'
 require 'rpush/daemon/delivery'
 require 'rpush/daemon/feeder'
 require 'rpush/daemon/batch'
+require 'rpush/daemon/queue_payload'
 require 'rpush/daemon/app_runner'
 require 'rpush/daemon/tcp_connection'
 require 'rpush/daemon/dispatcher_loop'
 require 'rpush/daemon/dispatcher_loop_collection'
 require 'rpush/daemon/dispatcher/http'
 require 'rpush/daemon/dispatcher/tcp'
+require 'rpush/daemon/dispatcher/apns_tcp'
 require 'rpush/daemon/service_config_methods'
 require 'rpush/daemon/retry_header_parser'
+require 'rpush/daemon/ring_buffer'
+require 'rpush/daemon/signal_handler'
+require 'rpush/daemon/proc_title'
+
+require 'rpush/daemon/store/interface'
 
 require 'rpush/daemon/apns/delivery'
-require 'rpush/daemon/apns/disconnection_error'
-require 'rpush/daemon/apns/certificate_expired_error'
 require 'rpush/daemon/apns/feedback_receiver'
 require 'rpush/daemon/apns'
 
@@ -46,69 +51,59 @@ module Rpush
     end
 
     def self.start
-      setup_signal_traps if trap_signals?
-
+      SignalHandler.start
+      Process.daemon if daemonize?
       initialize_store
-      return unless store
-
-      if daemonize?
-        daemonize
-        store.after_daemonize
-      end
-
       write_pid_file
       AppRunner.sync
+
+      # No further store connections will be made from this thread.
+      store.release_connection
+
+      # Blocking call, returns after Feeder.stop is called from another thread.
       Feeder.start
+
+      # Wait for shutdown to complete.
+      shutdown_lock.synchronize { true }
     end
 
     def self.shutdown(quiet = false)
       puts "\nShutting down..." unless quiet
-      Feeder.stop
-      AppRunner.stop
-      delete_pid_file
+
+      shutdown_lock.synchronize do
+        Feeder.stop
+        AppRunner.stop
+        delete_pid_file
+      end
+    end
+
+    def self.shutdown_lock
+      return @shutdown_lock if @shutdown_lock
+      @shutdown_lock = Mutex.new
+      @shutdown_lock
     end
 
     def self.initialize_store
       return if store
       begin
-        name = Rpush.config.store.to_s
+        name = Rpush.config.client.to_s
         require "rpush/daemon/store/#{name}"
         self.store = Rpush::Daemon::Store.const_get(name.camelcase).new
       rescue StandardError, LoadError => e
-        Rpush.logger.error("Failed to load '#{Rpush.config.store}' storage backend.")
+        Rpush.logger.error("Failed to load '#{Rpush.config.client}' storage backend.")
         Rpush.logger.error(e)
+        exit 1
       end
     end
 
     protected
 
     def self.daemonize?
-      !(Rpush.config.foreground || Rpush.config.embedded || Rpush.jruby?)
-    end
-
-    def self.trap_signals?
-      !Rpush.config.embedded
-    end
-
-    def self.setup_signal_traps
-      @shutting_down = false
-
-      Signal.trap('SIGHUP') { AppRunner.sync }
-      Signal.trap('SIGUSR2') { AppRunner.debug }
-
-      ['SIGINT', 'SIGTERM'].each do |signal|
-        Signal.trap(signal) { handle_shutdown_signal }
-      end
-    end
-
-    def self.handle_shutdown_signal
-      exit 1 if @shutting_down
-      @shutting_down = true
-      shutdown
+      !(Rpush.config.push || Rpush.config.foreground || Rpush.config.embedded || Rpush.jruby?)
     end
 
     def self.write_pid_file
-      if !Rpush.config.pid_file.blank?
+      unless Rpush.config.pid_file.blank?
         begin
           File.open(Rpush.config.pid_file, 'w') { |f| f.puts Process.pid }
         rescue SystemCallError => e
@@ -119,22 +114,7 @@ module Rpush
 
     def self.delete_pid_file
       pid_file = Rpush.config.pid_file
-      File.delete(pid_file) if !pid_file.blank? && File.exists?(pid_file)
-    end
-
-    # :nocov:
-    def self.daemonize
-      if RUBY_VERSION < "1.9"
-        exit if fork
-        Process.setsid
-        exit if fork
-        Dir.chdir "/"
-        STDIN.reopen "/dev/null"
-        STDOUT.reopen "/dev/null", "a"
-        STDERR.reopen "/dev/null", "a"
-      else
-        Process.daemon
-      end
+      File.delete(pid_file) if !pid_file.blank? && File.exist?(pid_file)
     end
   end
 end

data/lib/rpush/daemon/adm/delivery.rb

@@ -12,7 +12,7 @@ module Rpush
         AMAZON_ADM_URL = 'https://api.amazon.com/messaging/registrations/%s/messages'
 
         # Data used to request authorization tokens.
-        ACCESS_TOKEN_REQUEST_DATA = {"grant_type" => "client_credentials", "scope" => "messaging:push"}
+        ACCESS_TOKEN_REQUEST_DATA = { "grant_type" => "client_credentials", "scope" => "messaging:push" }
 
         def initialize(app, http, notification, batch)
           @app = app
@@ -24,29 +24,27 @@ module Rpush
         end
 
         def perform
-          begin
-            @notification.registration_ids.each do |registration_id|
-              handle_response(do_post(registration_id), registration_id)
-            end
-
-            if(@sent_registration_ids.empty?)
-              raise Rpush::DeliveryError.new(nil, @notification.id, describe_errors)
-            else
-              unless(@failed_registration_ids.empty?)
-                @notification.error_description = describe_errors
-                Rpush::Daemon.store.update_notification(@notification)
-              end
-
-              mark_delivered
+          @notification.registration_ids.each do |registration_id|
+            handle_response(do_post(registration_id), registration_id)
+          end
+          if @sent_registration_ids.empty?
+            fail Rpush::DeliveryError.new(nil, @notification.id, describe_errors)
+          else
+            unless @failed_registration_ids.empty?
+              @notification.error_description = describe_errors
+              Rpush::Daemon.store.update_notification(@notification)
             end
-          rescue Rpush::RetryableError => error
-            handle_retryable(error)
-          rescue Rpush::TooManyRequestsError => error
-            handle_too_many_requests(error)
-          rescue Rpush::DeliveryError => error
-            mark_failed(error.code, error.description)
-            raise
+            mark_delivered
           end
+        rescue Rpush::RetryableError => error
+          handle_retryable(error)
+        rescue Rpush::TooManyRequestsError => error
+          handle_too_many_requests(error)
+        rescue StandardError => error
+          mark_failed(error)
+          raise
+        ensure
+          @batch.notification_processed
         end
 
         protected
@@ -62,25 +60,25 @@ module Rpush
           when 429
             too_many_requests(response)
           when 500
-            internal_server_error(response, current_registration_id)
+            internal_server_error(current_registration_id)
           when 503
             service_unavailable(response)
           else
-            raise Rpush::DeliveryError.new(response.code, @notification.id, Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i])
+            fail Rpush::DeliveryError.new(response.code, @notification.id, Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i])
           end
         end
 
         def ok(response, current_registration_id)
           response_body = multi_json_load(response.body)
 
-          if(response_body.has_key?('registrationID'))
+          if response_body.key?('registrationID')
             @sent_registration_ids << response_body['registrationID']
             log_info("#{@notification.id} sent to #{response_body['registrationID']}")
           end
 
-          if(current_registration_id != response_body['registrationID'])
-            reflect(:adm_canonical_id, current_registration_id, response_body['registrationID'])
-          end
+          return if current_registration_id == response_body['registrationID']
+
+          reflect(:adm_canonical_id, current_registration_id, response_body['registrationID'])
         end
 
         def handle_retryable(error)
@@ -88,7 +86,7 @@ module Rpush
           when 401
             # clear app access_token so a new one is fetched
             @notification.app.access_token = nil
-            get_access_token
+            access_token
             mark_retryable(@notification, Time.now) if @notification.app.access_token
           when 503
             retry_delivery(@notification, error.response)
@@ -97,7 +95,7 @@ module Rpush
         end
 
         def handle_too_many_requests(error)
-          if(@sent_registration_ids.empty?)
+          if @sent_registration_ids.empty?
             # none sent yet, just resend after the specified retry-after response.header
             retry_delivery(@notification, error.response)
           else
@@ -120,30 +118,30 @@ module Rpush
         def bad_request(response, current_registration_id)
           response_body = multi_json_load(response.body)
 
-          if(response_body.has_key?('reason'))
-            log_warn("bad_request: #{current_registration_id} (#{response_body['reason']})")
-            @failed_registration_ids[current_registration_id] = response_body['reason']
-          end
+          return unless response_body.key?('reason')
+
+          log_warn("bad_request: #{current_registration_id} (#{response_body['reason']})")
+          @failed_registration_ids[current_registration_id] = response_body['reason']
         end
 
         def unauthorized(response)
           # Indicate a notification is retryable. Because ADM requires separate request for each push token, this will safely mark the entire notification to retry delivery.
-          raise Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Unauthorized Error.', response)
+          fail Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Unauthorized Error.', response)
         end
 
         def too_many_requests(response)
           # raise error so the current notification stops sending messages to remaining reg ids
-          raise Rpush::TooManyRequestsError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
+          fail Rpush::TooManyRequestsError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
         end
 
-        def internal_server_error(response, current_registration_id)
+        def internal_server_error(current_registration_id)
           @failed_registration_ids[current_registration_id] = "Internal Server Error"
           log_warn("internal_server_error: #{current_registration_id} (Internal Server Error)")
         end
 
         def service_unavailable(response)
           # Indicate a notification is retryable. Because ADM requires separate request for each push token, this will safely mark the entire notification to retry delivery.
-          raise Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Service Unavailable Error.', response)
+          fail Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Service Unavailable Error.', response)
         end
 
         def create_new_notification(response, registration_ids)
@@ -156,7 +154,8 @@ module Rpush
         end
 
         def retry_delivery(notification, response)
-          if time = deliver_after_header(response)
+          time = deliver_after_header(response)
+          if time
             mark_retryable(notification, time)
           else
             mark_retryable_exponential(notification)
@@ -178,23 +177,22 @@ module Rpush
         end
 
         def do_post(registration_id)
-          adm_uri = URI.parse(AMAZON_ADM_URL % [registration_id])
-          post = Net::HTTP::Post.new(adm_uri.path, initheader = {
-            'Content-Type' => 'application/json',
-            'Accept' => 'application/json',
-            'x-amzn-type-version' => 'com.amazon.device.messaging.ADMMessage@1.0',
-            'x-amzn-accept-type' => 'com.amazon.device.messaging.ADMSendResult@1.0',
-            'Authorization' => "Bearer #{get_access_token}"
-          })
+          adm_uri = URI.parse(format(AMAZON_ADM_URL, registration_id))
+          post = Net::HTTP::Post.new(adm_uri.path,
+                                     'Content-Type' => 'application/json',
+                                     'Accept' => 'application/json',
+                                     'x-amzn-type-version' => 'com.amazon.device.messaging.ADMMessage@1.0',
+                                     'x-amzn-accept-type' => 'com.amazon.device.messaging.ADMSendResult@1.0',
+                                     'Authorization' => "Bearer #{access_token}")
           post.body = @notification.as_json.to_json
 
           @http.request(adm_uri, post)
         end
 
-        def get_access_token
-          if(@notification.app.access_token.nil? || @notification.app.access_token_expired?)
-            post = Net::HTTP::Post.new(AMAZON_TOKEN_URI.path, initheader = {'Content-Type' => 'application/x-www-form-urlencoded'})
-            post.set_form_data(ACCESS_TOKEN_REQUEST_DATA.merge({'client_id' => @notification.app.client_id, 'client_secret' => @notification.app.client_secret}))
+        def access_token
+          if @notification.app.access_token.nil? || @notification.app.access_token_expired?
+            post = Net::HTTP::Post.new(AMAZON_TOKEN_URI.path, 'Content-Type' => 'application/x-www-form-urlencoded')
+            post.set_form_data(ACCESS_TOKEN_REQUEST_DATA.merge('client_id' => @notification.app.client_id, 'client_secret' => @notification.app.client_secret))
 
             handle_access_token(@http.request(AMAZON_TOKEN_URI, post))
           end
@@ -203,7 +201,7 @@ module Rpush
         end
 
         def handle_access_token(response)
-          if(response.code.to_i == 200)
+          if response.code.to_i == 200
             update_access_token(JSON.parse(response.body))
             Rpush::Daemon.store.update_app(@notification.app)
             log_info("ADM access token updated: token = #{@notification.app.access_token}, expires = #{@notification.app.access_token_expiration}")