rpush 2.0.0.beta1 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d5bf4a64ca72a0c58b62a78da3e4315d06601cc
-  data.tar.gz: 2472ea351a2cc76e46668951eeabcfaf43b94b1f
+  metadata.gz: 09d2df386688b4c0ac01e8aab5e4c725257a3263
+  data.tar.gz: a7233c67417785808daf0e8d0f637d17b31a33b9
 SHA512:
-  metadata.gz: 1e34c0d97f7a604e0cc47b9c2e3548055207d87cd7a09c0800632c123cc4d7f4f62c7dbc7d014fa302c797ae822e2df2ae788d50b9670c24b003dbe00e7af767
-  data.tar.gz: 39e8509bb7fcfc76cb0347d55b4eee1a74f2083248ea3c71ccfbfff5e08a4ca8a3cfe6d8f6d1b7f788955f8af8fea016c469e741a5306c0c547fef5afd031029
+  metadata.gz: 4e19a18011c6e4e06b84deb49b82172ebb580a71ba8aef64e7ba6dce9edfc8aa42273bc131643a1f174aa9a30429b9797617e0661f7005eb657f9d9f1daf0b76
+  data.tar.gz: 47c703cdd66bb3fd80327d991604d0ee573db02b4324023484a90ac5ce7793cd022906ea3b1f424c97390edf7e59e13649c41efc9f2de9cadf68859fbc937f01

data/lib/rpush/daemon.rb

@@ -8,18 +8,18 @@ require 'rpush/daemon/errors'
 require 'rpush/daemon/constants'
 require 'rpush/daemon/reflectable'
 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/too_many_requests_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_loop_collection'
 require 'rpush/daemon/dispatcher/http'
 require 'rpush/daemon/dispatcher/tcp'
 require 'rpush/daemon/dispatcher/apns_tcp'
@@ -55,7 +55,7 @@ module Rpush
       Process.daemon if daemonize?
       initialize_store
       write_pid_file
-      AppRunner.sync
+      Synchronizer.sync
 
       # No further store connections will be made from this thread.
       store.release_connection

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

@@ -36,10 +36,10 @@ module Rpush
             end
             mark_delivered
           end
+        rescue Rpush::RateLimitError => error
+          handle_rate_limited(error)
         rescue Rpush::RetryableError => error
           handle_retryable(error)
-        rescue Rpush::TooManyRequestsError => error
-          handle_too_many_requests(error)
         rescue StandardError => error
           mark_failed(error)
           raise
@@ -58,7 +58,7 @@ module Rpush
           when 401
             unauthorized(response)
           when 429
-            too_many_requests(response)
+            rate_limited(response)
           when 500
             internal_server_error(current_registration_id)
           when 503
@@ -94,7 +94,7 @@ module Rpush
           end
         end
 
-        def handle_too_many_requests(error)
+        def handle_rate_limited(error)
           if @sent_registration_ids.empty?
             # none sent yet, just resend after the specified retry-after response.header
             retry_delivery(@notification, error.response)
@@ -129,9 +129,9 @@ module Rpush
           fail Rpush::RetryableError.new(response.code.to_i, @notification.id, 'ADM responded with an Unauthorized Error.', response)
         end
 
-        def too_many_requests(response)
+        def rate_limited(response)
           # raise error so the current notification stops sending messages to remaining reg ids
-          fail Rpush::TooManyRequestsError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
+          fail Rpush::RateLimitError.new(response.code.to_i, @notification.id, 'Exceeded maximum allowable rate of messages.', response)
         end
 
         def internal_server_error(current_registration_id)

data/lib/rpush/daemon/app_runner.rb

@@ -4,64 +4,73 @@ module Rpush
       extend Reflectable
       include Reflectable
       include Loggable
-
-      class << self
-        attr_reader :runners
-      end
+      include StringHelpers
 
       @runners = {}
 
       def self.enqueue(notifications)
         notifications.group_by(&:app_id).each do |app_id, group|
-          sync_app_with_id(app_id) unless runners[app_id]
-          runners[app_id].enqueue(group) if runners[app_id]
+          start_app_with_id(app_id) unless @runners[app_id]
+          @runners[app_id].enqueue(group) if @runners[app_id]
         end
+
         ProcTitle.update
       end
 
-      def self.sync
-        apps = Rpush::Daemon.store.all_apps
-        apps.each { |app| sync_app(app) }
-        removed = runners.keys - apps.map(&:id)
-        removed.each { |app_id| runners.delete(app_id).stop }
-        ProcTitle.update
+      def self.start_app_with_id(app_id)
+        start_app(Rpush::Daemon.store.app(app_id))
       end
 
-      def self.sync_app(app)
-        if runners[app.id]
-          runners[app.id].sync(app)
-        else
-          runner = new(app)
-          begin
-            runners[app.id] = runner
-            runner.start
-          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
+      def self.start_app(app)
+        @runners[app.id] = new(app)
+        @runners[app.id].start
+      rescue StandardError => e
+        @runners.delete(app.id)
+        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
 
