resque-pool 0.6.0 → 0.7.0

data/config/alternate.yml

@@ -0,0 +1,4 @@
+foo: 37
+bar: 42
+baz: 3
+quux: 7

data/config/cucumber.yml

@@ -0,0 +1,2 @@
+default: --format pretty   --strict --require features --tags "not @wip and not @pending"
+rake:    --format progress --strict --require features --tags "not @wip and not @pending"

data/examples/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec :path => ".."

data/examples/Gemfile.lock

@@ -0,0 +1,80 @@
+PATH
+  remote: /home/nick/src/active/resque-pool
+  specs:
+    resque-pool (0.3.0.dev)
+      rake
+      resque (~> 1.20)
+      trollop (~> 1.16)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    SystemTimer (1.2.3)
+    aruba (0.4.11)
+      childprocess (>= 0.2.3)
+      cucumber (>= 1.1.1)
+      ffi (>= 1.0.11)
+      rspec (>= 2.7.0)
+    builder (3.0.0)
+    childprocess (0.3.2)
+      ffi (~> 1.0.6)
+    cucumber (1.1.9)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.9.0)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
+    diff-lcs (1.1.3)
+    ffi (1.0.11)
+    gherkin (2.9.3)
+      json (>= 1.4.6)
+    hpricot (0.8.6)
+    json (1.6.6)
+    multi_json (1.3.2)
+    mustache (0.99.4)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rake (0.9.2.2)
+    rdiscount (1.6.8)
+    redis (2.2.2)
+    redis-namespace (1.0.3)
+      redis (< 3.0.0)
+    resque (1.20.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.0.2)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      mustache (>= 0.7.0)
+      rdiscount (>= 1.5.8)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    sinatra (1.3.2)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    term-ansicolor (1.0.7)
+    tilt (1.3.3)
+    trollop (1.16.2)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  SystemTimer
+  aruba (~> 0.4.11)
+  bundler (~> 1.0)
+  cucumber (~> 1.1.9)
+  resque-pool!
+  ronn
+  rspec (~> 2.9.0)

data/examples/Rakefile

@@ -0,0 +1,8 @@
+# If you have redis running on the standard port on localhost, then you can
+# test out resque-pool in the examples directory by running:
+#
+#    rake --trace resque:pool
+#
+# And then you can poke and prod the various processes with signals and edit
+# the config file, etc.
+require 'resque/pool/tasks'

data/examples/chef_cookbook/recipes/default.rb

