resqued 0.0.1 → 0.4.0

data/README.md

@@ -1,9 +1,6 @@
 # resqued - a long-running daemon for resque workers.
 
-[image of a ninja rescuing an ear of corn]
-
-resqued provides a resque worker that works well with
-slow jobs and continuous delivery.
+Resqued is a multi-process daemon that controls and monitors a pool of resque workers. It works well with slow jobs and continuous delivery.
 
 ## Installation
 
@@ -11,7 +8,15 @@ Install by adding resqued to your Gemfile
 
     gem 'resqued'
 
-## Set up
+Run resqued with a config file, like this:
+
+    resqued config/resqued.rb
+
+Or like this to daemonize it:
+
+    resqued -p tmp/pids/resqued-master.pid -D config/resqued.rb
+
+## Configuring workers
 
 Let's say you were running workers like this:
 
@@ -24,43 +29,97 @@ Let's say you were running workers like this:
 To run the same fleet of workers with resqued, create a config file
 `config/resqued.rb` like this:
 
-    base = File.expand_path('..', File.dirname(__FILE__))
-    pidfile File.join(base, 'tmp/pids/resqued-listener.pid')
+    2.times { worker 'high' }
+    worker 'slow'
+    worker 'medium'
+    worker 'medium', 'low'
 
-    worker do
-      workers 2
-      queue 'high'
-    end
+Another syntax for workers:
+
+    worker_pool 5
+    queue 'low', '20%'
+    queue 'normal', '60%'
+    queue '*'
+
+This time, you'd end up with something similar to this:
+
+    rake resque:work QUEUE=low,normal,* &
+    rake resque:work QUEUE=normal,*     &
+    rake resque:work QUEUE=normal,*     &
+    rake resque:work QUEUE=*            &
+    rake resque:work QUEUE=*            &
+
+`worker` and `worker_pool` accept a hash of options that will be passed to `Resqued::Worker`. The supported options are:
+
+* `:interval` - The interval to pass to `Resque::Worker#run`.
 
-    worker do
-      queue 'slow'
-      timeout -1 # never time out
+## Loading your application
+
+An advantage of using resqued (over `rake resque:work`) is that you can load your application just once, before forking all the workers.
+
+For a Rails application, you might do this:
+
+    before_fork do
+      require "./config/environment.rb"
+      Rails.application.eager_load!
+      # `before_fork` runs in the Listener, and it doesn't actually run any application code.
+      ActiveRecord::Base.connection.disconnect!
     end
 
-    worker do
-      queue 'medium'
+    after_fork do |resque_worker|
+      # Set up a new connection to the database.
+      ActiveRecord::Base.establish_connection
+      # `resque_worker.reconnect` already happens
     end
 
-    worker do
-      queues 'medium', 'low'
+## Customizing Resque::Worker
+
+You can configure the Resque worker in the `after_fork` block
+
+    after_fork do |resque_worker|
+      # Do not fork to `perform` jobs.
+      resque_worker.cant_fork = true
+
+      # Wait a loooong time on SIGTERM.
+      resque_worker.term_timeout = 1.day
+
+      resque_worker.run_at_exit_hooks = true
+
+      Resque.before_first_fork do
+        # ...
+      end
     end
 
-Run it like this:
+## Full config file example
 
-    resqued config/resqued.rb
+    worker 'high'
+    worker 'low', :interval => 30
 
-Or like this to daemonize it:
+    worker_pool 5, :interval => 1
+    queue 'low', '20%'
+    queue 'normal', 4
+    queue '*'
 
-    resqued -p tmp/pids/resqued-master.pid -D config/resqued.rb
+    before_fork do
+      require "./config/environment.rb"
+      Rails.application.eager_load!
+      ActiveRecord::Base.connection.disconnect!
+    end
 
-When resqued is running, it has the following processes:
+    after_fork do |worker|
+      ActiveRecord::Base.establish_connection
+      worker.term_timeout = 1.minute
+    end
 
-* master - brokers signals to child processes.
-* queue reader - retrieves jobs from queues and forks worker processes.
-* worker - runs a single job.
+In this example, a Rails application is being set up with 7 workers:
+* high
+* low (interval = 30)
+* low, normal, * (interval = 1)
+* normal, * (interval = 1)
+* normal, * (interval = 1)
+* normal, * (interval = 1)
+* * (interval = 1)
 
