rpush 2.4.0 → 2.5.0

data/lib/rpush/daemon/signal_handler.rb

@@ -1,6 +1,8 @@
 module Rpush
   module Daemon
     class SignalHandler
+      extend Loggable
+
       class << self
         attr_reader :thread
       end
@@ -18,6 +20,11 @@ module Rpush
       def self.stop
         @write_io.puts('break') if @write_io
         @thread.join if @thread
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
       end
 
       def self.start_handler(read_io)

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

@@ -11,7 +11,8 @@ module Rpush
         DEFAULT_MARK_OPTIONS = { persist: true }
 
         def initialize
-          reopen_log
+          @using_oracle = adapter_name =~ /oracle/
+          reopen_log unless Rpush.config.embedded
         end
 
         def reopen_log
@@ -31,7 +32,7 @@ module Rpush
             Rpush::Client::ActiveRecord::Notification.transaction do
               relation = ready_for_delivery
               relation = relation.limit(limit)
-              notifications = relation.lock(true).to_a
+              notifications = claim(relation)
               mark_processing(notifications)
               notifications
             end
@@ -188,7 +189,8 @@ module Rpush
         end
 
         def ready_for_delivery
-          Rpush::Client::ActiveRecord::Notification.where('processing = ? AND delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)', false, false, false, Time.now).order('created_at ASC')
+          relation = Rpush::Client::ActiveRecord::Notification.where('processing = ? AND delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)', false, false, false, Time.now)
+          @using_oracle ? relation : relation.order('created_at ASC')
         end
 
         def mark_processing(notifications)
@@ -201,6 +203,18 @@ module Rpush
           end
           Rpush::Client::ActiveRecord::Notification.where(id: ids).update_all(['processing = ?', true])
         end
+
+        def claim(relation)
+          notifications = relation.lock(true).to_a
+          @using_oracle ? notification.sort_by(&:created_at) : notifications
+        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

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

@@ -96,12 +96,12 @@ module Rpush
           Rpush::Client::Mongoid::Apns::Feedback.create!(failed_at: failed_at, device_token: device_token, app: app)
         end
 
-        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app) # rubocop:disable ParameterLists
+        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
           notification = Rpush::Client::Mongoid::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) # rubocop:disable ParameterLists
+        def create_adm_notification(attrs, data, registration_ids, deliver_after, app)
           notification = Rpush::Client::Mongoid::Adm::Notification.new
           create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
         end

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

@@ -82,12 +82,12 @@ module Rpush
           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) # rubocop:disable ParameterLists
+        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) # rubocop:disable ParameterLists
+        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

data/lib/rpush/daemon/tcp_connection.rb

@@ -156,7 +156,7 @@ module Rpush
         [tcp_socket, ssl_socket]
       rescue *TCP_ERRORS => error
         if error.message =~ /certificate revoked/i
-          log_warn('Certificate has been revoked.')
+          log_error('Certificate has been revoked.')
           reflect(:ssl_certificate_revoked, @app, error)
         end
         raise TcpConnectionError, "#{error.class.name}, #{error.message}"
@@ -166,7 +166,7 @@ module Rpush
         cert = @ssl_context.cert
         if certificate_expired?
           log_error(certificate_msg('expired'))
-          fail Rpush::CertificateExpiredError.new(@app, cert.not_after)
+          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)

