qs 0.1.0 → 0.2.0

data/bench/config.qs

@@ -8,6 +8,7 @@ LOGGER = if ENV['BENCH_REPORT']
 else
   Logger.new(STDOUT)
 end
+LOGGER.datetime_format = "" # turn off the datetime in the logs
 
 PROGRESS_IO = if ENV['BENCH_PROGRESS_IO']
   ::IO.for_fd(ENV['BENCH_PROGRESS_IO'].to_i)

data/bench/report.txt

@@ -5,7 +5,7 @@ Adding jobs
 Running jobs
 ....................................................................................................
 
-Adding 10000 Jobs Time:   1.6041s
-Running 10000 Jobs Time: 12.3159s
+Adding 10000 Jobs Time:   1.6155s
+Running 10000 Jobs Time: 12.4848s
 
 Done running benchmark report

data/lib/qs/daemon.rb

@@ -6,6 +6,7 @@ require 'thread'
 require 'qs'
 require 'qs/client'
 require 'qs/daemon_data'
+require 'qs/io_pipe'
 require 'qs/logger'
 require 'qs/payload_handler'
 require 'qs/redis_item'
@@ -16,6 +17,8 @@ module Qs
 
     InvalidError = Class.new(ArgumentError)
 
+    SIGNAL = '.'.freeze
+
     def self.included(klass)
       klass.class_eval do
         extend ClassMethods
@@ -94,20 +97,21 @@ module Qs
       end
 
       def work_loop
-        self.logger.debug "Starting work loop..."
+        log "Starting work loop", :debug
         setup_redis_and_ios
         @worker_pool = build_worker_pool
         process_inputs while @signal.start?
-        self.logger.debug "Stopping work loop..."
-        shutdown_worker_pool
+        log "Stopping work loop", :debug
       rescue StandardError => exception
-        self.logger.error "Exception occurred, stopping daemon!"
-        self.logger.error "#{exception.class}: #{exception.message}"
-        self.logger.error exception.backtrace.join("\n")
+        @signal.set :stop
+        log "Error occurred while running the daemon, exiting", :error
+        log "#{exception.class}: #{exception.message}", :error
+        log exception.backtrace.join("\n"), :error
       ensure
+        shutdown_worker_pool
         @worker_available_io.teardown
         @work_loop_thread = nil
-        self.logger.debug "Stopped work loop"
+        log "Stopped work loop", :debug
       end
 
       def setup_redis_and_ios
@@ -122,9 +126,9 @@ module Qs
           self.daemon_data.max_workers
         ){ |redis_item| process(redis_item) }
         wp.on_worker_error do |worker, exception, redis_item|
-          handle_worker_exception(redis_item)
+          handle_worker_exception(exception, redis_item)
         end
-        wp.on_worker_sleep{ @worker_available_io.signal }
+        wp.on_worker_sleep{ @worker_available_io.write(SIGNAL) }
         wp.start
         wp
       end
@@ -134,27 +138,42 @@ module Qs
       #   shuffling we ensure they are randomly ordered so every queue should
       #   get a chance.
       # * Use 0 for the brpop timeout which means block indefinitely.
+      # * Rescue runtime errors so the daemon thread doesn't fail if redis is
+      #   temporarily down. Sleep for a second to keep the thread from thrashing
+      #   by repeatedly erroring if redis is down.
       def process_inputs
         wait_for_available_worker
         return unless @worker_pool.worker_available? && @signal.start?
 
-        args = [self.signals_redis_key, self.queue_redis_keys.shuffle, 0].flatten
-        redis_key, serialized_payload = @client.block_dequeue(*args)
-        if redis_key != @signals_redis_key
-          @worker_pool.add_work(RedisItem.new(redis_key, serialized_payload))
+        begin
+          args = [self.signals_redis_key, self.queue_redis_keys.shuffle, 0].flatten
+          redis_key, serialized_payload = @client.block_dequeue(*args)
+          if redis_key != @signals_redis_key
+            @worker_pool.add_work(RedisItem.new(redis_key, serialized_payload))
+          end
+        rescue RuntimeError => exception
+          log "Error dequeueing #{exception.message.inspect}", :error
+          log exception.backtrace.join("\n"), :error
+          sleep 1
         end
       end
 
       def wait_for_available_worker
         if !@worker_pool.worker_available? && @signal.start?