-      def self.sync_app_with_id(app_id)
-        sync_app(Rpush::Daemon.store.app(app_id))
+      def self.stop_app(app_id)
+        @runners.delete(app_id).stop
+      end
+
+      def self.app_running?(app)
+        @runners.key?(app.id)
+      end
+
+      def self.app_ids
+        @runners.keys
       end
 
       def self.stop
-        runners.values.map(&:stop)
-        runners.clear
+        @runners.values.map(&:stop)
+        @runners.clear
+      end
+
+      def self.total_dispatchers
+        @runners.values.sum(&:num_dispatcher_loops)
       end
 
-      def self.num_dispatchers
-        runners.values.sum(&:num_dispatcher_loops)
+      def self.total_queued
+        @runners.values.sum(&:queue_size)
       end
 
-      def self.num_queued
-        runners.values.sum(&:queue_size)
+      def self.num_dispatchers_for_app(app)
+        runner = @runners[app.id]
+        runner ? runner.num_dispatcher_loops : 0
+      end
+
+      def self.decrement_dispatchers(app, num)
+        @runners[app.id].decrement_dispatchers(num)
+      end
+
+      def self.increment_dispatchers(app, num)
+        @runners[app.id].increment_dispatchers(num)
       end
 
       def self.debug
-        runners.values.map(&:debug)
+        @runners.values.map(&:debug)
       end
 
       attr_reader :app
@@ -69,12 +78,12 @@ module Rpush
       def initialize(app)
         @app = app
         @loops = []
+        @dispatcher_loops = []
       end
 
       def start
-        app.connections.times { dispatcher_loops.push(new_dispatcher_loop) }
+        app.connections.times { @dispatcher_loops.push(new_dispatcher_loop) }
         start_loops
-        log_info("Started, #{dispatchers_str}.")
       end
 
       def stop
@@ -103,31 +112,18 @@ module Rpush
         end
       end
 
-      def sync(app)
-        @app = app
-        diff = dispatcher_loops.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 { dispatcher_loops.pop }
+        num.times { @dispatcher_loops.pop.stop }
       end
 
       def increment_dispatchers(num)
-        num.times { dispatcher_loops.push(new_dispatcher_loop) }
+        num.times { @dispatcher_loops.push(new_dispatcher_loop) }
       end
 
       def debug
         dispatcher_details = {}
 
