resqued 0.8.5 → 0.10.2

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.8.5'
+  VERSION = '0.10.2'
 end

data/lib/resqued/worker.rb

@@ -1,17 +1,19 @@
-require 'resque'
+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.redis.client.reconnect
+      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
     }
 
@@ -42,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
-      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
@@ -55,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
 
@@ -76,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
@@ -85,7 +90,7 @@ 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') }
+        Resqued::Listener::ALL_SIGNALS.each { |signal| trap(signal, "DEFAULT") }
         trap(:QUIT) { exit! 0 } # If we get a QUIT during boot, just spin back down.
         $0 = "STARTING RESQUE FOR #{queues.join(',')}"
         resque_worker = @worker_factory.call(queues)

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/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 1.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,63 @@
+require "spec_helper"
+
+describe "Resqued can restart" do
+  include ResquedPath
+
+  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
+
+  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 start_resqued
+    # 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, "")
+
+    logfile = File.join(SPEC_TEMPDIR, "resqued.log")
+    File.write(logfile, "") # truncate it
+
+    @pid = spawn resqued_path, "--logfile", logfile, config_path
+    sleep 1.0
+  end
+
+  def restart_resqued
+    Process.kill(:HUP, @pid)
+    sleep 1.0
+  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/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