-The following signals are handled by the resqued master process:
+## See also
 
-* HUP - reread config file and gracefully restart all workers.
-* INT / TERM - immediately kill all workers and shut down.
-* QUIT - graceful shutdown. Waits for workers to finish.
+For information about how resqued works, see the [documentation](docs/).

data/lib/resqued/backoff.rb

@@ -4,16 +4,20 @@ module Resqued
       @time = options.fetch(:time) { Time }
       @min  = options.fetch(:min) { 1.0 }
       @max  = options.fetch(:max) { 16.0 }
+      @backoff_duration = @min
     end
 
     # Public: Tell backoff that the thing we might want to back off from just started.
     def started
       @last_started_at = now
-      @backoff_duration = @backoff_duration ? [@backoff_duration * 2.0, @max].min : @min
+      @backoff_duration = @min if @last_event == :start
+      @last_event = :start
     end
 
-    def finished
-      @backoff_duration = nil if ok?
+    # Public: Tell backoff that the thing unexpectedly died.
+    def died
+      @backoff_duration = @backoff_duration ? [@backoff_duration * 2.0, @max].min : @min
+      @last_event = :died
     end
 
     # Public: Check if we should wait before starting again.
@@ -21,14 +25,9 @@ module Resqued
       @last_started_at && next_start_at > now
     end
 
-    # Public: Check if we are ok to start (i.e. we don't need to back off).
-    def ok?
-      ! wait?
-    end
-
-    # Public: How much longer until `ok?` will be true?
+    # Public: How much longer until `wait?` will be false?
     def how_long?
-      ok? ? nil : next_start_at - now
+      wait? ? next_start_at - now : nil
     end
 
     private

data/lib/resqued/config.rb

@@ -1,87 +1,36 @@
-module Resqued
-  class Config
-    # Public: Build a new config instance from the given file.
-    def self.load_file(filename)
-      new.load_file(filename)
-    end
-
-    # Public: Build a new config instance from the given `config` script.
-    def self.load_string(config, filename = nil)
-      new.load_string(config, filename)
-    end
-
-    # Public: Build a new config instance.
-    def initialize
-      @workers = []
-    end
-
-    # Public: The configured pidfile path, or nil.
-    attr_reader :pidfile
-    
-    # Public: An array of configured workers.
-    attr_reader :workers
-
-    # Public: Add to this config using the script `config`.
-    def load_string(config, filename = nil)
-      DSL.new(self)._apply(config, filename)
-      self
-    end
+require 'resqued/config/after_fork'
+require 'resqued/config/before_fork'
+require 'resqued/config/worker'
 
-    # Public: Add to this config using the script in the given file.
-    def load_file(filename)
-      load_string(File.read(filename), filename)
+module Resqued
+  module Config
+    # Public: Build a new ConfigFile instance.
+    #
+    # Resqued::Config is a module because the evaluators say so, so this `new` is a factory for another class.
+    def self.new(*args)
+      ConfigFile.new(*args)
     end
 
-    # Private.
-    class DSL
-      def initialize(config)
-        @config = config
-      end
-
-      # Internal.
-      def _apply(script, filename)
-        if filename.nil?
-          instance_eval(script)
-        else
-          instance_eval(script, filename)
-        end
-      end
-
-      # Public: Set the pidfile path.
-      def pidfile(path)
-        raise ArgumentError unless path.is_a?(String)
-        _set(:pidfile, path)
-      end
-
-      # Public: Define a worker.
-      def worker
-        @current_worker = {:size => 1, :queues => []}
-        yield
-        _push(:workers, @current_worker)
-        @current_worker = nil
-      end
-
-      # Public: Add queues to a worker
-      def queues(*queues)
-        queues = [queues].flatten.map { |q| q.to_s }
-        @current_worker[:queues] += queues
+    # Does the things that the config file says to do.
+    class ConfigFile
+      def initialize(config_path)
+        @path = config_path
+        @contents = File.read(@path)
       end
-      alias queue queues
 
-      # Public: Set the number of workers
-      def workers(count)
-        raise ArgumentError unless count.is_a?(Fixnum)
-        @current_worker[:size] = count
+      # Public: Performs the `before_fork` action from the config.
+      def before_fork
+        Resqued::Config::BeforeFork.new.apply(@contents, @path)
       end
 