-        dispatcher_loops.loops.each_with_index do |dispatcher_loop, i|
+        @dispatcher_loops.each_with_index do |dispatcher_loop, i|
           dispatcher_details[i] = {
             started_at: dispatcher_loop.started_at.iso8601,
             dispatched: dispatcher_loop.dispatch_count,
@@ -144,7 +140,7 @@ module Rpush
       end
 
       def num_dispatcher_loops
-        dispatcher_loops.size
+        @dispatcher_loops.size
       end
 
       private
@@ -160,8 +156,8 @@ module Rpush
       end
 
       def stop_dispatcher_loops
-        dispatcher_loops.stop
-        @dispatcher_loops = nil
+        @dispatcher_loops.map(&:stop)
+        @dispatcher_loops.clear
       end
 
       def new_dispatcher_loop
@@ -179,16 +175,6 @@ module Rpush
       def queue
         @queue ||= Queue.new
       end
-
-      def dispatcher_loops
-        @dispatcher_loops ||= Rpush::Daemon::DispatcherLoopCollection.new
-      end
-
-      def dispatchers_str(count = num_dispatcher_loops)
-        count = count.abs
-        str = count == 1 ? 'dispatcher' : 'dispatchers'
-        "#{count} #{str}"
-      end
     end
   end
 end

data/lib/rpush/daemon/dispatcher_loop.rb

@@ -6,7 +6,7 @@ module Rpush
 
       attr_reader :started_at, :dispatch_count
 
-      WAKEUP = :wakeup
+      STOP = :stop
 
       def initialize(queue, dispatcher)
         @queue = queue
@@ -23,8 +23,17 @@ module Rpush
 
         @thread = Thread.new do
           loop do
-            dispatch
-            break if @stop
+            payload = @queue.pop
+            if stop_payload?(payload)
+              break if should_stop?(payload)
+
+              # Intended for another dispatcher loop.
+              @queue.push(payload)
+              Thread.pass
+              sleep 0.1
+            else
+              dispatch(payload)
+            end
           end
 
           Rpush::Daemon.store.release_connection
@@ -32,31 +41,27 @@ module Rpush
       end
 
       def stop
-        @stop = true
-      end
-
-      def wakeup
-        @queue.push(WAKEUP) if @thread
-      end
-
-      def wait
+        @queue.push([STOP, object_id]) if @thread
         @thread.join if @thread
         @dispatcher.cleanup
       end
 
-      protected
+      private
 
-      def dispatch
-        payload = @queue.pop
-        return if payload == WAKEUP
+      def stop_payload?(payload)
+        payload.is_a?(Array) && payload.first == STOP
+      end
 
-        begin
-          @dispatch_count += 1
-          @dispatcher.dispatch(payload)
-        rescue StandardError => e
-          log_error(e)
-          reflect(:error, e)
-        end
+      def should_stop?(payload)
+        payload.last == object_id
+      end
+
+      def dispatch(payload)
+        @dispatch_count += 1
+        @dispatcher.dispatch(payload)
+      rescue StandardError => e
+        log_error(e)
+        reflect(:error, e)
       end
     end
   end

data/lib/rpush/daemon/feeder.rb

@@ -37,7 +37,7 @@ module Rpush
       end
 
       def self.enqueue_notifications
-        batch_size = Rpush.config.batch_size - Rpush::Daemon::AppRunner.num_queued
+        batch_size = Rpush.config.batch_size - Rpush::Daemon::AppRunner.total_queued
         return if batch_size <= 0
         notifications = Rpush::Daemon.store.deliverable_notifications(batch_size)
         Rpush::Daemon::AppRunner.enqueue(notifications)

data/lib/rpush/daemon/proc_title.rb

@@ -6,9 +6,9 @@ module Rpush
       end
 
       def self.proc_title
-        total_dispatchers = AppRunner.num_dispatchers
+        total_dispatchers = AppRunner.total_dispatchers
         dispatchers_str = total_dispatchers == 1 ? 'dispatcher' : 'dispatchers'
-        total_queued = AppRunner.num_queued
+        total_queued = AppRunner.total_queued
         format("rpush | %s | %d queued | %d %s", Rpush.config.environment, total_queued, total_dispatchers, dispatchers_str)
       end
     end

data/lib/rpush/daemon/retryable_error.rb

@@ -17,4 +17,6 @@ module Rpush
       "Retryable error for #{@notification_id}, received error #{@code} (#{@description}) - retry after #{@response.header['retry-after']}"
     end
   end
+
+  class RateLimitError < RetryableError; end
 end

data/lib/rpush/daemon/signal_handler.rb

@@ -25,7 +25,7 @@ module Rpush
           loop do
             case read_io.readline.strip.to_i
             when Signal.list['HUP']
-              AppRunner.sync
+              Synchronizer.sync
               Feeder.wakeup
             when Signal.list['USR2']
               AppRunner.debug

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

@@ -1,4 +1,7 @@
 class PGError < StandardError; end unless defined?(PGError)
+module PG
+  class Error < StandardError; end unless defined?(::PG::Error)
+end
 class Mysql; class Error < StandardError; end; end unless defined?(Mysql)
 module Mysql2; class Error < StandardError; end; end unless defined?(Mysql2)
 module ActiveRecord
@@ -17,8 +20,9 @@ module Rpush
     module Store
       class ActiveRecord
         module Reconnectable
-          ADAPTER_ERRORS = [::ActiveRecord::StatementInvalid, PGError, Mysql::Error,
-                            Mysql2::Error, ::ActiveRecord::JDBCError, SQLite3::Exception]
+          ADAPTER_ERRORS = [::ActiveRecord::StatementInvalid, PGError, PG::Error,
+                            Mysql::Error, Mysql2::Error, ::ActiveRecord::JDBCError,
+                            SQLite3::Exception]
 
           def with_database_reconnect_and_retry
             ::ActiveRecord::Base.connection_pool.with_connection do

data/lib/rpush/daemon/string_helpers.rb

@@ -0,0 +1,15 @@
+module Rpush
+  module Daemon
+    module StringHelpers
+      def pluralize(count, singular, plural = nil)
+        if count == 1 || count =~ /^1(\.0+)?$/
+          word = singular
+        else
+          word = plural || singular.pluralize
+        end
+
+        "#{count || 0} #{word}"
+      end
+    end
+  end
+end

data/lib/rpush/daemon/synchronizer.rb

@@ -0,0 +1,44 @@
+module Rpush
+  module Daemon
+    class Synchronizer
+      extend Loggable
+      extend StringHelpers
+
+      def self.sync
+        apps = Rpush::Daemon.store.all_apps
+        apps.each { |app| sync_app(app) }
+        removed = AppRunner.app_ids - apps.map(&:id)
+        removed.each { |app_id| AppRunner.stop_app(app_id) }
+
+        ProcTitle.update
+      end
+
+      def self.sync_app(app)
+        unless AppRunner.app_running?(app)
+          AppRunner.start_app(app)
+          log_info("[#{app.name}] Started, #{pluralize(app.connections, 'dispatcher')}.")
+          return
+        end
+
+        sync_dispatcher_count(app)
+      end
+
+      def self.sync_dispatcher_count(app)
+        num_dispatchers = AppRunner.num_dispatchers_for_app(app)
+        diff = num_dispatchers - app.connections
+        return if diff == 0
+
+        if diff > 0
+          AppRunner.decrement_dispatchers(app, diff)
+          start_stop_str = "Stopped"
+        else
+          AppRunner.increment_dispatchers(app, diff.abs)
+          start_stop_str = "Started"
+        end
+
+        num_dispatchers = AppRunner.num_dispatchers_for_app(app)
+        log_info("[#{app.name}] #{start_stop_str} #{pluralize(diff.abs, 'dispatcher')}. #{num_dispatchers} running.")
+      end
+    end
+  end
+end

data/lib/rpush/embed.rb

@@ -23,7 +23,7 @@ module Rpush
 
   def self.sync
     return unless Rpush.config.embedded
-    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon::Synchronizer.sync
   end
 
   def self.debug

data/lib/rpush/push.rb

@@ -8,7 +8,7 @@ module Rpush
     Rpush.config.update(config)
 
     Rpush::Daemon.initialize_store
-    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon::Synchronizer.sync
     Rpush::Daemon::Feeder.start
     Rpush::Daemon::AppRunner.stop
   end

data/lib/rpush/version.rb

@@ -1,3 +1,3 @@
 module Rpush
-  VERSION = '2.0.0.beta1'
+  VERSION = '2.0.0.beta2'
 end

data/spec/functional/synchronization_spec.rb

@@ -0,0 +1,46 @@
+require 'functional_spec_helper'
+
+describe 'Synchronization' do
+  let(:timeout) { 10 }
+  let(:app) { Rpush::Gcm::App.new }
+
+  def wait_for_num_dispatchers(num)
+    Timeout.timeout(timeout) do
+      until Rpush::Daemon::AppRunner.num_dispatchers_for_app(app) == num
+        sleep 0.1
+      end
+    end
+  end
+
+  before do
+    app.name = 'test'
+    app.auth_key = 'abc123'
+    app.connections = 2
+    app.save!
+
+    Rpush.embed
+    wait_for_num_dispatchers(app.connections)
+  end
+
+  after { Timeout.timeout(timeout) { Rpush.shutdown } }
+
+  it 'increments the number of dispatchers' do
+    app.connections += 1
+    app.save!
+    Rpush.sync
+    wait_for_num_dispatchers(app.connections)
+  end
+
+  it 'decrements the number of dispatchers' do
+    app.connections -= 1
+    app.save!
+    Rpush.sync
+    wait_for_num_dispatchers(app.connections)
+  end
+
+  it 'stops a deleted app' do
+    app.destroy
+    Rpush.sync
+    Rpush::Daemon::AppRunner.app_running?(app).should be_false
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,8 @@
 ENV['RAILS_ENV'] = 'test'
+client = (ENV['CLIENT'] || :active_record).to_sym
 
-require 'bundler'
+require 'bundler/setup'
 Bundler.require(:default)
-client = (ENV['CLIENT'] || :active_record).to_sym
 
 unless ENV['TRAVIS'] && ENV['QUALITY'] == 'false'
   begin

data/spec/unit/client/active_record/apns/notification_spec.rb

@@ -156,7 +156,7 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'to_binary' do
     notification.badge = nil
     notification.sound = nil
     notification.content_available = true
-    bytes = notification.to_binary.bytes[-4..-1]
+    bytes = notification.to_binary.bytes.to_a[-4..-1]
     bytes.first.should eq 5 # priority item ID
     bytes.last.should eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_CONSERVE_POWER
   end
@@ -166,7 +166,7 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'to_binary' do
     notification.badge = nil
     notification.sound = nil
     notification.content_available = true
-    bytes = notification.to_binary.bytes[-4..-1]
+    bytes = notification.to_binary.bytes.to_a[-4..-1]
     bytes.first.should eq 5 # priority item ID
     bytes.last.should eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_IMMEDIATE
   end

data/spec/unit/daemon/adm/delivery_spec.rb

@@ -134,7 +134,7 @@ describe Rpush::Daemon::Adm::Delivery do
   describe 'a 429 (Too Many Request) response' do
     let(:http) { double(shutdown: nil) }
     let(:notification) { Rpush::Adm::Notification.create!(app: app, registration_ids: %w(abc xyz), deliver_after: Time.now, collapse_key: 'sync', data: { 'message' => 'test' }) }
-    let(:too_many_request_response) { double(code: 429, header: { 'retry-after' => 3600 }) }
+    let(:rate_limited_response) { double(code: 429, header: { 'retry-after' => 3600 }) }
 
     it 'should retry the entire notification respecting the Retry-After header if none sent out yet' do
       response.stub(code: 429, header: { 'retry-after' => 3600 })
@@ -167,7 +167,7 @@ describe Rpush::Daemon::Adm::Delivery do
 
       # first request to deliver message that returns too many request response
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'xyz'))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(too_many_request_response)
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(rate_limited_response)
 
       store.should_receive(:update_notification).with do |notif|
         notif.registration_ids.include?('abc').should be_true

