resque-pool 0.1.0 → 0.2.0

data/Changelog.md

@@ -1,4 +1,19 @@
-## 0.1.0 (unreleased)
+## unreleased
+
+* new feature: sending `HUP` to pool manager will reload the logfiles and
+  gracefully restart all workers.
+* enhancement: logging now includes timestamp, process "name" (worker or
+  manager), and PID.
+* enhancement: can be used with no config file or empty config file (not all
+  *that* useful, but it's better than unceromoniously dieing!)
+* bugfix: pidfile will be cleaned up on startup, e.g. if old process was
+  kill-9'd (Jason Haruska)
+* bugfix: TERM/INT are no longer ignored when HUP is waiting on children
+* bugfix: `resque-pool -c config.yml` command line option was broken
+* development: simple cucumber features for core functionality.
+* upstream: depends on resque ~> 1.13
+
+## 0.1.0 (2011-01-18)
 
 * new feature: `resque-pool` command line interface
   * this replaces need for a special startup script.

data/README.md

@@ -1,9 +1,10 @@
 Resque Pool
 ===========
 
-Resque pool is a simple library for managing a pool of resque workers.  Given a
-a config file, it manages your workers for you, starting up the appropriate
-number of workers for each.
+Resque pool is a simple library for managing a pool of
+[resque](http://github.com/defunkt/resque) workers.  Given a a config file, it
+manages your workers for you, starting up the appropriate number of workers for
+each worker type.
 
 Benefits
 ---------
@@ -16,17 +17,18 @@ Benefits
   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 almost instantaneously fork all of the workers.
+  environment once and fork all of the workers almost instantly.
 
 How to use
 -----------
 
 ### YAML file config
 
-Create a `config/resque-pool.yml` with your worker counts.  The YAML file
-supports both using root level defaults as well as environment specific
-overrides (`RACK_ENV`, `RAILS_ENV`, and `RESQUE_ENV` environment variables can
-be used to determine environment).  For example in `config/resque-pool.yml`:
+Create a `config/resque-pool.yml` (or `resque-pool.yml`) with your worker
+counts.  The YAML file supports both using root level defaults as well as
+environment specific overrides (`RACK_ENV`, `RAILS_ENV`, and `RESQUE_ENV`
+environment variables can be used to determine environment).  For example in
+`config/resque-pool.yml`:
 
     foo: 1
     bar: 2
@@ -37,10 +39,11 @@ be used to determine environment).  For example in `config/resque-pool.yml`:
 
 ### Rake task config
 
-Require the rake tasks (`resque/pool/tasks`) in your rake file, configure
-Resque as necessary, and configure `Resque::Pool` to disconnect all open
-sockets in the pool manager and reconnect in the workers.  For example, with
-rails you should put the following into `lib/tasks/resque.rake`:
+Require the rake tasks (`resque/pool/tasks`) in your `Rakefile`, load your
+application environment, configure Resque as necessary, and configure
+`resque:pool:setup` to disconnect all open files and sockets in the pool
+manager and reconnect in the workers.  For example, with rails you should put
+the following into `lib/tasks/resque.rake`:
 
     require 'resque/pool/tasks'
     # this task will get called before resque:pool:setup
@@ -61,7 +64,7 @@ rails you should put the following into `lib/tasks/resque.rake`:
 
 Then you can start the queues via:
 
-    resque-pool --environment production
+    resque-pool --daemon --environment production
 
 This will start up seven worker processes, one exclusively for the foo queue,
 two exclusively for the bar queue, and four workers looking at all queues in
@@ -80,20 +83,19 @@ three levels: a single pool manager, many worker parents, and one worker child
 per worker (when the actual job is being processed).  For example, `ps -ef f |
 grep [r]esque` (in Linux) might return something like the following:
 
-    rails    13858     1  0 13:44 ?        S      0:02 resque-pool-manager: managing [13867, 13875, 13871, 13872, 13868, 13870, 13876]
-    rails    13867 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for foo
-    rails    13868 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for bar
-    rails    13870 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for bar
-    rails    13871 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for foo,bar,baz
-    rails    13872 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Forked 7481 at 1280343254
-    rails     7481 13872  0 14:54 ?        S      0:00      \_ resque-1.9.9: Processing foo since 1280343254
-    rails    13875 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for foo,bar,baz
-    rails    13876 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Forked 7485 at 1280343255
-    rails     7485 13876  0 14:54 ?        S      0:00      \_ resque-1.9.9: Processing bar since 1280343254
-
-You can also run resque-pool as a daemon via `--daemon`.  It will default to
-placing the pidfile and logfiles in the rails default locations, which you may
-want to configure.  The `RAILS_ENV` can be specified via `--environment`.  See
+    resque    13858     1  0 13:44 ?        S      0:02 resque-pool-manager: managing [13867, 13875, 13871, 13872, 13868, 13870, 13876]
+    resque    13867 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for foo
+    resque    13868 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for bar
+    resque    13870 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for bar
+    resque    13871 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for foo,bar,baz
+    resque    13872 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Forked 7481 at 1280343254
+    resque     7481 13872  0 14:54 ?        S      0:00      \_ resque-1.9.9: Processing foo since 1280343254
+    resque    13875 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Waiting for foo,bar,baz
+    resque    13876 13858  0 13:44 ?        S      0:00  \_ resque-1.9.9: Forked 7485 at 1280343255
+    resque     7485 13876  0 14:54 ?        S      0:00      \_ resque-1.9.9: Processing bar since 1280343254
+
+Running as a daemon will default to placing the pidfile and logfiles in the
+conventional rails locations, although you can configure that.  See
 `resque-pool --help` for more options.
 
 SIGNALS
@@ -101,24 +103,23 @@ SIGNALS
 
 The pool manager responds to the following signals:
 
-* `HUP`   - reload the config file, e.g. to change the number of workers per queue list
+* `HUP`   - reload the config file, reload logfiles, restart all workers.
 * `QUIT`  - send `QUIT` to each worker parent and shutdown the manager after all workers are done.
 * `INT`   - send `QUIT` to each worker parent and immediately shutdown manager
 * `TERM`  - send `TERM` to each worker parent and immediately shutdown manager
 * `WINCH` - send `QUIT` to each worker, but keep manager running (send `HUP` to reload config and restart workers)
-* `USR1`/`USR2`/`CONT` - send the signal on to all worker parents (see Resque docs).
+* `USR1`/`USR2`/`CONT` - pass the signal on to all worker parents (see Resque docs).
 
-After a `HUP`, workers that are no longer needed will be gracefully shutdown
-via `QUIT`.
+Use `HUP` to help logrotate run smoothly and to change the number of workers
+per worker type.
 
 Other Features
 --------------
 
-An example chef recipe is provided (it should work at Engine Yard as is; just
-provide a `/data/#{app_name}/shared/config/resque-pool.yml` on your utility
-servers).  Even if you don't use chef, you can still use the example init.d
-script and monitrc (erb templates) provided in
-`examples/chef_cookbook/templates/default`.
+An example chef cookbook is provided (and should Just Work at Engine Yard as
+is; just provide a `/data/#{app_name}/shared/config/resque-pool.yml` on your
+utility instances).  Even if you don't use chef you can use the example init.d
+and monitrc erb templates in `examples/chef_cookbook/templates/default`.
 
 You can also start a pool manager via `rake resque:pool` or from a plain old
 ruby script by calling `Resque::Pool.run`.
@@ -132,20 +133,7 @@ with the `--config` command line option.
 TODO
 -----
 
-* web interface for adding and removing workers (etc)
-* config file split by hostname
-* rename to `resque-squad`?
-* cmd line option for non-rake loading
-* cmd line option for preloading ruby file
-* provide Unix style log formatter (compatible with $stdout/$stderr)
-* recover gracefully from a malformed config file (on startup and HUP)
-* change procline for malformed config file, graceful shutdown... and other states?
-* figure out a good automated way to test this (cucumber or rspec?)
-* clean up the code (I stole most of it from unicorn, and it's still a bit
-  bastardized); excessive use of vim foldmarkers are a code smell!
-* rdoc
-* integrate with or incorporate resque-batchworker features? (v2.0)
-* integrate with resque-scheduler? (v2.0)
+See [the TODO list](https://github.com/nevans/resque-pool/issues) at github issues.
 
 Contributors
 -------------
@@ -154,3 +142,4 @@ Contributors
 * Stephen Celis (increased gemspec sanity)
 * Vincent Agnello, Robert Kamunyori, Paul Kauders; for pairing with me at
   B'more on Rails Open Source Hack Nights. :)
+

data/Rakefile

@@ -1,3 +1,17 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+# for loading the example config file in config/resque-pool.yml
 require 'resque/pool/tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress"]
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features) do |c|
+  c.profile = "rake"
+end
+
+task :default => [:spec, :features]

data/config/cucumber.yml

@@ -0,0 +1,3 @@
+default: --format pretty   --strict --require features --tags ~@wip --tags ~@pending
+rake:    --format progress --strict --require features --tags ~@wip --tags ~@pending
+

data/examples/Gemfile

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

data/examples/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: /home/nick/src/active/resque-pool
+  specs:
+    resque-pool (0.1.0.dev)
+      rake
+      resque (~> 1.13)
+      trollop (~> 1.16)
+
+GEM
+  specs:
+    SystemTimer (1.2.2)
+    aruba (0.3.2)
+      childprocess (~> 0.1.6)
+      cucumber (~> 0.10.0)
+      rspec (~> 2.3.0)
+    builder (3.0.0)
+    childprocess (0.1.7)
+      ffi (~> 0.6.3)
+    cucumber (0.10.0)
+      builder (>= 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    diff-lcs (1.1.2)
+    ffi (0.6.3)
+      rake (>= 0.8.7)
+    gherkin (2.3.3)
+      json (~> 1.4.6)
+    json (1.4.6)
+    rack (1.2.1)
+    rake (0.8.7)
+    redis (2.1.1)
+    redis-namespace (0.10.0)
+      redis (< 3.0.0)
+    resque (1.13.0)
+      json (~> 1.4.6)
+      redis-namespace (>= 0.10.0)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    sinatra (1.1.3)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    term-ansicolor (1.0.5)
+    tilt (1.2.2)
+    trollop (1.16.2)
+    vegas (0.1.8)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  SystemTimer
+  aruba (~> 0.3.2)
+  bundler (~> 1.0)
+  cucumber (~> 0.10.0)
+  resque-pool!
+  rspec (~> 2.3.0)

data/examples/chef_cookbook/recipes/default.rb

@@ -30,7 +30,7 @@ if roles.include?(node[:instance_role])
     execute "enable-resque" do
       command "rc-update add #{app}_resque default"
       action :run
-      not_if "rc-update show | grep -q '^ *#{app}_resque |.*default"
+      not_if "rc-update show | grep -q '^ *#{app}_resque |.*default'"
     end
 
     execute "start-resque" do

data/examples/log/resque-pool.stdout.log.2

@@ -0,0 +1,53 @@
+resque-pool-manager[15490]: Reopened logfile: log/resque-pool.stdout.log
+resque-pool-manager[15490]: trying to reopen a log... File
+resque-pool-manager[15490]: orig_st: #<File::Stat dev=0x804, ino=3409002, mode=0100644, nlink=1, uid=1000, gid=1000, rdev=0x0, size=1063, blksize=4096, blocks=8, atime=Wed Feb 23 12:20:58 -0500 2011, mtime=Tue Mar 15 21:33:44 -0400 2011, ctime=Tue Mar 15 21:33:44 -0400 2011>
+resque-pool-manager[15490]: cur_stat: #<File::Stat dev=0x804, ino=3409002, mode=0100644, nlink=1, uid=1000, gid=1000, rdev=0x0, size=1063, blksize=4096, blocks=8, atime=Wed Feb 23 12:20:58 -0500 2011, mtime=Tue Mar 15 21:33:44 -0400 2011, ctime=Tue Mar 15 21:33:44 -0400 2011>
+resque-pool-manager[15490]: Reopen logs: close old children which have old logfiles open
+resque-pool-manager[15490]: Reopen logs: new children will inherit new logfiles
+resque-pool-manager[15490]: Reaped resque worker[16074] (status: 0) queues: bar
+resque-pool-manager[15490]: Reaped resque worker[16076] (status: 0) queues: foo
+resque-pool-worker[16638]: Starting worker arrakis:16638:bar
+resque-pool-worker[16640]: Starting worker arrakis:16640:foo
+resque-pool-manager[15490]: Reaped resque worker[16083] (status: 0) queues: bar
+resque-pool-manager[15490]: Reaped resque worker[16073] (status: 0) queues: foo,bar,baz
+resque-pool-worker[16650]: Starting worker arrakis:16650:bar
+resque-pool-worker[16652]: Starting worker arrakis:16652:foo,bar,baz
+resque-pool-manager[15490]: Reaped resque worker[16078] (status: 0) queues: foo,bar,baz
+resque-pool-worker[16659]: Starting worker arrakis:16659:foo,bar,baz
+resque-pool-manager[15490]: Reaped resque worker[16084] (status: 0) queues: foo,bar,baz
+resque-pool-manager[15490]: Reaped resque worker[16086] (status: 0) queues: foo,bar,baz
+resque-pool-worker[16669]: Starting worker arrakis:16669:foo,bar,baz
+resque-pool-worker[16664]: Starting worker arrakis:16664:foo,bar,baz
+resque-pool-manager[15490]: TERM: immediate shutdown (and immediate worker shutdown)
+resque-pool-manager[15490]: manager finished
+resque-pool-manager[24768]: Resque Pool running in development environment
+(in /home/nick/src/active/resque-pool/examples)
+resque-pool-manager[24768]: started manager
+resque-pool-manager[24768]: Pool contains worker PIDs: [24790, 24788, 24789, 24786, 24787, 24794, 24793]
+resque-pool-worker[24787]: Starting worker arrakis:24787:foo,bar,baz
+resque-pool-worker[24788]: Starting worker arrakis:24788:foo,bar,baz
+resque-pool-worker[24786]: Starting worker arrakis:24786:foo,bar,baz
+resque-pool-worker[24789]: Starting worker arrakis:24789:foo,bar,baz
+resque-pool-worker[24794]: Starting worker arrakis:24794:bar
+resque-pool-worker[24793]: Starting worker arrakis:24793:bar
+resque-pool-worker[24790]: Starting worker arrakis:24790:foo
+resque-pool-manager[24768]: HUP: reload config file and reload logfiles
+resque-pool-manager[24768]: Flushing logs
+resque-pool-manager[24768]: HUP: close old children which have old logfiles open
+resque-pool-manager[24768]: HUP: new children will inherit new logfiles
+resque-pool-manager[24768]: Reaped resque worker[24787] (status: 0) queues: foo,bar,baz
+resque-pool-manager[24768]: Reaped resque worker[24794] (status: 0) queues: bar
+resque-pool-manager[24768]: Reaped resque worker[24786] (status: 0) queues: foo,bar,baz
+resque-pool-worker[25311]: Starting worker arrakis:25311:foo,bar,baz
+resque-pool-worker[25312]: Starting worker arrakis:25312:bar
+resque-pool-worker[25315]: Starting worker arrakis:25315:foo,bar,baz
+resque-pool-manager[24768]: Reaped resque worker[24790] (status: 0) queues: foo
+resque-pool-manager[24768]: Reaped resque worker[24788] (status: 0) queues: foo,bar,baz
+resque-pool-manager[24768]: Reaped resque worker[24789] (status: 0) queues: foo,bar,baz
+resque-pool-manager[24768]: Reaped resque worker[24793] (status: 0) queues: bar
+resque-pool-worker[25326]: Starting worker arrakis:25326:foo
+resque-pool-worker[25327]: Starting worker arrakis:25327:foo,bar,baz
+resque-pool-worker[25328]: Starting worker arrakis:25328:foo,bar,baz
+resque-pool-worker[25330]: Starting worker arrakis:25330:bar
+resque-pool-manager[24768]: HUP: reload config file and reload logfiles
+resque-pool-manager[24768]: Flushing logs

data/features/basic_daemon_config.feature

@@ -0,0 +1,68 @@
+Feature: Basic resque-pool daemon configuration and operation
+  To easily manage a pool of resque workers, resque-pool provides a daemon with
+  simple configuration.  Static configuration is handled in the
+  config/config.yml file and dynamic configuration is handled in the Rakefile.
+
+  Background:
+    Given a file named "Rakefile" with:
+    """
+    require 'resque/pool/tasks'
+    """
+
+  Scenario: no config file
+    When I run the pool manager as "resque-pool"
+    Then the pool manager should report that it has started up
+    And the pool manager should report that the pool is empty
+    And the pool manager should have no child processes
+    When I send the pool manager the "QUIT" signal
+    Then the pool manager should finish
+    And the pool manager should report that it is finished
+
+  @slow_exit
+  Scenario: basic config file
+    Given a file named "config/resque-pool.yml" with:
+    """
+    foo: 1
+    bar: 2
+    "bar,baz": 3
+    """
+    When I run the pool manager as "resque-pool"
+    Then the pool manager should report that it has started up
+    And the pool manager should report that 6 workers are in the pool
+    And the pool manager should have 1 "foo" worker child processes
+    And the pool manager should have 2 "bar" worker child processes
+    And the pool manager should have 3 "bar,baz" worker child processes
+    When I send the pool manager the "QUIT" signal
+    Then the resque workers should all shutdown
+    And the pool manager should finish
+    And the pool manager should report that a "foo" worker has been reaped
+    And the pool manager should report that a "bar" worker has been reaped
+    And the pool manager should report that a "bar,baz" worker has been reaped
+    And the pool manager should report that it is finished
+
+  Scenario: daemonized
+    Given a directory named "log"
+    And a directory named "tmp/pids"
+    And a file named "config/resque-pool.yml" with:
+    """
+    foo: 2
+    bar: 4
+    "baz,quux": 4
+    """
+    When I run the pool manager as "resque-pool -d"
+    Then the pool manager should record its pid in "tmp/pids/resque-pool.pid"
+    And the pool manager should daemonize
+    And a file named "log/resque-pool.stdout.log" should exist
+    And a file named "log/resque-pool.stderr.log" should exist
+    And the pool manager should log that it has started up
+    And the pool manager should log that 10 workers are in the pool
+    And the pool manager should have 2 "foo" worker child processes
+    And the pool manager should have 4 "bar" worker child processes
+    And the pool manager should have 4 "baz,quux" worker child processes
+    When I send the pool manager the "QUIT" signal
+    Then the resque workers should all shutdown
+    And the pool manager daemon should finish
+    And the pool manager should log that a "foo" worker has been reaped
+    And the pool manager should log that a "bar" worker has been reaped
+    And the pool manager should log that a "baz,quux" worker has been reaped
+    And the pool manager should log that it is finished

data/features/step_definitions/daemon_steps.rb

@@ -0,0 +1,29 @@
+# syntactic sugar, and separate ivar.  daemons aren't interactive
+When /^I run "([^"]*)" in the background$/ do |cmd|
+  run_background(unescape(cmd))
+end
+
+Then /^the (output|logfiles) should contain the following lines \(with interpolated \$PID\):$/ do |output_logfiles, partial_output|
+  interpolate_background_pid(partial_output).split("\n").each do |line|
+    output_or_log(output_logfiles).should include(line)
+  end
+end
+
+When /^I send "([^"]*)" the "([^"]*)" signal$/ do |cmd, signal|
+  send_signal(cmd, signal)
+end
+
+Then /^the "([^"]*)" process should finish$/ do |cmd|
+  # doesn't actually stop... just polls for exit
+  processes[cmd].stop
+end
+
+Before("@slow_exit") do
+  @aruba_timeout_seconds = 10
+end
+
+After do
+  kill_all_processes!
+  # now kill the daemon!
+  `pkill -9 -f resque-pool`
+end

