qs 0.6.1 → 0.7.0

data/lib/qs/daemon_data.rb

@@ -2,37 +2,38 @@ module Qs
 
   class DaemonData
 
-    # The daemon uses this to "compile" its configuration for speed. NsOptions
-    # is relatively slow everytime an option is read. To avoid this, we read the
-    # options one time here and memoize their values. This way, we don't pay the
-    # NsOptions overhead when reading them while handling a message.
+    # The daemon uses this to "compile" the common configuration data used
+    # by the daemon instances, error handlers and routes. The goal here is
+    # to provide these with a simplified interface with the minimal data needed
+    # and to decouple the configuration from each thing that needs its data.
 
-    attr_reader :name, :process_label, :pid_file
+    attr_reader :name, :pid_file, :shutdown_timeout
     attr_reader :worker_class, :worker_params, :num_workers
-    attr_reader :debug, :logger, :dwp_logger, :verbose_logging
-    attr_reader :shutdown_timeout
-    attr_reader :error_procs, :queue_redis_keys, :routes
+    attr_reader :error_procs, :logger, :queue_redis_keys
+    attr_reader :verbose_logging
+    attr_reader :debug, :dwp_logger, :routes, :process_label
 
     def initialize(args = nil)
       args ||= {}
-      @name          = args[:name]
-      @process_label = !(v = ENV['QS_PROCESS_LABEL'].to_s).empty? ? v : args[:name]
-      @pid_file      = args[:pid_file]
+      @name     = args[:name]
+      @pid_file = args[:pid_file]
 
-      @worker_class  = args[:worker_class]
-      @worker_params = args[:worker_params] || {}
-      @num_workers   = args[:num_workers]
+      @shutdown_timeout = args[:shutdown_timeout]
+
+      @worker_class     = args[:worker_class]
+      @worker_params    = args[:worker_params] || {}
+      @num_workers      = args[:num_workers]
+      @error_procs      = args[:error_procs] || []
+      @logger           = args[:logger]
+      @queue_redis_keys = (args[:queues] || []).map(&:redis_key)
 
-      @debug           = !ENV['QS_DEBUG'].to_s.empty?
-      @logger          = args[:logger]
-      @dwp_logger      = @logger if @debug
       @verbose_logging = !!args[:verbose_logging]
 
-      @shutdown_timeout = args[:shutdown_timeout]
+      @debug      = !ENV['QS_DEBUG'].to_s.empty?
+      @dwp_logger = @logger if @debug
+      @routes     = build_routes(args[:routes] || [])
 
-      @error_procs      = args[:error_procs] || []
-      @queue_redis_keys = args[:queue_redis_keys] || []
-      @routes           = build_routes(args[:routes] || [])
+      @process_label = !(v = ENV['QS_PROCESS_LABEL'].to_s).empty? ? v : @name
     end
 
     def route_for(route_id)

data/lib/qs/message_handler.rb

@@ -50,6 +50,7 @@ module Qs
 
       def logger; @qs_runner.logger; end
       def params; @qs_runner.params; end
+      def halt;   @qs_runner.halt;   end
 
     end
 

data/lib/qs/process.rb

@@ -51,17 +51,15 @@ module Qs
       @pid_file.remove
     end
 
-    def daemonize?
-      @daemonize
-    end
+    def daemonize?; @daemonize; end
 
     private
 
     def start_daemon(daemon)
-      @daemon.start
-      log "#{@daemon.name} daemon started and ready."
+      daemon.start
+      log "#{daemon.name} daemon started and ready."
     rescue StandardError => exception
-      log "#{@daemon.name} daemon never started."
+      log "#{daemon.name} daemon never started."
       raise exception
     end
 
@@ -102,7 +100,6 @@ module Qs
 
     def run_restart_cmd(daemon, restart_cmd)
       log "Restarting #{daemon.name} daemon"
-      ENV['QS_SKIP_DAEMONIZE'] = 'yes'
       restart_cmd.run
     end
 
@@ -126,9 +123,22 @@ module Qs
       @argv = [Gem.ruby, $0, ARGV.dup].flatten
     end
 
