resqued 0.9.0 → 0.11.0

data/lib/resqued/master_state.rb

@@ -0,0 +1,73 @@
+module Resqued
+  class MasterState
+    def initialize
+      @listeners_created = 0
+      @listener_states = {}
+    end
+
+    # Public: When starting fresh, from command-line options, assign the initial values.
+    def init(options)
+      @config_paths = options.fetch(:config_paths)
+      @exec_on_hup  = options.fetch(:exec_on_hup, false)
+      @fast_exit    = options.fetch(:fast_exit, false)
+      @pidfile      = options.fetch(:master_pidfile, nil)
+    end
+
+    # Public: Restore state from a serialized form.
+    def restore(data)
+      @config_paths = data[:config_paths]
+      @current_listener_pid = data[:current_listener_pid]
+      @exec_on_hup = data[:exec_on_hup]
+      @fast_exit = data[:fast_exit]
+      @last_good_listener_pid = data[:last_good_listener_pid]
+      @listeners_created = data[:listeners_created]
+      data[:listener_states].each do |lsh|
+        @listener_states[lsh[:pid]] = ListenerState.new.tap do |ls|
+          ls.master_socket = lsh[:master_socket] && Socket.for_fd(lsh[:master_socket])
+          ls.options = lsh[:options]
+          ls.pid = lsh[:pid]
+          ls.worker_pids = lsh[:worker_pids]
+        end
+      end
+      @paused = data[:paused]
+      @pidfile = data[:pidfile]
+    end
+
+    # Public: Return this state so that it can be serialized.
+    def to_h
+      {
+        config_paths: @config_paths,
+        current_listener_pid: @current_listener_pid,
+        exec_on_hup: @exec_on_hup,
+        fast_exit: @fast_exit,
+        last_good_listener_pid: @last_good_listener_pid,
+        listeners_created: @listeners_created,
+        listener_states: @listener_states.values.map { |ls|
+          {
+            master_socket: ls.master_socket&.to_i,
+            options: ls.options,
+            pid: ls.pid,
+            worker_pids: ls.worker_pids,
+          }
+        },
+        paused: @paused,
+        pidfile: @pidfile,
+      }
+    end
+
+    # Public: Return an array of open sockets or other file handles that should be forwarded to a new master.
+    def sockets
+      @listener_states.values.map { |l| l.master_socket }.compact
+    end
+
+    attr_reader :config_paths
+    attr_accessor :current_listener_pid
+    attr_reader :exec_on_hup
+    attr_reader :fast_exit
+    attr_accessor :last_good_listener_pid
+    attr_accessor :listeners_created
+    attr_reader :listener_states
+    attr_accessor :paused
+    attr_reader :pidfile
+  end
+end

data/lib/resqued/procline_version.rb

@@ -1,4 +1,4 @@
-require 'resqued/version'
+require "resqued/version"
 
 module Resqued
   module ProclineVersion
@@ -6,7 +6,7 @@ module Resqued
       @version ||=
         begin
           # If we've built a custom version, this should show the custom version.
-          Gem.loaded_specs['resqued'].version.to_s
+          Gem.loaded_specs["resqued"].version.to_s
         rescue Object
           # If this isn't a gem, fall back to the version in resqued/version.rb.
           Resqued::VERSION

data/lib/resqued/sleepy.rb

@@ -1,9 +1,11 @@
-require 'fcntl'
-require 'kgio'
+require "fcntl"
+require "kgio"
 
 module Resqued
   module Sleepy
-    # 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).
+    # 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)
       if duration > 0
         inputs = [self_pipe[0]] + [inputs].flatten.compact
@@ -14,7 +16,7 @@ module Resqued
 
     # Public: Break out of `yawn`.
     def awake
-      self_pipe[1].kgio_trywrite('.')
+      self_pipe[1].kgio_trywrite(".")
     end
 
     # Private.

data/lib/resqued/test_case.rb

@@ -1,5 +1,5 @@
-require 'resqued/config'
-require 'resqued/runtime_info'
+require "resqued/config"
+require "resqued/runtime_info"
 
 module Resqued
   module TestCase
@@ -17,7 +17,7 @@ module Resqued
         config = Resqued::Config.new(paths)
         config.before_fork(RuntimeInfo.new)
         config.build_workers
-        config.after_fork(Resque::Worker.new('*'))
+        config.after_fork(Resque::Worker.new("*"))
       end
     end
 

data/lib/resqued/version.rb

