rpush 1.0.0-java

data/lib/rpush/daemon/apns.rb

@@ -0,0 +1,16 @@
+module Rpush
+  module Daemon
+    module Apns
+      extend ServiceConfigMethods
+
+      HOSTS = {
+        :production  => ['gateway.push.apple.com', 2195],
+        :development => ['gateway.sandbox.push.apple.com', 2195], # deprecated
+        :sandbox     => ['gateway.sandbox.push.apple.com', 2195]
+      }
+
+      dispatcher :tcp, :host => Proc.new { |app| HOSTS[app.environment.to_sym] }
+      loops Rpush::Daemon::Apns::FeedbackReceiver
+    end
+  end
+end

data/lib/rpush/daemon/app_runner.rb

@@ -0,0 +1,187 @@
+module Rpush
+  module Daemon
+    class AppRunner
+      extend Reflectable
+      include Reflectable
+      include Loggable
+
+      class << self
+        attr_reader :runners
+      end
+
+      @runners = {}
+
+      def self.enqueue(notifications)
+        notifications.group_by(&:app_id).each do |app_id, group|
+          batch = Batch.new(group)
+          if app = runners[app_id]
+            app.enqueue(batch)
+          else
+            Rpush.logger.error("No such app '#{app_id}' for notifications #{batch.describe}.")
+          end
+        end
+      end
+
+      def self.sync
+        apps = Rpush::App.all
+        apps.each { |app| sync_app(app) }
+        removed = runners.keys - apps.map(&:id)
+        removed.each { |app_id| runners.delete(app_id).stop }
+      end
+
+      def self.sync_app(app)
+        if runners[app.id]
+          runners[app.id].sync(app)
+        else
+          runner = new(app)
+          begin
+            runner.start
+            runners[app.id] = runner
+          rescue StandardError => e
+            Rpush.logger.error("[#{app.name}] Exception raised during startup. Notifications will not be delivered for this app.")
+            Rpush.logger.error(e)
+            reflect(:error, e)
+          end
+        end
+      end
+
+      def self.stop
+        runners.values.map(&:stop)
+        runners.clear
+      end
+
+      def self.debug
+        runners.values.map(&:debug)
+      end
+
+      def self.idle
+        runners.values.select(&:idle?)
+      end
+
+      def self.wait
+        sleep 0.1 while !runners.values.all?(&:idle?)
+      end
+
+      attr_reader :app
+      attr_accessor :batch
+
+      def initialize(app)
+        @app = app
+        @loops = []
+      end
+
+      def start
+        app.connections.times { dispatchers.push(new_dispatcher_loop) }
+        start_loops
+        log_info("Started, #{dispatchers_str}.")
+      end
+
+      def stop
+        dispatchers.stop
+        stop_loops
+      end
+
+      def enqueue(batch)
+        self.batch = batch
+        batch.notifications.each do |notification|
+          queue.push([notification, batch])
+          reflect(:notification_enqueued, notification)
+        end
+      end
+
+      def sync(app)
+        @app = app
+        diff = dispatchers.size - app.connections
+        return if diff == 0
+        if diff > 0
+          decrement_dispatchers(diff)
+          log_info("Stopped #{dispatchers_str(diff)}. #{dispatchers_str} running.")
+        else
+          increment_dispatchers(diff.abs)
+          log_info("Started #{dispatchers_str(diff)}. #{dispatchers_str} running.")
+        end
+      end
+
+      def decrement_dispatchers(num)
+        num.times { dispatchers.pop }
+      end
+
+      def increment_dispatchers(num)
+        num.times { dispatchers.push(new_dispatcher_loop) }
+      end
+
+      def debug
+        Rpush.logger.info <<-EOS
+
+#{@app.name}:
+  dispatchers: #{num_dispatchers}
+  queued: #{queue_size}
+  batch size: #{batch_size}
+  batch processed: #{batch_processed}
+  idle: #{idle?}
+        EOS
+      end
+
+      def idle?
+        batch ? batch.complete? : true
+      end
+
+      def queue_size
+        queue.size
+      end
+
+      def batch_size
+        batch ? batch.num_notifications : 0
+      end
+
+      def batch_processed
+        batch ? batch.num_processed : 0
+      end
+
+      def num_dispatchers
+        dispatchers.size
+      end
+
+      protected
+
+      def start_loops
+        service_module.loops.each do |loop_class|
+          instance = loop_class.new(@app)
+          instance.start
+          @loops << instance
+        end
+      end
+
+      def stop_loops
+        @loops.map(&:stop)
+        @loops = []
+      end
+
+      def new_dispatcher_loop
+        dispatcher = service_module.new_dispatcher(@app)
+        dispatcher_loop = Rpush::Daemon::DispatcherLoop.new(queue, dispatcher)
+        dispatcher_loop.start
+        dispatcher_loop
+      end
+
+      def service_module
+        return @service_module if defined? @service_module
+        @service_module = "Rpush::Daemon::#{@app.service_name.camelize}".constantize
+      end
+
+      def queue
+        @queue ||= Queue.new
+      end
+
+      def dispatchers
+        @dispatchers ||= Rpush::Daemon::DispatcherLoopCollection.new
+      end
+
+      def dispatchers_str(count = app.connections)
+        count = count.abs
+        str = count == 1 ? 'dispatcher' : 'dispatchers'
+        "#{count} #{str}"
+      end
+    end
+  end
+end

