resqued 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dab65ebe5befd4cb605dc27208740e8c11079ca6
-  data.tar.gz: 73d6a230a3273aaf351e55008a01fe4a0a479944
+  metadata.gz: 4dd030c6805cad2c45c30a29e5415913b813b6b9
+  data.tar.gz: 997391384ab8db66c4dc1b9fc61efd3b2e9ce556
 SHA512:
-  metadata.gz: f8215347e188cbd78fef8561cfaed3ae9e00156de9bb255dd3a2fc90d3b2dbe3dc30870ad44e22a95e73b57f798be7cd169133b07779c93c5a180394b0be242e
-  data.tar.gz: 249de2ac4fb9a5d40c97322b9d8176907bee59748051f22679cd1bba8eff6154256cd4b3b6d330097e3aaf790798185eae503240dc0589a5f5288f20007a95f2
+  metadata.gz: d1d646630aeceb8d1b4915e23d3f5dae31cf06d7aa7bdeca11efa7f5c632345c3e3c42668a49cc204b1a4e1a63df011ec6d399c04f6f26c78281b8818e82826d
+  data.tar.gz: 7c774e66d83c5a8dd5279c2b0c57ce83bdd7cf12f565a48c3d1c50a65b148da0297025606b92443126901cec54ec648ef06635781eba4c5d2e0c97815745968a

data/docs/ipc.md

@@ -0,0 +1,23 @@
+# Inter-Process Communication
+
+## Master / Listener
+
+`Resqued::ListenerProxy` opens a Unix domain socket to communicate between the Master and Listener processes. Resqued uses a socket (instead of a pipe) because the socket is bidirectional and a socket can be reopened after `exec`.
+
+The Listener process sends information about the lifecycle of worker processes that it controls. When a worker starts, the listener writes `"+#{pid},#{queues}\n"`, e.g. `"+21234,important,*\n"`. When a worker exits, the listener writes `"-#{pid}\n"`.
+
+The Master process broadcasts dead worker PIDs to all running listeners. This allows a new listener to wait for old workers to exit before starting their replacements. These messages are just the pid, `"#{pid}\n"`, e.g. `"21234\n"`.
+
+*Does the dead worker broadcast need to go to all listeners? Or just the current listener?*
+
+## Listener / Worker
+
+There is no direct communication between the Listener and the Worker.
+
+## Daemon / Master
+
+The Daemon process opens a pipe. When the Master process starts, it writes its pid to the pipe, and the daemon reads it and exits. If the read fails, the daemon exits with an error status.
+
+## `self_pipe`
+
+Each process has a `self_pipe` that it uses as a sleep timer. When the process has no work to do, it performs an `IO.select` on the pipe. If a signal is received, the signal is recorded and a `'.'` is written to the pipe, which causes `IO.select` to finish. This helps avoid race conditions between the main loop and signal handling blocks.

data/docs/processes.md

