resque-forker 1.3.0 → 2.0.0

data/CHANGELOG

@@ -1,3 +1,18 @@
+2011-02-02 v2.0 Now, with resque-ctl
+
+You can now run workers from the command line
+
+  $ resque-ctl -c config/resque_workers.rb
+
+or with bundler
+
+  $ bundle exec resque-ctl -c config/resque_workers.rb
+
+Check the README for more details and how to configure.
+
+This awesome feature, brought to you by Todd Fisher (taf2).
+
+
 2010-09-16 v1.3 Show command in Resque console, USR1 dumps to syslog
 
 Resque console now shows forker script command (look for 'script'). This will

data/README.rdoc

@@ -16,7 +16,60 @@ application once and then forking it. Forking all these workers takes
 milliseconds. Faster restart means faster deploy and less downtime. Yay!
 
 
-== Creating the script
+== Configuring your Workers to use resque-ctl
+
+Create a Ruby script that loads the applications, handles
+connections, and decides what kind of workload (how many workers on which
+queues) to process.
+
+Edit this to your needs and place it in config/resque_workers.rb:
+
+  worker_processes 1 # number of worker processes to spawn
+  worker_queues ["*"] # listen on all worker queues
+  worker_timeout 30 # timeout a worker
+  work_interval 3 # intervals to poll
+
+  working_directory "/app/path"  # where to run daemonized workers
+  pid "/app/path/tmp/pids/workers.pid" # master process pid
+  stderr_path "/app/path/log/workers.stderr.log"
+  stdout_path "/app/path/log/workers.stdout.log"
+  preload_app true
+  daemonize true
+
+  GC.respond_to?(:copy_on_write_friendly=) and GC.copy_on_write_friendly = true
+
+  setup do|forker|
+    defined?(ActiveRecord::Base) and ActiveRecord::Base.connection.disconnect!
+
+    if Rails.env.development?
+      forker.options.verbose = true
+    else
+      forker.logger   = Rails.logger
+    end
+
+  end
+
+  # run in master
+  before_fork do
+    defined?(ActiveRecord::Base) and ActiveRecord::Base.connection.disconnect!
+  end
+
+  # run in worker
+  after_fork do
+    defined?(ActiveRecord::Base) and ActiveRecord::Base.establish_connection
+  end
+
+The configuration should seem very similar to how unicorn sets up it's configuration.
+
+You can now run workers from the command line:
+
+  $ resque-ctl -c config/resque_workers.rb
+
+or with bundler
+
+  $ bundle exec resque-ctl -c config/resque_workers.rb
+
+== Using a script/workers control file
 
 We're going to create a Ruby script that loads the applications, handles
 connections, and decides what kind of workload (how many workers on which
@@ -25,21 +78,18 @@ queues) to process.
 Edit this to your needs and place it in script/workers:
 
   #!/usr/bin/env ruby
-  # If using Bundler, you might need to uncomment next two lines
-  #require "bundler"
-  #Bundler.setup
   require "resque/forker"
 
   # Load the application.
   Resque.setup do |forker|
     $:.unshift File.dirname(__FILE__) + "/.." # Makes 1.9.2 happy
-    require "config/environment"
+    require File.dirname(__FILE__) + "/../config/environment"
     ActiveRecord::Base.connection.disconnect!
-    forker.options.interval = 1
     if Rails.env.production?
       forker.logger = Rails.logger
       forker.workload = ["*"] * 4        # 4 workers on all queues
       forker.user "www-data", "www-data" # don't run as root
+      forker.options.interval = 1
     else
       forker.options.verbose = true
     end

data/bin/resque-ctl

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+
+ENV["RACK_ENV"] ||= "development"
+require 'optparse'
+require "resque/forker"
+require "resque/master"
+
+options = Resque::Master.optparse!
+options = Resque::Master.process(options[:config]).merge(options) if options[:config]
+options = Resque::Master.defaults.merge(options)
+
+Resque::Master.setup(options)
+
+if options[:daemon]
+  STDERR.puts "[Warning]: running without dropping a pid file #{Process.pid}" if options[:pidfile].nil?
+  STDERR.puts "[Warning]: running daemon in #{options[:runpath]}" if options[:runpath] == '/'
+
+  Resque::Master.daemonize(options)
+else
+  Resque.fork!
+end

data/lib/resque/forker.rb

@@ -1,6 +1,7 @@
 require "logger"
 require "resque"
 require "syslog"