data/features/step_definitions/resque-pool_steps.rb

@@ -0,0 +1,147 @@
+def process_should_exist(pid)
+  lambda { Process.kill(0, pid) }.should_not raise_error(Errno::ESRCH)
+end
+
+def process_should_not_exist(pid)
+  lambda { Process.kill(0, pid) }.should raise_error(Errno::ESRCH)
+end
+
+def grab_worker_pids(count, str)
+  announce "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
+  @worker_pids = full_regex.match(str).captures.map {|pid| pid.to_i }
+end
+
+def output_or_logfiles_string(report_log)
+  case report_log
+  when "report", "output"
+    "output"
+  when "log", "logfiles"
+    "logfiles"
+  else
+    raise ArgumentError
+  end
+end
+
+def output_or_log(report_log)
+  case report_log
+  when "report", "output"
+    all_output
+  when "log", "logfiles"
+    in_current_dir do
+      File.read("log/resque-pool.stdout.log") << File.read("log/resque-pool.stderr.log")
+    end
+  else
+    raise ArgumentError
+  end
+end
+
+def children_of(ppid)
+  ps = `ps -eo ppid,pid,cmd | grep '^ *#{ppid} '`
+  ps.split(/\s*\n/).map do |line|
+    _, pid, cmd = line.strip.split(/\s+/, 3)
+    [pid, cmd]
+  end
+end
+
+When /^I run the pool manager as "([^"]*)"$/ do |cmd|
+  @pool_manager_process = run_background(unescape(cmd))
+end
+
+When /^I send the pool manager the "([^"]*)" signal$/ do |signal|
+  Process.kill signal, background_pid
+  output_logfiles = @pid_from_pidfile ? "logfiles" : "output"
+  case signal
+  when "QUIT"
+    keep_trying do
+      Then "the #{output_logfiles} should contain the following lines (with interpolated $PID):", <<-EOF
+resque-pool-manager[$PID]: QUIT: graceful shutdown, waiting for children
+      EOF
+    end
+  else
+    raise ArgumentError
+  end
+end
+
+Then /^the pool manager should record its pid in "([^"]*)"$/ do |pidfile|
+  in_current_dir do
+    keep_trying do
+      File.should be_file(pidfile)
+      @pid_from_pidfile = File.read(pidfile).to_i
+      @pid_from_pidfile.should_not == 0
+      process_should_exist(@pid_from_pidfile)
+    end
+  end
+end
+
+Then /^the pool manager should daemonize$/ do
+  @pool_manager_process.stop
+end
+
+Then /^the pool manager daemon should finish$/ do
+  keep_trying do
+    process_should_not_exist(@pid_from_pidfile)
+  end
+end
+
+# nomenclature: "report" => output to stdout/stderr
+#               "log"    => output to default logfile
+
+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
+resque-pool-manager[$PID]: Resque Pool running in development environment
+resque-pool-manager[$PID]: started manager
+    EOF
+  end
+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
+resque-pool-manager[$PID]: Pool is empty
+  EOF
+end
+
+Then /^the pool manager should (report|log) that (\d+) workers are in the pool$/ do |report_log, count|
+  grab_worker_pids Integer(count), output_or_log(report_log)
+end
+
+Then /^the resque workers should all shutdown$/ do
+  @worker_pids.each do |pid|
+    keep_trying do
+      process_should_not_exist(pid)
+    end
+  end
+end
+
+Then "the pool manager should have no child processes" do
+  children_of(background_pid).should have(:no).keys
+end
+
+Then /^the pool manager should have (\d+) "([^"]*)" worker child processes$/ do |count, queues|
+  children_of(background_pid).select do |pid, cmd|
+    cmd =~ /^resque-\d+.\d+.\d+: Waiting for #{queues}$/
+  end.should have(Integer(count)).members
+end
+
+Then "the pool manager should finish" do
+  # assuming there will not be multiple processes running
+  processes.each { |cmd, p| p.stop }
+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
+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 + '/'
+end
+
+Then /^the logfiles should match \/([^\/]*)\/$/ do |partial_output|
+  output_or_log("log").should =~ /#{partial_output}/
+end
+ 