-          @worker_available_io.wait
+          @worker_available_io.wait.read
         end
       end
 
       def shutdown_worker_pool
-        self.logger.debug "Shutting down worker pool"
+        return unless @worker_pool
         timeout = @signal.stop? ? self.daemon_data.shutdown_timeout : 0
+        if timeout
+          log "Shutting down, waiting up to #{timeout} seconds for work to finish"
+        else
+          log "Shutting down, waiting for work to finish"
+        end
         @worker_pool.shutdown(timeout)
+        log "Requeueing #{@worker_pool.work_items.size} job(s)"
         @worker_pool.work_items.each do |ri|
           @client.prepend(ri.queue_redis_key, ri.serialized_payload)
         end
@@ -165,8 +184,8 @@ module Qs
       end
 
       def wakeup_work_loop_thread
-        @client.append(self.signals_redis_key, '.')
-        @worker_available_io.signal
+        @client.append(self.signals_redis_key, SIGNAL)
+        @worker_available_io.write(SIGNAL)
       end
 
       # * This only catches errors that happen outside of running the payload
@@ -177,11 +196,20 @@ module Qs
       # * If we never started processing the redis item, its safe to requeue it.
       #   Otherwise it happened while processing so the payload handler caught
       #   it or it happened after the payload handler which we don't care about.
-      def handle_worker_exception(redis_item)
+      def handle_worker_exception(exception, redis_item)
         return if redis_item.nil?
         if !redis_item.started
+          log "Worker error, requeueing job because it hasn't started", :error
           @client.prepend(redis_item.queue_redis_key, redis_item.serialized_payload)
+        else
+          log "Worker error after job was processed, ignoring", :error
         end
+        log "#{exception.class}: #{exception.message}", :error
+        log exception.backtrace.join("\n"), :error
+      end
+
+      def log(message, level = :info)
+        self.logger.send(level, "[Qs] #{message}")
       end
 
     end
@@ -290,38 +318,6 @@ module Qs
       end
     end
 
-    class IOPipe
-      NULL   = File.open('/dev/null', 'w')
-      SIGNAL = '.'.freeze
-
-      attr_reader :reader, :writer
-
-      def initialize
-        @reader = NULL
-        @writer = NULL
-      end
-
-      def wait
-        ::IO.select([@reader])
-        @reader.read_nonblock(SIGNAL.bytesize)
-      end
-
-      def signal
-        @writer.write_nonblock(SIGNAL)
-      end
-
-      def setup
-        @reader, @writer = ::IO.pipe
-      end
-
-      def teardown
-        @reader.close unless @reader === NULL
-        @writer.close unless @writer === NULL
-        @reader = NULL
-        @writer = NULL
-      end
-    end
-
     class Signal
       def initialize(value)
         @value = value

data/lib/qs/io_pipe.rb

@@ -0,0 +1,41 @@
+module Qs
+
+  class IOPipe
+
+    NULL = File.open('/dev/null', 'w')
+    NUMBER_OF_BYTES = 1
+
+    attr_reader :reader, :writer
+
+    def initialize
+      @reader = NULL
+      @writer = NULL
+    end
+
+    def setup
+      @reader, @writer = ::IO.pipe
+    end
+
+    def teardown
+      @reader.close unless @reader === NULL
+      @writer.close unless @writer === NULL
+      @reader = NULL
+      @writer = NULL
+    end
+
+    def read
+      @reader.read_nonblock(NUMBER_OF_BYTES)
+    end
+
+    def write(value)
+      @writer.write_nonblock(value[0, NUMBER_OF_BYTES])
+    end
+
+    def wait
+      ::IO.select([@reader])
+      self
+    end
+
+  end
+
+end

data/lib/qs/process.rb

@@ -1,73 +1,107 @@
+require 'qs/io_pipe'
 require 'qs/pid_file'
 
 module Qs
 
   class Process
 
