resque-pool 0.3.0.beta.1 → 0.3.0.beta.2

data/Changelog.md

@@ -1,17 +1,3 @@
-## unreleased
-
-* enhancement: new callbacks for configuration
-  * `Resque::Pool.configure do |pool| ... end`
-  * `pool.after_manager_wakeup`
-  * `pool.to_calculate_worker_offset`
-  * `pool.after_prefork` (instance callback prefered over class callback)
-* experimental: memory management
-* experimental: check orphaned workers
-* development: a good bit of code cleanup and rearrangement
-
-See ExperimentalFeatures.md for more info.  Thanks to Jason Haruska for these
-features!
-
 ## 0.2.0 (2011-03-15)
 
 * new feature: sending `HUP` to pool manager will reload the logfiles and

data/README.md

@@ -13,12 +13,19 @@ Benefits
   will monitor your workers for you.  An example init.d script, monit config,
   and chef cookbook are provided.
 * Less memory - If you are using Ruby Enterprise Edition, or any ruby with
-  copy-on-write safe garbage collection, this should save you a lot of memory
+  copy-on-write safe garbage collection, this should save you a *lot* of memory
   when you are managing many workers.
 * Faster startup - when you start many workers at once, they would normally
   compete for CPU as they load their environments.  Resque-pool can load the
   environment once and fork all of the workers almost instantly.
 
+Upgrading?
+-----------
+
+See
+[Changelog.md](https://github.com/nevans/resque-pool/blob/master/Changelog.md)
+in case there are important or helpful changes.
+
 How to use
 -----------
 
@@ -130,11 +137,6 @@ their current job) if the manager process disappears before them.
 You can specify an alternate config file by setting the `RESQUE_POOL_CONFIG` or
 with the `--config` command line option.
 
-Experimental Features
----------------------
-
-See `ExperimentalFeatures.md` for some potentially useful works in progress.
-
 TODO
 -----
 
@@ -143,8 +145,8 @@ See [the TODO list](https://github.com/nevans/resque-pool/issues) at github issu
 Contributors
 -------------
 
-* Jason Haruska from Backupify (pidfile management, memory management, wait for orphaned workers)
 * John Schult (config file can be split by environment)
 * Stephen Celis (increased gemspec sanity)
 * Vincent Agnello, Robert Kamunyori, Paul Kauders; for pairing with me at
-  [B'more on Rails](http://twitter.com/bmoreonrails) Open Source Hack Nights. :)
+  B'more on Rails Open Source Hack Nights. :)
+

data/Rakefile

@@ -15,3 +15,16 @@ Cucumber::Rake::Task.new(:features) do |c|
 end
 
 task :default => [:spec, :features]
+
+rule(/\.[1-9]$/ => [proc { |tn| "#{tn}.ronn" }]) do |t|
+  name = Resque::Pool.name.sub('::','-').upcase
+  version = "%s %s" % [name, Resque::Pool::VERSION.upcase]
+
+  manual = '--manual "%s"' % name
+  organization = '--organization "%s"' % version
+  sh "ronn #{manual} #{organization} <#{t.source} >#{t.name}"
+end
+
+file 'man/resque-pool.1'
+file 'man/resque-pool.yml.5'
+task :manpages => ['man/resque-pool.1','man/resque-pool.yml.5']

data/bin/resque-pool

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 # -*- encoding: utf-8 -*-
 
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
 require 'resque/pool/cli'
 Resque::Pool::CLI.run

data/features/step_definitions/daemon_steps.rb

@@ -25,5 +25,9 @@ end
 After do
   kill_all_processes!
   # now kill the daemon!
-  `pkill -9 -f resque-pool`
+  begin
+    Process.kill(9, @pid_from_pidfile) if @pid_from_pidfile
+  rescue Errno::ESRCH
+  end
+  #`pkill -9 resque-pool`
 end

data/features/step_definitions/resque-pool_steps.rb

@@ -7,7 +7,7 @@ def process_should_not_exist(pid)
 end
 
 def grab_worker_pids(count, str)
-  announce "TODO: check output_or_log for #{count} worker started messages"
+  puts "TODO: check output_or_log for #{count} worker started messages"
   pid_regex = (1..count).map { '(\d+)' }.join ', '
   full_regex = /resque-pool-manager\[\d+\]: Pool contains worker PIDs: \[#{pid_regex}\]/m
   str.should =~ full_regex
@@ -28,7 +28,7 @@ end
 def output_or_log(report_log)
   case report_log
   when "report", "output"
-    all_output
+    interactive_output
   when "log", "logfiles"
     in_current_dir do
       File.read("log/resque-pool.stdout.log") << File.read("log/resque-pool.stderr.log")
@@ -56,7 +56,7 @@ When /^I send the pool manager the "([^"]*)" signal$/ do |signal|
   case signal
   when "QUIT"
     keep_trying do
-      Then "the #{output_logfiles} should contain the following lines (with interpolated $PID):", <<-EOF
+      step "the #{output_logfiles} should contain the following lines (with interpolated $PID):", <<-EOF
 resque-pool-manager[$PID]: QUIT: graceful shutdown, waiting for children
       EOF
     end
@@ -77,7 +77,7 @@ Then /^the pool manager should record its pid in "([^"]*)"$/ do |pidfile|
 end
 
 Then /^the pool manager should daemonize$/ do