data/features/support/aruba_daemon_support.rb

@@ -0,0 +1,60 @@
+require 'aruba/api'
+require 'aruba/process'
+
+module Aruba
+
+  module Api
+
+    # 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
+      yield
+    rescue RSpec::Expectations::ExpectationNotMetError
+      if tries < timeout
+        sleep 1
+        tries += 1
+        retry
+      else
+        raise
+      end
+    end
+
+    def run_background(cmd)
+      @background = run(cmd)
+    end
+
+    def send_signal(cmd, signal)
+      announce_or_puts "$ kill -#{signal} #{processes[cmd].pid}" if @announce_env
+      processes[cmd].send_signal signal
+    end
+
+    def background_pid
+      @pid_from_pidfile || @background.pid
+    end
+
+    def interpolate_background_pid(string)
+      interpolated = string.gsub('$PID', background_pid.to_s)
+      announce_or_puts interpolated if @announce_env
+      interpolated
+    end
+
+    def kill_all_processes!
+      stop_processes!
+    rescue
+      processes.each {|cmd,process| send_signal(cmd, 'KILL') }
+      raise
+    end
+
+  end
+
+  class Process
+    def pid
+      @process.pid
+    end
+    def send_signal signal
+      @process.send :send_signal, signal
+    end
+  end
+
+end

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/lib/resque/pool/cli.rb