-    attr_reader :daemon, :name, :pid_file, :restart_cmd
+    HALT    = 'H'.freeze
+    STOP    = 'S'.freeze
+    RESTART = 'R'.freeze
+
+    attr_reader :daemon, :name
+    attr_reader :pid_file, :signal_io, :restart_cmd
 
     def initialize(daemon, options = nil)
       options ||= {}
       @daemon = daemon
+      process_label = ignore_if_blank(ENV['QS_PROCESS_LABEL']) || @daemon.name
+      @name   = "qs: #{process_label}"
       @logger = @daemon.logger
-      @pid_file = PIDFile.new(@daemon.pid_file)
-      @restart_cmd = RestartCmd.new
 
-      @name = ignore_if_blank(ENV['QS_PROCESS_NAME']) || "qs-#{@daemon.name}"
+      @pid_file    = PIDFile.new(@daemon.pid_file)
+      @signal_io   = IOPipe.new
+      @restart_cmd = RestartCmd.new
 
-      @daemonize = !!options[:daemonize]
-      @skip_daemonize = !!ignore_if_blank(ENV['QS_SKIP_DAEMONIZE'])
-      @restart = false
+      skip_daemonize = ignore_if_blank(ENV['QS_SKIP_DAEMONIZE'])
+      @daemonize = !!options[:daemonize] && !skip_daemonize
     end
 
     def run
       ::Process.daemon(true) if self.daemonize?
-      log "Starting Qs daemon for #{@daemon.name}..."
+      log "Starting Qs daemon for #{@daemon.name}"
 
       $0 = @name
       @pid_file.write
       log "PID: #{@pid_file.pid}"
 
-      ::Signal.trap("TERM"){ @daemon.stop }
-      ::Signal.trap("INT"){ @daemon.halt }
-      ::Signal.trap("USR2") do
-        @daemon.stop
-        @restart = true
+      @signal_io.setup
+      trap_signals(@signal_io)
+
+      start_daemon(@daemon)
+
+      signal = catch(:signal) do
+        wait_for_signals(@signal_io, @daemon)
       end
+      @signal_io.teardown
 
-      thread = @daemon.start
-      log "#{@daemon.name} daemon started and ready."
-      thread.join
-      run_restart_cmd if self.restart?
-    rescue StandardError => exception
-      log "Error: #{exception.message}"
-      log "#{@daemon.name} daemon never started."
+      run_restart_cmd(@daemon, @restart_cmd) if signal == RESTART
     ensure
       @pid_file.remove
     end
 
     def daemonize?
-      @daemonize && !@skip_daemonize
+      @daemonize
     end
 
-    def restart?
-      @restart
+    private
+
+    def start_daemon(daemon)
+      @daemon.start
+      log "#{@daemon.name} daemon started and ready."
+    rescue StandardError => exception
+      log "#{@daemon.name} daemon never started."
+      raise exception
     end
 
-    private
+    def trap_signals(signal_io)
+      trap_signal('INT'){  signal_io.write(HALT) }
+      trap_signal('TERM'){ signal_io.write(STOP) }
+      trap_signal('USR2'){ signal_io.write(RESTART) }
+    end
 
-    def log(message)
-      @logger.info "[Qs] #{message}"
+    def trap_signal(signal, &block)
+      ::Signal.trap(signal, &block)
+    rescue ArgumentError
+      log "'#{signal}' signal not supported"
+    end
+
+    def wait_for_signals(signal_io, daemon)
+      while signal_io.wait do
+        os_signal = signal_io.read
+        handle_signal(os_signal, daemon)
+      end
+    end
+
+    def handle_signal(signal, daemon)
+      log "Got '#{signal}' signal"
+      case signal
+      when HALT
+        daemon.halt(true)
+      when STOP, RESTART
+        daemon.stop(true)
+      end
+      throw :signal, signal
     end
 
-    def run_restart_cmd
-      log "Restarting #{@daemon.name} daemon..."
+    def run_restart_cmd(daemon, restart_cmd)
+      log "Restarting #{daemon.name} daemon"
       ENV['QS_SKIP_DAEMONIZE'] = 'yes'