-      # Private.
-      def _set(instance_variable, value)
-        @config.instance_variable_set("@#{instance_variable}", value)
+      # Public: Performs the `after_fork` action from the config.
+      def after_fork(worker)
+        Resqued::Config::AfterFork.new(:worker => worker).apply(@contents, @path)
       end
 
-      # Private.
-      def _push(instance_variable, value)
-        @config.instance_variable_get("@#{instance_variable}").push(value)
+      # Public: Builds the workers specified in the config.
+      def build_workers
+        Resqued::Config::Worker.new(:config => self).apply(@contents, @path)
       end
     end
   end

data/lib/resqued/config/after_fork.rb

@@ -0,0 +1,22 @@
+require 'resqued/config/base'
+
+module Resqued
+  module Config
+    # A config handler that executes the `after_fork` block.
+    #
+    #     after_fork do |resque_worker|
+    #       # Runs in each worker.
+    #     end
+    class AfterFork < Base
+      # Public.
+      def initialize(options = {})
+        @resque_worker = options.fetch(:worker)
+      end
+
+      # DSL: execute the `after_fork` block.
+      def after_fork
+        yield @resque_worker
+      end
+    end
+  end
+end

data/lib/resqued/config/base.rb

@@ -0,0 +1,25 @@
+require 'resqued/config/dsl'
+
+module Resqued
+  module Config
+    # Base class for config handlers.
+    class Base
+      # Implement the DSL on the config handler itself.
+      include Dsl
+
+      # Public: Apply the configuration in `str`.
+      #
+      # Currently, this is a simple wrapper around `instance_eval`.
+      def apply(str, filename = "INLINE")
+        instance_eval(str, filename)
+        results
+      end
+
+      private
+
+      # Private: The results of applying the config.
+      def results
+      end
+    end
+  end
+end

data/lib/resqued/config/before_fork.rb

@@ -0,0 +1,17 @@
+require 'resqued/config/base'
+
+module Resqued
+  module Config
+    # A config handler that executes the `before_fork` block.
+    #
+    #     before_fork do
+    #       # Runs once, before forking all the workers.
+    #     end
+    class BeforeFork < Base
+      # DSL: Execute the `before_fork` block.
+      def before_fork
+        yield
+      end
+    end
+  end
+end

data/lib/resqued/config/dsl.rb

@@ -0,0 +1,28 @@
+module Resqued
+  module Config
+    # Defines the DSL for resqued config files.
+    #
+    # Each subclass should override parts of the dsl that it cares about.
+    module Dsl
+      # Public: Define a block to be run once, before forking all the workers.
+      def before_fork(&block)
+      end
+
+      # Public: Define a block to be run in each worker.
+      def after_fork(&block)
+      end
+
+      # Public: Define a worker that will work on a queue.
+      def worker(*queues)
+      end
+
+      # Public: Define a pool of workers that will work '*', or the queues specified by `queue`.
+      def worker_pool(count, options = {})
+      end
+
+      # Public: Define the queues worked by members of the worker pool.
+      def queue(queue_name, concurrency = nil)
+      end
+    end
+  end
+end

data/lib/resqued/config/worker.rb