data/spec/unit/daemon/app_runner_spec.rb

@@ -31,104 +31,49 @@ module Rpush
   end
 end
 
-describe Rpush::Daemon::AppRunner, 'stop' do
-  let(:runner) { double }
-  before { Rpush::Daemon::AppRunner.runners['app'] = runner }
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'stops all runners' do
-    runner.should_receive(:stop)
-    Rpush::Daemon::AppRunner.stop
-  end
-end
-
 describe Rpush::Daemon::AppRunner, 'enqueue' do
-  let(:runner) { double(enqueue: nil) }
-  let(:notification1) { double(app_id: 1) }
-  let(:notification2) { double(app_id: 2) }
+  let(:app) { double(id: 1) }
+  let(:notification) { double(app_id: 1) }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start: nil, stop: nil) }
   let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
     Rpush.stub(logger: logger)
     Rpush::Daemon::ProcTitle.stub(:update)
-    Rpush::Daemon::AppRunner.runners[1] = runner
-    Rpush::Daemon::AppRunner.runners[2] = runner
+    Rpush::Daemon::AppRunner.stub(new: runner)
+    Rpush::Daemon::AppRunner.start_app(app)
   end
 
-  after { Rpush::Daemon::AppRunner.runners.clear }
+  after { Rpush::Daemon::AppRunner.stop }
 