-      @restart_cmd.run
+      restart_cmd.run
     end
 
-    def default_if_blank(value, default, &block)
-      ignore_if_blank(value, &block) || default
+    def log(message)
+      @logger.info "[Qs] #{message}"
     end
 
     def ignore_if_blank(value, &block)

data/lib/qs/version.rb

@@ -1,3 +1,3 @@
 module Qs
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/support/app_daemon.rb

@@ -1,5 +1,8 @@
 require 'qs'
 
+LOGGER = Logger.new(ROOT_PATH.join('log/app_daemon.log').to_s)
+LOGGER.datetime_format = "" # turn off the datetime in the logs
+
 AppQueue = Qs::Queue.new do
   name 'app_main'
 
@@ -16,7 +19,7 @@ class AppDaemon
 
   name 'app'
 
-  logger Logger.new(ROOT_PATH.join('log/app_daemon.log').to_s)
+  logger LOGGER
   verbose_logging true
 
   queue AppQueue

data/test/unit/daemon_tests.rb

@@ -286,6 +286,34 @@ module Qs::Daemon
 
   end
 
+  class RunningWithErrorWhileDequeuingTests < InitSetupTests
+    desc "running with an error while dequeueing"
+    setup do
+      @daemon = @daemon_class.new
+      @thread = @daemon.start
+
+      @block_dequeue_calls = 0
+      Assert.stub(@client_spy, :block_dequeue) do
+        @block_dequeue_calls += 1
+        raise RuntimeError
+      end
+      # cause the daemon to loop, its sleeping on the original block_dequeue
+      # call that happened before the stub
+      @client_spy.append(@queue.redis_key, Factory.string)
+      @thread.join(0.1)
+    end
+    subject{ @daemon }
+
+    should "not cause the thread to exit" do
+      assert_true @thread.alive?
+      assert_equal 1, @block_dequeue_calls
+      @thread.join(1)
+      assert_true @thread.alive?
+      assert_equal 2, @block_dequeue_calls
+    end
+
+  end
+
   class RunningWithMultipleQueuesTests < InitSetupTests
     desc "running with multiple queues"
     setup do
@@ -460,6 +488,40 @@ module Qs::Daemon
 
   end
 
+  class WorkLoopErrorTests < StartTests
+    desc "with a work loop error"
+    setup do
+      # cause a non-dequeue error
+      Assert.stub(@worker_pool_spy, :worker_available?){ raise RuntimeError }
+
+      # cause the daemon to loop, its sleeping on the original block_dequeue
+      # call that happened before the stub
+      @redis_item = Qs::RedisItem.new(@queue.redis_key, Factory.string)
+      @client_spy.append(@redis_item.queue_redis_key, @redis_item.serialized_payload)
+    end
+
+    should "shutdown the worker pool" do
+      assert_true @worker_pool_spy.shutdown_called
+      assert_equal @daemon_class.shutdown_timeout, @worker_pool_spy.shutdown_timeout
+    end
+
+    should "requeue any work left on the pool" do
+      call = @client_spy.calls.last
+      assert_equal :prepend, call.command
+      assert_equal @redis_item.queue_redis_key,    call.args.first
+      assert_equal @redis_item.serialized_payload, call.args.last
+    end
+
+    should "stop the work loop thread" do
+      assert_false @thread.alive?
+    end
+
+    should "not be running" do
+      assert_false subject.running?
+    end
+
+  end
+
   class ConfigurationTests < UnitTests
     include NsOptions::AssertMacros
 
@@ -565,54 +627,6 @@ module Qs::Daemon
 
   end
 