data/lib/rpush/daemon/wns.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Daemon
+    module Wns
+      extend ServiceConfigMethods
+
+      dispatcher :http
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+module Rpush
+  module Daemon
+    module Wns
+      # https://msdn.microsoft.com/en-us/library/windows/apps/hh465435.aspx
+      class Delivery < Rpush::Daemon::Delivery
+        # Oauth2.0 token endpoint. This endpoint is used to request authorization tokens.
+        WPN_TOKEN_URI = URI.parse('https://login.live.com/accesstoken.srf')
+
+        # Data used to request authorization tokens.
+        ACCESS_TOKEN_REQUEST_DATA = { "grant_type" => "client_credentials", "scope" => "notify.windows.com" }
+
+        MAX_RETRIES = 14
+
+        FAILURE_MESSAGES = {
+          400 => 'One or more headers were specified incorrectly or conflict with another header.',
+          401 => 'The cloud service did not present a valid authentication ticket. The OAuth ticket may be invalid.',
+          403 => 'The cloud service is not authorized to send a notification to this URI even though they are authenticated.',
+          404 => 'The channel URI is not valid or is not recognized by WNS.',
+          405 => 'Invalid method (GET, CREATE); only POST (Windows or Windows Phone) or DELETE (Windows Phone only) is allowed.',
+          406 => 'The cloud service exceeded its throttle limit.',
+          410 => 'The channel expired.',
+          413 => 'The notification payload exceeds the 5000 byte size limit.',
+          500 => 'An internal failure caused notification delivery to fail.',
+          503 => 'The server is currently unavailable.'
+        }
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          handle_response(do_post)
+        rescue SocketError => error
+          mark_retryable(@notification, Time.now + 10.seconds, error)
+          raise
+        rescue StandardError => error
+          mark_failed(error)
+          raise
+        ensure
+          @batch.notification_processed
+        end
+
+        private
+
+        def handle_response(response)
+          code = response.code.to_i
+          case code
+          when 200
+            ok(response)
+          when 401
+            unauthorized
+          when 404
+            invalid_channel(code)
+          when 406
+            not_acceptable
+          when 410
+            invalid_channel(code)
+          when 412
+            precondition_failed
+          when 503
+            service_unavailable
+          else
+            handle_failure(code)
+          end
+        end
+
+        def handle_failure(code, msg = nil)
+          unless msg
+            msg = FAILURE_MESSAGES.key?(code) ? FAILURE_MESSAGES[code] : Rpush::Daemon::HTTP_STATUS_CODES[code]
+          end
+          fail Rpush::DeliveryError.new(code, @notification.id, msg)
+        end
+
+        def ok(response)
+          status = status_from_response(response)
+          case status[:notification]
+          when ["received"]
+            mark_delivered
+            log_info("#{@notification.id} sent successfully")
+          when ["channelthrottled"]
+            mark_retryable(@notification, Time.now + (60 * 10))
+            log_warn("#{@notification.id} cannot be sent. The Queue is full.")
+          when ["dropped"]
+            log_error("#{@notification.id} was dropped. Headers: #{status}")
+            handle_failure(200, "Notification was received but suppressed by the service (#{status[:error_description]}).")
+          end
+        end
+
+        def unauthorized
+          @notification.app.access_token = nil
+          Rpush::Daemon.store.update_app(@notification.app)
+          if @notification.retries < MAX_RETRIES
+            retry_notification("Token invalid.")
+          else
+            msg = "Notification failed to be delivered in #{MAX_RETRIES} retries."
+            mark_failed(Rpush::DeliveryError.new(nil, @notification.id, msg))
+          end
+        end
+
+        def invalid_channel(code, msg = nil)
+          unless msg
+            msg = FAILURE_MESSAGES.key?(code) ? FAILURE_MESSAGES[code] : Rpush::Daemon::HTTP_STATUS_CODES[code]
+          end
+          reflect(:wns_invalid_channel, @notification, @notification.uri, "#{code}. #{msg}")
+          handle_failure(code, msg)
+        end
+
+        def not_acceptable
+          retry_notification("Per-day throttling limit reached.")
+        end
+
+        def precondition_failed
+          retry_notification("Device unreachable.")
+        end
+
+        def service_unavailable
+          mark_retryable_exponential(@notification)
+          log_warn("Service Unavailable. " + retry_message)
+        end
+
+        def retry_message
+          "Notification #{@notification.id} will be retried after #{@notification.deliver_after.strftime('%Y-%m-%d %H:%M:%S')} (retry #{@notification.retries})."
+        end
+
+        def retry_notification(reason)
+          deliver_after = Time.now + (60 * 60)
+          mark_retryable(@notification, deliver_after)
+          log_warn("#{reason} " + retry_message)
+        end
+
+        def do_post
+          body = 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/toast",
+                                     "X-WNS-RequestForStatus" => "true",
+                                     "Authorization" => "Bearer #{access_token}")
+          post.body = body
+          @http.request(URI.parse(@notification.uri), post)
+        end
+
+        def status_from_response(response)
+          headers = response.to_hash
+          {
+            notification:         headers["X-WNS-Status"],
+            device_connection:    headers["X-WNS-DeviceConnectionStatus"],
+            msg_id:               headers["X-WNS-Msg-ID"],
+            error_description:    headers["X-WNS-Error-Description"],
+            debug_trace:          headers["X-WNS-Debug-Trace"]
+          }
+        end
+
+        def notification_to_xml
+          title = clean_param_string(@notification.data['title']) if @notification.data['title'].present?
+          body = clean_param_string(@notification.data['body']) if @notification.data['body'].present?
+          param = clean_param_string(@notification.data['param']) if @notification.data['param'].present?
+          "<toast>
+            <visual version='1' lang='en-US'>
+              <binding template='ToastText02'>
+                <text id='1'>#{title}</text>
+                <text id='2'>#{body}</text>
+                <param>#{param}</param>
+              </binding>
+            </visual>
+          </toast>"
+        end
+
+        def clean_param_string(string)
+          string.gsub(/&/, "&amp;").gsub(/</, "&lt;") \
+            .gsub(/>/, "&gt;").gsub(/'/, "&apos;").gsub(/"/, "&quot;")
+        end
+
+        def access_token
+          if @notification.app.access_token.nil? || @notification.app.access_token_expired?
+            post = Net::HTTP::Post.new(WPN_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(WPN_TOKEN_URI, post))
+          end
+
+          @notification.app.access_token
+        end
+
+        def handle_access_token(response)
+          if response.code.to_i == 200
+            update_access_token(JSON.parse(response.body))
+            Rpush::Daemon.store.update_app(@notification.app)
+            log_info("WNS access token updated: token = #{@notification.app.access_token}, expires = #{@notification.app.access_token_expiration}")
+          else
+            log_warn("Could not retrieve access token from WNS: #{response.body}")
+          end
+        end
+
+        def update_access_token(data)
+          @notification.app.access_token = data['access_token']
+          @notification.app.access_token_expiration = Time.now + data['expires_in'].to_i
+        end
+      end
+    end
+  end
+end

data/lib/rpush/embed.rb

@@ -1,21 +1,13 @@
 module Rpush
-  def self.embed(options = {})
+  def self.embed
     require 'rpush/daemon'
 
-    unless options.empty?
-      warning = "Passing configuration options directly to Rpush.embed is deprecated and will be removed from Rpush 2.5.0. Please setup configuration using Rpush.configure { |config| ... } before calling embed."
-      Rpush::Deprecation.warn_with_backtrace(warning)
-    end
-
     if @embed_thread
       STDERR.puts 'Rpush.embed can only be run once inside this process.'
     end
 
-    config = Rpush::ConfigurationWithoutDefaults.new
-    options.each { |k, v| config.send("#{k}=", v) }
-    config.embedded = true
-    config.foreground = true
-    Rpush.config.update(config)
+    Rpush.config.embedded = true
+    Rpush.config.foreground = true
     Kernel.at_exit { shutdown }
     @embed_thread = Thread.new { Rpush::Daemon.start }
   end
@@ -24,6 +16,10 @@ module Rpush
     return unless Rpush.config.embedded
     Rpush::Daemon.shutdown
     @embed_thread.join if @embed_thread
+  rescue StandardError => e
+    STDERR.puts(e.message)
+    STDERR.puts(e.backtrace.join("\n"))
+  ensure
     @embed_thread = nil
   end
 
@@ -32,8 +28,14 @@ module Rpush
     Rpush::Daemon::Synchronizer.sync
   end
 
-  def self.debug
+  def self.status
     return unless Rpush.config.embedded
-    Rpush::Daemon::AppRunner.debug
+    status = Rpush::Daemon::AppRunner.status
+    Rpush.logger.info(JSON.pretty_generate(status))
+    status
+  end
+
+  def self.debug
+    status
   end
 end

data/lib/rpush/logger.rb

@@ -11,6 +11,10 @@ module Rpush
       error('Logging disabled.')
     end
 
+    def debug(msg, inline = false)
+      log(:debug, msg, inline)
+    end
+
     def info(msg, inline = false)
       log(:info, msg, inline)
     end

data/lib/rpush/plugin.rb

@@ -32,7 +32,7 @@ module Rpush
       Rpush.config.plugin.send("#{@name}=", @config)
     end
 
-    def init(&block) # rubocop:disable Style/TrivialAccessors
+    def init(&block)
       @init_block = block
     end
 

data/lib/rpush/push.rb

@@ -1,17 +1,8 @@
 module Rpush
-  def self.push(options = {})
+  def self.push
     require 'rpush/daemon'
 
-    unless options.empty?
-      warning = "Passing configuration options directly to Rpush.push is deprecated and will be removed from Rpush 2.5.0. Please setup configuration using Rpush.configure { |config| ... } before calling push."
-      Rpush::Deprecation.warn_with_backtrace(warning)
-    end
-
-    config = Rpush::ConfigurationWithoutDefaults.new
-    options.each { |k, v| config.send("#{k}=", v) }
-    config.push = true
-    Rpush.config.update(config)
-
+    Rpush.config.push = true
     Rpush::Daemon.common_init
     Rpush::Daemon::Synchronizer.sync
     Rpush::Daemon::Feeder.start(true) # non-blocking

data/lib/rpush/reflection_collection.rb

@@ -6,7 +6,7 @@ module Rpush
       :apns_feedback, :notification_enqueued, :notification_delivered,
       :notification_failed, :notification_will_retry, :gcm_delivered_to_recipient,
       :gcm_failed_to_recipient, :gcm_canonical_id, :gcm_invalid_registration_id,
-      :error, :adm_canonical_id, :adm_failed_to_recipient,
+      :error, :adm_canonical_id, :adm_failed_to_recipient, :wns_invalid_channel,
       :tcp_connection_lost, :ssl_certificate_will_expire, :ssl_certificate_revoked,
       :notification_id_will_retry, :notification_id_failed
     ]