@@ -0,0 +1,72 @@
+# Process types in resqued
+
+Resqued runs the following processes, named after the main class that runs in them:
+
+* `Resqued::Daemon` is the first process run, if the `-D` flag is provided. It runs until the Master process is started.
+* `Resqued::Master` is the main process. This process does not restart, so it is somewhat minimal, and should work with different versions of the Listener.
+* `Resqued::Listener` is started by the Master. A new Listener is started each time the configuration or application is reloaded (on SIGHUP). It manages the pool of workers.
+* `Resqued::Worker` is started by the Listener, once for each worker.
+
+In normal operation, there are one Master, one Listener, and several Worker processes.
+
+When the workers are idle:
+
+```
+-+= 77038 burke resqued master [gen 1] [1 running] config/resqued.rb
+ \-+- 77208 burke resqued listener 1 [running] config/resqued.rb
+   |--- 77492 burke resque-1.24.1: Waiting for import_high
+   |--- 77493 burke resque-1.24.1: Waiting for import_high
+   |--- 77494 burke resque-1.24.1: Waiting for important,import_low
+   |--- 77495 burke resque-1.24.1: Waiting for important,import_low
+   |--- 77496 burke resque-1.24.1: Waiting for normal
+   \--- 77497 burke resque-1.24.1: Waiting for normal
+```
+
+When the workers are working:
+
+```
+-+= 77038 burke resqued master [gen 1] [1 running] config/resqued.rb
+ \-+- 51166 burke resqued listener 1 [running] config/resqued.rb
+   |-+- 51638 burke resque-1.24.1: Forked 78947 at 1377103813
+   | \--- 78947 burke SlowJob::ImportHigh 23 seconds remaining...
+   |-+- 51639 burke resque-1.24.1: Forked 78948 at 1377103813
+   | \--- 78948 burke SlowJob::ImportHigh 23 seconds remaining...
+   |-+- 51642 burke resque-1.24.1: Forked 78950 at 1377103813
+   | \--- 78950 burke SlowJob::Normal 4 seconds remaining...
+   |-+- 51643 burke resque-1.24.1: Forked 78949 at 1377103813
+   | \--- 78949 burke SlowJob::Normal 4 seconds remaining...
+   |-+- 79907 burke resque-1.24.1: Forked 79920 at 1377103819
+   | \--- 79920 burke SlowJob::ImportLow 29 seconds remaining...
+   \-+- 79908 burke resque-1.24.1: Forked 79921 at 1377103819
+     \--- 79921 burke SlowJob::ImportLow 29 seconds remaining...
+```
+
+During restart, there should be no more workers than the configuration specifies, but they may be spread out across several listeners. As the workers finish working on the old listener, they will exit and start up on the new listener. When the old listener has no more workers, it exits.
+
+```
+-+= 51121 burke resqued master [gen 2] [2 running] config/resqued.rb
+ |-+- 51166 burke resqued listener 1 [shutdown] config/resqued.rb
+ | |-+- 51638 burke resque-1.24.1: Forked 78947 at 1377103813
+ | | \--- 78947 burke SlowJob::ImportHigh 23 seconds remaining...
+ | |-+- 51639 burke resque-1.24.1: Forked 78948 at 1377103813
+ | | \--- 78948 burke SlowJob::ImportHigh 23 seconds remaining...
+ | |-+- 51642 burke resque-1.24.1: Forked 78950 at 1377103813
+ | | \--- 78950 burke SlowJob::Normal 4 seconds remaining...
+ | \-+- 51643 burke resque-1.24.1: Forked 78949 at 1377103813
+ |   \--- 78949 burke SlowJob::Normal 4 seconds remaining...
+ \-+- 79528 burke resqued listener 2 [running] config/resqued.rb
+   |-+- 79907 burke resque-1.24.1: Forked 79920 at 1377103819
+   | \--- 79920 burke SlowJob::ImportLow 29 seconds remaining...
+   \-+- 79908 burke resque-1.24.1: Forked 79921 at 1377103819
+     \--- 79921 burke SlowJob::ImportLow 29 seconds remaining...
+```
+
+## Spawning
+
+The Daemon process starts the Master process with a double-fork, the normal daemonization process.
+
+The Master process starts the Listener process with a fork+exec. `bin/resqued-listener` is the process that is executed. Doing a full exec on the listener allows it to load any application changes, including changes to the `Gemfile`, without any special code. In order to keep the exec interface flexible, all initialization data is passed to the listener from the master via environment variables. This information is minimal, and includes the location of the config file and the status of other workers.
+
+The Listener process loads the application configuration (the `before_fork` block in the configuration file) before starting any workers. Worker processes are started by forking, and starting the Resque::Worker run loop.
+
+In the event that a Listener or Worker exits quickly and unexpectedly, resqued will not immediately restart the process.

data/docs/signals.md