-  class IOPipeTests < UnitTests
-    desc "IOPipe"
-    setup do
-      @io = IOPipe.new
-    end
-    subject{ @io }
-
-    should have_readers :reader, :writer
-    should have_imeths :wait, :signal
-    should have_imeths :setup, :teardown
-
-    should "default its reader and writer" do
-      assert_same IOPipe::NULL, subject.reader
-      assert_same IOPipe::NULL, subject.writer
-    end
-
-    should "be able to wait until signalled" do
-      subject.setup
-
-      thread = Thread.new{ subject.wait }
-      thread.join(0.1)
-      assert_equal 'sleep', thread.status
-
-      subject.signal
-      thread.join
-      assert_false thread.status
-    end
-
-    should "set its reader and writer to an IO pipe when setup" do
-      subject.setup
-      assert_instance_of ::IO, subject.reader
-      assert_instance_of ::IO, subject.writer
-    end
-
-    should "close its reader/writer and set them to defaults when torn down" do
-      subject.setup
-      reader = subject.reader
-      writer = subject.writer
-
-      subject.teardown
-      assert_true reader.closed?
-      assert_true writer.closed?
-      assert_same IOPipe::NULL, subject.reader
-      assert_same IOPipe::NULL, subject.writer
-    end
-
-  end
-
   class SignalTests < UnitTests
     desc "Signal"
     setup do

data/test/unit/io_pipe_tests.rb

@@ -0,0 +1,76 @@
+require 'assert'
+require 'qs/io_pipe'
+
+require 'thread'
+
+class Qs::IOPipe
+
+  class UnitTests < Assert::Context
+    desc "Qs::IOPipe"
+    setup do
+      @io_pipe = Qs::IOPipe.new
+    end
+    subject{ @io_pipe }
+
+    should have_readers :reader, :writer
+    should have_imeths :setup, :teardown
+    should have_imeths :read, :write, :wait
+
+    should "default its reader and writer" do
+      assert_same NULL, subject.reader
+      assert_same NULL, subject.writer
+    end
+
+    should "change its reader/writer to an IO pipe when setup" do
+      subject.setup
+      assert_not_same NULL, subject.reader
+      assert_not_same NULL, subject.writer
+      assert_instance_of IO, subject.reader
+      assert_instance_of IO, subject.writer
+    end
+
+    should "close its reader/writer and set them to defaults when torn down" do
+      subject.setup
+      reader = subject.reader
+      writer = subject.writer
+
+      subject.teardown
+      assert_true reader.closed?
+      assert_true writer.closed?
+      assert_same NULL, subject.reader
+      assert_same NULL, subject.writer
+    end
+
+    should "be able to read/write values" do
+      subject.setup
+
+      value = Factory.string(NUMBER_OF_BYTES)
+      subject.write(value)
+      assert_equal value, subject.read
+    end
+
+    should "only read/write a fixed number of bytes" do
+      subject.setup
+
+      value = Factory.string
+      subject.write(value)
+      assert_equal value[0, NUMBER_OF_BYTES], subject.read
+    end
+
+    should "be able to wait until there is something to read" do
+      subject.setup
+
+      result = nil
+      thread = Thread.new{ result = subject.wait }
+      thread.join(0.1)
+      assert_equal 'sleep', thread.status
+
+      subject.write(Factory.string)
+      thread.join
+      assert_false thread.status
+      assert_equal subject, result
+    end
+
+  end
+
+end

data/test/unit/process_tests.rb

@@ -18,9 +18,9 @@ class Qs::Process
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @current_env_process_name = ENV['QS_PROCESS_NAME']
+      @current_env_process_label  = ENV['QS_PROCESS_LABEL']
       @current_env_skip_daemonize = ENV['QS_SKIP_DAEMONIZE']
-      ENV.delete('QS_PROCESS_NAME')
+      ENV.delete('QS_PROCESS_LABEL')
       ENV.delete('QS_SKIP_DAEMONIZE')
 
       @daemon_spy = DaemonSpy.new
@@ -37,34 +37,36 @@ class Qs::Process
     end
     teardown do
       ENV['QS_SKIP_DAEMONIZE'] = @current_env_skip_daemonize
-      ENV['QS_PROCESS_NAME'] = @current_env_process_name
+      ENV['QS_PROCESS_LABEL']  = @current_env_process_label
     end
     subject{ @process }
 
-    should have_readers :daemon, :name, :pid_file, :restart_cmd
-    should have_imeths :run, :daemonize?, :restart?
+    should have_readers :daemon, :name
+    should have_readers :pid_file, :signal_io, :restart_cmd
+    should have_imeths :run, :daemonize?
 
     should "know its daemon" do
       assert_equal @daemon_spy, subject.daemon
     end
 
