rpush 2.4.0 → 2.5.0

data/lib/rpush/client/redis.rb

@@ -30,6 +30,9 @@ require 'rpush/client/redis/adm/notification'
 require 'rpush/client/redis/wpns/app'
 require 'rpush/client/redis/wpns/notification'
 
+require 'rpush/client/redis/wns/app'
+require 'rpush/client/redis/wns/notification'
+
 Modis.configure do |config|
   config.namespace = :rpush
 end

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

@@ -0,0 +1,14 @@
+module Rpush
+  module Client
+    module Redis
+      module Wns
+        class App < Rpush::Client::Redis::App
+          include Rpush::Client::ActiveModel::Wns::App
+
+          attribute :access_token, :string
+          attribute :access_token_expiration, :timestamp
+        end
+      end
+    end
+  end
+end

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

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

data/lib/rpush/configuration.rb

@@ -1,4 +1,5 @@
 require 'pathname'
+require 'ostruct'
 
 module Rpush
   class << self
@@ -16,7 +17,7 @@ module Rpush
   end
 
   CURRENT_ATTRS = [:push_poll, :embedded, :pid_file, :batch_size, :push, :client, :logger, :log_file, :foreground, :log_level, :plugin, :apns]
-  DEPRECATED_ATTRS = [:feedback_poll]
+  DEPRECATED_ATTRS = []
   CONFIG_ATTRS = CURRENT_ATTRS + DEPRECATED_ATTRS
 
   class ConfigurationError < StandardError; end
@@ -97,11 +98,6 @@ module Rpush
       Modis.redis_options = options if client == :redis
     end
 
-    def feedback_poll=(frequency)
-      apns.feedback_receiver.frequency = frequency
-    end
-    deprecated(:feedback_poll=, '2.5.0', 'Please use apns.feedback_receiver.frequency= instead.')
-
     def initialize_client
       return if @client_initialized
       raise ConfigurationError, 'Rpush.config.client is not set.' unless client
@@ -110,7 +106,7 @@ module Rpush
       client_module = Rpush::Client.const_get(client.to_s.camelize)
       Rpush.send(:include, client_module) unless Rpush.ancestors.include?(client_module)
 
-      [:Apns, :Gcm, :Wpns, :Adm].each do |service|
+      [:Apns, :Gcm, :Wpns, :Wns, :Adm].each do |service|
         Rpush.const_set(service, client_module.const_get(service)) unless Rpush.const_defined?(service)
       end
 

data/lib/rpush/daemon.rb

@@ -30,6 +30,10 @@ 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'
@@ -42,6 +46,9 @@ require 'rpush/daemon/gcm'
 require 'rpush/daemon/wpns/delivery'
 require 'rpush/daemon/wpns'
 
+require 'rpush/daemon/wns/delivery'
+require 'rpush/daemon/wns'
+
 require 'rpush/daemon/adm/delivery'
 require 'rpush/daemon/adm'
 
@@ -57,6 +64,7 @@ module Rpush
       SignalHandler.start
       common_init
       Synchronizer.sync
+      Rpc::Server.start
 
       # No further store connections will be made from this thread.
       store.release_connection
@@ -81,6 +89,7 @@ module Rpush
       Rpush.logger.info('Shutting down... ', true)
 
       shutdown_lock.synchronize do
+        Rpc::Server.stop
         Feeder.stop
         AppRunner.stop
         delete_pid_file

data/lib/rpush/daemon/apns/feedback_receiver.rb

@@ -43,6 +43,11 @@ module Rpush
           @stop = true
           @interruptible_sleep.stop
           @thread.join if @thread
+        rescue StandardError => e
+          log_error(e)
+          reflect(:error, e)
+        ensure
+          @thread = nil
         end
 
         def check_for_feedback

data/lib/rpush/daemon/app_runner.rb

@@ -84,8 +84,8 @@ module Rpush
         @runners[app.id].increment_dispatchers(num)
       end
 
-      def self.debug
-        @runners.values.map(&:debug)
+      def self.status
+        { app_runners: @runners.values.map(&:status) }
       end
 
       attr_reader :app
@@ -140,7 +140,7 @@ module Rpush
         num.times { @dispatcher_loops.push(new_dispatcher_loop) }
       end
 
-      def debug
+      def status
         dispatcher_details = {}
 
         @dispatcher_loops.each_with_index do |dispatcher_loop, i|
@@ -151,8 +151,7 @@ module Rpush
           }
         end
 
-        runner_details = { dispatchers: dispatcher_details, queued: queue_size }
-        log_info(JSON.pretty_generate(runner_details))
+        { app_name: @app.name, dispatchers: dispatcher_details, queued: queue_size }
       end
 
       def num_dispatcher_loops

data/lib/rpush/daemon/dispatcher/apns_tcp.rb

@@ -16,6 +16,7 @@ module Rpush
           6 => 'Missing topic size',
           7 => 'Missing payload size',
           8 => 'Invalid token',
+          10 => 'APNs closed connection (possible maintenance)',
           255 => 'None (unknown error)'
         }
 
@@ -34,9 +35,21 @@ module Rpush
         end
 
         def cleanup
+          if Rpush.config.push
+            # In push mode only a single batch is sent, followed my immediate shutdown.
+            # Allow the error receiver time to handle any errors.
+            @reconnect_disabled = true
+            sleep 1
+          end
+
           @stop_error_receiver = true
           super
           @error_receiver_thread.join if @error_receiver_thread