@@ -4,12 +4,13 @@ require 'resque/pool'
 module Resque
   class Pool
     module CLI
+      extend Logging
       extend self
 
       def run
         opts = parse_options
         daemonize if opts[:daemon]
-        pidfile opts[:pidfile]
+        manage_pidfile opts[:pidfile]
         redirect opts
         setup_environment opts
         start_pool
@@ -28,12 +29,12 @@ Usage:
    resque-pool [options]
 where [options] are:
           EOS
-          opt :config, "Alternate path to config file",                 :short => "-c"
-          opt :daemon, "Run as a background daemon", :default => false, :short => "-d"
-          opt :stdout, "Redirect stdout to logfile", :type => String,   :short => '-o'
-          opt :stderr, "Redirect stderr to logfile", :type => String,   :short => '-e'
+          opt :config, "Alternate path to config file", :type => String, :short => "-c"
+          opt :daemon, "Run as a background daemon", :default => false,  :short => "-d"
+          opt :stdout, "Redirect stdout to logfile", :type => String,    :short => '-o'
+          opt :stderr, "Redirect stderr to logfile", :type => String,    :short => '-e'
           opt :nosync, "Don't sync logfiles on every write"
-          opt :pidfile, "PID file location",         :type => String,   :short => "-p"
+          opt :pidfile, "PID file location",         :type => String,    :short => "-p"
           opt :environment, "Set RAILS_ENV/RACK_ENV/RESQUE_ENV", :type => String, :short => "-E"
         end
         if opts[:daemon]