-    should "know its name, pid file and restart cmd" do
-      assert_equal "qs-#{@daemon_spy.name}", subject.name
+    should "know its name, pid file, signal io and restart cmd" do
+      assert_equal "qs: #{@daemon_spy.name}", subject.name
       assert_equal @pid_file_spy, subject.pid_file
+      assert_instance_of Qs::IOPipe, subject.signal_io
       assert_equal @restart_cmd_spy, subject.restart_cmd
     end
 
     should "set its name using env vars" do
-      ENV['QS_PROCESS_NAME'] = Factory.string
+      ENV['QS_PROCESS_LABEL'] = Factory.string
       process = @process_class.new(@daemon_spy)
-      assert_equal ENV['QS_PROCESS_NAME'], process.name
+      assert_equal "qs: #{ENV['QS_PROCESS_LABEL']}", process.name
     end
 
     should "ignore blank env values for its name" do
-      ENV['QS_PROCESS_NAME'] = ''
+      ENV['QS_PROCESS_LABEL'] = ''
       process = @process_class.new(@daemon_spy)
-      assert_equal "qs-#{@daemon_spy.name}", process.name
-    end
+      assert_equal "qs: #{@daemon_spy.name}", process.name
+     end
 
     should "not daemonize by default" do
       process = @process_class.new(@daemon_spy)
@@ -90,10 +92,6 @@ class Qs::Process
       assert_true process.daemonize?
     end
 
-    should "not restart by default" do
-      assert_false subject.restart?
-    end
-
   end
 
   class RunSetupTests < InitTests
@@ -103,28 +101,14 @@ class Qs::Process
 
       @current_process_name = $0
 
-      @term_signal_trap_block = nil
-      @term_signal_trap_called = false
-      Assert.stub(::Signal, :trap).with("TERM") do |&block|
-        @term_signal_trap_block = block
-        @term_signal_trap_called = true
-      end
-
-      @int_signal_trap_block = nil
-      @int_signal_trap_called = false
-      Assert.stub(::Signal, :trap).with("INT") do |&block|
-        @int_signal_trap_block = block
-        @int_signal_trap_called = true
-      end
-
-      @usr2_signal_trap_block = nil
-      @usr2_signal_trap_called = false
-      Assert.stub(::Signal, :trap).with("USR2") do |&block|
-        @usr2_signal_trap_block = block
-        @usr2_signal_trap_called = true
+      @signal_traps = []
+      Assert.stub(::Signal, :trap) do |signal, &block|
+        @signal_traps << SignalTrap.new(signal, block)
       end
     end
     teardown do
+      @process.signal_io.write(HALT)
+      @thread.join if @thread
       $0 = @current_process_name
     end
 
@@ -133,87 +117,168 @@ class Qs::Process
   class RunTests < RunSetupTests
     desc "and run"
     setup do
-      @process.run
+      @thread = Thread.new{ @process.run }
+      @thread.join(0.1)
     end
 
-    should "not have daemonized the process" do
+    should "not daemonize the process" do
       assert_false @daemonize_called
     end
 
-    should "have set the process name" do
+    should "set the process name" do
       assert_equal $0, subject.name
     end
 
-    should "have written the PID file" do
+    should "write its PID file" do
       assert_true @pid_file_spy.write_called
     end
 
-    should "have trapped signals" do
-      assert_true @term_signal_trap_called
-      assert_false @daemon_spy.stop_called
-      @term_signal_trap_block.call
-      assert_true @daemon_spy.stop_called
-
-      assert_true @int_signal_trap_called
-      assert_false @daemon_spy.halt_called
-      @int_signal_trap_block.call
-      assert_true @daemon_spy.halt_called
-
-      @daemon_spy.stop_called = false
-
-      assert_true @usr2_signal_trap_called
-      assert_false subject.restart?
-      @usr2_signal_trap_block.call
-      assert_true @daemon_spy.stop_called
-      assert_true subject.restart?
+    should "trap signals" do
+      assert_equal 3, @signal_traps.size
+      assert_equal ['INT', 'TERM', 'USR2'], @signal_traps.map(&:signal)
     end
 
