rpush 2.4.0-java → 2.6.0-java

data/lib/rpush/daemon/rpc.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Daemon
+    module Rpc
+      def self.socket_path(pid = Process.pid)
+        "/tmp/rpush.#{pid}.sock"
+      end
+    end
+  end
+end

data/lib/rpush/daemon/rpc/client.rb

@@ -0,0 +1,27 @@
+module Rpush
+  module Daemon
+    module Rpc
+      class Client
+        def initialize(pid)
+          @socket = UNIXSocket.open(Rpc.socket_path(pid))
+        end
+
+        def status
+          call(:status)
+        end
+
+        def close
+          @socket.close
+        rescue StandardError # rubocop:disable Lint/HandleExceptions
+        end
+
+        private
+
+        def call(cmd, args = {})
+          @socket.puts(JSON.dump([cmd, args]))
+          JSON.parse(@socket.gets)
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/rpc/server.rb

@@ -0,0 +1,82 @@
+require 'socket'
+require 'singleton'
+
+module Rpush
+  module Daemon
+    module Rpc
+      class Server
+        include Singleton
+        include Loggable
+        include Reflectable
+
+        def self.start
+          instance.start
+        end
+
+        def self.stop
+          instance.stop
+        end
+
+        def start
+          @stop = false
+
+          @thread = Thread.new(UNIXServer.open(Rpc.socket_path)) do |server|
+            begin
+              loop do
+                socket = server.accept
+                break if @stop
+                read_loop(socket)
+              end
+
+              server.close
+            rescue StandardError => e
+              log_error(e)
+            ensure
+              File.unlink(Rpc.socket_path) if File.exist?(Rpc.socket_path)
+            end
+          end
+        end
+
+        def stop
+          @stop = true
+          UNIXSocket.new(Rpc.socket_path)
+          @thread.join if @thread
+        rescue StandardError => e
+          log_error(e)
+        end
+
+        private
+
+        def read_loop(socket)
+          loop do
+            line = socket.gets
+            break unless line
+
+            begin
+              cmd, args = JSON.load(line)
+              log_debug("[rpc:server] #{cmd.to_sym.inspect}, args: #{args.inspect}")
+              response = process(cmd, args)
+              socket.puts(JSON.dump(response))
+            rescue StandardError => e
+              log_error(e)
+              reflect(:error, e)
+            end
+          end
+
+          socket.close
+        end
+
+        def process(cmd, args) # rubocop:disable Lint/UnusedMethodArgument
+          case cmd
+          when 'status'
+            status
+          end
+        end
+
+        def status
+          Rpush::Daemon::AppRunner.status
+        end
+      end
+    end
+  end
+end

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 ? notifications.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,204 @@
+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.inject({}) {|h, v| h[v[0].downcase] = v[1]; h}
+          {
+            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?
+          "<toast>
+            <visual version='1' lang='en-US'>
+              <binding template='ToastText02'>
+                <text id='1'>#{title}</text>
+                <text id='2'>#{body}</text>
+              </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