-  it 'enqueues notifications on each runner' do
-    runner.should_receive(:enqueue).with([notification1])
-    runner.should_receive(:enqueue).with([notification2])
-    Rpush::Daemon::AppRunner.enqueue([notification1, notification2])
+  it 'enqueues notifications on the runner' do
+    runner.should_receive(:enqueue).with([notification])
+    Rpush::Daemon::AppRunner.enqueue([notification])
   end
 
-  it 'syncs the app if a runner does not exist' do
-    Rpush::Daemon::AppRunner.runners[3].should be_nil
+  it 'starts the app if a runner does not exist' do
     notification = double(app_id: 3)
-    app = double(Rpush::App, id: 3, connections: 1, service_name: 'app_runner_spec_service', environment: 'sandbox', certificate: TEST_CERT, password: nil, name: 'test')
-    Rpush::Daemon.store = double(app: app)
+    new_app = double(Rpush::App, id: 3)
+    Rpush::Daemon.store = double(app: new_app)
     Rpush::Daemon::AppRunner.enqueue([notification])
-    Rpush::Daemon::AppRunner.runners[3].should_not be_nil
+    Rpush::Daemon::AppRunner.app_running?(new_app).should be_true
   end
 end
 
-describe Rpush::Daemon::AppRunner, 'sync' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, name: 'test') }
-  let(:new_app) { double(Rpush::AppRunnerSpecService::App, name: 'new_test') }
-  let(:runner) { double(sync: nil, stop: nil, start: nil) }
-  let(:logger) { double(Rpush::Logger, error: nil, warn: nil) }
-  let(:queue) { Queue.new }
-  let(:store) { double(all_apps: [app]) }
+describe Rpush::Daemon::AppRunner, 'start_app' do
+  let(:app) { double(id: 1, name: 'test') }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start: nil, stop: nil) }
+  let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
-    app.stub(id: 1)
-    new_app.stub(id: 2)
-    Queue.stub(new: queue)
-    Rpush::Daemon::AppRunner.runners[app.id] = runner
     Rpush.stub(logger: logger)
-    Rpush::Daemon.stub(store: store)
-    Rpush::Daemon::ProcTitle.stub(:update)
-  end
-
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'instructs existing runners to sync' do
-    runner.should_receive(:sync).with(app)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  it 'starts a runner for a new app' do
-    store.stub(all_apps: [app, new_app])
-    new_runner = double
-    Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
-    new_runner.should_receive(:start)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  it 'deletes old runners' do
-    store.stub(all_apps: [])
-    runner.should_receive(:stop)
-    Rpush::Daemon::AppRunner.sync
   end
 
   it 'logs an error if the runner could not be started' do
-    store.stub(all_apps: [app, new_app])
-    new_runner = double
-    Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
-    new_runner.stub(:start).and_raise(StandardError)
+    Rpush::Daemon::AppRunner.should_receive(:new).with(app).and_return(runner)
+    runner.stub(:start).and_raise(StandardError)
     Rpush.logger.should_receive(:error)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  it 'reflects errors if the runner could not be started' do
-    store.stub(all_apps: [app, new_app])
-    new_runner = double
-    Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
-    e = StandardError.new
-    new_runner.stub(:start).and_raise(e)
-    Rpush::Daemon::AppRunner.should_receive(:reflect).with(:error, e)
-    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon::AppRunner.start_app(app)
   end
 end
 
@@ -137,15 +82,15 @@ describe Rpush::Daemon::AppRunner, 'debug' do
                                                         environment: 'development', certificate: TEST_CERT, service_name: 'app_runner_spec_service')
   end
   let(:logger) { double(Rpush::Logger, info: nil) }
-  let(:store) { double(all_apps: [app]) }
+  let(:store) { double(all_apps: [app], release_connection: nil) }
 
   before do
     Rpush::Daemon.stub(config: {}, store: store)
     Rpush.stub(logger: logger)
-    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon::AppRunner.start_app(app)
   end
 
-  after { Rpush::Daemon::AppRunner.runners.clear }
+  after { Rpush::Daemon::AppRunner.stop_app(app.id) }
 
   it 'prints debug app states to the log' do
     Rpush.logger.should_receive(:info).with(kind_of(String))