+require 'resque/forker/version'
 
 module Resque
   # Loading Rails, the application and all its dependencies takes significant time
@@ -63,8 +64,6 @@ module Resque
   #   respawn
   class Forker
 
-    VERSION = "1.3.0"
-
     Options = Struct.new(:verbose, :very_verbose, :interval, :terminate)
 
     def initialize(options = nil)

data/lib/resque/forker/version.rb

@@ -0,0 +1,5 @@
+module Resque
+  class Forker
+    VERSION = "2.0.0"
+  end
+end

data/lib/resque/master.rb

@@ -0,0 +1,222 @@
+require 'optparse'
+require "resque/forker"
+
+module Resque
+
+  class Master
+    attr_reader :options
+
+    def worker_processes(count)
+      @options[:worker_processes] = count
+    end
+
+    def worker_queues(queues)
+      @options[:worker_queues] = queues
+    end
+
+    def worker_timeout(timeout)
+      @options[:worker_timeout] = timeout
+    end
+
+    def work_interval(interval)
+      @options[:work_interval] = interval
+    end
+
+    def working_directory(path)
+      @options[:runpath] = path
+    end
+
+    def pid(pidfile)
+      @options[:pidfile] = pidfile
+    end
+
+    def stderr_path(path)
+      @options[:stderr_path] = path
+    end
+
+    def stdout_path(path)
+      @options[:stdout_path] = path
+    end
+
+    def setup(&block)
+      @options[:setup] = block
+    end
+
+    def teardown(&block)
+      @options[:teardown] = block
+    end
+
+    def before_fork(&block)
+      @options[:before_fork] = block
+    end
+
+    def after_fork(&block)
+      @options[:after_fork] = block
+    end
+
+    def preload_app(yes_no)
+      @options[:preload_app] = yes_no
+    end
+
+    def daemonize(yes_no)
+      @options[:daemon] = yes_no
+    end
+
+    def initialize(path)
+      @config_path = path
+      @options = {}
+    end
+
+    def self.process(config_path)
+      loader = Resque::Master.new(config_path)
+      loader.run
+      loader.options
+    end
+
+    def run
+      eval(File.read(@config_path), binding)
+    end
+
+    def self.setup(options)
+      puts "running setup with: #{options.inspect}"
+
+      Resque.setup do |forker|
+        puts "calling resque setup: #{options.inspect}"
+        if options[:preload_app]
+          $:.unshift options[:runpath] # Makes 1.9.2 happy
+          require options[:runpath] + "/config/environment"
+          forker.logger   = Rails.logger
+        end
+
+        File.open(options[:pidfile],"wb") {|f| f << Process.pid }
+        forker.workload = options[:worker_queues] * options[:worker_processes].to_i
+        forker.options.interval = options[:work_interval].to_i if options.key?(:work_interval)
+      end
+
+      Resque.teardown do|forker|
+        File.unlink(options[:pidfile]) if File.exist?(options[:pidfile])
+      end
+
+      Resque.before_first_fork do
+        options[:before_first_fork].call if options[:before_first_fork].is_a?(Proc)
+      end
+
+      Resque.before_fork do
+        options[:before_fork].call if options[:before_fork].is_a?(Proc)
+      end
+
+      Resque.after_fork do
+        options[:after_fork].call if options[:after_fork].is_a?(Proc)
+      end
+    end
+
+    def self.daemonize(options)
+      $pidfile = options[:pidfile]
+      rd, wr = IO.pipe
+
+      stdout = options[:stdout_path] || "/dev/null"
+      stderr = options[:stderr_path] || "/dev/null"
+
+      # wait for child process to start running before exiting parent process
+      fork do
+        rd.close
+        Process.setsid
+        fork do
+          begin
+            wr.write "Prepare to fork: #{options.inspect}, stdout: #{stdout.inspect}, stderr: #{stderr.inspect}, stdin: /dev/null"
+            Process.setsid
+            Dir.chdir(options[:runpath])
+            File.umask 0000
+            STDIN.reopen "/dev/null"
+            STDOUT.reopen stdout, "a"
+            STDERR.reopen stderr, "a"
+
+            wr.flush
+            wr.close # signal to our parent we're up and running, this lets the parent exit
+
+            Resque.fork! # fork to startup the workers
+          rescue => e
+            if wr.closed?
+              STDERR.puts "#{e.message} #{e.backtrace.join("\n")}"
+            else
+              wr.write e.message
+              wr.write e.backtrace.join("\n")
+              wr.write "\n"
+              wr.write "ERROR!"
+              wr.flush
+              wr.close
+            end
+          end
+        end
+        wr.close
+      end
+
+      wr.close
+      output = rd.read
+      puts output
+      rd.close
+
+    end
+
+    def self.optparse!
+      options = {}
+
+      optparse = OptionParser.new do|opts|
+       # Set a banner, displayed at the top
+       # of the help screen.
+       opts.banner = "Usage: optparse1.rb [options] file1 file2 ..."
+
+       opts.on( '-d', '--daemon', 'Run the master process as daemon' ) do
+         options[:daemon] = true
+       end
+
+       opts.on( '-p', '--pid FILE', 'Write pid file to FILE' ) do|file|
+         options[:pidfile] = file
+       end
+
+       opts.on( '-r', '--run PATH', 'Where to run the forked daemon' ) do|file|
+         options[:runpath] = file
+       end
+
+       opts.on( '-e', '--stderr PATH', 'Where to send stderr output' ) do|file|
+         options[:stderr_path] = file
+       end
+
+       opts.on( '-o', '--stdout PATH', 'Where to send stdout output' ) do|file|
+         options[:stdout_path] = file
+       end
+
+       opts.on( '-c', '--config PATH', 'Path to a configuration file to load' ) do|file|
+         options[:config] = file
+       end
+
+       opts.on( '-l', '--logfile FILE', 'Write log to FILE' ) do|file|
+         options[:logfile] = file
+       end
+
+       # This displays the help screen, all programs are
+       # assumed to have this option.
+       opts.on( '-h', '--help', 'Display this screen' ) do
+         puts opts
+         exit
+       end
+      end
+
+      optparse.parse!
+      options
+    end
+
+    def self.defaults
+      {
+        :config => nil,
+        :logfile => nil,
+        :stderr_path => "/dev/null",
+        :stdout_path => "/dev/null",
+        :runpath => "/",
+        :pidfile => nil,
+        :daemon => false
+      }
+    end
+
+  end
+end