data/lib/rpush/daemon/batch.rb

@@ -0,0 +1,115 @@
+module Rpush
+  module Daemon
+    class Batch
+      include Reflectable
+
+      attr_reader :num_processed, :notifications,
+        :delivered, :failed, :retryable
+
+      def initialize(notifications)
+        @notifications = notifications
+        @num_processed = 0
+        @delivered = []
+        @failed = {}
+        @retryable = {}
+        @mutex = Mutex.new
+      end
+
+      def num_notifications
+        @notifications.size
+      end
+
+      def mark_retryable(notification, deliver_after)
+        if Rpush.config.batch_storage_updates
+          retryable[deliver_after] ||= []
+          retryable[deliver_after] << notification
+          Rpush::Daemon.store.mark_retryable(notification, deliver_after, :persist => false)
+        else
+          Rpush::Daemon.store.mark_retryable(notification, deliver_after)
+          reflect(:notification_will_retry, notification)
+        end
+      end
+
+      def mark_delivered(notification)
+        if Rpush.config.batch_storage_updates
+          delivered << notification
+          Rpush::Daemon.store.mark_delivered(notification, Time.now, :persist => false)
+        else
+          Rpush::Daemon.store.mark_delivered(notification, Time.now)
+          reflect(:notification_delivered, notification)
+        end
+      end
+
+      def mark_failed(notification, code, description)
+        if Rpush.config.batch_storage_updates
+          key = [code, description]
+          failed[key] ||= []
+          failed[key] << notification
+          Rpush::Daemon.store.mark_failed(notification, code, description, Time.now, :persist => false)
+        else
+          Rpush::Daemon.store.mark_failed(notification, code, description, Time.now)
+          reflect(:notification_failed, notification)
+        end
+      end
+
+      def notification_dispatched
+        @mutex.synchronize do
+          @num_processed += 1
+          complete if @num_processed >= @notifications.size
+        end
+      end
+
+      def complete?
+        @complete == true
+      end
+
+      def describe
+        notifications.map(&:id).join(', ')
+      end
+
+      private
+
+      def complete
+        [:complete_delivered, :complete_failed, :complete_retried].each do |method|
+          begin
+            send(method)
+          rescue StandardError => e
+            Rpush.logger.error(e)
+            reflect(:error, e)
+          end
+        end
+
+        notifications.clear
+        @complete = true
+      end
+
+      def complete_delivered
+        Rpush::Daemon.store.mark_batch_delivered(delivered)
+        delivered.each do |notification|
+          reflect(:notification_delivered, notification)
+        end
+        delivered.clear
+      end
+
+      def complete_failed
+        failed.each do |(code, description), notifications|
+          Rpush::Daemon.store.mark_batch_failed(notifications, code, description)
+          notifications.each do |notification|
+            reflect(:notification_failed, notification)
+          end
+        end
+        failed.clear
+      end
+
+      def complete_retried
+        retryable.each do |deliver_after, notifications|
+          Rpush::Daemon.store.mark_batch_retryable(notifications, deliver_after)
+          notifications.each do |notification|
+            reflect(:notification_will_retry, notification)
+          end
+        end
+        retryable.clear
+      end
+    end
+  end
+end