-    def run
-      Dir.chdir self.dir
-      Kernel.exec(*self.argv)
+    if RUBY_VERSION == '1.8.7'
+
+      def run
+        ENV['QS_SKIP_DAEMONIZE'] = 'yes'
+        Dir.chdir self.dir
+        Kernel.exec(*self.argv)
+      end
+
+    else
+
+      def run
+        env     = { 'QS_SKIP_DAEMONIZE' => 'yes' }
+        options = { :chdir => self.dir }
+        Kernel.exec(*([env] + self.argv + [options]))
+      end
+
     end
 
     private

data/lib/qs/qs_runner.rb

@@ -1,4 +1,4 @@
-require 'system_timer'
+require 'much-timeout'
 require 'qs'
 require 'qs/runner'
 
@@ -14,32 +14,24 @@ module Qs
     end
 
     def run
-      OptionalTimeout.new(self.timeout) do
-        self.handler.qs_run_callback 'before'
-        self.handler.qs_init
-        self.handler.qs_run
-        self.handler.qs_run_callback 'after'
+      MuchTimeout.optional_timeout(self.timeout, TimeoutInterrupt) do
+        catch(:halt) do
+          self.handler.qs_run_callback 'before'
+          catch(:halt){ self.handler.qs_init; self.handler.qs_run }
+          self.handler.qs_run_callback 'after'
+        end
       end
-    rescue TimeoutError => exception
-      error = TimeoutError.new "#{handler_class} timed out (#{timeout}s)"
+    rescue TimeoutInterrupt => exception
+      error = Qs::TimeoutError.new "#{handler_class} timed out (#{timeout}s)"
       error.set_backtrace(exception.backtrace)
       raise error
     end
 
-    private
-
-    module OptionalTimeout
-      def self.new(timeout, &block)
-        if !timeout.nil?
-          SystemTimer.timeout_after(timeout, TimeoutError, &block)
-        else
-          block.call
-        end
-      end
-    end
+    # this error should never be "swallowed", if it is caught be sure to re-raise
+    # it so the workers will be able to honor their timeout setting.  otherwise
+    # workers will never timeout.
+    TimeoutInterrupt = Class.new(Interrupt)
 
   end
 
-  TimeoutError = Class.new(RuntimeError)
-
 end

data/lib/qs/runner.rb

@@ -21,6 +21,10 @@ module Qs
       raise NotImplementedError
     end
 
+    def halt
+      throw :halt
+    end
+
   end
 
 end

data/lib/qs/test_runner.rb

@@ -17,11 +17,21 @@ module Qs
       })
       a.each{ |key, value| self.handler.send("#{key}=", value) }
 
-      self.handler.qs_init
+      @halted = false
+      catch(:halt){ self.handler.qs_init }
     end
 
+    def halted?; @halted; end
+
     def run
-      self.handler.qs_run
+      catch(:halt){ self.handler.qs_run } if !self.halted?
+    end
+
+    # helpers
+
+    def halt
+      @halted = true
+      super
     end
 
     private

data/lib/qs/version.rb

@@ -1,3 +1,3 @@
 module Qs
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/qs.gemspec

@@ -18,13 +18,12 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.15.1"])
-  gem.add_development_dependency("scmd",   ["~> 3.0.1"])
+  gem.add_development_dependency("assert", ["~> 2.16.1"])
+  gem.add_development_dependency("scmd",   ["~> 3.0.2"])
 
-  gem.add_dependency("dat-worker-pool", ["~> 0.6.0"])
-  gem.add_dependency("hella-redis",     ["~> 0.3.0"])
-  gem.add_dependency("much-plugin",     ["~> 0.1.0"])
-  gem.add_dependency("ns-options",      ["~> 1.1.6"])
-  gem.add_dependency("SystemTimer",     ["~> 1.2"])
+  gem.add_dependency("dat-worker-pool", ["~> 0.6.1"])
+  gem.add_dependency("hella-redis",     ["~> 0.3.1"])
+  gem.add_dependency("much-plugin",     ["~> 0.2.0"])
+  gem.add_dependency("much-timeout",    ["~> 0.1.0"])
 
 end

data/test/helper.rb

@@ -12,3 +12,14 @@ ROOT_PATH = Pathname.new(File.expand_path('../..', __FILE__))
 require 'test/support/factory'
 
 require 'json' # so the default encoder/decoder procs will work