@@ -0,0 +1,46 @@
+roles = %w[solo util]
+if roles.include?(node[:instance_role])
+  node[:applications].each do |app, data|
+
+    pidfile = "/data/#{app}/current/tmp/pids/#{app}_resque.pid"
+
+    template "/etc/monit.d/#{app}_resque.monitrc" do
+      owner 'root'
+      group 'root'
+      mode 0644
+      source "monitrc.erb"
+      variables({
+        :app_name => app,
+        :pidfile  => pidfile,
+        #:max_mem  => "400 MB",
+      })
+    end
+
+    template "/etc/init.d/#{app}_resque" do
+      owner 'root'
+      group 'root'
+      mode 0744
+      source "initd.erb"
+      variables({
+        :app_name => app,
+        :pidfile  => pidfile,
+      })
+    end
+
+    execute "enable-resque" do
+      command "rc-update add #{app}_resque default"
+      action :run
+      not_if "rc-update show | grep -q '^ *#{app}_resque |.*default'"
+    end
+
+    execute "start-resque" do
+      command %Q{/etc/init.d/#{app}_resque start}
+      creates pidfile
+    end
+
+    execute "ensure-resque-is-setup-with-monit" do
+      command %Q{monit reload}
+    end
+
+  end
+end

data/examples/chef_cookbook/templates/default/initd.erb

@@ -0,0 +1,69 @@
+#!/bin/sh -e
+# Copyright (C) nicholas a. evans <nick@ekenosen.net>
+# See LICENSE.txt
+
+### BEGIN INIT INFO
+# Provides:          resque-pool-<%= @app_name %>
+# Required-Start:    $local_fs $remote_fs $network
+# Required-Stop:     $local_fs $remote_fs $network
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: resque-pool init script for <%= @app_name %>
+# Description:       resque-pool manages the resque workers
+### END INIT INFO
+
+# configure these values here or in /etc/default/resque-pool
+# make sure your pidfile here matches your monitrc
+app_name="<%= @app_name %>"
+pidfile="<%= @pidfile %>"
+app_dir="/data/${app_name}/current"
+run_as_user="deploy"
+sleep_time_during_restart=5
+stop_schedule="QUIT/30/INT/10/KILL/5"
+bundler="/usr/bin/bundle"
+environment="production"
+stdout_log="${app_dir}/log/resque-pool-${app_name}.stdout.log"
+stderr_log="${app_dir}/log/resque-pool-${app_name}.stderr.log"
+
+# override above values, and set any other env variables you need
+if [ -f /etc/default/resque ] ; then
+  . /etc/default/resque
+fi
+if [ -f /etc/default/${app_name}_resque ] ; then
+  . /etc/default/${app_name}_resque
+fi
+
+case "$1" in
+  start)
+    # I'm assuming that you are using bundler.  If you are using rip or
+    # something else, you'll need to change this.  Remember to
+    # keep the double-dash; e.g.: --startas CMD -- ARGS
+    start-stop-daemon --start --pidfile ${pidfile} \
+      --chuid ${run_as_user} --chdir ${app_dir} \
+      --startas ${bundler} -- exec \
+      resque-pool -d -a ${app_name} -p ${pidfile} -E ${environment} -o ${stdout_log} -e ${stderr_log}
+    ;;
+  reload)
+    start-stop-daemon --stop --pidfile ${pidfile} --signal HUP
+    ;;
+  graceful-stop)
+    start-stop-daemon --stop --pidfile ${pidfile} --signal QUIT
+    ;;
+  quick-stop)
+    start-stop-daemon --stop --pidfile ${pidfile} --signal INT
+    ;;
+  stop)
+    start-stop-daemon --stop --pidfile ${pidfile} --retry=${stop_schedule}
+    ;;
+  restart)
+    $0 stop
+    sleep ${sleep_time_during_restart}
+    $0 start
+    ;;
+  *)
+    echo "Usage: $0 {start|stop|graceful-stop|quick-stop|restart|reload}"
+    exit 1
+    ;;
+esac
+
+# vim:ft=sh

data/examples/chef_cookbook/templates/default/monitrc.erb

@@ -0,0 +1,6 @@
+check process <%= @app_name %>_resque
+  with pidfile <%= @pidfile %>
+  start program = "/etc/init.d/<%= @app_name %>_resque start" with timeout 90 seconds
+  stop program  = "/etc/init.d/<%= @app_name %>_resque stop"  with timeout 90 seconds
+  #if totalmem is greater than <%= @max_mem || "300 MB" %> for 10 cycles then restart # eating up memory?
+  group resque

data/examples/rails-resque.rake

@@ -0,0 +1,22 @@
+require 'resque/pool/tasks'
+
+# this task will get called before resque:pool:setup
+# preload the rails environment in the pool master
+task "resque:setup" => :environment do
+  # generic worker setup, e.g. Hoptoad for failed jobs
+end
+
+task "resque:pool:setup" do
+  # close any sockets or files in pool master
+  ActiveRecord::Base.connection.disconnect!
+
+  # and re-open them in the resque worker parent
+  Resque::Pool.after_prefork do |job|
+    ActiveRecord::Base.establish_connection
+  end
+
+  # you could also re-open them in the resque worker child, using
+  # Resque.after_fork, but that probably isn't necessary, and
+  # Resque::Pool.after_prefork should be faster, since it won't run
+  # for every single job.
+end

data/examples/resque-pool.god