@@ -0,0 +1,111 @@
+require 'resqued/config/base'
+
+module Resqued
+  module Config
+    # A config handler that builds workers.
+    #
+    # No worker processes are spawned by this class.
+    class Worker < Base
+      # Public.
+      def initialize(options = {})
+        options = options.dup
+        @worker_class = options.delete(:worker_class) || Resqued::Worker
+        @worker_options = options
+        @workers = []
+      end
+
+      # DSL: Create a worker for the exact queues listed.
+      #
+      #     worker 'one', :interval => 1
+      def worker(*queues)
+        options = queues.last.is_a?(Hash) ? queues.pop : {}
+        queues = ['*'] if queues.empty?
+        @workers << @worker_class.new(options.merge(@worker_options).merge(:queues => queues.flatten))
+      end
+
+      # DSL: Set up a pool of workers. Define queues for the members of the pool with `queue`.
+      #
+      #     worker_pool 20, :interval => 1
+      def worker_pool(count, options = {})
+        @pool_size = count
+        @pool_options = options
+        @pool_queues = {}
+      end
+
+      # DSL: Define a queue for the worker_pool to work from.
+      #
+      #     queue 'one'
+      #     queue '*'
+      #     queue 'two', '10%'
+      #     queue 'three', 5
+      #     queue 'four', :percent => 10
+      #     queue 'five', :count => 5
+      def queue(queue_name, concurrency = nil)
+        @pool_queues[queue_name] =
+          case concurrency
+          when Hash
+            if percent = concurrency[:percent]
+              percent * 0.01
+            elsif count = concurrency[:count]
+              count
+            else
+              1.0
+            end
+          when nil, '';    1.0
+          when /%$/;       concurrency.chomp('%').to_i * 0.01
+          else             concurrency.to_i
+          end
+      end
+
+      private
+
+      def results
+        build_pool_workers!
+        @workers
+      end
+
+      # Internal: Build the pool workers.
+      #
+      # Build an array of Worker objects with queue lists configured based
+      # on the concurrency values established and the total number of workers.
+      def build_pool_workers!
+        return unless @pool_size
+        queues = _fixed_concurrency_queues
+        1.upto(@pool_size) do |worker_num|
+          queue_names = queues.
+            select { |name, concurrency| concurrency >= worker_num }.
+            map { |name, _| name }
+          if queue_names.any?
+            worker(queue_names, @pool_options)
+          else
+            worker('*', @pool_options)
+          end
+        end
+      end
+
+      # Internal: Like @queues but with concrete fixed concurrency values. All
+      # percentage based concurrency values are converted to fixnum total number
+      # of workers that queue should run on.
+      def _fixed_concurrency_queues
+        @pool_queues.map { |name, concurrency| [name, _translate_concurrency_value(concurrency)] }
+      end
+
+      # Internal: Convert a queue worker concurrency value to a fixed number of
+      # workers. This supports values that are fixed numbers as well as percentage
+      # values (between 0.0 and 1.0). The value may also be nil, in which case the
+      # maximum worker_processes value is returned.
+      def _translate_concurrency_value(value)
+        case
+        when value.nil?
+          @pool_size
+        when value.is_a?(Fixnum)
+          value < @pool_size ? value : @pool_size
+        when value.is_a?(Float) && value >= 0.0 && value <= 1.0
+          (@pool_size * value).to_i
+        else
+          raise TypeError, "Unknown concurrency value: #{value.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/resqued/daemon.rb

@@ -23,6 +23,7 @@ module Resqued
         exit
       else
         # master
+        rd.close
         @master.run(wr)
       end
     end

data/lib/resqued/listener.rb

@@ -2,7 +2,6 @@ require 'socket'
 
 require 'resqued/config'
 require 'resqued/logging'
-require 'resqued/pidfile'
 require 'resqued/sleepy'
 require 'resqued/worker'
 
@@ -10,10 +9,11 @@ module Resqued
   # A listener process. Watches resque queues and forks workers.
   class Listener
     include Resqued::Logging
-    include Resqued::Pidfile
     include Resqued::Sleepy
 
     # Configure a new listener object.
+    #
+    # Runs in the master process.
     def initialize(options)
       @config_path     = options.fetch(:config_path)
       @running_workers = options.fetch(:running_workers) { [] }
@@ -22,6 +22,8 @@ module Resqued
     end
 
     # Public: As an alternative to #run, exec a new ruby instance for this listener.
+    #
+    # Runs in the master process.
     def exec
       ENV['RESQUED_SOCKET']      = @socket.fileno.to_s
       ENV['RESQUED_CONFIG_PATH'] = @config_path
@@ -48,12 +50,7 @@ module Resqued
       new(options).run
     end
 
-    # Private: memoizes the worker configuration.
-    def config
-      @config ||= Config.load_file(@config_path)
-    end
-
-    SIGNALS = [ :QUIT ]
+    SIGNALS = [ :QUIT, :INT, :TERM ]
 
     SIGNAL_QUEUE = []
 
@@ -63,15 +60,15 @@ module Resqued
       SIGNALS.each { |signal| trap(signal) { SIGNAL_QUEUE << signal ; awake } }
       @socket.close_on_exec = true
 
-      with_pidfile(config.pidfile) do
-        write_procline('running')
-        load_environment
-        init_workers
-        run_workers_run
-      end
+      config = Resqued::Config.new(@config_path)
+      config.before_fork
+
+      write_procline('running')
+      init_workers(config)
+      exit_signal = run_workers_run
 
       write_procline('shutdown')