+
+JOIN_SECONDS = 0.1
+
+# 1.8.7 backfills
+
+# Array#sample
+if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+  class Array
+    alias_method :sample, :choice
+  end
+end

data/test/support/app_queue.rb

@@ -0,0 +1,104 @@
+require 'qs'
+
+AppQueue = Qs::Queue.new do
+  name 'qs-app-main'
+
+  job_handler_ns 'AppHandlers'
+
+  job 'basic',   'Basic'
+  job 'basic1',  'Basic'
+  job 'error',   'Error'
+  job 'timeout', 'Timeout'
+  job 'slow',    'Slow'
+  job 'slow1',   'Slow'
+  job 'slow2',   'Slow'
+
+  event_handler_ns 'AppHandlers'
+
+  event 'qs-app', 'basic',   'BasicEvent'
+  event 'qs-app', 'error',   'ErrorEvent'
+  event 'qs-app', 'timeout', 'TimeoutEvent'
+  event 'qs-app', 'slow',    'SlowEvent'
+end
+
+module AppHandlers
+
+  class Basic
+    include Qs::JobHandler
+
+    def run!
+      Qs.redis.with{ |c| c.set("qs-app:#{params['key']}", params['value']) }
+    end
+  end
+
+  class Error
+    include Qs::JobHandler
+
+    def run!
+      raise params['error_message']
+    end
+  end
+
+  class Timeout
+    include Qs::JobHandler
+
+    TIMEOUT_TIME = 0.1
+
+    timeout TIMEOUT_TIME
+
+    def run!
+      sleep 2*TIMEOUT_TIME
+    end
+  end
+
+  class Slow
+    include Qs::JobHandler
+
+    SLOW_TIME = 1
+
+    def run!
+      sleep SLOW_TIME
+      Qs.redis.with{ |c| c.set('qs-app:slow', 'finished') }
+    end
+  end
+
+  class BasicEvent
+    include Qs::EventHandler
+
+    def run!
+      Qs.redis.with{ |c| c.set("qs-app:#{params['key']}", params['value']) }
+    end
+  end
+
+  class ErrorEvent
+    include Qs::EventHandler
+
+    def run!
+      raise params['error_message']
+    end
+  end
+
+  class TimeoutEvent
+    include Qs::EventHandler
+
+    TIMEOUT_TIME = 0.1
+
+    timeout TIMEOUT_TIME
+
+    def run!
+      sleep 2*TIMEOUT_TIME
+    end
+  end
+
+  class SlowEvent
+    include Qs::EventHandler
+
+    SLOW_TIME = 1
+
+    def run!
+      sleep SLOW_TIME
+      Qs.redis.with{ |c| c.set('qs-app:slow:event', 'finished') }
+    end
+  end
+
+end

data/test/support/client_spy.rb

@@ -3,8 +3,8 @@ require 'qs/client'
 class ClientSpy < Qs::TestClient
   attr_reader :calls
 
-  def initialize(redis_config = nil)
-    super(redis_config || {})
+  def initialize(redis_connect_hash = nil)
+    super(redis_connect_hash || {})
     @calls = []
     @list  = []
     @mutex = Mutex.new

data/test/support/config.qs

@@ -1,7 +1,14 @@
-require 'test/support/app_daemon'
+require 'test/support/app_queue'
 
 if !defined?(TestConstant)
   TestConstant = Class.new
 end
 
-run AppDaemon.new
+class ConfigFileTestDaemon
+  include Qs::Daemon
+
+  name  'qs-config-file-test'
+  queue AppQueue
+end
+
+run ConfigFileTestDaemon.new

data/test/support/factory.rb

@@ -16,7 +16,7 @@ module Factory
   end
 
   def self.message(params = nil)
-    self.send([:job, :event].choice, params)
+    self.send([:job, :event].sample, params)
   end
 
   def self.job(args = nil)

data/test/system/daemon_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'qs/daemon'
 
-require 'test/support/app_daemon'
+require 'test/support/app_queue'
 
 module Qs::Daemon
 
@@ -11,15 +11,15 @@ module Qs::Daemon
       Qs.reset!
       @qs_test_mode = ENV['QS_TEST_MODE']
       ENV['QS_TEST_MODE'] = nil