@@ -0,0 +1,43 @@
+rails_env = ENV['RAILS_ENV'] || 'production'
+rails_root = ENV['RAILS_ROOT'] || "YOUR-APP-PATH"
+
+God.watch do |w|
+  w.dir      = "#{rails_root}"
+  w.name     = "resque-pool"
+  w.group    = 'resque'
+  w.interval = 30.seconds
+  w.env      = { "RAILS_ENV" => rails_env }
+  w.start    = "bundle exec resque-pool -d -o #{rails_root}/log/resque-pool.stdout -e #{rails_root}/log/resque-pool.stderr -p #{rails_root}/tmp/pids/resque-pool.pid"
+
+  w.pid_file = "#{rails_root}/tmp/pids/resque-pool.pid"
+  w.behavior(:clean_pid_file)
+
+  # determine the state on startup
+  w.transition(:init, { true => :up, false => :start }) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+
+  # determine when process has finished starting
+  w.transition([:start, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+      c.interval = 5.seconds
+    end
+
+    # failsafe
+    on.condition(:tries) do |c|
+      c.times = 5
+      c.transition = :start
+      c.interval = 5.seconds
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_running) do |c|
+      c.running = false
+    end
+  end
+end

data/examples/resque-pool.yml

@@ -0,0 +1,4 @@
+foo: 1
+bar: 2
+"foo,bar,baz": 4
+

data/examples/upstart-reload.conf

@@ -0,0 +1,24 @@
+# Seamless reload of resque-pool after a deploy.
+# Assuming resque-pool is already running, invoke with
+# `sudo initctl emit resque-pool-reload`.
+description "resque-pool-reload"
+
+start on resque-pool-reload
+
+task
+
+limit nofile 65536 65536
+
+# You may need to set things like PATH here.
+env HOME=/home/your_app_user
+export HOME
+
+script
+  source /home/your_app_user/app_env.sh
+  cd /your/app_root
+  /usr/local/bin/setuidgid your_app_user bundle exec resque-pool \
+    --daemon --hot-swap
+    # Optionally add:
+    # --lock /path/to/your/lock_file
+    # --config /path/to/resque_pool_config.yml
+end script

data/examples/upstart.conf

@@ -0,0 +1,44 @@
+# Manages resque-pool.
+# Start the process with `initctl start resque-pool`.
+description "resque-pool"
+
+start on virtual-filesystems
+stop on runlevel [06]
+
+respawn
+kill timeout 30
+limit nofile 65536 65536
+
+# You may need to set things like PATH here.
+env HOME=/home/your_app_user
+export HOME
+
+# Ensure no subsequently deployed instances are running after shutdown.
+post-stop script
+  /usr/bin/pkill -INT -f resque-pool-master
+end script
+
+# This script assumes you will deploy new application code by using
+# something similar to upstart-reload.conf which runs a second copy of
+# the application then shuts down the first when ready to fork.  The
+# --lock argument should point to a file that is accessible across
+# deploys (i.e. not under a capistrano versioned path).  setuidgid is
+# only necessary if you are running an older version of upstart such as
+# the one included with RHEL/Centos 6.  In Upstart 1.4 and above you can
+# use the setuid and setgid directives instead.
+script
+  # Assuming you use environment-based configuration.
+  source /home/your_app_user/app_env.sh
+  cd /your/app_root
+  /usr/local/bin/setuidgid your_app_user bundle exec resque-pool \
+    --daemon --hot-swap
+    # Optionally add:
+    # --lock /path/to/your/lock_file \         # default: tmp/resque-pool.lock
+    # --config /path/to/resque_pool_config.yml # default: config/resque-pool.yml
+
+  # The above daemon will shutdown if another resque-pool is started using the
+  # --kill-others or --hot-swap.  This line will block until all pool instances
+  # are terminated, ensuring that upstart doesn't try to restart our process
+  # unless it is actually dead.
+  flock -x 0 < /path/to/your/lock_file
+end script

data/lib/resque/pool.rb

@@ -4,7 +4,7 @@ require 'resque/worker'
 require 'resque/pool/version'
 require 'resque/pool/logging'
 require 'resque/pool/pooled_worker'
-require 'resque/pool/file_or_hash_loader'
+require 'resque/pool/config_loaders/file_or_hash_loader'
 require 'erb'
 require 'fcntl'
 require 'yaml'
@@ -28,34 +28,49 @@ module Resque
       procline "(initialized)"
     end
 
-    # Config: after_prefork {{{
+    # Config: hooks {{{
 
-    # The `after_prefork` hooks will be run in workers if you are using the
-    # preforking master worker to save memory. Use these hooks to reload
-    # database connections and so forth to ensure that they're not shared
-    # among workers. The worker instance is passed as an argument to the block.
-    #
-    # Call with a block to set a hook.
-    # Call with no arguments to return all registered hooks.
-    #
-    def self.after_prefork(&block)
-      @after_prefork ||= []
-      block ? (@after_prefork << block) : @after_prefork
+    def self.hook(name) # :nodoc:
+      class_eval <<-CODE
+        def self.#{name}(&block)
+          @#{name} ||= []
+          block ? (@#{name} << block) : @#{name}
+        end
+
+        def self.#{name}=(block)
+          @#{name} = [block]
+        end
+
+        def call_#{name}!(*args)
+          self.class.#{name}.each do |hook|
+            hook.call(*args)
+          end
+        end
+      CODE
     end
 
-    # Sets the after_prefork proc, clearing all pre-existing hooks.
-    # Warning: you probably don't want to clear out the other hooks.
-    # You can use `Resque::Pool.after_prefork << my_hook` instead.
+    ##
+    # :call-seq:
+    #   after_prefork do |worker| ... end   => add a hook
+    #   after_prefork << hook               => add a hook
     #
-    def self.after_prefork=(after_prefork)
-      @after_prefork = [after_prefork]
-    end
+    # +after_prefork+ will run in workers before any jobs.  Use these hooks e.g.
+    # to reload database connections to ensure that they're not shared among
+    # workers.
+    #
+    # :yields: worker
+    hook :after_prefork
 
-    def call_after_prefork!(worker)
-      self.class.after_prefork.each do |hook|
-        hook.call(worker)
-      end
-    end
+    ##
+    # :call-seq:
+    #   after_prefork do |worker, pid, workers| ... end  => add a hook
+    #   after_prefork << hook                            => add a hook
+    #
+    # The `after_spawn` hooks will run in the master after spawning a new
+    # worker.
+    #
+    # :yields: worker, pid, workers
+    hook :after_spawn
 
     # }}}
     # Config: class methods to start up the pool using the config loader {{{
@@ -73,6 +88,11 @@ module Resque
       @handle_winch = bool
     end
 
+    def self.kill_other_pools!
+      require 'resque/pool/killer'
+      Resque::Pool::Killer.run
+    end
+
     def self.single_process_group=(bool)
       ENV["RESQUE_SINGLE_PGRP"] = !!bool ? "YES" : "NO"
     end
@@ -99,7 +119,7 @@ module Resque
     def init_config(loader)
       case loader
       when String, Hash, nil
-        @config_loader = FileOrHashLoader.new(loader)
+        @config_loader = ConfigLoaders::FileOrHashLoader.new(loader)
       else
         @config_loader = loader
       end
@@ -220,6 +240,7 @@ module Resque
 
     class << self
       attr_accessor :term_behavior
+      attr_accessor :kill_other_pools
     end
 
     def graceful_worker_shutdown_and_wait!(signal)
@@ -264,6 +285,7 @@ module Resque
       procline("(started)")
       log "started manager"
       report_worker_pool_pids
+      self.class.kill_other_pools! if self.class.kill_other_pools
       self
     end
 
@@ -396,13 +418,14 @@ module Resque
         worker.work(ENV['INTERVAL'] || DEFAULT_WORKER_INTERVAL) # interval, will block
       end
       workers[queues][pid] = worker
+      call_after_spawn!(worker, pid, workers)
     end
 
     def create_worker(queues)
       queues = queues.to_s.split(',')
       worker = ::Resque::Worker.new(*queues)
       worker.pool_master_pid = Process.pid
-      worker.term_timeout = ENV['RESQUE_TERM_TIMEOUT'] || 4.0
+      worker.term_timeout = (ENV['RESQUE_TERM_TIMEOUT'] || 4.0).to_f
       worker.term_child = ENV['TERM_CHILD']
       if worker.respond_to?(:run_at_exit_hooks=)
         # resque doesn't support this until 1.24, but we support 1.22