@@ -161,18 +106,16 @@ describe Rpush::Daemon::AppRunner do
   let(:runner) { Rpush::Daemon::AppRunner.new(app) }
   let(:logger) { double(Rpush::Logger, info: nil) }
   let(:queue) { Queue.new }
-  let(:dispatcher_loop_collection) { Rpush::Daemon::DispatcherLoopCollection.new }
-  let(:service_loop) do double(Rpush::Daemon::AppRunnerSpecService::ServiceLoop,
-                               start: nil, stop: nil)
-  end
+  let(:service_loop) { double(Rpush::Daemon::AppRunnerSpecService::ServiceLoop, start: nil, stop: nil) }
+  let(:dispatcher_loop) { double(Rpush::Daemon::DispatcherLoop, stop: nil, start: nil) }
   let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil) }
 
   before do
+    Rpush::Daemon::DispatcherLoop.stub(new: dispatcher_loop)
     Rpush::Daemon.stub(store: store)
     Rpush::Daemon::AppRunnerSpecService::ServiceLoop.stub(new: service_loop)
     Queue.stub(new: queue)
     Rpush.stub(logger: logger)
-    Rpush::Daemon::DispatcherLoopCollection.stub(new: dispatcher_loop_collection)
   end
 
   describe 'start' do
@@ -182,6 +125,11 @@ describe Rpush::Daemon::AppRunner do
       runner.num_dispatcher_loops.should eq 2
     end
 
+    it 'starts the dispatcher loop' do
+      dispatcher_loop.should_receive(:start)
+      runner.start
+    end
+
     it 'starts the loops' do
       service_loop.should_receive(:start)
       runner.start
@@ -209,7 +157,7 @@ describe Rpush::Daemon::AppRunner do
     before { runner.start }
 
     it 'stops the delivery dispatchers' do
-      dispatcher_loop_collection.should_receive(:stop)
+      dispatcher_loop.should_receive(:stop)
       runner.stop
     end
 
@@ -218,18 +166,4 @@ describe Rpush::Daemon::AppRunner do
       runner.stop
     end
   end
-
-  describe 'sync' do
-    before { runner.start }
-
-    it 'reduces the number of dispatchers if needed' do
-      app.stub(connections: 0)
-      expect { runner.sync(app) }.to change(runner, :num_dispatcher_loops).to(0)
-    end
-
-    it 'increases the number of dispatchers if needed' do
-      app.stub(connections: 2)
-      expect { runner.sync(app) }.to change(runner, :num_dispatcher_loops).to(2)
-    end
-  end
 end

data/spec/unit/daemon/dispatcher_loop_spec.rb

@@ -4,8 +4,6 @@ describe Rpush::Daemon::DispatcherLoop do
   def run_dispatcher_loop
     dispatcher_loop.start
     dispatcher_loop.stop
-    dispatcher_loop.wakeup
-    dispatcher_loop.wait
   end
 
   let(:notification) { double }
@@ -37,20 +35,9 @@ describe Rpush::Daemon::DispatcherLoop do
     run_dispatcher_loop
   end
 
-  it 'instructs the queue to wakeup the thread when told to stop' do
-    queue.should_receive(:push).with(Rpush::Daemon::DispatcherLoop::WAKEUP).and_call_original
-    run_dispatcher_loop
-  end
-
   describe 'stop' do
     before do
       queue.clear
-      queue.push(Rpush::Daemon::DispatcherLoop::WAKEUP)
-    end
-
-    it 'does not attempt to dispatch when a WAKEUP is dequeued' do
-      dispatcher.should_not_receive(:dispatch)
-      run_dispatcher_loop
     end
 
     it 'instructs the dispatcher to cleanup' do

data/spec/unit/daemon/feeder_spec.rb

@@ -33,14 +33,14 @@ describe Rpush::Daemon::Feeder do
   end
 
   it 'does not load more notifications if the total queue size is equal to the batch size' do
-    Rpush::Daemon::AppRunner.stub(num_queued: Rpush.config.batch_size)
+    Rpush::Daemon::AppRunner.stub(total_queued: Rpush.config.batch_size)
     Rpush::Daemon.store.should_not_receive(:deliverable_notifications)
     start_and_stop
   end
 
   it 'limits the batch size if some runners are still processing notifications' do
     Rpush.config.stub(batch_size: 10)
-    Rpush::Daemon::AppRunner.stub(num_queued: 6)
+    Rpush::Daemon::AppRunner.stub(total_queued: 6)
     Rpush::Daemon.store.should_receive(:deliverable_notifications).with(4)
     start_and_stop
   end

data/spec/unit/daemon/signal_handler_spec.rb

@@ -42,13 +42,13 @@ describe Rpush::Daemon::SignalHandler do
 
   describe 'HUP' do
     before do
-      Rpush::Daemon::AppRunner.stub(:sync)
+      Rpush::Daemon::Synchronizer.stub(:sync)
       Rpush::Daemon::Feeder.stub(:wakeup)
     end
 
-    it 'syncs the AppRunner' do
+    it 'syncs' do
       with_handler_start_stop do