@@ -52,33 +53,52 @@ where [options] are:
         exit unless pid.nil?
       end
 
-      def pidfile(pidfile)
+      def manage_pidfile(pidfile)
+        return unless pidfile
         pid = Process.pid
-        if pidfile
-          if File.exist? pidfile
-            raise "Pidfile already exists at #{pidfile}.  Check to make sure process is not already running."
+        if File.exist? pidfile
+          if process_still_running? pidfile
+            raise "Pidfile already exists at #{pidfile} and process is still running."
+          else
+            File.delete pidfile
           end
-          File.open pidfile, "w" do |f|
-            f.write pid
-          end
-          at_exit do
-            if Process.pid == pid
-              File.delete pidfile
-            end
+        end
+        File.open pidfile, "w" do |f|
+          f.write pid
+        end
+        at_exit do
+          if Process.pid == pid
+            File.delete pidfile
           end
         end
       end
 
+      def process_still_running?(pidfile)
+        old_pid = open(pidfile).read.strip.to_i
+        Process.kill 0, old_pid
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      rescue ::Exception
+        $stderr.puts "While checking if PID #{old_pid} is running, unexpected #{e.class}: #{e}"
+        true
+      end
+
       def redirect(opts)
         $stdin.reopen  '/dev/null'        if opts[:daemon]