-    should "have started the daemon" do
+    should "start the daemon" do
       assert_true @daemon_spy.start_called
     end
 
-    should "have joined the daemon thread" do
-      assert_true @daemon_spy.thread.join_called
+    should "sleep its thread waiting for signals" do
+      assert_equal 'sleep', @thread.status
     end
 
     should "not run the restart cmd" do
       assert_false @restart_cmd_spy.run_called
     end
 
-    should "have removed the PID file" do
-      assert_true @pid_file_spy.remove_called
+  end
+
+  class SignalTrapsTests < RunSetupTests
+    desc "signal traps"
+    setup do
+      # setup the io pipe so we can see whats written to it
+      @process.signal_io.setup
+    end
+    teardown do
+      @process.signal_io.teardown
+    end
+
+    should "write the signals to processes signal IO" do
+      @signal_traps.each do |signal_trap|
+        signal_trap.block.call
+        assert_equal signal_trap.signal, subject.signal_io.read
+      end
     end
 
   end
 
   class RunWithDaemonizeTests < RunSetupTests
-    desc "that should daemonize is run"
+    desc "and run when it should daemonize"
     setup do
       Assert.stub(@process, :daemonize?){ true }
-      @process.run
+      @thread = Thread.new{ @process.run }
+      @thread.join(0.1)
     end
 
-    should "have daemonized the process" do
+    should "daemonize the process" do
       assert_true @daemonize_called
     end
 
   end
 
-  class RunAndDaemonPausedTests < RunSetupTests
-    desc "then run and sent a restart signal"
+  class RunAndHaltTests < RunSetupTests
+    desc "and run with a halt signal"
+    setup do
+      @thread = Thread.new{ @process.run }
+      @process.signal_io.write(HALT)
+      @thread.join(0.1)
+    end
+
+    should "halt its daemon" do
+      assert_true @daemon_spy.halt_called
+      assert_equal [true], @daemon_spy.halt_args
+    end
+
+    should "not set the env var to skip daemonize" do
+      assert_equal @current_env_skip_daemonize, ENV['QS_SKIP_DAEMONIZE']
+    end
+
+    should "not run the restart cmd" do
+      assert_false @restart_cmd_spy.run_called
+    end
+
+    should "remove the PID file" do
+      assert_true @pid_file_spy.remove_called
+    end
+
+  end
+
+  class RunAndStopTests < RunSetupTests
+    desc "and run with a stop signal"
+    setup do
+      @thread = Thread.new{ @process.run }
+      @process.signal_io.write(STOP)
+      @thread.join(0.1)
+    end
+
+    should "stop its daemon" do
+      assert_true @daemon_spy.stop_called
+      assert_equal [true], @daemon_spy.stop_args
+    end
+
+    should "not set the env var to skip daemonize" do
+      assert_equal @current_env_skip_daemonize, ENV['QS_SKIP_DAEMONIZE']
+    end
+
+    should "not run the restart cmd" do
+      assert_false @restart_cmd_spy.run_called
+    end
+
+    should "remove the PID file" do
+      assert_true @pid_file_spy.remove_called
+    end
+
+  end
+
+  class RunAndRestartTests < RunSetupTests
+    desc "and run with a restart signal"
     setup do
-      # mimicing pause being called by a signal, after the thread is joined
-      @daemon_spy.thread.on_join{ @usr2_signal_trap_block.call }
-      @process.run
+      @thread = Thread.new{ @process.run }
+      @process.signal_io.write(RESTART)
+      @thread.join(0.1)
+    end
+
+    should "stop its daemon" do
+      assert_true @daemon_spy.stop_called
+      assert_equal [true], @daemon_spy.stop_args
     end
 
-    should "set env vars for restarting and run the restart cmd" do
+    should "set the env var to skip daemonize" do
       assert_equal 'yes', ENV['QS_SKIP_DAEMONIZE']
+    end
+
+    should "run the restart cmd" do
       assert_true @restart_cmd_spy.run_called
     end
 
   end
 