-      burn_down_workers(:QUIT)
+      burn_down_workers(exit_signal || :QUIT)
     end
 
     # Private.
@@ -83,8 +80,8 @@ module Resqued
         case signal = SIGNAL_QUEUE.shift
         when nil
           yawn
-        when :QUIT
-          return
+        when :QUIT, :INT, :TERM
+          return signal
         end
       end
     end
@@ -98,9 +95,7 @@ module Resqued
         SIGNAL_QUEUE.clear
 
         break if :no_child == reap_workers(Process::WNOHANG)
-
-        log "kill -#{signal} #{running_workers.map { |r| r.pid }.inspect}"
-        running_workers.each { |worker| worker.kill(signal) }
+        kill_all(signal)
 
         sleep 1 # Don't kill any more often than every 1s.
         yawn 5
@@ -109,6 +104,12 @@ module Resqued
       reap_workers
     end
 
+    # Private: send a signal to all the workers.
+    def kill_all(signal)
+      log "kill -#{signal} #{running_workers.map { |r| r.pid }.inspect}"
+      running_workers.each { |worker| worker.kill(signal) }
+    end
+
     # Private: all available workers
     attr_reader :workers
 
@@ -174,19 +175,13 @@ module Resqued
     end
 
     # Private.
-    def init_workers
-      workers = []
-      config.workers.each do |worker_config|
-        worker_config[:size].times do
-          workers << Worker.new(worker_config)
-        end
-      end
+    def init_workers(config)
+      @workers = config.build_workers
       @running_workers.each do |running_worker|
-        if blocked_worker = workers.detect { |worker| worker.idle? && worker.queue_key == running_worker[:queue] }
+        if blocked_worker = @workers.detect { |worker| worker.idle? && worker.queue_key == running_worker[:queue] }
           blocked_worker.wait_for(running_worker[:pid].to_i)
         end
       end
-      @workers = workers
     end
 
     # Private: Report child process status.
@@ -197,16 +192,8 @@ module Resqued
     #     report_to_master("-12345")        # Worker process PID:12345 exited.
     def report_to_master(status)
       @socket.puts(status)
-    end
-
-    # Private: load the application.
-    #
-    # To do:
-    # * Does this reload correctly if the bundle changes and `bundle exec resqued config/resqued.rb`?
-    # * Maybe make the specific app environment configurable (i.e. load rails, load rackup, load some custom thing)
-    def load_environment
-      require File.expand_path('config/environment.rb')
-      Rails.application.eager_load!
+    rescue Errno::EPIPE
+      Process.kill(:QUIT, $$) # If the master is gone, LIFE IS NOW MEANINGLESS.
     end
 
     # Private.

data/lib/resqued/listener_proxy.rb

@@ -5,6 +5,7 @@ require 'resqued/listener'
 require 'resqued/logging'
 
 module Resqued
+  # Controls a listener process from the master process.
   class ListenerProxy
     include Resqued::Logging
 
@@ -42,7 +43,7 @@ module Resqued
       else
         # listener
         master_socket.close
-        Master::SIGNALS.each { |signal| trap(signal, 'DEFAULT') }
+        Master::TRAPS.each { |signal| trap(signal, 'DEFAULT') rescue nil }
         Listener.new(@options.merge(:socket => listener_socket)).exec
         exit
       end
@@ -81,7 +82,7 @@ module Resqued
           log "Malformed data from listener: #{line.inspect}"
         end
       end
-    rescue EOFError
+    rescue EOFError, Errno::ECONNRESET
       @master_socket.close
       @master_socket = nil
     end

data/lib/resqued/logging.rb

@@ -1,13 +1,40 @@
 module Resqued
+  # Mixin for any class that wants to write messages to the log file.
   module Logging
-    # Public.
-    def self.log_file=(path)
-      ENV['RESQUED_LOGFILE'] = File.expand_path(path)
-    end
+    # Global logging state.
+    class << self
+      # Public: Get an IO to write log messages to.
+      def logging_io
+        @logging_io = nil if @logging_io && @logging_io.closed?
+        @logging_io ||=
+          if path = Resqued::Logging.log_file
+            File.open(path, 'a').tap do |f|
+              f.sync = true
+              f.close_on_exec = true
+            end
+          else
+            $stdout
+          end
+      end
 
