resqued 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d56c813a2d3adf7d10fe76dafefff24c263f9766
-  data.tar.gz: e3c9cd5fc92aca0b70d4d8ed31de6f15c418c94c
+SHA256:
+  metadata.gz: 3b8956c8d1035f7289519c1bb7c136efa41fafde26f9caec7feb514b09270132
+  data.tar.gz: 05150d5f65763b0712b7d272cd44bc328b7a302042cc6fc98f5d34424aaca15d
 SHA512:
-  metadata.gz: a28be514424a281b554224c78ba0d4fa6ff328f1d9fff622c76653c09ceefc6bc6c70cdb389d41dbd566fa202741d073ad6817103d2231237cbfdd726dd32473
-  data.tar.gz: 14375d125a0c9e89ecc1918fa6d46f062206ddc0ac08a3ac8f504e7aeab563f90ea3d62cb54b955b1408f3308692b9cc98479c19d2d420b0136d73c10182687d
+  metadata.gz: 12b640ca8b2d567dffd82e19e150e984461ba42c7b143650162b31e8812c31c47b9a1813c9f54df72f1cd19ccd51f80fa8f71dcc74c5805e5453c3798f5707a2
+  data.tar.gz: 355f43fe2e0d2b6d91b440e9bd7a7cd921c5134b17d4e934a06cbe33e52c5feef99fd8b14e93706a6e78b3c2f04e1fbc98386eba711e550855a5c023b0c57d4e

data/CHANGES.md

@@ -1,5 +1,26 @@
 Starting with version 0.6.1, resqued uses semantic versioning to indicate incompatibilities between the master process, listener process, and configuration.
 