-  @pool_manager_process.stop
+  stop_processes!
 end
 
 Then /^the pool manager daemon should finish$/ do
@@ -91,7 +91,7 @@ end
 
 Then /^the pool manager should (report|log) that it has started up$/ do |report_log|
   keep_trying do
-    Then "the #{output_or_logfiles_string(report_log)} should contain the following lines (with interpolated $PID):", <<-EOF
+    step "the #{output_or_logfiles_string(report_log)} should contain the following lines (with interpolated $PID):", <<-EOF
 resque-pool-manager[$PID]: Resque Pool running in development environment
 resque-pool-manager[$PID]: started manager
     EOF
@@ -99,7 +99,7 @@ resque-pool-manager[$PID]: started manager
 end
 
 Then /^the pool manager should (report|log) that the pool is empty$/ do |report_log|
-  Then "the #{output_or_logfiles_string(report_log)} should contain the following lines (with interpolated $PID):", <<-EOF
+  step "the #{output_or_logfiles_string(report_log)} should contain the following lines (with interpolated $PID):", <<-EOF
 resque-pool-manager[$PID]: Pool is empty
   EOF
 end
@@ -128,17 +128,17 @@ end
 
 Then "the pool manager should finish" do
   # assuming there will not be multiple processes running
-  processes.each { |cmd, p| p.stop }
+  stop_processes!
 end
 
 Then /^the pool manager should (report|log) that it is finished$/ do |report_log|
-  Then "the #{output_or_logfiles_string(report_log)} should contain the following lines (with interpolated $PID):", <<-EOF
+  step "the #{output_or_logfiles_string(report_log)} should contain the following lines (with interpolated $PID):", <<-EOF
 resque-pool-manager[$PID]: manager finished
   EOF
 end
 
 Then /^the pool manager should (report|log) that a "([^"]*)" worker has been reaped$/ do |report_log, worker_type|
-  And 'the '+ output_or_logfiles_string(report_log) +' should match /Reaped resque worker\[\d+\] \(status: 0\) queues: '+ worker_type + '/'
+  step 'the '+ output_or_logfiles_string(report_log) +' should match /Reaped resque worker\[\d+\] \(status: 0\) queues: '+ worker_type + '/'
 end
 
 Then /^the logfiles should match \/([^\/]*)\/$/ do |partial_output|

data/features/support/aruba_daemon_support.rb

@@ -8,7 +8,7 @@ module Aruba
     # this is a horrible hack, to make sure that it's done what it needs to do
     # before we do our next step
     def keep_trying(timeout=10, tries=0)
-      announce "Try: #{tries}" if @announce_env
+      puts "Try: #{tries}" if @announce_env
       yield
     rescue RSpec::Expectations::ExpectationNotMetError
       if tries < timeout
@@ -33,6 +33,21 @@ module Aruba
       @pid_from_pidfile || @background.pid
     end
 
+    # like all_stdout, but doesn't stop processes first
+    def interactive_stdout
+      only_processes.inject("") { |out, ps| out << ps.stdout(@aruba_keep_ansi) }
+    end
+
+    # like all_stderr, but doesn't stop processes first
+    def interactive_stderr
+      only_processes.inject("") { |out, ps| out << ps.stderr(@aruba_keep_ansi) }
+    end
+
+    # like all_output, but doesn't stop processes first
+    def interactive_output
+      interactive_stdout << interactive_stderr
+    end
+
     def interpolate_background_pid(string)
       interpolated = string.gsub('$PID', background_pid.to_s)
       announce_or_puts interpolated if @announce_env