@@ -17,30 +17,28 @@ module Rpush
       class_eval(<<-RUBY, __FILE__, __LINE__)
         def #{reflection}(*args, &blk)
           raise "block required" unless block_given?
-          reflections[:#{reflection}] = blk
+          @reflections[:#{reflection}] = blk
         end
       RUBY
     end
 
+    def initialize
+      @reflections = {}
+    end
+
     def __dispatch(reflection, *args)
-      reflection = reflection.to_sym
+      blk = @reflections[reflection]
 
-      unless REFLECTIONS.include?(reflection)
-        fail NoSuchReflectionError, reflection
-      end
+      if blk
+        blk.call(*args)
 
-      if DEPRECATIONS.key?(reflection)
-        replacement, removal_version = DEPRECATIONS[reflection]
-        Rpush::Deprecation.warn("#{reflection} is deprecated and will be removed in version #{removal_version}. Use #{replacement} instead.")
+        if DEPRECATIONS.key?(reflection)
+          replacement, removal_version = DEPRECATIONS[reflection]
+          Rpush::Deprecation.warn("#{reflection} is deprecated and will be removed in version #{removal_version}. Use #{replacement} instead.")
+        end
+      elsif !REFLECTIONS.include?(reflection)
+        raise NoSuchReflectionError, reflection
       end
-
-      reflections[reflection].call(*args) if reflections[reflection]
-    end
-
-    private
-
-    def reflections
-      @reflections ||= {}
     end
   end
 end