+        rescue StandardError => e
+          log_error(e)
+          reflect(:error, e)
+        ensure
+          @error_receiver_thread = nil
         end
 
         private
@@ -63,12 +76,12 @@ module Rpush
             # On Linux, select returns nil from a dropped connection.
             # On OS X, Errno::EBADF is raised following a Errno::EADDRNOTAVAIL from the write call.
             return unless @connection.select(SELECT_TIMEOUT)
-          rescue SystemCallError, IOError
-            # Connection closed.
+            tuple = @connection.read(ERROR_TUPLE_BYTES)
+          rescue *TcpConnection::TCP_ERRORS
+            reconnect unless @stop_error_receiver
             return
           end
 
-          tuple = @connection.read(ERROR_TUPLE_BYTES)
           @dispatch_mutex.synchronize { handle_error_response(tuple) }
         rescue StandardError => e
           log_error(e)
@@ -82,12 +95,23 @@ module Rpush
             handle_disconnect
           end
 
-          log_error("Lost connection to #{@connection.host}:#{@connection.port}, reconnecting...")
-          @connection.reconnect_with_rescue
+          if Rpush.config.push
+            # Only attempt to handle a single error in Push mode.
+            @stop_error_receiver = true
+            return
+          end
+
+          reconnect
         ensure
           delivered_buffer.clear
         end
 
+        def reconnect
+          return if @reconnect_disabled
+          log_error("Lost connection to #{@connection.host}:#{@connection.port}, reconnecting...")
+          @connection.reconnect_with_rescue
+        end
+
         def handle_disconnect
           log_error("The APNs disconnected before any notifications could be delivered. This usually indicates you are using an invalid certificate.") if delivered_buffer.size == 0
         end
@@ -95,22 +119,33 @@ module Rpush
         def handle_error(code, notification_id)
           notification_id = Rpush::Daemon.store.translate_integer_notification_id(notification_id)
           failed_pos = delivered_buffer.index(notification_id)
-          description = APNS_ERRORS[code.to_i] || "Unknown error code #{code.inspect}. Possible Rpush bug?"
-          log_error(description + " (#{code})")
+          description = description_for_code(code)
+          log_error("Notification #{notification_id} failed with error: " + description)
           Rpush::Daemon.store.mark_ids_failed([notification_id], code, description, Time.now)
           reflect(:notification_id_failed, @app, notification_id, code, description)
 
           if failed_pos
             retry_ids = delivered_buffer[(failed_pos + 1)..-1]
-            if retry_ids.size > 0
-              now = Time.now
-              Rpush::Daemon.store.mark_ids_retryable(retry_ids, now)
-              retry_ids.each { |id| reflect(:notification_id_will_retry, @app, id, now) }
-            end
+            retry_notification_ids(retry_ids, notification_id)
           elsif delivered_buffer.size > 0
             log_error("Delivery sequence unknown for notifications following #{notification_id}.")
           end
         end
+
+        def description_for_code(code)
+          APNS_ERRORS[code.to_i] ? "#{APNS_ERRORS[code.to_i]} (#{code})" : "Unknown error code #{code.inspect}. Possible Rpush bug?"
+        end
+
+        def retry_notification_ids(ids, notification_id)
+          return if ids.size == 0
+
+          now = Time.now
+          Rpush::Daemon.store.mark_ids_retryable(ids, now)
+          notifications_str = 'Notification'
+          notifications_str += 's' if ids.size > 1
+          log_warn("#{notifications_str} #{ids.join(', ')} will be retried due to the failure of notification #{notification_id}.")
+          ids.each { |id| reflect(:notification_id_will_retry, @app, id, now) }
+        end
       end
     end
   end

data/lib/rpush/daemon/dispatcher_loop.rb

@@ -44,6 +44,11 @@ module Rpush
         @queue.push([STOP, object_id]) if @thread
         @thread.join if @thread
         @dispatcher.cleanup
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
       end
 
       private

data/lib/rpush/daemon/feeder.rb

@@ -2,6 +2,7 @@ module Rpush
   module Daemon
     class Feeder
       extend Reflectable
+      extend Loggable
 
       def self.start(push_mode = false)
         self.should_stop = false
@@ -12,12 +13,22 @@ module Rpush
         end
 
         @thread.join
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
       end
 
       def self.stop
         self.should_stop = true
         interruptible_sleeper.stop
         @thread.join if @thread
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
+      ensure
+        @thread = nil
       end
 
       def self.wakeup

data/lib/rpush/daemon/interruptible_sleep.rb

@@ -1,17 +1,22 @@
-require 'monitor'
-
 module Rpush
   module Daemon
     class InterruptibleSleep
       def sleep(duration)
         @thread = Thread.new { Kernel.sleep duration }
         Thread.pass
-        @thread.join
+
+        begin
+          @thread.join
+        rescue StandardError
+          @thread = nil
+        end
       end
 
       def stop
         @thread.kill if @thread
       rescue StandardError # rubocop:disable Lint/HandleExceptions
+      ensure
+        @thread = nil
       end
     end
   end

data/lib/rpush/daemon/loggable.rb

@@ -1,6 +1,10 @@
 module Rpush
   module Daemon
     module Loggable
+      def log_debug(msg)
+        Rpush.logger.debug(app_prefix(msg))
+      end
+
       def log_info(msg)
         Rpush.logger.info(app_prefix(msg))
       end

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