data/resque-forker.gemspec

@@ -1,5 +1,5 @@
-$: << File.dirname(__FILE__) + "/lib"
-require "resque/forker"
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/lib")
+require "resque/forker/version"
 
 Gem::Specification.new do |spec|
   spec.name           = "resque-forker"
@@ -10,8 +10,9 @@ Gem::Specification.new do |spec|
   spec.summary        = "Super awesome forking action for Resque workers"
   spec.description    = "Use the power of forking to run multiple Resque workers."
   spec.post_install_message = ""
+  spec.executables    = %w(resque-ctl)
 
-  spec.files          = Dir["{lib,script,etc}/**/*", "CHANGELOG", "MIT-LICENSE", "README.rdoc", "Rakefile", "*.gemspec"]
+  spec.files          = Dir["{lib,script,etc,bin}/**/*", "CHANGELOG", "MIT-LICENSE", "README.rdoc", "Rakefile", "*.gemspec"]
 
   spec.has_rdoc         = true
   spec.extra_rdoc_files = "README.rdoc", "CHANGELOG"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: resque-forker
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 15
   prerelease: false
   segments: 
-  - 1
-  - 3
+  - 2
   - 0
-  version: 1.3.0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Assaf Arkin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-16 00:00:00 -07:00
+date: 2011-02-03 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,8 +34,8 @@ dependencies:
   version_requirements: *id001
 description: Use the power of forking to run multiple Resque workers.
 email: assaf@labnotes.org
-executables: []
-
+executables: 
+- resque-ctl
 extensions: []
 
 extra_rdoc_files: 
@@ -43,10 +43,13 @@ extra_rdoc_files:
 - CHANGELOG
 files: 
 - lib/resque/capistrano.rb
+- lib/resque/forker/version.rb
 - lib/resque/forker.rb
+- lib/resque/master.rb
 - script/trigger
 - script/workers
 - etc/init/workers.conf
+- bin/resque-ctl
 - CHANGELOG
 - MIT-LICENSE
 - README.rdoc
@@ -59,7 +62,7 @@ licenses: []
 post_install_message: ""
 rdoc_options: 
 - --title
-- Resque Forker  1.3.0
+- Resque Forker  2.0.0
 - --main
 - README.rdoc
 - --webcvs