-        $stdout.reopen opts[:stdout], "a" if opts[:stdout] && !opts[:stdout].empty?
-        $stderr.reopen opts[:stderr], "a" if opts[:stderr] && !opts[:stderr].empty?
+        # need to reopen as File, or else Resque::Pool::Logging.reopen_logs! won't work
+        out = File.new(opts[:stdout], "a") if opts[:stdout] && !opts[:stdout].empty?
+        err = File.new(opts[:stderr], "a") if opts[:stderr] && !opts[:stderr].empty?
+        $stdout.reopen out if out
+        $stderr.reopen err if err
         $stdout.sync = $stderr.sync = true unless opts[:nosync]
       end
 
       def setup_environment(opts)
         ENV["RACK_ENV"] = ENV["RAILS_ENV"] = ENV["RESQUE_ENV"] = opts[:environment] if opts[:environment]
-        puts "Resque Pool running in #{ENV["RAILS_ENV"] || "development"} environment."
+        log "Resque Pool running in #{ENV["RAILS_ENV"] || "development"} environment"
         ENV["RESQUE_POOL_CONFIG"] = opts[:config] if opts[:config]
       end
 

data/lib/resque/pool/logging.rb

@@ -1,6 +1,38 @@
 module Resque
   class Pool
     module Logging
+      extend self
+
+      # more than a little bit complicated...
+      # copied this from Unicorn.
+      def self.reopen_logs!
+        log "Flushing logs"
+        [$stdout, $stderr].each do |fd|
+          if fd.instance_of? File
+            # skip if the file is the exact same inode and device
+            orig_st = fd.stat
+            begin
+              cur_st = File.stat(fd.path)
+              next if orig_st.ino == cur_st.ino && orig_st.dev == cur_st.dev
+            rescue Errno::ENOENT
+            end
+            # match up the encoding
+            open_arg = 'a'
+            if fd.respond_to?(:external_encoding) && enc = fd.external_encoding
+              open_arg << ":#{enc.to_s}"
+              enc = fd.internal_encoding and open_arg << ":#{enc.to_s}"
+            end
+            # match up buffering (does reopen reset this?)
+            sync = fd.sync
+            # sync to disk
+            fd.fsync
+            # reopen, and set ruby buffering appropriately
+            fd.reopen fd.path, open_arg
+            fd.sync = sync
+            log "Reopened logfile: #{fd.path}"
+          end
+        end
+      end
 
       # Given a string, sets the procline ($0)
       # Procline is always in the format of:
@@ -11,7 +43,14 @@ module Resque
 
       # TODO: make this use an actual logger
       def log(message)
-        puts message
+        puts "resque-pool-manager[#{Process.pid}]: #{message}"
+        #$stdout.fsync
+      end
+
+      # TODO: make this use an actual logger
+      def log_worker(message)
+        puts "resque-pool-worker[#{Process.pid}]: #{message}"
+        #$stdout.fsync
       end
 
     end

data/lib/resque/pool/tasks.rb

@@ -4,11 +4,11 @@ require 'resque/pool'
 
 namespace :resque do
 
-  desc "resque worker config (not pool related).  e.g. hoptoad"
+  # resque worker config (not pool related).  e.g. hoptoad, rails environment
   task :setup
 
   namespace :pool do
-    "resque pool config.  e.g. after_prefork connection handling"
+     # resque pool config.  e.g. after_prefork connection handling
     task :setup
   end
 

data/lib/resque/pool/version.rb

@@ -1,5 +1,5 @@
 module Resque
   class Pool
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/resque/pool.rb

@@ -8,16 +8,14 @@ require 'yaml'
 
 module Resque
   class Pool
-    include Logging
-    attr_reader :config
-    attr_reader :workers
-
-    # CONSTANTS {{{
     SIG_QUEUE_MAX_SIZE = 5
     DEFAULT_WORKER_INTERVAL = 5
     QUEUE_SIGS = [ :QUIT, :INT, :TERM, :USR1, :USR2, :CONT, :HUP, :WINCH, ]
-    CHUNK_SIZE=(16 * 1024)
-    # }}}
+    CHUNK_SIZE = (16 * 1024)
+
+    include Logging
+    attr_reader :config
+    attr_reader :workers
 
     def initialize(config)
       init_config(config)