@@ -1,3 +1,3 @@
 module Resqued
-  VERSION = '0.9.0'
+  VERSION = "0.11.0".freeze
 end

data/lib/resqued/worker.rb

@@ -1,17 +1,17 @@
-require 'resque'
-require 'digest'
+require "resque"
+require "digest"
 
-require 'resqued/backoff'
-require 'resqued/logging'
+require "resqued/backoff"
+require "resqued/logging"
 
 module Resqued
   # Models a worker process.
   class Worker
     include Resqued::Logging
 
-    DEFAULT_WORKER_FACTORY = ->(queues) {
+    DEFAULT_WORKER_FACTORY = lambda { |queues|
       resque_worker = Resque::Worker.new(*queues)
-      resque_worker.term_child = true if resque_worker.respond_to?('term_child=')
+      resque_worker.term_child = true if resque_worker.respond_to?("term_child=")
       redis_client = Resque.redis.respond_to?(:_client) ? Resque.redis._client : Resque.redis.client
       redis_client.reconnect
       resque_worker
@@ -44,12 +44,13 @@ module Resqued
 
     # Public: A string that compares if this worker is equivalent to a worker in another Resqued::Listener.
     def queue_key
-      Digest::SHA256.hexdigest(queues.sort.join(';'))
+      Digest::SHA256.hexdigest(queues.sort.join(";"))
     end
 
     # 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 = false
       @pids << pid
       @pid = pid
@@ -57,16 +58,17 @@ module Resqued
 
     # Public: The old worker process finished!
     def finished!(process_status)
-      if process_status.nil? && ! @self_started
-        log :debug, "(#{@pid}/#{@pids.inspect}/self_started=#{@self_started}/killed=#{@killed}) I am no longer blocked."
+      summary = "(#{@pid}/#{@pids.inspect}/self_started=#{@self_started}/killed=#{@killed})"
+      if process_status.nil? && !@self_started
+        log :debug, "#{summary} I am no longer blocked."
         @pid = nil
         @backoff.died unless @killed
-      elsif ! process_status.nil? && @self_started
-        log :debug, "(#{@pid}/#{@pids.inspect}/self_started=#{@self_started}/killed=#{@killed}) I exited: #{process_status}"
+      elsif !process_status.nil? && @self_started
+        log :debug, "#{summary} I exited: #{process_status}"
         @pid = nil
         @backoff.died unless @killed
       else
-        log :debug, "(#{@pid}/#{@pids.inspect}/self_started=#{@self_started}/killed=#{@killed}) Reports of my death are highly exaggerated (#{process_status.inspect})"
+        log :debug, "#{summary} Reports of my death are highly exaggerated (#{process_status.inspect})"
       end
     end
 
@@ -78,6 +80,7 @@ module Resqued
     # Public: Start a job, if there's one waiting in one of my queues.
     def try_start
       return if @backoff.wait?
+
       @backoff.started
       @self_started = true
       @killed = false
@@ -87,8 +90,12 @@ module Resqued
         log "Forked worker #{@pid}"
       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.
+        Resqued::Listener::ALL_SIGNALS.each { |signal| trap(signal, "DEFAULT") }
+        # 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/fixtures/test_case_after_fork_raises.rb

@@ -1,3 +1,6 @@
-after_fork { raise 'boom' }
+after_fork do
+  raise "boom"
+end
+
 worker_pool 100
-queue 'test'
+queue "test"

data/spec/fixtures/test_case_before_fork_raises.rb

@@ -1,2 +1,5 @@
-before_fork { raise 'boom' }
+before_fork do
+  raise "boom"
+end
+
 worker "test"

data/spec/fixtures/test_case_environment.rb

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

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

@@ -1,61 +1,61 @@
-require 'spec_helper'
+require "spec_helper"
 
-require 'resqued/backoff'
+require "resqued/backoff"
 
 describe Resqued::Backoff do
-  let(:backoff) { described_class.new(:min => 0.5, :max => 64.0) }
+  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
+  it "can start on the first try" do
+    expect(backoff.wait?).to be_falsey
   end
 
-  it 'has no waiting at first' do
+  it "has no waiting at first" do
     expect(backoff.how_long?).to be_nil
   end
 
-  context 'after expected exits' 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 }
+  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 }
+  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 }
+  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 }
+  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 }
+  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
+    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
 
-  def be_close_to(x)
-    be_within(0.005).of(x)
+  def be_close_to(number)
+    be_within(0.005).of(number)
   end
 end