-      Qs.config.dispatcher.queue_name = 'qs-app-dispatcher'
+      Qs.config.dispatcher_queue_name = 'qs-app-dispatcher'
       Qs.config.event_publisher       = 'Daemon System Tests'
       Qs.init
       AppQueue.sync_subscriptions
-      @orig_config = AppDaemon.configuration.to_hash
+
+      @app_daemon_class = build_app_daemon_class
     end
     teardown do
       @daemon_runner.stop if @daemon_runner
-      AppDaemon.configuration.apply(@orig_config) # reset daemon config
       Qs.redis.with do |c|
         keys = c.keys('*qs-app*')
         c.pipelined{ keys.each{ |k| c.del(k) } }
@@ -32,10 +32,42 @@ module Qs::Daemon
 
     private
 
+    # manually build new anonymous app daemon classes for each run.  We do this
+    # both to not mess with global state when tweaking config values for tests
+    # and b/c there is no way to "reset" an existing class's config.
+    def build_app_daemon_class
+      Class.new do
+        include Qs::Daemon
+
+        name 'qs-app'
+
+        logger Logger.new(ROOT_PATH.join('log/app_daemon.log').to_s)
+        logger.datetime_format = "" # turn off the datetime in the logs
+
+        verbose_logging true
+
+        queue AppQueue
+
+        error do |exception, context|
+          return unless (message = context.message)
+          payload_type = message.payload_type
+          route_name   = message.route_name
+          case(route_name)
+          when 'error', 'timeout', 'qs-app:error', 'qs-app:timeout'
+            error = "#{exception.class}: #{exception.message}"
+            Qs.redis.with{ |c| c.set("qs-app:last_#{payload_type}_error", error) }
+          when 'slow', 'qs-app:slow'
+            error = exception.class.to_s
+            Qs.redis.with{ |c| c.set("qs-app:last_#{payload_type}_error", error) }
+          end
+        end
+      end
+    end
+
     def setup_app_and_dispatcher_daemon
-      @app_daemon        = AppDaemon.new
-      @dispatcher_daemon = DispatcherDaemon.new
-      @daemon_runner     = DaemonRunner.new(@app_daemon, @dispatcher_daemon)
+      @app_daemon        = @app_daemon_class.new
+      @dispatcher_daemon = AppDispatcherDaemon.new
+      @daemon_runner     = AppDaemonRunner.new(@app_daemon, @dispatcher_daemon)
       @app_thread        = @daemon_runner.start
     end
 
@@ -56,7 +88,7 @@ module Qs::Daemon
         'key'   => @key,
         'value' => @value
       })
-      @app_thread.join 0.5
+      @app_thread.join(JOIN_SECONDS)
     end
 
     should "run the job" do
@@ -70,7 +102,7 @@ module Qs::Daemon
     setup do
       @error_message = Factory.text
       AppQueue.add('error', 'error_message' => @error_message)
-      @app_thread.join 0.5
+      @app_thread.join(JOIN_SECONDS)
     end
 
     should "run the configured error handler procs" do
@@ -84,7 +116,7 @@ module Qs::Daemon
     desc "with a job that times out"
     setup do
       AppQueue.add('timeout')
-      @app_thread.join 1 # let the daemon have time to process the job
+      @app_thread.join(AppHandlers::Timeout::TIMEOUT_TIME + JOIN_SECONDS)
     end
 
     should "run the configured error handler procs" do
@@ -104,7 +136,7 @@ module Qs::Daemon
         'key'   => @key,
         'value' => @value
       })
-      @app_thread.join 0.5
+      @app_thread.join(JOIN_SECONDS)
     end
 
     should "run the event" do
@@ -118,7 +150,7 @@ module Qs::Daemon
     setup do
       @error_message = Factory.text
       Qs.publish('qs-app', 'error', 'error_message' => @error_message)
-      @app_thread.join 0.5
+      @app_thread.join(JOIN_SECONDS)
     end
 
     should "run the configured error handler procs" do
@@ -132,7 +164,7 @@ module Qs::Daemon
     desc "with an event that times out"
     setup do
       Qs.publish('qs-app', 'timeout')