data/lib/rpush/daemon/constants.rb

@@ -0,0 +1,59 @@
+module Rpush
+  module Daemon
+    HTTP_STATUS_CODES = {
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      102  => 'Processing',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      207  => 'Multi-Status',
+      226  => 'IM Used',
+      300  => 'Multiple Choices',
+      301  => 'Moved Permanently',
+      302  => 'Found',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      306  => 'Reserved',
+      307  => 'Temporary Redirect',
+      400  => 'Bad Request',
+      401  => 'Unauthorized',
+      402  => 'Payment Required',
+      403  => 'Forbidden',
+      404  => 'Not Found',
+      405  => 'Method Not Allowed',
+      406  => 'Not Acceptable',
+      407  => 'Proxy Authentication Required',
+      408  => 'Request Timeout',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Long',
+      415  => 'Unsupported Media Type',
+      416  => 'Requested Range Not Satisfiable',
+      417  => 'Expectation Failed',
+      418  => "I'm a Teapot",
+      422  => 'Unprocessable Entity',
+      423  => 'Locked',
+      424  => 'Failed Dependency',
+      426  => 'Upgrade Required',
+      429  => 'Too Many Requests',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Timeout',
+      505  => 'HTTP Version Not Supported',
+      506  => 'Variant Also Negotiates',
+      507  => 'Insufficient Storage',
+      510  => 'Not Extended'
+    }
+  end
+end

data/lib/rpush/daemon/delivery.rb

@@ -0,0 +1,28 @@
+module Rpush
+  module Daemon
+    class Delivery
+      include Reflectable
+      include Loggable
+
+      def mark_retryable(notification, deliver_after)
+        if notification.fail_after && notification.fail_after < Time.now
+          @batch.mark_failed(notification, nil, "Notification failed to be delivered before #{notification.fail_after.strftime("%Y-%m-%d %H:%M:%S")}.")
+        else
+          @batch.mark_retryable(notification, deliver_after)
+        end
+      end
+
+      def mark_retryable_exponential(notification)
+        mark_retryable(notification, Time.now + 2 ** (notification.retries + 1))
+      end
+
+      def mark_delivered
+        @batch.mark_delivered(@notification)
+      end
+
+      def mark_failed(code, description)
+        @batch.mark_failed(@notification, code, description)
+      end
+    end
+  end
+end

data/lib/rpush/daemon/delivery_error.rb

@@ -0,0 +1,19 @@
+module Rpush
+  class DeliveryError < StandardError
+    attr_reader :code, :description
+
+    def initialize(code, notification_id, description)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      "Unable to deliver notification #{@notification_id}, received error #{@code} (#{@description})"
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class Http
+        def initialize(app, delivery_class, options = {})
+          @app = app
+          @delivery_class = delivery_class
+          @http = Net::HTTP::Persistent.new('rpush')
+        end
+
+        def dispatch(notification, batch)
+          @delivery_class.new(@app, @http, notification, batch).perform
+        end
+
+        def cleanup
+          @http.shutdown
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Rpush
+  module Daemon
+    module Dispatcher
+      class Tcp
+        def initialize(app, delivery_class, options = {})
+          @app = app
+          @delivery_class = delivery_class
+          @host, @port = options[:host].call(@app)
+        end
+
+        def dispatch(notification, batch)
+          @delivery_class.new(@app, connection, notification, batch).perform
+        end
+
+        def cleanup
+          @connection.close if @connection
+        end
+
+        private
+
+        def connection
+          return @connection if defined? @connection
+          connection = Rpush::Daemon::TcpConnection.new(@app, @host, @port)
+          connection.connect
+          @connection = connection
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/dispatcher_loop.rb