@@ -0,0 +1,46 @@
+# Signals in resqued
+
+Signals control restart, reload, and shutdown in resqued. This file documents the signals that resqued's processes handle. You should normally only send signals to the Master process.
+
+Here is a summary of how signals get passed between resqued's processes:
+
+```
+                  master    listener    worker
+                  ------    --------    ------
+restart            HUP   -> QUIT     -> QUIT
+exit now           INT   ->  INT     ->  INT
+exit now          TERM   -> TERM     -> TERM
+exit when ready   QUIT   -> QUIT     -> QUIT
+pause             USR2   -> QUIT     -> QUIT
+unpause           CONT   -> (start)
+unpause           CONT   -> CONT     -> CONT
+```
+
+Read on for more information about what the signals mean.
+
+## Master
+
+The Master process handles several signals.
+
+* `HUP`: Start a new listener. After it boots, kill the previous listener with `SIGQUIT`.
+* `USR2`: Pause processing. Kills the current listener, and does not start a replacement.
+* `CONT`: Resume processing. If there is no listener, start one. If there is a listener, send it SIGCONT.
+* `QUIT`, `INT`, or `TERM`: Kill the listener with the same signal and wait for it to exit.
+* `CHLD`: Clean up any listeners that have exited. If the current listener exited
+
+## Listener
+
+The Listener process forwards `SIGCONT` to all of its workers.
+
+The Listener process handles `SIGINT`, `SIGTERM`, and `SIGQUIT`. When it receives one of these signals, it goes into shutdown mode. It sends the received signal to all of its workers. When all workers have exited, the Listener process exits.
+
+## Worker
+
+The Worker process uses resque's signal handling. Resque 1.23.0 handles the following signals:
+
+* `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

data/exe/resqued

@@ -46,7 +46,6 @@ end
 
 opts.parse!
 options[:config_paths] = ARGV
-options[:status_pipe] = STDOUT
 
 if options[:config_paths].size == 0
   puts opts

data/lib/resqued/listener.rb

@@ -142,9 +142,15 @@ module Resqued
     def reap_workers(waitpidflags = 0)
       loop do
         worker_pid, status = Process.waitpid2(-1, waitpidflags)
-        return :none_ready if worker_pid.nil?
-        finish_worker(worker_pid, status)
-        report_to_master("-#{worker_pid}")
+        if worker_pid.nil?
+          return :none_ready
+        elsif status.exited?
+          log "Worker exited #{status}"
+          finish_worker(worker_pid, status)
+          report_to_master("-#{worker_pid}")
+        else
+          log "Worker reported #{status}"
+        end
       end
     rescue Errno::ECHILD
       # All done

data/lib/resqued/logging.rb

@@ -11,6 +11,9 @@ module Resqued
             File.open(path, 'a').tap do |f|
               f.sync = true
               f.close_on_exec = true
+              # Make sure we're not holding onto a stale filehandle.
+              $stdout.reopen(f)
+              $stderr.reopen(f)
             end
           else
             $stdout

data/lib/resqued/version.rb

@@ -1,3 +1,3 @@
 module Resqued
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

data/lib/resqued/worker.rb

@@ -88,6 +88,8 @@ module Resqued
     def kill(signal)
       Process.kill(signal.to_s, pid) if pid && @self_started
       @killed = true
+    rescue Errno::ESRCH => e
+      log "Can't kill #{pid}: #{e}"
     end
   end
 end

data/spec/fixtures/test_case_after_fork_raises.rb

@@ -0,0 +1,3 @@
+after_fork { raise 'boom' }
+worker_pool 100
+queue 'test'

data/spec/fixtures/test_case_before_fork_raises.rb

@@ -0,0 +1,2 @@
+before_fork { raise 'boom' }
+worker "test"

data/spec/fixtures/test_case_clean.rb

@@ -0,0 +1 @@
+worker "test"

data/spec/fixtures/test_case_environment.rb

@@ -0,0 +1 @@
+before_fork { Resque.redis = Redis.new(:host => 'localhost', :port => ENV['RESQUED_TEST_REDIS_PORT'].to_i) }

data/spec/resqued/backoff_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+require 'resqued/backoff'
+
+describe Resqued::Backoff do
+  let(:backoff) { described_class.new(:min => 0.5, :max => 64.0) }
+
+  it 'can start on the first try' do
+    expect(backoff.wait?).to be_false
+  end
+
+  it 'has no waiting at first' do
+    expect(backoff.how_long?).to be_nil
+  end
+
+  context 'after expected exits' do
+    before { 3.times { backoff.started } }
+    it { expect(backoff.wait?).to be_true }
+    it { expect(backoff.how_long?).to be_close_to(0.5) }
+  end
+
+  context 'after one quick exit' do
+    before { 1.times { backoff.started ; backoff.died } }
+    it { expect(backoff.wait?).to be_true }
+    it { expect(backoff.how_long?).to be_close_to(1.0) }
+  end
+
+  context 'after two quick starts' do
+    before { 2.times { backoff.started ; backoff.died } }
+    it { expect(backoff.wait?).to be_true }
+    it { expect(backoff.how_long?).to be_close_to(2.0) }
+  end
+
+  context 'after five quick starts' do
+    before { 6.times { backoff.started ; backoff.died } }
+    it { expect(backoff.wait?).to be_true }
+    it { expect(backoff.how_long?).to be_close_to(32.0) }
+  end
+
+  context 'after six quick starts' do
+    before { 7.times { backoff.started ; backoff.died } }
+    it { expect(backoff.wait?).to be_true }
+    it { expect(backoff.how_long?).to be_close_to(64.0) }
+  end
+
+  context 'does not wait longer than 64s' do
+    before { 8.times { backoff.started ; backoff.died } }
+    it { expect(backoff.wait?).to be_true }
+    it { expect(backoff.how_long?).to be_close_to(64.0) }
+    it 'and resets after an expected exit' do
+      backoff.started
+      backoff.started
+      expect(backoff.wait?).to be_true
+      expect(backoff.how_long?).to be_close_to(0.5)
+    end
+  end
+
+  def be_close_to(x)
+    be_within(0.005).of(x)
+  end
+end

data/spec/resqued/config/fork_event_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'resqued/config/after_fork'
+require 'resqued/config/before_fork'
+
+describe do
+  before { evaluator.apply(config) }
+
+  context 'after_fork' do
+    # Run the after_fork block.
+    #
+    #    after_fork do |resque_worker|
+    #      ActiveRecord::Base.establish_connection
+    #    end
+    #
+    # ignore calls to any other top-level method.
+
+    let(:config) { <<-END_CONFIG }
+      before_fork { }
+      worker('one')
+      worker_pool(10)
+      queue('*')
+
+      after_fork do |worker|
+        worker.token = :called
+      end
+    END_CONFIG
+
+    let(:evaluator) { Resqued::Config::AfterFork.new(:worker => worker) }
+    let(:worker) { FakeResqueWorker.new }
+
+    it { expect(worker.token).to eq(:called) }
+  end
+
+  context 'before_fork' do
+    # Run the before_fork block.
+    #
+    #    before_fork do
+    #      require "./config/environment.rb"
+    #      Rails.application.eager_load!
+    #    end
+    #
+    # ignore calls to any other top-level method.
+
+    let(:config) { <<-END_CONFIG }
+      after_fork { |worker| }
+      worker('one')
+      worker_pool(10)
+      queue('*')
+
+      before_fork do
+        $before_fork_called = true
+      end
+    END_CONFIG
+
+    let(:evaluator) { $before_fork_called = false ; Resqued::Config::BeforeFork.new }
+
+    it { expect($before_fork_called).to eq(true) }
+  end
+end
+
+class FakeResqueWorker
+  attr_accessor :token
+end

data/spec/resqued/config/worker_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'resqued/config/worker'
+
+describe Resqued::Config::Worker do
+  # Create a bunch of Resqued::Worker objects from
+  #
+  #    worker 'one'
+  #    worker 'two', 'three', :interval => 2
+  #    worker # assumes '*' as the queue
+  #    worker_pool 10
+  #    queue 'four', :percent => 20
+  #    queue 'five', :count => 5
+  #    queue 'six', 'seven', :count => 1
+  #    queue '*'
+  #
+  # ignore calls to any other top-level method.
+
+  let(:evaluator) { described_class.new(:worker_class => FakeWorker) }
+  let(:result) { evaluator.apply(config) }
+  module FakeWorker
+    def self.new(options)
+      options
+    end
+  end
+
+  context 'individual' do
+    let(:config) { <<-END_CONFIG }
+      before_fork { }
+      after_fork { }
+      2.times { worker 'a' }
+      worker 'b'
+      worker 'c', 'd'
+      worker 'd', 'c', :interval => 3
+      worker
+      after_fork { } # So that we don't rely on `workers`'s result falling through.
+    END_CONFIG
+    it { expect(result.size).to eq(6) }
+    it { expect(result[0]).to eq(:queues => ['a']) }
+    it { expect(result[1]).to eq(:queues => ['a']) }
+    it { expect(result[2]).to eq(:queues => ['b']) }
+    it { expect(result[3]).to eq(:queues => ['c', 'd']) }
+    it { expect(result[4]).to eq(:queues => ['d', 'c'], :interval => 3) }
+    it { expect(result[5]).to eq(:queues => ['*']) }
+  end
+
+  context 'concise pool' do
+    let(:config) { <<-END_CONFIG }
+      worker_pool 2, 'a', 'b', 'c', :interval => 1
+    END_CONFIG
+    it { expect(result).to eq([
+      { :queues => ['a', 'b', 'c'], :interval => 1 },
+      { :queues => ['a', 'b', 'c'], :interval => 1 },
+    ]) }
+  end
+
+  context 'pool (hash for concurrency)' do
+    let(:config) { <<-END_CONFIG }
+      before_fork { }
+      after_fork { }
+      worker_pool 20, :interval => 1
+      queue 'a', :percent => 20
+      queue 'b1', 'b2', :count => 10
+      queue 'c'
+      after_fork { } # So that we don't rely on `worker_pool`'s result falling through.
+    END_CONFIG
+    it { expect(result.size).to eq(20) }
+    it { expect(result[0]).to eq(:queues => ['a', 'b1', 'b2', 'c'], :interval => 1) }
+    it { expect(result[3]).to eq(:queues => ['a', 'b1', 'b2', 'c'], :interval => 1) }
+    it { expect(result[4]).to eq(:queues => ['b1', 'b2', 'c'], :interval => 1) }
+    it { expect(result[9]).to eq(:queues => ['b1', 'b2', 'c'], :interval => 1) }
+    it { expect(result[10]).to eq(:queues => ['c'], :interval => 1) }
+    it { expect(result[19]).to eq(:queues => ['c'], :interval => 1) }
+  end
+
+  context 'pool, with implied queue' do
+    let(:config) { <<-END_CONFIG }
+      before_fork { }
+      after_fork { }
+      worker_pool 20
+      after_fork { } # So that we don't rely on `worker_pool`'s result falling through.
+    END_CONFIG
+    it { expect(result.size).to eq(20) }
+    it { expect(result[0]).to eq(:queues => ['*']) }
+    it { expect(result[19]).to eq(:queues => ['*']) }
+  end
+
+  context 'pool, with fewer queues than workers' do
+    let(:config) { <<-END_CONFIG }
+      before_fork { }
+      after_fork { }
+      worker_pool 20
+      queue 'a', :count => 10
+      after_fork { } # So that we don't rely on `worker_pool`'s result falling through.
+    END_CONFIG
+    it { expect(result.size).to eq(20) }
+    it { expect(result[0]).to eq(:queues => ['a']) }
+    it { expect(result[9]).to eq(:queues => ['a']) }
+    it { expect(result[10]).to eq(:queues => ['*']) }
+    it { expect(result[19]).to eq(:queues => ['*']) }
+  end
+
+  context 'pool, with more queues than workers' do
+    let(:config) { <<-END_CONFIG }
+      before_fork { }
+      after_fork { }
+      worker_pool 20
+      queue 'a', :count => 30
+      after_fork { } # So that we don't rely on `worker_pool`'s result falling through.
+    END_CONFIG
+    it { expect(result.size).to eq(20) }
+  end
+
+  context 'pool, with shuffled queues' do
+    let(:config) { <<-END_CONFIG }
+      worker_pool 20, :shuffle_queues => true
+      queue 'a', :count => 10
+      queue 'b', :count => 15
+    END_CONFIG
+    it { expect(result.size).to eq(20) }
+    it { (0..9).each { |i| expect(result[i][:queues].sort).to eq(['a', 'b']) } }
+    it { (10..14).each { |i| expect(result[i][:queues]).to eq(['b']) } }
+    it { (15..19).each { |i| expect(result[i][:queues]).to eq(['*']) } }
+    it { result.each { |x| expect(x).not_to have_key(:shuffle_queues) } }
+    it do
+      shuffled_queues = result.take(10).map { |x| x[:queues] }
+      expect(shuffled_queues.sort.uniq).to eq([ ['a','b'], ['b','a'] ]) # Some of the queues should be shuffled
+    end
+  end
+
+  context 'multiple worker configs' do
+    let(:config) { <<-END_CONFIG }
+      worker 'one'
+      worker 'two'
+      worker_pool 2
+    END_CONFIG
+    it { expect(result.size).to eq(4) }
+    it { expect(result[0]).to eq(:queues => ['one']) }
+    it { expect(result[1]).to eq(:queues => ['two']) }
+    it { expect(result[2]).to eq(:queues => ['*']) }
+    it { expect(result[3]).to eq(:queues => ['*']) }
+  end
+
+  context 'with default options' do
+    let(:evaluator) { described_class.new(:worker_class => FakeWorker, :config => 'something') }
+    let(:config) { <<-END_CONFIG }
+      worker 'a', :interval => 1
+    END_CONFIG
+    it { expect(result[0]).to eq(:queues => ['a'], :interval => 1, :config => 'something') }
+  end
+end

data/spec/resqued/sleepy_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'resqued/sleepy'
+require 'thread'
+
+describe Resqued::Sleepy do
+  include Resqued::Sleepy
+
+  it 'sleeps' do
+    expect { yawn(0.2) }.to run_for(0.2)
+  end
+
+  it 'wakes on `awake`' do
+    Thread.new { sleep 0.1 ; awake }
+    expect { yawn(2.0) }.to run_for(0.1)
+  end
+
+  it 'wakes on IO' do
+    rd, wr = IO.pipe
+    Thread.new { sleep 0.1 ; wr.write('.') }
+    expect { yawn(2.0, rd) }.to run_for(0.1)
+  end
+
+  it 'does not sleep if duration is 0' do
+    expect { yawn(-0.000001) }.to run_for(0.0)
+  end
+
+  it 'does not sleep if duration is negative' do
+    expect { yawn(0) }.to run_for(0.0)
+  end
+end

data/spec/resqued/test_case_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'resqued/test_case'
+
+describe Resqued::TestCase do
+  let(:test_case) { Object.new.extend(the_module) }
+  before { mock_redis.start ; ENV['RESQUED_TEST_REDIS_PORT'] = mock_redis.port.to_s }
+  after  { mock_redis.stop  }
+  let(:mock_redis) { MockRedisServer.new }
+
+  context 'ForkToStart' do
+    let(:the_module) { described_class::ForkToStart }
+    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_clean.rb'              }.not_to raise_error }
+    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_before_fork_raises.rb' }.to     raise_error }
+    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_after_fork_raises.rb'  }.not_to raise_error }
+    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_no_workers.rb'         }.not_to raise_error }
+    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_clean.rb',             :expect_workers => true }.not_to raise_error }
+    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_after_fork_raises.rb', :expect_workers => true }.to raise_error }
+    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_no_workers.rb',        :expect_workers => true }.to raise_error }
+  end
+end
+
+class MockRedisServer
+  def start
+    return if @server
+    require 'socket'
+    @server = TCPServer.new(0)
+  end
+
+  def stop
+    return unless @server
+    @server.close
+  ensure
+    @server = nil
+  end
+
+  def port
+    @server && @server.addr[1]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'support/custom_matchers'

data/spec/support/custom_matchers.rb

@@ -0,0 +1,35 @@
+module CustomMatchers
+  # Examples:
+  #     expect { sleep 0.5 }.to run_for(0.5).within(0.0001)
+  def run_for(expected_duration)
+    RunFor.new(expected_duration)
+  end
+
+  class RunFor
+    def initialize(expected_duration)
+      @expected_duration = expected_duration
+      @epsilon  = 0.01
+    end
+
+    def within(epsilon)
+      @epsilon = epsilon
+      self
+    end
+
+    def matches?(event_proc)
+      start_time = Time.now
+      event_proc.call
+      @actual_duration = Time.now - start_time
+      diff = (@actual_duration - @expected_duration).abs
+      @epsilon >= diff
+    end
+
+    def failure_message_for_should
+      "Expected block to run for #{@expected_duration} +/-#{@epsilon} seconds, but it ran for #{@actual_duration} seconds."
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include CustomMatchers
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resqued
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Matt Burke
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2013-10-23 00:00:00.000000000 Z
+date: 2013-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio
@@ -150,6 +150,21 @@ files:
 - lib/resqued/worker.rb
 - lib/resqued.rb
 - README.md
+- docs/ipc.md
+- docs/processes.md
+- docs/signals.md
+- spec/fixtures/test_case_after_fork_raises.rb
+- spec/fixtures/test_case_before_fork_raises.rb
+- spec/fixtures/test_case_clean.rb
+- spec/fixtures/test_case_environment.rb
+- spec/fixtures/test_case_no_workers.rb
+- spec/resqued/backoff_spec.rb
+- spec/resqued/config/fork_event_spec.rb
+- spec/resqued/config/worker_spec.rb
+- spec/resqued/sleepy_spec.rb
+- spec/resqued/test_case_spec.rb
+- spec/spec_helper.rb
+- spec/support/custom_matchers.rb
 - exe/resqued
 - exe/resqued-listener
 homepage: https://github.com
@@ -175,4 +190,16 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Daemon of resque workers
-test_files: []
+test_files:
+- spec/fixtures/test_case_after_fork_raises.rb
+- spec/fixtures/test_case_before_fork_raises.rb
+- spec/fixtures/test_case_clean.rb
+- spec/fixtures/test_case_environment.rb
+- spec/fixtures/test_case_no_workers.rb
+- spec/resqued/backoff_spec.rb
+- spec/resqued/config/fork_event_spec.rb
+- spec/resqued/config/worker_spec.rb
+- spec/resqued/sleepy_spec.rb
+- spec/resqued/test_case_spec.rb
+- spec/spec_helper.rb
+- spec/support/custom_matchers.rb