-      @app_thread.join 1 # let the daemon have time to process the job
+      @app_thread.join(AppHandlers::Timeout::TIMEOUT_TIME + JOIN_SECONDS)
     end
 
     should "run the configured error handler procs" do
@@ -147,17 +179,22 @@ module Qs::Daemon
   class ShutdownWithoutTimeoutTests < SystemTests
     desc "without a shutdown timeout"
     setup do
-      AppDaemon.shutdown_timeout nil # disable shutdown timeout
+      @app_daemon_class.shutdown_timeout nil # disable shutdown timeout
+      @nil_shutdown_timeout = 10 # something absurdly long, it should be faster
+                                 # than this but want some timout to keep tests
+                                 # from hanging in case it never shuts down
+
       setup_app_and_dispatcher_daemon
 
       AppQueue.add('slow')
       Qs.publish('qs-app', 'slow')
-      @app_thread.join 1 # let the daemon have time to process the job and event
+      @app_thread.join(JOIN_SECONDS)
     end
 
     should "shutdown and let the job and event finish" do
       @app_daemon.stop
-      @app_thread.join 10 # give it time to shutdown, should be faster
+      @app_thread.join(@nil_shutdown_timeout)
+
       assert_false @app_thread.alive?
       assert_equal 'finished', Qs.redis.with{ |c| c.get('qs-app:slow') }
       assert_equal 'finished', Qs.redis.with{ |c| c.get('qs-app:slow:event') }
@@ -165,12 +202,15 @@ module Qs::Daemon
 
     should "shutdown and not let the job or event finish" do
       @app_daemon.halt
-      @app_thread.join 2 # give it time to shutdown, should be faster
+      @app_thread.join(@nil_shutdown_timeout)
+
       assert_false @app_thread.alive?
       assert_nil Qs.redis.with{ |c| c.get('qs-app:slow') }
+
       exp = "Qs::ShutdownError"
       assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
       assert_nil Qs.redis.with{ |c| c.get('qs-app:slow:event') }
+
       exp = "Qs::ShutdownError"
       assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
     end
@@ -180,34 +220,41 @@ module Qs::Daemon
   class ShutdownWithTimeoutTests < SystemTests
     desc "with a shutdown timeout"
     setup do
-      AppDaemon.shutdown_timeout 1
+      @shutdown_timeout = AppHandlers::Slow::SLOW_TIME * 0.5
+      @app_daemon_class.shutdown_timeout @shutdown_timeout
       setup_app_and_dispatcher_daemon
 
       AppQueue.add('slow')
       Qs.publish('qs-app', 'slow')
-      @app_thread.join 1 # let the daemon have time to process the job and event
+      @app_thread.join(JOIN_SECONDS)
     end
 
     should "shutdown and not let the job or event finish" do
       @app_daemon.stop
-      @app_thread.join 2 # give it time to shutdown, should be faster
+      @app_thread.join(@shutdown_timeout + JOIN_SECONDS)
+
       assert_false @app_thread.alive?
       assert_nil Qs.redis.with{ |c| c.get('qs-app:slow') }
+
       exp = "Qs::ShutdownError"
       assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
       assert_nil Qs.redis.with{ |c| c.get('qs-app:slow:event') }
+
       exp = "Qs::ShutdownError"
       assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
     end
 
     should "shutdown and not let the job or event finish" do
       @app_daemon.halt
-      @app_thread.join 2 # give it time to shutdown, should be faster
+      @app_thread.join(@shutdown_timeout + JOIN_SECONDS)
+
       assert_false @app_thread.alive?
       assert_nil Qs.redis.with{ |c| c.get('qs-app:slow') }
+
       exp = "Qs::ShutdownError"
       assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_job_error') }
       assert_nil Qs.redis.with{ |c| c.get('qs-app:slow:event') }
+
       exp = "Qs::ShutdownError"
       assert_equal exp, Qs.redis.with{ |c| c.get('qs-app:last_event_error') }
     end
@@ -217,34 +264,44 @@ module Qs::Daemon
   class ShutdownWithUnprocessedQueueItemTests < SystemTests
     desc "with a queue item that gets picked up but doesn't get processed"
     setup do