@@ -40,10 +55,10 @@ module Aruba
     end
 
     def kill_all_processes!
-      stop_processes!
-    rescue
-      processes.each {|cmd,process| send_signal(cmd, 'KILL') }
-      raise
+    #  stop_processes!
+    #rescue
+    #  processes.each {|cmd,process| send_signal(cmd, 'KILL') }
+    #  raise
     end
 
   end

data/lib/resque/pool.rb

@@ -1,13 +1,9 @@
 # -*- encoding: utf-8 -*-
 require 'resque'
+require 'resque/worker'
 require 'resque/pool/version'
 require 'resque/pool/logging'
-require 'resque/pool/manager'
-require 'resque/pool/worker_type_manager'
-# experimental features!
-require 'resque/pool/memory_manager'
-require 'resque/pool/orphan_watcher'
-
+require 'resque/pool/pooled_worker'
 require 'fcntl'
 require 'yaml'
 
@@ -24,74 +20,30 @@ module Resque
 
     def initialize(config)
       init_config(config)
-      @workers = {}
+      @workers = Hash.new { |workers, queues| workers[queues] = {} }
       procline "(initialized)"
     end
 
-    # Config: hooks {{{
-
-    # The +configure+ block will be run once during pool startup, after the
-    # internal initialization is complete, but before any workers are started
-    # up.  This is for configuring any runtime callbacks that you want to
-    # customize (e.g.  +after_wakup+, +worker_offset_handler+)
-    #
-    # Call with a block to set.
-    # Call with no arguments to return the hook.
-    def self.configure(&block)
-      block ? (@configure = block) : @configure
-    end
-
-    def call_configure!
-      self.class.configure && self.class.configure.call(self)
-    end
-
-    # The +after_manager_wakeup+ hook will be run in the pool manager every
-    # time the pool manager wakes up from IO.select (normally once a second).
-    # It will run immediately before the pool manager performs its normal
-    # worker maintenance (starting and stopping workers as necessary).  If you
-    # have some special logic for killing workers that are taking too long or
-    # using too much memory, this is the place to put it.
-    #
-    # Call with a block to set the hook.
-    # Call with no arguments to return the hook.
-    def after_manager_wakeup(&block)
-      block ? (@after_manager_wakeup = block) : @after_manager_wakeup
-    end
-
-    def call_after_manager_wakeup!
-      after_manager_wakeup && after_manager_wakeup.call(self)
-    end
-
-    def to_calculate_worker_offset(&block)
-      block ? (@to_calculate_worker_offset = block) : @to_calculate_worker_offset
-    end
-
-    # deprecated by instance level +after_prefork+ hook
-    def self.after_prefork(&block)
-      #log '"Resque::Pool.after_prefork(&blk)" is deprecated.'
-      #log 'Please use "Resque::Pool.configure {|p| p.after_prefork(&blk) }" instead.'
-      block ? (@after_prefork = block) : @after_prefork
-    end
+    # Config: after_prefork {{{
 
-    # The +after_prefork+ hook will be run in workers if you are using the
+    # The `after_prefork` hook will be run in workers if you are using the
     # preforking master worker to save memory. Use this hook to reload
     # database connections and so forth to ensure that they're not shared
     # among workers.
     #
     # Call with a block to set the hook.
     # Call with no arguments to return the hook.
-    def after_prefork(&block)
+    def self.after_prefork(&block)
       block ? (@after_prefork = block) : @after_prefork
     end
 
     # Set the after_prefork proc.
-    def after_prefork=(after_prefork)
+    def self.after_prefork=(after_prefork)
       @after_prefork = after_prefork
     end
 
     def call_after_prefork!
-      (after_prefork && after_prefork.call) ||
-        (self.class.after_prefork && self.class.after_prefork.call)
+      self.class.after_prefork && self.class.after_prefork.call
     end
 
     # }}}
@@ -142,9 +94,7 @@ module Resque
     end
 
     def environment