@@ -70,13 +68,14 @@ module Resque
     # }}}
     # Config: load config and config file {{{
 
+    def config_file
+      @config_file || (!@config && ::Resque::Pool.choose_config_file)
+    end
+
     def init_config(config)
-      unless config
-        raise ArgumentError,
-          "No configuration found. Please setup config/resque-pool.yml"
-      end
-      if config.kind_of? String
-        @config_file = config.to_s
+      case config
+      when String, nil
+        @config_file = config
       else
         @config = config.dup
       end
@@ -84,7 +83,11 @@ module Resque
     end
 
     def load_config
-      @config_file and @config = YAML.load_file(@config_file)
+      if config_file
+        @config = YAML.load_file(config_file)
+      else
+        @config ||= {}
+      end
       environment and @config[environment] and config.merge!(@config[environment])
       config.delete_if {|key, value| value.is_a? Hash }
     end
@@ -124,9 +127,14 @@ module Resque
       end
     end
 
+    class QuitNowException < Exception; end
     # defer a signal for later processing in #join (master process)
     def trap_deferred(signal)
       trap(signal) do |sig_nr|
+        if @waiting_for_reaper && [:INT, :TERM].include?(signal)
+          log "Recieved #{signal}: short circuiting QUIT waitpid"
+          raise QuitNowException
+        end
         if sig_queue.size < SIG_QUEUE_MAX_SIZE
           sig_queue << signal
           awaken_master
@@ -146,8 +154,12 @@ module Resque
         log "#{signal}: sending to all workers"
         signal_all_workers(signal)
       when :HUP
-        log "HUP: reload config file"
+        log "HUP: reload config file and reload logfiles"
         load_config
+        Logging.reopen_logs!
+        log "HUP: gracefully shutdown old children (which have old logfiles open)"
+        signal_all_workers(:QUIT)
+        log "HUP: new children will inherit new logfiles"
         maintain_worker_count
       when :WINCH
         log "WINCH: gracefully stopping all workers"
@@ -178,11 +190,19 @@ module Resque
       init_sig_handlers!
       maintain_worker_count
       procline("(started)")
-      log "**** started master at PID: #{Process.pid}"
-      log "**** Pool contains PIDs: #{all_pids.inspect}"
+      log "started manager"
+      report_worker_pool_pids
       self
     end
 
+    def report_worker_pool_pids
+      if workers.empty?
+        log "Pool is empty"
+      else
+        log "Pool contains worker PIDs: #{all_pids.inspect}"
+      end
+    end
+
     def join
       loop do
         reap_all_workers
@@ -195,7 +215,7 @@ module Resque
       end
       procline("(shutting down)")
       #stop # gracefully shutdown all workers on our way out
-      log "**** master complete"
+      log "manager finished"
       #unlink_pid_safe(pid) if pid
     end
 
@@ -212,15 +232,17 @@ module Resque
     # worker process management {{{
 
     def reap_all_workers(waitpid_flags=Process::WNOHANG)
+      @waiting_for_reaper = waitpid_flags == 0
       begin
         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 #{status.inspect}, worker=#{worker.queues.join(",")}"
+          log "Reaped resque worker[#{status.pid}] (status: #{status.exitstatus}) queues: #{worker.queues.join(",")}"
         end
-      rescue Errno::ECHILD
+      rescue Errno::ECHILD, QuitNowException
       end
     end
 
@@ -285,7 +307,7 @@ module Resque
     def spawn_worker!(queues)
       worker = create_worker(queues)
       pid = fork do
-        log "*** Starting worker #{worker}"
+        log_worker "Starting worker #{worker}"
         call_after_prefork!
         reset_sig_handlers!
         #self_pipe.each {|io| io.close }

data/resque-pool.gemspec

@@ -15,15 +15,20 @@ Gem::Specification.new do |s|
     saving memory (w/REE) and monitoring their uptime
   EOF
 
-  s.add_dependency "resque", "~> 1.10"
+  s.add_dependency "resque",  "~> 1.13"
   s.add_dependency "trollop", "~> 1.16"
   s.add_dependency "rake"
-  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec",    "~> 2.3.0"
+  s.add_development_dependency "cucumber", "~> 0.10.0"
+  s.add_development_dependency "aruba",    "~> 0.3.2"
   s.add_development_dependency "SystemTimer" # to silence redis gem's warning
   s.add_development_dependency "bundler", "~> 1.0"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  # hidden files are automatically ignored by Dir.glob