-      Assert.stub(Qs::PayloadHandler, :new){ sleep 5 }
+      Assert.stub(Qs::PayloadHandler, :new) do
+        sleep AppHandlers::Slow::SLOW_TIME + JOIN_SECONDS
+      end
 
-      AppDaemon.shutdown_timeout 1
-      AppDaemon.workers 2
+      @shutdown_timeout = AppHandlers::Slow::SLOW_TIME * 0.5
+      @app_daemon_class.shutdown_timeout @shutdown_timeout
+      @app_daemon_class.workers 2
       setup_app_and_dispatcher_daemon
 
-      AppQueue.add('slow')
-      AppQueue.add('slow')
-      AppQueue.add('basic')
-      @app_thread.join 1 # let the daemon have time to process jobs
+      AppQueue.add('slow1')
+      AppQueue.add('slow2')
+      AppQueue.add('basic1')
+
+      @app_thread.join(JOIN_SECONDS)
     end
 
     should "shutdown and requeue the queue item" do
       @app_daemon.stop
-      @app_thread.join 2 # give it time to shutdown, should be faster
+      @app_thread.join(@shutdown_timeout + JOIN_SECONDS)
+
       assert_false @app_thread.alive?
+
       encoded_payloads = Qs.redis.with{ |c| c.lrange(AppQueue.redis_key, 0, 3) }
       names = encoded_payloads.map{ |sp| Qs::Payload.deserialize(sp).name }
-      assert_equal ['basic', 'slow', 'slow'], names
+
+      ['slow1', 'slow2', 'basic1'].each{ |n| assert_includes n, names }
     end
 
     should "shutdown and requeue the queue item" do
       @app_daemon.halt
-      @app_thread.join 2 # give it time to shutdown, should be faster
+      @app_thread.join(@shutdown_timeout + JOIN_SECONDS)
+
       assert_false @app_thread.alive?
-      encoded_payloads = Qs.redis.with{ |c| c.lrange(AppQueue.redis_key, 0, 3) }
+
+      encoded_payloads = Qs.redis.with{ |c| c.lrange(AppQueue.redis_key, 0, 4) }
       names = encoded_payloads.map{ |sp| Qs::Payload.deserialize(sp).name }
-      assert_equal ['basic', 'slow', 'slow'], names
+
+      ['slow1', 'slow2', 'basic1'].each{ |n| assert_includes n, names }
     end
 
   end
@@ -254,7 +311,7 @@ module Qs::Daemon
     setup do
       ENV['QS_PROCESS_LABEL'] = Factory.string
 
-      @daemon = AppDaemon.new
+      @daemon = @app_daemon_class.new
     end
     teardown do
       ENV.delete('QS_PROCESS_LABEL')
@@ -267,7 +324,27 @@ module Qs::Daemon
 
   end
 
-  class DaemonRunner
+  class AppDispatcherDaemon
+    include Qs::Daemon
+
+    name 'qs-app-dispatcher'
+
+    logger Logger.new(ROOT_PATH.join('log/app_dispatcher_daemon.log').to_s)
+    logger.datetime_format = "" # turn off the datetime in the logs
+
+    verbose_logging true
+
+    # we build a "custom" dispatcher because we can't rely on Qs being initialized
+    # when this is required
+    queue Qs::DispatcherQueue.new({
+      :queue_class            => Qs.config.dispatcher_queue_class,
+      :queue_name             => 'qs-app-dispatcher',
+      :job_name               => Qs.config.dispatcher_job_name,
+      :job_handler_class_name => Qs.config.dispatcher_job_handler_class_name
+    })
+  end
+
+  class AppDaemonRunner
     def initialize(app_daemon, dispatcher_daemon = nil)
       @app_daemon = app_daemon
       @dispatcher_daemon = dispatcher_daemon
@@ -277,7 +354,11 @@ module Qs::Daemon
 
     def start
       @app_thread = @app_daemon.start
-      @dispatcher_thread = @dispatcher_daemon.start if @dispatcher_daemon
+      @app_thread.join(JOIN_SECONDS)
+      if @dispatcher_daemon
+        @dispatcher_thread = @dispatcher_daemon.start
+        @dispatcher_thread.join(JOIN_SECONDS)
+      end
       @app_thread
     end