@@ -0,0 +1,54 @@
+module Rpush
+  module Daemon
+    class DispatcherLoop
+      include Reflectable
+
+      WAKEUP = :wakeup
+
+      def initialize(queue, dispatcher)
+        @queue = queue
+        @dispatcher = dispatcher
+      end
+
+      def start
+        @thread = Thread.new do
+          loop do
+            dispatch
+            break if @stop
+          end
+
+          Rpush::Daemon.store.release_connection
+        end
+      end
+
+      def stop
+        @stop = true
+      end
+
+      def wakeup
+        @queue.push(WAKEUP) if @thread
+      end
+
+      def wait
+        @thread.join if @thread
+        @dispatcher.cleanup
+      end
+
+      protected
+
+      def dispatch
+        notification, batch = @queue.pop
+        return if notification == WAKEUP
+
+        begin
+          @dispatcher.dispatch(notification, batch)
+        rescue StandardError => e
+          Rpush.logger.error(e)
+          reflect(:error, e)
+        ensure
+          batch.notification_dispatched
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/dispatcher_loop_collection.rb

@@ -0,0 +1,33 @@
+module Rpush
+  module Daemon
+    class DispatcherLoopCollection
+      attr_reader :loops
+
+      def initialize
+        @loops = []
+      end
+
+      def push(dispatcher_loop)
+        @loops << dispatcher_loop
+      end
+
+      def pop
+        dispatcher_loop = @loops.pop
+        dispatcher_loop.stop
+        dispatcher_loop.wakeup
+        @loops.map(&:wakeup)
+        dispatcher_loop.wait
+      end
+
+      def size
+        @loops.size
+      end
+
+      def stop
+        @loops.map(&:stop)
+        @loops.map(&:wakeup)
+        @loops.map(&:wait)
+      end
+    end
+  end
+end

data/lib/rpush/daemon/feeder.rb

@@ -0,0 +1,68 @@
+module Rpush
+  module Daemon
+    class Feeder
+      extend Reflectable
+
+      def self.start
+        @stop = false
+
+        if Rpush.config.embedded
+          Thread.new { feed_forever }
+        elsif Rpush.config.push
+          enqueue_notifications
+        else
+          feed_forever
+        end
+      end
+
+      def self.stop
+        @stop = true
+        interrupt_sleep
+      end
+
+      def self.interrupt_sleep
+        interruptible_sleeper.interrupt_sleep
+      end
+
+      protected
+
+      def self.feed_forever
+        loop do
+          enqueue_notifications
+          interruptible_sleeper.sleep(Rpush.config.push_poll)
+          break if stop?
+        end
+
+        Rpush::Daemon.store.release_connection
+      end
+
+      # :nocov:
+      def self.stop?
+        @stop
+      end
+
+      def self.enqueue_notifications
+        begin
+          idle = Rpush::Daemon::AppRunner.idle.map(&:app)
+          return if idle.empty?
+          notifications = Rpush::Daemon.store.deliverable_notifications(idle)
+          Rpush::Daemon::AppRunner.enqueue(notifications)
+        rescue StandardError => e
+          Rpush.logger.error(e)
+          reflect(:error, e)
+        end
+      end
+
+      def self.interruptible_sleeper
+        return @interruptible_sleeper if @interruptible_sleeper
+
+        @interruptible_sleeper = InterruptibleSleep.new
+        if Rpush.config.wakeup
+          @interruptible_sleeper.enable_wake_on_udp Rpush.config.wakeup[:bind], Rpush.config.wakeup[:port]
+        end
+
+        @interruptible_sleeper
+      end
+    end
+  end
+end