-    # Public.
-    def self.log_file
-      ENV['RESQUED_LOGFILE']
+      # Public: Make sure the log IO is closed.
+      def close_log
+        if @logging_io && @logging_io != $stdout
+          @logging_io.close
+          @logging_io = nil
+        end
+      end
+
+      # Public.
+      def log_file=(path)
+        ENV['RESQUED_LOGFILE'] = File.expand_path(path)
+        close_log
+      end
+
+      # Public.
+      def log_file
+        ENV['RESQUED_LOGFILE']
+      end
     end
 
     # Public.
@@ -15,23 +42,14 @@ module Resqued
       Resqued::Logging.log_file.nil?
     end
 
-    # Private (in classes that include this module)
-    def log(message)
-      logging_io.puts "[#{$$} #{Time.now.strftime('%H:%M:%S')}] #{message}"
+    # Public: Re-open all log files.
+    def reopen_logs
+      Resqued::Logging.close_log # it gets opened the next time it's needed.
     end
 
-    # Private (may be overridden in classes that include this module to send output to a different IO)
-    def logging_io
-      @logging_io = nil if @logging_io && @logging_io.closed?
-      @logging_io ||=
-        if path = Resqued::Logging.log_file
-          File.open(path, 'a').tap do |f|
-            f.sync = true
-            f.close_on_exec = true
-          end
-        else
-          $stdout
-        end
+    # Private (in classes that include this module)
+    def log(message)
+      Resqued::Logging.logging_io.puts "[#{$$} #{Time.now.strftime('%H:%M:%S')}] #{message}"
     end
   end
 end

data/lib/resqued/master.rb

@@ -48,6 +48,7 @@ module Resqued
         when :INFO
           dump_object_counts
         when :HUP
+          reopen_logs
           log "Restarting listener with new configuration and application."
           kill_listener(:QUIT)
         when :INT, :TERM, :QUIT
@@ -147,7 +148,7 @@ module Resqued
         if lpid
           log "Listener exited #{status}"
           if @current_listener && @current_listener.pid == lpid
-            @listener_backoff.finished
+            @listener_backoff.died
             @current_listener = nil
           end
           listener_pids.delete(lpid).dispose # This may leak workers.
@@ -160,13 +161,17 @@ module Resqued
       end while true
     end
 
-    SIGNALS = [ :HUP, :INT, :TERM, :QUIT, :INFO ]
+    SIGNALS = [ :HUP, :INT, :TERM, :QUIT ]
+    OPTIONAL_SIGNALS = [ :INFO ]
+    OTHER_SIGNALS = [:CHLD, 'EXIT']
+    TRAPS = SIGNALS + OPTIONAL_SIGNALS + OTHER_SIGNALS
 
     SIGNAL_QUEUE = []
 
     def install_signal_handlers
       trap(:CHLD) { awake }
       SIGNALS.each { |signal| trap(signal) { SIGNAL_QUEUE << signal ; awake } }
+      OPTIONAL_SIGNALS.each { |signal| trap(signal) { SIGNAL_QUEUE << signal ; awake } rescue nil }
     end
 
     def report_unexpected_exits

data/lib/resqued/pidfile.rb

@@ -1,5 +1,7 @@
 module Resqued
+  # Mixin that manages a pidfile for a process.
   module Pidfile
+    # Public: Create a pidfile, execute the block, then remove the pidfile.
     def with_pidfile(filename)
       write_pidfile(filename) if filename
       yield
@@ -7,6 +9,7 @@ module Resqued
       remove_pidfile(filename) if filename
     end
 
+    # Private.
     def write_pidfile(filename)
       pf =
         begin
@@ -20,6 +23,7 @@ module Resqued
       pf.close
     end
 
+    # Private.
     def remove_pidfile(filename)
       (File.read(filename).to_i == $$) and File.unlink(filename) rescue nil
     end

data/lib/resqued/sleepy.rb

@@ -3,18 +3,21 @@ require 'kgio'
 
 module Resqued
   module Sleepy
-    def self_pipe
-      @self_pipe ||= Kgio::Pipe.new.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
-    end
-
+    # Public: Like sleep, but the sleep is interrupted if input is detected on one of the provided IO objects, or if `awake` is called (e.g. from a signal handler).
     def yawn(duration, *inputs)
       inputs = [self_pipe[0]] + [inputs].flatten.compact
       IO.select(inputs, nil, nil, duration) or return
       self_pipe[0].kgio_tryread(11)
     end
 
