rpush_extended 3.2.5

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

@@ -0,0 +1,178 @@
+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
+          post = PostRequest.create(@notification, access_token)
+          @http.request(URI.parse(@notification.uri), post)
+        end
+
+        def status_from_response(response)
+          headers = response.to_hash.each_with_object({}) { |e, a| a[e[0].downcase] = e[1] }
+          {
+            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 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/daemon/wns/post_request.rb

@@ -0,0 +1,33 @@
+module Rpush
+  module Daemon
+    module Wns
+      class PostRequest
+        def self.create(notification, access_token)
+          stringify_keys(notification.data) unless notification.data.nil?
+
+          if raw_notification?(notification)
+            RawRequest.create(notification, access_token)
+          elsif badge_notification?(notification)
+            BadgeRequest.create(notification, access_token)
+          else
+            ToastRequest.create(notification, access_token)
+          end
+        end
+
+        private_class_method
+
+        def self.raw_notification?(notification)
+          notification.class.name.match(/RawNotification/)
+        end
+
+        def self.badge_notification?(notification)
+          notification.class.name.match(/BadgeNotification/)
+        end
+
+        def self.stringify_keys(data)
+          data.keys.each { |key| data[key.to_s || key] = data.delete(key) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Rpush
+  module Daemon
+    module Wns
+      class RawRequest
+        def self.create(notification, access_token)
+          body = notification.data.to_json
+          uri = URI.parse(notification.uri)
+          post = Net::HTTP::Post.new(
+            uri.request_uri,
+            "Content-Length" => body.length.to_s,
+            "Content-Type" => "application/octet-stream",
+            "X-WNS-Type" => "wns/raw",
+            "X-WNS-RequestForStatus" => "true",
+            "Authorization" => "Bearer #{access_token}"
+          )
+          post.body = body
+          post
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Rpush
+  module Daemon
+    module Wns
+      class ToastRequest
+        def self.create(notification, access_token)
+          body = ToastRequestPayload.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/toast",
+            "X-WNS-RequestForStatus" => "true",
+            "Authorization" => "Bearer #{access_token}"
+          )
+          post.body = body
+          post
+        end
+      end
+
+      class ToastRequestPayload
+        def initialize(notification)
+          @title = notification.data['title'] || ''
+          @body = notification.data['body'] || ''
+          @launch = notification.data['launch']
+          @sound = notification.sound unless notification.sound.eql?("default".freeze)
+        end
+
+        def to_xml
+          launch_string = "" unless @launch
+          launch_string = " launch='#{CleanParamString.clean(@launch)}'" if @launch
+          audio_string = "" unless @sound
+          audio_string = "<audio src='#{CleanParamString.clean(@sound)}'/>" if @sound
+          "<toast#{launch_string}>
+            <visual version='1' lang='en-US'>
+              <binding template='ToastText02'>
+                <text id='1'>#{CleanParamString.clean(@title)}</text>
+                <text id='2'>#{CleanParamString.clean(@body)}</text>
+              </binding>
+            </visual>
+            #{audio_string}
+          </toast>"
+        end
+      end
+
+      class CleanParamString
+        def self.clean(string)
+          string.gsub(/&/, "&amp;").gsub(/</, "&lt;") \
+            .gsub(/>/, "&gt;").gsub(/'/, "&apos;").gsub(/"/, "&quot;")
+        end
+      end
+    end
+  end
+end

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/wpns/delivery.rb

@@ -0,0 +1,132 @@
+module Rpush
+  module Daemon
+    module Wpns
+      # http://msdn.microsoft.com/en-us/library/windowsphone/develop/ff941100%28v=vs.105%29.aspx
+      class Delivery < Rpush::Daemon::Delivery
+        FAILURE_MESSAGES = {
+          400 => 'Bad XML or malformed notification URI.',
+          401 => 'Unauthorized to send a notification to this app.'
+        }
+
+        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 406
+            not_acceptable
+          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 ["QueueFull"]
+            mark_retryable(@notification, Time.now + (60 * 10))
+            log_warn("#{@notification.id} cannot be sent. The Queue is full.")
+          when ["Suppressed"]
+            handle_failure(200, "Notification was received but suppressed by the service.")
+          end
+        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
+          post = Net::HTTP::Post.new(URI.parse(@notification.uri).path, "Content-Length" => body.length.to_s,
+                                                                        "Content-Type" => "text/xml",
+                                                                        "X-WindowsPhone-Target" => "toast",
+                                                                        "X-NotificationClass" => '2')
+          post.body = body
+          @http.request(URI.parse(@notification.uri), post)
+        end
+
+        def status_from_response(response)
+          headers = response.to_hash
+          {
+            notification:         headers["x-notificationstatus"],
+            notification_channel: headers["x-subscriptionstatus"],
+            device_connection:    headers["x-deviceconnectionstatus"]
+          }
+        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?
+          "<?xml version=\"1.0\" encoding=\"utf-8\"?>
+           <wp:Notification xmlns:wp=\"WPNotification\">
+             <wp:Toast>
+               <wp:Text1>#{title}</wp:Text1>
+               <wp:Text2>#{body}</wp:Text2>
+               <wp:Param>#{param}</wp:Param>
+             </wp:Toast>
+           </wp:Notification>"
+        end
+
+        def clean_param_string(string)
+          string.gsub(/&/, "&amp;").gsub(/</, "&lt;") \
+            .gsub(/>/, "&gt;").gsub(/'/, "&apos;").gsub(/"/, "&quot;")
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/wpns.rb

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

data/lib/rpush/daemon.rb

@@ -0,0 +1,179 @@
+# encoding: UTF-8
+
+require 'thread'
+require 'socket'
+require 'pathname'
+require 'openssl'
+require 'net/http/persistent'
+
+require 'rpush/daemon/errors'
+require 'rpush/daemon/constants'
+require 'rpush/daemon/loggable'
+require 'rpush/daemon/string_helpers'
+require 'rpush/daemon/interruptible_sleep'
+require 'rpush/daemon/delivery_error'
+require 'rpush/daemon/retryable_error'
+require 'rpush/daemon/delivery'
+require 'rpush/daemon/feeder'
+require 'rpush/daemon/batch'
+require 'rpush/daemon/queue_payload'
+require 'rpush/daemon/synchronizer'
+require 'rpush/daemon/app_runner'
+require 'rpush/daemon/tcp_connection'
+require 'rpush/daemon/dispatcher_loop'
+require 'rpush/daemon/dispatcher/http'
+require 'rpush/daemon/dispatcher/tcp'
+require 'rpush/daemon/dispatcher/apns_tcp'
+require 'rpush/daemon/dispatcher/apns_http2'
+require 'rpush/daemon/dispatcher/apnsp8_http2'
+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/rpc'
+require 'rpush/daemon/rpc/server'
+require 'rpush/daemon/rpc/client'
+
+require 'rpush/daemon/store/interface'
+
+require 'rpush/daemon/apns/delivery'
+require 'rpush/daemon/apns/feedback_receiver'
+require 'rpush/daemon/apns'
+
+require 'rpush/daemon/apns2/delivery'
+require 'rpush/daemon/apns2'
+
+require 'rpush/daemon/apnsp8/delivery'
+require 'rpush/daemon/apnsp8/token'
+require 'rpush/daemon/apnsp8'
+
+require 'rpush/daemon/gcm/delivery'
+require 'rpush/daemon/gcm'
+
+require 'rpush/daemon/wpns/delivery'
+require 'rpush/daemon/wpns'
+
+require 'rpush/daemon/wns/post_request'
+require 'rpush/daemon/wns/raw_request'
+require 'rpush/daemon/wns/toast_request'
+require 'rpush/daemon/wns/badge_request'
+require 'rpush/daemon/wns/delivery'
+require 'rpush/daemon/wns'
+
+require 'rpush/daemon/adm/delivery'
+require 'rpush/daemon/adm'
+
+require 'rpush/daemon/pushy'
+require 'rpush/daemon/pushy/delivery'
+
+module Rpush
+  module Daemon
+    class << self
+      attr_accessor :store
+    end
+
+    def self.start
+      Process.daemon if daemonize?
+      write_pid_file
+      SignalHandler.start
+      common_init
+      Synchronizer.sync
+      Rpc::Server.start
+
+      # No further store connections will be made from this thread.
+      store.release_connection
+
+      Rpush.logger.info('Rpush operational.')
+      show_welcome_if_needed
+
+      # 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
+      if Rpush.config.foreground
+        # Eat the '^C'
+        STDOUT.write("\b\b")
+        STDOUT.flush
+      end
+
+      Rpush.logger.info('Shutting down... ', true)
+
+      shutdown_lock.synchronize do
+        Rpc::Server.stop
+        Feeder.stop
+        AppRunner.stop
+        delete_pid_file
+        puts ANSI.green { '✔' } if Rpush.config.foreground
+      end
+    end
+
+    def self.shutdown_lock
+      @shutdown_lock ||= Mutex.new
+    end
+
+    def self.common_init
+      init_store
+      init_plugins
+    end
+
+    protected
+
+    def self.init_store
+      return if store
+      begin
+        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.client}' storage backend.")
+        Rpush.logger.error(e)
+        exit 1
+      end
+    end
+
+    def self.init_plugins
+      Rpush.plugins.each do |name, plugin|
+        plugin.init_block.call
+        Rpush.logger.info("[plugin:#{name}] Loaded.")
+      end
+    end
+
+    def self.daemonize?
+      !(Rpush.config.push || Rpush.config.foreground || Rpush.config.embedded || Rpush.jruby?)
+    end
+
+    def self.write_pid_file
+      unless Rpush.config.pid_file.blank?
+        begin
+          FileUtils.mkdir_p(File.dirname(Rpush.config.pid_file))
+          File.open(Rpush.config.pid_file, 'w') { |f| f.puts Process.pid }
+        rescue SystemCallError => e
+          Rpush.logger.error("Failed to write PID to '#{Rpush.config.pid_file}': #{e.inspect}")
+        end
+      end
+    end
+
+    def self.delete_pid_file
+      pid_file = Rpush.config.pid_file
+      File.delete(pid_file) if !pid_file.blank? && File.exist?(pid_file)
+    end
+
+    def self.show_welcome_if_needed
+      if Rpush::Daemon::AppRunner.app_ids.count == 0
+        puts <<-EOS
+
+* #{ANSI.green { 'Is this your first time using Rpush?' }}
+  You need to create an App before you can start using Rpush.
+  Please refer to the documentation at https://github.com/rpush/rpush
+
+        EOS
+      end
+    end
+  end
+end

data/lib/rpush/deprecatable.rb

@@ -0,0 +1,24 @@
+module Rpush
+  module Deprecatable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def deprecated(method_name, version, msg = nil)
+        method_name_as_var = method_name.to_s.tr('=', '_setter_')
+        instance_eval do
+          alias_method "#{method_name_as_var}_without_warning", method_name
+        end
+        warning = "#{method_name} is deprecated and will be removed from Rpush #{version}."
+        warning << " #{msg}" if msg
+        class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{method_name}(*args, &blk)
+            Rpush::Deprecation.warn_with_backtrace(#{warning.inspect})
+            #{method_name_as_var}_without_warning(*args, &blk)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rpush/deprecation.rb

@@ -0,0 +1,26 @@
+module Rpush
+  class Deprecation
+    def self.muted
+      orig_val = Thread.current[:rpush_mute_deprecations]
+      Thread.current[:rpush_mute_deprecations] = true
+      yield
+    ensure
+      Thread.current[:rpush_mute_deprecations] = orig_val
+    end
+
+    def self.muted?
+      Thread.current[:rpush_mute_deprecations] == true
+    end
+
+    def self.warn(msg)
+      return if Rpush::Deprecation.muted?
+      STDERR.puts "DEPRECATION WARNING: #{msg}"
+    end
+
+    def self.warn_with_backtrace(msg)
+      return if Rpush::Deprecation.muted?
+      trace = "\n\nCALLED FROM:\n" + caller.join("\n")
+      warn(msg + trace)
+    end
+  end
+end