-        Rpush::Daemon::AppRunner.should_receive(:sync)
+        Rpush::Daemon::Synchronizer.should_receive(:sync)
         signal_handler('HUP')
       end
     end

data/spec/unit/daemon/store/active_record/reconnectable_spec.rb

@@ -41,6 +41,7 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
       fail "Please update #{__FILE__} for adapter #{SPEC_ADAPTER}"
     end
   end
+
   let(:error) { adapter_error_class.new("db down!") }
   let(:test_double) { TestDouble.new(error, 1) }
 

data/spec/unit/daemon_spec.rb

@@ -11,7 +11,8 @@ describe Rpush::Daemon, "when starting" do
   before do
     Rpush.stub(logger: logger)
     Rpush::Daemon::Feeder.stub(:start)
-    Rpush::Daemon::AppRunner.stub(sync: nil, stop: nil)
+    Rpush::Daemon::Synchronizer.stub(sync: nil)
+    Rpush::Daemon::AppRunner.stub(stop: nil)
     Rpush::Daemon.stub(exit: nil, puts: nil)
     Rpush::Daemon::SignalHandler.stub(start: nil, stop: nil, handle_shutdown_signal: nil)
     Process.stub(:daemon)
@@ -87,7 +88,7 @@ describe Rpush::Daemon, "when starting" do
   end
 
   it "syncs apps" do
-    Rpush::Daemon::AppRunner.should_receive(:sync)
+    Rpush::Daemon::Synchronizer.should_receive(:sync)
     Rpush::Daemon.start
   end
 

data/spec/unit/embed_spec.rb

@@ -36,8 +36,8 @@ end
 describe Rpush, 'sync' do
   before { Rpush.config.embedded = true }
 
-  it 'syncs the AppRunner' do
-    Rpush::Daemon::AppRunner.should_receive(:sync)
+  it 'syncs' do
+    Rpush::Daemon::Synchronizer.should_receive(:sync)
     Rpush.sync
   end
 end

data/spec/unit/logger_spec.rb

@@ -70,11 +70,13 @@ describe Rpush::Logger do
     logger.info("hi mom")
   end
 
-  it "should not print out the msg if not running in the foreground" do
-    Rpush.config.foreground = false
-    logger = Rpush::Logger.new
-    STDOUT.should_not_receive(:puts).with(/hi mom/)
-    logger.info("hi mom")
+  unless Rpush.jruby? # These tests do not work on JRuby.
+    it "should not print out the msg if not running in the foreground" do
+      Rpush.config.foreground = false
+      logger = Rpush::Logger.new
+      STDOUT.should_not_receive(:puts).with(/hi mom/)
+      logger.info("hi mom")
+    end
   end
 
   it "should prefix log lines with the current time" do

data/spec/unit/push_spec.rb

@@ -2,7 +2,8 @@ require 'unit_spec_helper'
 
 describe Rpush, 'push' do
   before do
-    Rpush::Daemon::AppRunner.stub(sync: nil, wait: nil)
+    Rpush::Daemon::Synchronizer.stub(sync: nil)
+    Rpush::Daemon::AppRunner.stub(wait: nil)
     Rpush::Daemon::Feeder.stub(start: nil)
   end
 
@@ -16,8 +17,8 @@ describe Rpush, 'push' do
     Rpush.push
   end
 
-  it 'syncs the app runner' do
-    Rpush::Daemon::AppRunner.should_receive(:sync)
+  it 'syncs' do
+    Rpush::Daemon::Synchronizer.should_receive(:sync)
     Rpush.push
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rpush
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta1
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Ian Leitch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-13 00:00:00.000000000 Z
+date: 2014-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -136,7 +136,6 @@ files:
 - lib/rpush/daemon/dispatcher/http.rb
 - lib/rpush/daemon/dispatcher/tcp.rb
 - lib/rpush/daemon/dispatcher_loop.rb
-- lib/rpush/daemon/dispatcher_loop_collection.rb
 - lib/rpush/daemon/errors.rb
 - lib/rpush/daemon/feeder.rb
 - lib/rpush/daemon/gcm.rb
@@ -155,8 +154,9 @@ files:
 - lib/rpush/daemon/store/active_record/reconnectable.rb
 - lib/rpush/daemon/store/interface.rb
 - lib/rpush/daemon/store/redis.rb
+- lib/rpush/daemon/string_helpers.rb
+- lib/rpush/daemon/synchronizer.rb
 - lib/rpush/daemon/tcp_connection.rb
-- lib/rpush/daemon/too_many_requests_error.rb
 - lib/rpush/daemon/wpns.rb
 - lib/rpush/daemon/wpns/delivery.rb
 - lib/rpush/deprecatable.rb
@@ -176,6 +176,7 @@ files:
 - spec/functional/gcm_spec.rb
 - spec/functional/new_app_spec.rb
 - spec/functional/retry_spec.rb
+- spec/functional/synchronization_spec.rb
 - spec/functional/wpns_spec.rb
 - spec/functional_spec_helper.rb
 - spec/integration/rpush_spec.rb