-      if defined? Rails
-        Rails.env
-      elsif defined? RAILS_ENV # keep compatibility with older versions of rails
+      if defined? RAILS_ENV
         RAILS_ENV
       else
         ENV['RACK_ENV'] || ENV['RAILS_ENV'] || ENV['RESQUE_ENV']
@@ -195,6 +145,10 @@ module Resque
       end
     end
 
+    def reset_sig_handlers!
+      QUEUE_SIGS.each {|sig| trap(sig, "DEFAULT") }
+    end
+
     def handle_sig_queue!
       case signal = sig_queue.shift
       when :USR1, :USR2, :CONT
@@ -232,8 +186,6 @@ module Resque
     # start, join, and master sleep {{{
 
     def start
-      procline("(configuring)")
-      call_configure!
       procline("(starting)")
       init_self_pipe!
       init_sig_handlers!
@@ -258,7 +210,6 @@ module Resque
         break if handle_sig_queue! == :break
         if sig_queue.empty?
           master_sleep
-          call_after_manager_wakeup!
           maintain_worker_count
         end
         procline("managing #{all_pids.inspect}")
@@ -287,17 +238,20 @@ module Resque
         loop do
           # -1, wait for any child process
           wpid, status = Process.waitpid2(-1, waitpid_flags)
-          wpid or break
-          worker = delete_worker(wpid)
-          # TODO: close any file descriptors connected to worker, if any
-          log "Reaped resque worker[#{status.pid}] (status: #{status.exitstatus}) queues: #{worker.queues.join(",")}"
+          break unless wpid
+
+          if worker = delete_worker(wpid)
+            log "Reaped resque worker[#{status.pid}] (status: #{status.exitstatus}) queues: #{worker.queues.join(",")}"
+          else
+            # this died before it could be killed, so it's not going to have any extra info
+            log "Tried to reap worker [#{status.pid}], but it had already died. (status: #{status.exitstatus})"
+          end
         end
-      rescue Errno::EINTR
-        retry
       rescue Errno::ECHILD, QuitNowException
       end
     end
 
+    # TODO: close any file descriptors connected to worker, if any
     def delete_worker(pid)
       worker = nil
       workers.detect do |queues, pid_to_worker|
@@ -317,20 +271,63 @@ module Resque
     end
 
     # }}}
-    # maintain_worker_count, all_known_worker_types, worker_offset {{{
+    # ???: maintain_worker_count, all_known_queues {{{
 
     def maintain_worker_count
-      all_known_worker_types.each do |queues|
-        WorkerTypeManager.new(self, queues).maintain_worker_count(worker_offset)
+      all_known_queues.each do |queues|
+        delta = worker_delta_for(queues)
+        spawn_missing_workers_for(queues) if delta > 0
+        quit_excess_workers_for(queues)   if delta < 0
       end
     end
 
-    def all_known_worker_types
+    def all_known_queues
       config.keys | workers.keys
     end
 
-    def worker_offset
-      to_calculate_worker_offset && to_calculate_worker_offset.call || 0
+    # }}}
+    # methods that operate on a single grouping of queues {{{
+    # perhaps this means a class is waiting to be extracted
+
+    def spawn_missing_workers_for(queues)
+      worker_delta_for(queues).times do |nr|
+        spawn_worker!(queues)
+      end
+    end
+
+    def quit_excess_workers_for(queues)
+      delta = -worker_delta_for(queues)
+      pids_for(queues)[0...delta].each do |pid|
+        Process.kill("QUIT", pid)
+      end
+    end
+
+    def worker_delta_for(queues)
+      config.fetch(queues, 0) - workers.fetch(queues, []).size
+    end
+
+    def pids_for(queues)
+      workers[queues].keys
+    end
+
+    def spawn_worker!(queues)
+      worker = create_worker(queues)
+      pid = fork do
+        log_worker "Starting worker #{worker}"
+        call_after_prefork!
+        reset_sig_handlers!
+        #self_pipe.each {|io| io.close }
+        worker.work(ENV['INTERVAL'] || DEFAULT_WORKER_INTERVAL) # interval, will block
+      end
+      workers[queues][pid] = worker
+    end
+
+    def create_worker(queues)
+      queues = queues.to_s.split(',')
+      worker = ::Resque::Worker.new(*queues)
+      worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+      worker.very_verbose = ENV['VVERBOSE']
+      worker
     end
 
     # }}}