+v0.11.1
+-------
+* Fix a crash during shutdown. (#62)
+
+v0.11.0
+-------
+* Ignore SIGHUP in Listener and Worker processes. (#61)
+
+v0.10.3
+-------
+* Fix a timing related crash during reload. (#60)
+
+v0.10.2
+-------
+* Shut down cleanly even if there are other stray child processes of the master. (#59)
+
+v0.10.1
+-------
+* Avoid deadlock if a listener stops responding. (#58)
+* When using 'percent' for a queue in a worker pool, always assign at least one worker. (#57)
+
 v0.10.0
 -------
 * Master process restarts itself (#51), so that it doesn't continue running stale code indefinitely. This will help with the rollout process when changes like #50 are introduced, so that the master process will catch up. The risk of this is that the master process might not be able to be restarted, which would lead to it crashing. The mostly likely way for that to happen is if you try to roll back your version of resqued to 0.9.0 or earlier. If you need to do that, ensure that your process monitor (systemd, god, etc.) is able to restart the master process. You can disable the new behavior by passing `--no-exec-on-hup`.

data/docs/signals.md

@@ -34,6 +34,8 @@ 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.
 
+The Listener process handles `SIGHUP` and does nothing. This makes it easier to reload resqued in a docker container, since many container platforms will send a requested signal to all processes in the container.
+
 ## Worker
 
 The Worker process uses resque's signal handling. Resque 1.23.0 handles the following signals:
@@ -44,3 +46,5 @@ The Worker process uses resque's signal handling. Resque 1.23.0 handles the foll
 * `USR1`: Kill the forked child immediately, continue processing jobs.
 * `USR2`: Don't process any new jobs
 * `CONT`: Start processing jobs again after a USR2
+
+Resqued leaves a handler for `HUP` in place that does nothing. This makes it easier to reload resqued in a docker container, since many container platforms will send a requested signal to all processes in the container.

data/lib/resqued/config/worker.rb

@@ -112,7 +112,7 @@ module Resqued
         elsif value.is_a?(1.class)
           value < @pool_size ? value : @pool_size
         elsif value.is_a?(Float) && value >= 0.0 && value <= 1.0
-          (@pool_size * value).to_i
+          [(@pool_size * value).to_i, 1].max
         else
           raise TypeError, "Unknown concurrency value: #{value.inspect}"
         end

data/lib/resqued/listener.rb

@@ -63,12 +63,13 @@ module Resqued
     end
 
     SIGNALS = [:CONT, :QUIT, :INT, :TERM].freeze
-    ALL_SIGNALS = SIGNALS + [:CHLD]
+    ALL_SIGNALS = SIGNALS + [:CHLD, :HUP]
 
     SIGNAL_QUEUE = [] # rubocop: disable Style/MutableConstant
 
     # Public: Run the main loop.
     def run
+      trap(:HUP) {} # ignore this, in case it trickles in from the master.
       trap(:CHLD) { awake }
       SIGNALS.each { |signal| trap(signal) { SIGNAL_QUEUE << signal; awake } }
       @socket.close_on_exec = true
@@ -85,6 +86,8 @@ module Resqued
 
       write_procline("shutdown")
       burn_down_workers(exit_signal || :QUIT)
+      @socket&.close
+      @socket = nil
     end
 
     # Private.

data/lib/resqued/listener_pool.rb

@@ -25,6 +25,11 @@ module Resqued
       @listener_proxies.size
     end
 
+    # Public: Are the listeners all gone?
+    def empty?
+      @listener_proxies.empty?
+    end
+
     # Public: Initialize a new listener, run it, and record it as the current listener. Returns its ListenerProxy.
     def start!
       listener_state = ListenerState.new

data/lib/resqued/listener_proxy.rb

@@ -99,7 +99,10 @@ module Resqued
     def worker_finished(pid)
       return if @state.master_socket.nil?
 
-      @state.master_socket.puts(pid)
+      @state.master_socket.write_nonblock("#{pid}\n")
+    rescue IO::WaitWritable
+      log "Couldn't tell #{@state.pid} that #{pid} exited!"
+      # Ignore it, maybe the next time it'll work.
     rescue Errno::EPIPE
       @state.master_socket.close
       @state.master_socket = nil

data/lib/resqued/master.rb

@@ -187,7 +187,7 @@ module Resqued
     end
 
     def reap_all_listeners(waitpid_flags = 0)
-      loop do
+      until @listeners.empty?
         begin
           lpid, status = Process.waitpid2(-1, waitpid_flags)
           return unless lpid
@@ -200,12 +200,14 @@ module Resqued
           end
 
           if @listeners.last_good_pid == lpid
-            @state.clear_last_good!
+            @listeners.clear_last_good!
+          end
+
+          if dead_listener = @listeners.delete(lpid)
+            listener_status dead_listener, "stop"
+            dead_listener.dispose
           end
 
-          dead_listener = @listeners.delete(lpid)
-          listener_status dead_listener, "stop"
-          dead_listener.dispose
           write_procline
         rescue Errno::ECHILD
           return

data/lib/resqued/version.rb

@@ -1,3 +1,3 @@
 module Resqued
-  VERSION = "0.10.0".freeze
+  VERSION = "0.11.1".freeze
 end

data/lib/resqued/worker.rb

@@ -91,7 +91,11 @@ module Resqued
       else
         # In case we get a signal before resque is ready for it.
         Resqued::Listener::ALL_SIGNALS.each { |signal| trap(signal, "DEFAULT") }
-        trap(:QUIT) { exit! 0 } # If we get a QUIT during boot, just spin back down.
+        # Continue ignoring SIGHUP, though.
+        trap(:HUP) {}
+        # If we get a QUIT during boot, just spin back down.
+        trap(:QUIT) { exit! 0 }
+
         $0 = "STARTING RESQUE FOR #{queues.join(',')}"
         resque_worker = @worker_factory.call(queues)
         @config.after_fork(resque_worker)

data/spec/integration/listener_still_starting_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe "Listener still starting on SIGHUP" do
+  include ResquedIntegrationHelpers
+
+  it "expect master not to crash" do
+    start_resqued config: <<-CONFIG
+      before_fork do
+        sleep 1
+      end
+    CONFIG
+    expect_running listener: "listener #1"
+    restart_resqued
+    sleep 2
+    expect_running listener: "listener #2"
+  end
+
+  after do
+    begin
+      Process.kill(:QUIT, @pid) if @pid
+    rescue Errno::ESRCH
+    end
+  end
+end

data/spec/integration/master_inherits_child_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+require "timeout"
+
+describe "Resqued master with an extra child process" do
+  include ResquedPath
+
+  # Starts resqued with an extra child process.
+  def start_resqued_with_extra_child
+    shim_path = File.expand_path("../support/extra-child-shim", File.dirname(__FILE__))
+
+    config_path = File.join(SPEC_TEMPDIR, "config.rb")
+    File.write(config_path, <<-CONFIG)
+      before_fork { File.write(ENV["LISTENER_PIDFILE"], $$.to_s) }
+    CONFIG
+
+    logfile = File.join(SPEC_TEMPDIR, "resqued.log")
+    File.write(logfile, "") # truncate it
+
+    env = {
+      "LISTENER_PIDFILE" => listener_pidfile,
+      "EXTRA_CHILD_PIDFILE" => extra_child_pidfile,
+    }
+
+    pid = spawn(env, shim_path, resqued_path, "--logfile", logfile, config_path)
+    sleep 2.0
+    pid
+  end
+
+  let(:extra_child_pidfile) { File.join(SPEC_TEMPDIR, "extra-child.pid") }
+  def extra_child_pid
+    File.read(extra_child_pidfile).to_i
+  end
+
+  let(:listener_pidfile) { File.join(File.join(SPEC_TEMPDIR, "listener.pid")) }
+  def listener_pid
+    File.read(listener_pidfile).to_i
+  end
+
+  before do
+    File.unlink(extra_child_pidfile) rescue nil
+    File.unlink(listener_pidfile) rescue nil
+    @resqued_pid = start_resqued_with_extra_child
+  end
+
+  after do
+    kill_safely(:TERM) { @resqued_pid }
+    kill_safely(:KILL) { extra_child_pid }
+    sleep 0.1
+    kill_safely(:KILL) { @resqued_pid }
+  end
+
+  it "doesn't exit when listener dies unexpectedly" do
+    # Kill off the listener process.
+    first_listener_pid = listener_pid
+    Process.kill :QUIT, first_listener_pid
+    # Let Resqued::Backoff decide it's OK to start the listener again.
+    sleep 2.5
+    # Resqued should start a new listener to replace the dead one.
+    expect(listener_pid).not_to eq(first_listener_pid)
+  end
+
+  it "exits when listeners have all exited during shutdown" do
+    # Do a normal shutdown.
+    Process.kill :QUIT, @resqued_pid
+    # Expect the resqued process to exit.
+    expect(Timeout.timeout(5.0) { Process.waitpid(@resqued_pid) }).to eq(@resqued_pid)
+  end
+
+  it "doesn't crash when extra child exits" do
+    # Kill off the extra child process. Resqued should wait on it, but not exit.
+    Process.kill :KILL, extra_child_pid
+    sleep 1.0
+    # The resqued process should not have exited.
+    expect(Process.waitpid(@resqued_pid, Process::WNOHANG)).to be_nil
+    expect(Process.kill(0, @resqued_pid)).to eq(1)
+  end
+
+  def kill_safely(signal)
+    return unless pid = yield
+
+    Process.kill(signal, pid)
+  rescue Errno::ESRCH, Errno::ENOENT
+    # Process isn't there anymore, or pidfile isn't there. :+1:
+  end
+end

data/spec/integration/restart_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe "Resqued can restart" do
+  include ResquedIntegrationHelpers
+
+  it "expect to be able to restart" do
+    start_resqued
+    expect_running listener: "listener #1"
+    restart_resqued
+    expect_running listener: "listener #2"
+    stop_resqued
+    expect_not_running
+  end
+
+  after do
+    begin
+      Process.kill(:QUIT, @pid) if @pid
+    rescue Errno::ESRCH
+    end
+  end
+end

data/spec/resqued/backoff_spec.rb

@@ -6,7 +6,7 @@ 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
+    expect(backoff.wait?).to be_falsey
   end
 
   it "has no waiting at first" do
@@ -15,42 +15,42 @@ describe Resqued::Backoff do
 
   context "after expected exits" do
     before { 3.times { backoff.started } }
-    it { expect(backoff.wait?).to be_true }
+    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.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.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.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.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.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.wait?).to be true
       expect(backoff.how_long?).to be_close_to(0.5)
     end
   end

data/spec/resqued/config/worker_spec.rb

@@ -55,6 +55,17 @@ describe Resqued::Config::Worker do
     end
   end
 
+  context "small pool with percent" do
+    let(:config) { <<-END_CONFIG }
+      worker_pool 2
+      queue "a"
+      queue "b", :percent => 45
+    END_CONFIG
+    it { expect(result.size).to eq(2) }
+    it { expect(result[0]).to eq(queues: ["a", "b"]) }
+    it { expect(result[1]).to eq(queues: ["a"]) }
+  end
+
   context "pool (hash for concurrency)" do
     let(:config) { <<-END_CONFIG }
       before_fork { }
@@ -114,17 +125,17 @@ describe Resqued::Config::Worker do
 
   context "pool, with shuffled queues" do
     let(:config) { <<-END_CONFIG }
-      worker_pool 20, :shuffle_queues => true
-      queue 'a', :count => 10
-      queue 'b', :count => 15
+      worker_pool 200, :shuffle_queues => true
+      queue 'a', :count => 100
+      queue 'b', :count => 150
     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 { expect(result.size).to eq(200) }
+    it { (0..99).each { |i| expect(result[i][:queues].sort).to eq(["a", "b"]) } }
+    it { (100..149).each { |i| expect(result[i][:queues]).to eq(["b"]) } }
+    it { (150..199).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] }
+      shuffled_queues = result.take(100).map { |x| x[:queues] }
       expect(shuffled_queues.sort.uniq).to eq([["a", "b"], ["b", "a"]]) # Some of the queues should be shuffled
     end
   end

data/spec/resqued/test_case_spec.rb

@@ -7,8 +7,8 @@ describe Resqued::TestCase do
   context "LoadConfig" do
     let(:the_module) { described_class::LoadConfig }
     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"  }.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(RuntimeError) }
+    it { expect { test_case.assert_resqued "spec/fixtures/test_case_environment.rb", "spec/fixtures/test_case_after_fork_raises.rb"  }.to     raise_error(RuntimeError) }
     it { expect { test_case.assert_resqued "spec/fixtures/test_case_environment.rb", "spec/fixtures/test_case_no_workers.rb"         }.not_to raise_error }
   end
 end

data/spec/spec_helper.rb

@@ -1 +1,6 @@
 require "support/custom_matchers"
+require "support/resqued_path"
+require "support/resqued_integration_helpers"
+
+SPEC_TEMPDIR = File.expand_path("../tmp/spec", File.dirname(__FILE__))
+FileUtils.mkpath(SPEC_TEMPDIR)

data/spec/support/custom_matchers.rb

@@ -11,6 +11,10 @@ module CustomMatchers
       @epsilon = 0.01
     end
 
+    def supports_block_expectations?
+      true
+    end
+
     def within(epsilon)
       @epsilon = epsilon
       self
@@ -24,9 +28,13 @@ module CustomMatchers
       @epsilon >= diff
     end
 
-    def failure_message_for_should
+    def failure_message
       "Expected block to run for #{@expected_duration} +/-#{@epsilon} seconds, but it ran for #{@actual_duration} seconds."
     end
+
+    def failure_message_when_negated
+      "Expected block not to run for #{@expected_duration} +/-#{@epsilon} seconds, but it ran for #{@actual_duration} seconds."
+    end
   end
 end
 

data/spec/support/extra-child-shim

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+extra_child_pid = fork { sleep(100); exit! }
+File.write(ENV["EXTRA_CHILD_PIDFILE"], extra_child_pid.to_s)
+
+exec(*ARGV)

data/spec/support/resqued_integration_helpers.rb

@@ -0,0 +1,50 @@
+module ResquedIntegrationHelpers
+  include ResquedPath
+
+  def start_resqued(config: "", debug: false)
+    # Don't configure any workers. That way, we don't need to have redis running.
+    config_path = File.join(SPEC_TEMPDIR, "config.rb")
+    File.write(config_path, config)
+
+    @pid =
+      if debug
+        spawn resqued_path, config_path
+      else
+        logfile = File.join(SPEC_TEMPDIR, "resqued.log")
+        File.write(logfile, "") # truncate it
+
+        spawn resqued_path, "--logfile", logfile, config_path
+      end
+    sleep 1.0
+  end
+
+  def restart_resqued
+    Process.kill(:HUP, @pid)
+    sleep 1.0
+  end
+
+  def expect_running(listener:)
+    processes = list_processes
+    expect(processes).to include(is_resqued_master)
+    listeners = processes.select { |p| p[:ppid] == @pid }.map { |p| p[:args] }
+    expect(listeners).to all(match(/#{listener}/)).and(satisfy { |l| l.size == 1 })
+  end
+
+  def expect_not_running
+    processes = list_processes
+    expect(processes).not_to include(is_resqued_master)
+  end
+
+  def stop_resqued
+    Process.kill(:TERM, @pid)
+    sleep 1.0
+  end
+
+  def list_processes
+    `ps axo pid,ppid,args`.lines.map { |line| pid, ppid, args = line.strip.split(/\s+/, 3); { pid: pid.to_i, ppid: ppid.to_i, args: args } }
+  end
+
+  def is_resqued_master
+    satisfy { |p| p[:pid] == @pid && p[:args] =~ /resqued-/ }
+  end
+end

data/spec/support/resqued_path.rb

@@ -0,0 +1,11 @@
+module ResquedPath
+  def resqued_path
+    return @resqued_path if @resqued_path
+
+    @resqued_path = File.expand_path("../../gemfiles/bin/resqued", File.dirname(__FILE__))
+    unless File.executable?(@resqued_path)
+      @resqued_path = File.expand_path("../../bin/resqued", File.dirname(__FILE__))
+    end
+    @resqued_path
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resqued
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Matt Burke
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-30 00:00:00.000000000 Z
+date: 2021-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio
@@ -56,36 +56,30 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 13.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 13.0.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: 3.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: 3.9.0
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +137,9 @@ files:
 - spec/fixtures/test_case_clean.rb
 - spec/fixtures/test_case_environment.rb
 - spec/fixtures/test_case_no_workers.rb
+- spec/integration/listener_still_starting_spec.rb
+- spec/integration/master_inherits_child_spec.rb
+- spec/integration/restart_spec.rb
 - spec/resqued/backoff_spec.rb
 - spec/resqued/config/fork_event_spec.rb
 - spec/resqued/config/worker_spec.rb
@@ -152,7 +149,9 @@ files:
 - spec/resqued/test_case_spec.rb
 - spec/spec_helper.rb
 - spec/support/custom_matchers.rb
-- spec/test_restart.sh
+- spec/support/extra-child-shim
+- spec/support/resqued_integration_helpers.rb
+- spec/support/resqued_path.rb
 homepage: https://github.com/spraints/resqued
 licenses:
 - MIT
@@ -172,24 +171,28 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Daemon of resque workers
 test_files:
-- spec/resqued/sleepy_spec.rb
-- spec/resqued/backoff_spec.rb
-- spec/resqued/config/worker_spec.rb
-- spec/resqued/config/fork_event_spec.rb
-- spec/resqued/start_ctx_spec.rb
-- spec/resqued/config_spec.rb
-- spec/resqued/test_case_spec.rb
 - spec/spec_helper.rb
+- spec/integration/restart_spec.rb
+- spec/integration/listener_still_starting_spec.rb
+- spec/integration/master_inherits_child_spec.rb
+- spec/support/resqued_integration_helpers.rb
+- spec/support/custom_matchers.rb
+- spec/support/resqued_path.rb
+- spec/support/extra-child-shim
+- spec/fixtures/test_case_clean.rb
 - spec/fixtures/test_case_before_fork_raises.rb
 - spec/fixtures/test_case_environment.rb
 - spec/fixtures/test_case_no_workers.rb
 - spec/fixtures/test_case_after_fork_raises.rb
-- spec/fixtures/test_case_clean.rb
-- spec/test_restart.sh
-- spec/support/custom_matchers.rb
+- spec/resqued/config_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/resqued/start_ctx_spec.rb
+- spec/resqued/backoff_spec.rb

data/spec/test_restart.sh

@@ -1,84 +0,0 @@
-#!/bin/bash
-
-set -e
-set -o nounset
-
-WORKDIR="$(mktemp)"
-PIDFILE="${WORKDIR}/resqued.pid"
-CONFIG="${WORKDIR}/config.rb"
-
-# mktemp makes a file, but we want a dir.
-rm -f "$WORKDIR"
-mkdir "$WORKDIR"
-
-set -x
-cd "$(dirname "$0")/.."
-
-main() {
-  trap cleanup EXIT
-
-  configure_resqued
-  start_resqued
-  restart_resqued
-  stop_resqued
-}
-
-configure_resqued() {
-  # Don't configure any workers. That way, we don't need to have redis running.
-  touch "${CONFIG}"
-}
-
-start_resqued() {
-  bin_resqued=bin/resqued
-  if [ -x gemfiles/bin/resqued ]; then
-    bin_resqued=gemfiles/bin/resqued
-  fi
-  $bin_resqued --pidfile "${PIDFILE}" "${CONFIG}" &
-  sleep 1
-  echo expect to find the master process and the first listener
-  running # set -e will make the test fail if it's not running
-  ps axo pid,args -H | grep [r]esqued-
-  ps axo pid,args | grep [r]esqued- | grep -q 'listener #1.*running'
-}
-
-restart_resqued() {
-  local pid="$(cat "${PIDFILE}")"
-  kill -HUP "$pid"
-  sleep 1
-  echo expect to find the master process and the second listener
-  running
-  ps axo pid,args -H | grep [r]esqued-
-  ps axo pid,args | grep [r]esqued- | grep -qv 'listener #1'
-  ps axo pid,args | grep [r]esqued- | grep -q 'listener #2.*running'
-}
-
-stop_resqued() {
-  local pid="$(cat "${PIDFILE}")"
-  kill -TERM "$pid"
-  sleep 1
-  echo expect everything to be stopped
-  if running >&/dev/null; then
-    echo "expected resqued to be stopped"
-    false
-  fi
-  ps axo pid,args -H | grep [r]esqued- || true
-  test -z "$(ps axo pid,args | grep [r]esqued-)"
-}
-
-running() {
-  set -e
-  test -f "${PIDFILE}"
-  local pid="$(cat "${PIDFILE}")"
-  kill -0 "$pid"
-  ps o pid,args "$pid"
-}
-
-cleanup() {
-  while running >&/dev/null; do
-    kill -TERM "$(cat "${PIDFILE}")"
-    sleep 2
-  done
-  rm -rfv "${WORKDIR}" || rm -rf "${WORKDIR}"
-}
-
-main