+    # Public: Break out of `yawn`.
     def awake
       self_pipe[1].kgio_trywrite('.')
     end
+
+    # Private.
+    def self_pipe
+      @self_pipe ||= Kgio::Pipe.new.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
   end
 end

data/lib/resqued/version.rb

@@ -1,3 +1,4 @@
 module Resqued
-  VERSION = '0.0.1'
+  # Oh look, he's getting so big!
+  VERSION = '0.4.0'
 end

data/lib/resqued/worker.rb

@@ -10,6 +10,8 @@ module Resqued
 
     def initialize(options)
       @queues = options.fetch(:queues)
+      @config = options.fetch(:config)
+      @interval = options[:interval]
       @backoff = Backoff.new
     end
 
@@ -24,7 +26,7 @@ module Resqued
       pid.nil?
     end
 
-    # Public: Checks if this worker works on jobs from the queue.
+    # Public: A string that compares if this worker is equivalent to a worker in another Resqued::Listener.
     def queue_key
       queues.sort.join(';')
     end
@@ -32,14 +34,14 @@ module Resqued
     # Public: Claim this worker for another listener's worker.
     def wait_for(pid)
       raise "Already running #{@pid} (can't wait for #{pid})" if @pid
-      @self_started = nil
+      @self_started = false
       @pid = pid
     end
 
     # Public: The old worker process finished!
     def finished!(process_status)
       @pid = nil
-      @backoff.finished
+      @backoff.died unless @killed
     end
 
     # Public: The amount of time we need to wait before starting a new worker.
@@ -52,14 +54,19 @@ module Resqued
       return if @backoff.wait?
       @backoff.started
       @self_started = true
+      @killed = false
       if @pid = fork
         # still in the listener
       else
-        # In case we get a signal before the process is all the way up.
+        # In case we get a signal before resque is ready for it.
         [:QUIT, :TERM, :INT].each { |signal| trap(signal) { exit 1 } }
         $0 = "STARTING RESQUE FOR #{queues.join(',')}"
+        if Resque.respond_to?("logger")
+          Resque.logger.level = Logger::INFO
+          Resque.logger.formatter = Resque::VerboseFormatter.new
+        end
         if ! log_to_stdout?
-          lf = logging_io
+          lf = Resqued::Logging.logging_io
           if Resque.respond_to?("logger=")
             Resque.logger = Resque.logger.class.new(lf)
           else
@@ -69,28 +76,18 @@ module Resqued
         end
         resque_worker = Resque::Worker.new(*queues)
         resque_worker.log "Starting worker #{resque_worker}"
-        resque_worker.term_child = true # Hopefully do away with those warnings!
-        resque_worker.work(5)
+        resque_worker.term_child = true
+        resque_worker.reconnect
+        @config.after_fork(resque_worker)
+        resque_worker.work(@interval || 5)
         exit 0
       end
     end
 
     # Public: Shut this worker down.
-    #
-    # We are using these signal semantics:
-    # HUP: restart (QUIT workers)
-    # INT/TERM: immediately exit
-    # QUIT: graceful shutdown
-    #
-    # Resque uses these (compatible) signal semantics:
-    # TERM: Shutdown immediately, stop processing jobs.
-    #  INT: Shutdown immediately, stop processing jobs.
-    # QUIT: Shutdown after the current job has finished processing.
-    # USR1: Kill the forked child immediately, continue processing jobs.
-    # USR2: Don't process any new jobs
-    # CONT: Start processing jobs again after a USR2
     def kill(signal)
       Process.kill(signal.to_s, pid) if pid && @self_started
+      @killed = true
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resqued
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2013-08-20 00:00:00.000000000 Z
+date: 2013-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio
@@ -43,6 +43,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.22.0
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +148,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/resqued/backoff.rb
+- lib/resqued/config/after_fork.rb
+- lib/resqued/config/base.rb
+- lib/resqued/config/before_fork.rb
+- lib/resqued/config/dsl.rb
+- lib/resqued/config/worker.rb
 - lib/resqued/config.rb
 - lib/resqued/daemon.rb
 - lib/resqued/listener.rb