+  ignore_patterns = %w[**/*.gem **/*.pid **/*.log pkg Gemfile.lock]
+  ignore_files    = ignore_patterns.inject([]) {|a,p| a + Dir[p] }
+  s.files         = Dir["**/*"] - ignore_files
+  s.test_files    = Dir.glob("{spec,features}/**/*.{rb,yml,feature}")
+  s.executables   = 'resque-pool'
   s.require_paths = ["lib"]
 end

data/spec/resque_pool_spec.rb

@@ -1,6 +1,6 @@
 require 'spec/spec_helper'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.after {
     Object.send(:remove_const, :RAILS_ENV) if defined? RAILS_ENV
     ENV.delete 'RACK_ENV'
@@ -80,6 +80,13 @@ describe Resque::Pool, "when loading the pool configuration from a Hash" do
 
 end
 
+describe Resque::Pool, "given no configuration" do
+  subject { Resque::Pool.new(nil) }
+  it "should have no worker types" do
+    subject.config.should == {}
+  end
+end
+
 describe Resque::Pool, "when loading the pool configuration from a file" do
 
   subject { Resque::Pool.new("spec/resque-pool.yml") }

data/spec/spec_helper.rb

@@ -1,3 +1,3 @@
-require 'spec'
+require 'rspec'
 $LOAD_PATH << File.expand_path("../lib", File.dirname(__FILE__))
 require 'resque/pool'

data/tmp/aruba/Rakefile

@@ -0,0 +1 @@
+require 'resque/pool/tasks'

data/tmp/aruba/config/resque-pool.yml

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: resque-pool
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - nicholas a. evans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-18 00:00:00 -05:00
+date: 2011-03-15 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,11 +26,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 21
         segments: 
         - 1
-        - 10
-        version: "1.10"
+        - 13
+        version: "1.13"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -68,18 +68,52 @@ dependencies:
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         hash: 3
         segments: 
+        - 2
+        - 3
         - 0
-        version: "0"
+        version: 2.3.0
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: SystemTimer
+  name: cucumber
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 3
+        - 2
+        version: 0.3.2
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: SystemTimer
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -89,11 +123,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id005
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: bundler
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -104,7 +138,7 @@ dependencies:
         - 0
         version: "1.0"
   type: :development
-  version_requirements: *id006
+  version_requirements: *id008
 description: "    quickly and easily fork a pool of resque workers,\n    saving memory (w/REE) and monitoring their uptime\n"
 email: 
 - nick@ekenosen.net
@@ -115,33 +149,41 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- .gitignore
-- Changelog.md
-- Gemfile
-- Gemfile.lock
 - LICENSE.txt
+- features/basic_daemon_config.feature
+- features/support/aruba_daemon_support.rb
+- features/support/env.rb
+- features/step_definitions/resque-pool_steps.rb
+- features/step_definitions/daemon_steps.rb
+- bin/resque-pool
 - README.md
+- spec/spec_helper.rb
+- spec/resque_pool_spec.rb
+- spec/resque-pool.yml
+- spec/mock_config.rb
+- Changelog.md
 - Rakefile
-- bin/resque-pool
-- config/alternate.yml
-- config/resque-pool.yml
-- examples/Rakefile
+- examples/Gemfile.lock
 - examples/chef_cookbook/recipes/default.rb
 - examples/chef_cookbook/templates/default/initd.erb
 - examples/chef_cookbook/templates/default/monitrc.erb
 - examples/rails-resque.rake
 - examples/resque-pool.yml
+- examples/Rakefile
+- examples/log/resque-pool.stdout.log.2
+- examples/Gemfile
+- resque-pool.gemspec
+- tmp/aruba/Rakefile
+- tmp/aruba/config/resque-pool.yml
 - lib/resque/pool.rb
-- lib/resque/pool/cli.rb
-- lib/resque/pool/logging.rb
-- lib/resque/pool/pooled_worker.rb
 - lib/resque/pool/tasks.rb
+- lib/resque/pool/cli.rb
 - lib/resque/pool/version.rb
-- resque-pool.gemspec
-- spec/mock_config.rb
-- spec/resque-pool.yml
-- spec/resque_pool_spec.rb
-- spec/spec_helper.rb
+- lib/resque/pool/pooled_worker.rb
+- lib/resque/pool/logging.rb
+- config/cucumber.yml
+- config/alternate.yml
+- Gemfile
 has_rdoc: true
 homepage: http://github.com/nevans/resque-pool
 licenses: []
@@ -176,5 +218,13 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: quickly and easily fork a pool of resque workers
-test_files: []
-
+test_files: 
+- spec/spec_helper.rb
+- spec/resque_pool_spec.rb
+- spec/mock_config.rb
+- spec/resque-pool.yml
+- features/support/aruba_daemon_support.rb
+- features/support/env.rb
+- features/step_definitions/resque-pool_steps.rb
+- features/step_definitions/daemon_steps.rb
+- features/basic_daemon_config.feature

data/.gitignore

@@ -1,5 +0,0 @@
-pkg/*
-*.gem
-.bundle
-*.log
-*.pid

data/Gemfile.lock

@@ -1,51 +0,0 @@
-PATH
-  remote: .
-  specs:
-    resque-pool (0.0.12.0.alpha)
-      rake
-      resque (~> 1.10)
-      trollop (~> 1.16)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    SystemTimer (1.2.1)
-    diff-lcs (1.1.2)
-    json (1.4.6)
-    rack (1.2.1)
-    rake (0.8.7)
-    redis (2.1.1)
-    redis-namespace (0.8.0)
-      redis (< 3.0.0)
-    resque (1.10.0)
-      json (~> 1.4.6)
-      redis-namespace (~> 0.8.0)
-      sinatra (>= 0.9.2)
-      vegas (~> 0.1.2)
-    rspec (2.4.0)
-      rspec-core (~> 2.4.0)
-      rspec-expectations (~> 2.4.0)
-      rspec-mocks (~> 2.4.0)
-    rspec-core (2.4.0)
-    rspec-expectations (2.4.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.4.0)
-    sinatra (1.1.2)
-      rack (~> 1.1)
-      tilt (~> 1.2)
-    tilt (1.2.1)
-    trollop (1.16.2)
-    vegas (0.1.8)
-      rack (>= 1.0.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  SystemTimer
-  bundler (~> 1.0)
-  rake
-  resque (~> 1.10)
-  resque-pool!
-  rspec
-  trollop (~> 1.16)

data/config/resque-pool.yml

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