@@ -212,7 +213,6 @@ files:
 - spec/unit/daemon/delivery_spec.rb
 - spec/unit/daemon/dispatcher/http_spec.rb
 - spec/unit/daemon/dispatcher/tcp_spec.rb
-- spec/unit/daemon/dispatcher_loop_collection_spec.rb
 - spec/unit/daemon/dispatcher_loop_spec.rb
 - spec/unit/daemon/feeder_spec.rb
 - spec/unit/daemon/gcm/delivery_spec.rb
@@ -223,7 +223,6 @@ files:
 - spec/unit/daemon/store/active_record/reconnectable_spec.rb
 - spec/unit/daemon/store/active_record_spec.rb
 - spec/unit/daemon/tcp_connection_spec.rb
-- spec/unit/daemon/too_many_requests_error_spec.rb
 - spec/unit/daemon/wpns/delivery_spec.rb
 - spec/unit/daemon_spec.rb
 - spec/unit/deprecatable_spec.rb
@@ -267,6 +266,7 @@ test_files:
 - spec/functional/gcm_spec.rb
 - spec/functional/new_app_spec.rb
 - spec/functional/retry_spec.rb
+- spec/functional/synchronization_spec.rb
 - spec/functional/wpns_spec.rb
 - spec/functional_spec_helper.rb
 - spec/integration/rpush_spec.rb
@@ -303,7 +303,6 @@ test_files:
 - spec/unit/daemon/delivery_spec.rb
 - spec/unit/daemon/dispatcher/http_spec.rb
 - spec/unit/daemon/dispatcher/tcp_spec.rb
-- spec/unit/daemon/dispatcher_loop_collection_spec.rb
 - spec/unit/daemon/dispatcher_loop_spec.rb
 - spec/unit/daemon/feeder_spec.rb
 - spec/unit/daemon/gcm/delivery_spec.rb
@@ -314,7 +313,6 @@ test_files:
 - spec/unit/daemon/store/active_record/reconnectable_spec.rb
 - spec/unit/daemon/store/active_record_spec.rb
 - spec/unit/daemon/tcp_connection_spec.rb
-- spec/unit/daemon/too_many_requests_error_spec.rb
 - spec/unit/daemon/wpns/delivery_spec.rb
 - spec/unit/daemon_spec.rb
 - spec/unit/deprecatable_spec.rb

data/lib/rpush/daemon/dispatcher_loop_collection.rb

@@ -1,33 +0,0 @@
-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/too_many_requests_error.rb

@@ -1,20 +0,0 @@
-module Rpush
-  class TooManyRequestsError < StandardError
-    attr_reader :code, :description, :response
-
-    def initialize(code, notification_id, description, response)
-      @code = code
-      @notification_id = notification_id
-      @description = description
-      @response = response
-    end
-
-    def to_s
-      message
-    end
-
-    def message
-      "Too many requests for #{@notification_id}, received error #{@code} (#{@description}) - retry after #{@response.header['retry-after']}"
-    end
-  end
-end

data/spec/unit/daemon/dispatcher_loop_collection_spec.rb

@@ -1,37 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Daemon::DispatcherLoopCollection do
-  let(:dispatcher_loop) { double.as_null_object }
-  let(:collection) { Rpush::Daemon::DispatcherLoopCollection.new }
-
-  it 'returns the size of the collection' do
-    collection.push(dispatcher_loop)
-    collection.size.should eq 1
-  end
-
-  it 'pops a dispatcher loop from the collection' do
-    collection.push(dispatcher_loop)
-    dispatcher_loop.should_receive(:stop)
-    dispatcher_loop.should_receive(:wakeup)
-    dispatcher_loop.should_receive(:wait)
-    collection.pop
-    collection.size.should eq 0
-  end
-
-  it 'wakes up all dispatcher loops when popping a single dispatcher_loop' do
-    collection.push(dispatcher_loop)
-    dispatcher_loop2 = double.as_null_object
-    collection.push(dispatcher_loop2)
-    dispatcher_loop.should_receive(:wakeup)
-    dispatcher_loop2.should_receive(:wakeup)
-    collection.pop
-  end
-
-  it 'stops all dispatcher  detetcloops' do
-    collection.push(dispatcher_loop)
-    dispatcher_loop.should_receive(:stop)
-    dispatcher_loop.should_receive(:wakeup)
-    dispatcher_loop.should_receive(:wait)
-    collection.stop
-  end
-end

data/spec/unit/daemon/too_many_requests_error_spec.rb

@@ -1,14 +0,0 @@
-require "unit_spec_helper"
-
-describe Rpush::TooManyRequestsError do
-  let(:response) { double(code: 429, header: { 'retry-after' => 3600 }) }
-  let(:error) { Rpush::TooManyRequestsError.new(429, 12, "Too Many Requests", response) }
-
-  it "returns an informative message" do
-    error.to_s.should eq "Too many requests for 12, received error 429 (Too Many Requests) - retry after 3600"
-  end
-
-  it "returns the error code" do
-    error.code.should eq 429
-  end
-end