+  class RunWithInvalidSignalTests < RunSetupTests
+    desc "and run with unsupported signals"
+    setup do
+      # ruby throws an argument error if the OS doesn't support a signal
+      Assert.stub(::Signal, :trap){ raise ArgumentError }
+
+      @thread = Thread.new{ @process.run }
+      @thread.join(0.1)
+    end
+
+    should "start normally" do
+      assert_true @daemon_spy.start_called
+      assert_equal 'sleep', @thread.status
+    end
+
+  end
+
   class RestartCmdTests < UnitTests
     desc "RestartCmd"
     setup do
@@ -262,7 +327,7 @@ class Qs::Process
   end
 
   class RestartCmdWithPWDEnvNoMatchTests < RestartCmdTests
-    desc "when init with a PWD env variable that doesn't point to ruby working dir"
+    desc "when init with a PWD env variable that's not the ruby working dir"
     setup do
       @restart_cmd = @cmd_class.new
     end
@@ -274,7 +339,7 @@ class Qs::Process
   end
 
   class RestartCmdWithPWDEnvInitTests < RestartCmdTests
-    desc "when init with a PWD env variable that points to the ruby working dir"
+    desc "when init with a PWD env variable that's the ruby working dir"
     setup do
       # make ENV['PWD'] point to the same file as Dir.pwd
       Assert.stub(File, :stat).with(ENV['PWD']){ @ruby_pwd_stat }
@@ -300,6 +365,8 @@ class Qs::Process
 
   end
 
+  SignalTrap = Struct.new(:signal, :block)
+
   class DaemonSpy
     include Qs::Daemon
 
@@ -309,53 +376,34 @@ class Qs::Process
     queue Qs::Queue.new{ name Factory.string }
 
     attr_accessor :start_called, :stop_called, :halt_called
-    attr_reader :start_args
-    attr_reader :thread
+    attr_reader :start_args, :stop_args, :halt_args
 
     def initialize(*args)
       super
+      @start_args   = nil
       @start_called = false
-      @stop_called = false
-      @halt_called = false
-
-      @start_args = nil
-
-      @thread = ThreadSpy.new
+      @stop_args    = nil
+      @stop_called  = false
+      @halt_args    = nil
+      @halt_called  = false
     end
 
     def start(*args)
-      @start_args = args
+      @start_args   = args
       @start_called = true
-      @thread
     end
 
     def stop(*args)
+      @stop_args   = args
       @stop_called = true
     end
 
     def halt(*args)
+      @halt_args   = args
       @halt_called = true
     end
   end
 
-  class ThreadSpy
-    attr_reader :join_called, :on_join_proc
-
-    def initialize
-      @join_called = false
-      @on_join_proc = proc{ }
-    end
-
-    def on_join(&block)
-      @on_join_proc = block
-    end
-
-    def join
-      @join_called = true
-      @on_join_proc.call
-    end
-  end
-
   class RestartCmdSpy
     attr_reader :run_called
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: qs
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-04-24 00:00:00 Z
+date: 2015-05-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -136,6 +136,7 @@ files:
 - lib/qs/daemon.rb
 - lib/qs/daemon_data.rb
 - lib/qs/error_handler.rb
+- lib/qs/io_pipe.rb
 - lib/qs/job.rb
 - lib/qs/job_handler.rb
 - lib/qs/logger.rb
@@ -171,6 +172,7 @@ files:
 - test/unit/daemon_data_tests.rb
 - test/unit/daemon_tests.rb
 - test/unit/error_handler_tests.rb
+- test/unit/io_pipe_tests.rb
 - test/unit/job_handler_tests.rb
 - test/unit/job_tests.rb
 - test/unit/logger_tests.rb
@@ -239,6 +241,7 @@ test_files:
 - test/unit/daemon_data_tests.rb
 - test/unit/daemon_tests.rb
 - test/unit/error_handler_tests.rb
+- test/unit/io_pipe_tests.rb
 - test/unit/job_handler_tests.rb
 - test/unit/job_tests.rb
 - test/unit/logger_tests.rb