vitobotta-resque-pool 0.3.0.dev

data/lib/resque/pool.rb

@@ -0,0 +1,331 @@
+# -*- encoding: utf-8 -*-
+require 'resque'
+require 'resque/pool/version'
+require 'resque/pool/logging'
+require 'resque/pool/pooled_worker'
+require 'fcntl'
+require 'yaml'
+
+module Resque
+  class Pool
+    SIG_QUEUE_MAX_SIZE = 5
+    DEFAULT_WORKER_INTERVAL = 5
+    QUEUE_SIGS = [ :QUIT, :INT, :TERM, :USR1, :USR2, :CONT, :HUP, :WINCH, ]
+    CHUNK_SIZE = (16 * 1024)
+
+    include Logging
+    attr_reader :config
+    attr_reader :workers
+
+    def initialize(config)
+      init_config(config)
+      @workers = {}
+      procline "(initialized)"
+    end
+
+    # Config: after_prefork {{{
+
+    # 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 self.after_prefork(&block)
+      block ? (@after_prefork = block) : @after_prefork
+    end
+
+    # Set the after_prefork proc.
+    def self.after_prefork=(after_prefork)
+      @after_prefork = after_prefork
+    end
+
+    def call_after_prefork!
+      self.class.after_prefork && self.class.after_prefork.call
+    end
+
+    # }}}
+    # Config: class methods to start up the pool using the default config {{{
+
+    @config_files = ["resque-pool.yml", "config/resque-pool.yml"]
+    class << self; attr_accessor :config_files; end
+    def self.choose_config_file
+      if ENV["RESQUE_POOL_CONFIG"]
+        ENV["RESQUE_POOL_CONFIG"]
+      else
+        @config_files.detect { |f| File.exist?(f) }
+      end
+    end
+
+    def self.run
+      if GC.respond_to?(:copy_on_write_friendly=)
+        GC.copy_on_write_friendly = true
+      end
+      Resque::Pool.new(choose_config_file).start.join
+    end
+
+    # }}}
+    # Config: load config and config file {{{
+
+    def config_file
+      @config_file || (!@config && ::Resque::Pool.choose_config_file)
+    end
+
+    def init_config(config)
+      case config
+      when String, nil
+        @config_file = config
+      else
+        @config = config.dup
+      end
+      load_config
+    end
+
+    def load_config
+      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
+
+    def environment
+      if defined? RAILS_ENV
+        RAILS_ENV
+      else
+        ENV['RACK_ENV'] || ENV['RAILS_ENV'] || ENV['RESQUE_ENV']
+      end
+    end
+
+    # }}}
+
+    # Sig handlers and self pipe management {{{
+
+    def self_pipe; @self_pipe ||= [] end
+    def sig_queue; @sig_queue ||= [] end
+
+    def init_self_pipe!
+      self_pipe.each { |io| io.close rescue nil }
+      self_pipe.replace(IO.pipe)
+      self_pipe.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
+
+    def init_sig_handlers!
+      QUEUE_SIGS.each { |sig| trap_deferred(sig) }
+      trap(:CHLD)     { |_| awaken_master }
+    end
+
+    def awaken_master
+      begin
+        self_pipe.last.write_nonblock('.') # wakeup master process from select
+      rescue Errno::EAGAIN, Errno::EINTR
+        # pipe is full, master should wake up anyways
+        retry
+      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
+        else
+          log "ignoring SIG#{signal}, queue=#{sig_queue.inspect}"
+        end
+      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
+        log "#{signal}: sending to all workers"
+        signal_all_workers(signal)
+      when :HUP
+        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"
+        @config = {}
+        maintain_worker_count
+      when :QUIT
+        log "QUIT: graceful shutdown, waiting for children"
+        signal_all_workers(:QUIT)
+        reap_all_workers(0) # will hang until all workers are shutdown
+        :break
+      when :INT
+        log "INT: immediate shutdown (graceful worker shutdown)"
+        signal_all_workers(:QUIT)
+        :break
+      when :TERM
+        log "TERM: immediate shutdown (and immediate worker shutdown)"
+        signal_all_workers(:TERM)
+        :break
+      end
+    end
+
+    # }}}
+    # start, join, and master sleep {{{
+
+    def start
+      procline("(starting)")
+      init_self_pipe!
+      init_sig_handlers!
+      maintain_worker_count
+      procline("(started)")
+      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
+        break if handle_sig_queue! == :break
+        if sig_queue.empty?
+          master_sleep
+          maintain_worker_count
+        end
+        procline("managing #{all_pids.inspect}")
+      end
+      procline("(shutting down)")
+      #stop # gracefully shutdown all workers on our way out
+      log "manager finished"
+      #unlink_pid_safe(pid) if pid
+    end
+
+    def master_sleep
+      begin
+        ready = IO.select([self_pipe.first], nil, nil, 1) or return
+        ready.first && ready.first.first or return
+        loop { self_pipe.first.read_nonblock(CHUNK_SIZE) }
+      rescue Errno::EAGAIN, Errno::EINTR
+      end
+    end
+
+    # }}}
+    # 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 resque worker[#{status.pid}] (status: #{status.exitstatus}) queues: #{worker.queues.join(",")}"
+        end
+      rescue Errno::ECHILD, QuitNowException
+      end
+    end
+
+    def delete_worker(pid)
+      worker = nil
+      workers.detect do |queues, pid_to_worker|
+        worker = pid_to_worker.delete(pid)
+      end
+      worker
+    end
+
+    def all_pids
+      workers.map {|q,workers| workers.keys }.flatten
+    end
+
+    def signal_all_workers(signal)
+      all_pids.each do |pid|
+        Process.kill signal, pid
+      end
+    end
+
+    # }}}
+    # ???: maintain_worker_count, all_known_queues {{{
+
+    def maintain_worker_count
+      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_queues
+      config.keys | workers.keys
+    end
+
+    # }}}
+    # 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] ||= {}
+      workers[queues][pid] = worker
+    end
+
+    def create_worker(queues)
+      queues = queues.to_s.split(',')
+      worker = PooledWorker.new(*queues)
+      worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+      worker.very_verbose = ENV['VVERBOSE']
+      worker
+    end
+
+    # }}}
+
+  end
+end

data/resque-pool.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "resque/pool/version"
+
+Gem::Specification.new do |s|
+  s.name        = "vitobotta-resque-pool"
+  s.version     = Resque::Pool::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["nicholas a. evans", "Vito Botta"]
+  s.email       = ["nick@ekenosen.net", "vito@botta.name"]
+  s.homepage    = "https://github.com/vitobotta/resque-pool"
+  s.summary     = "quickly and easily fork a pool of resque workers"
+  s.description = <<-EOF
+    quickly and easily fork a pool of resque workers,
+    saving memory (w/REE) and monitoring their uptime
+  EOF
+
+  s.add_dependency "resque",  "~> 1.13"
+  s.add_dependency "trollop", "~> 1.16"
+  s.add_dependency "rake"
+  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" unless RUBY_VERSION =~ /1\.9/ # to silence redis gem's warning
+  s.add_development_dependency "bundler", "~> 1.0"
+
+  # 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/mock_config.rb

@@ -0,0 +1,6 @@
+RESQUE_POOL_CONFIG = {
+  'foo' => 1,
+  'bar' => 1,
+  'baz' => 1,
+  'foo,bar,baz' => 4,
+}

data/spec/resque-pool.yml

@@ -0,0 +1,13 @@
+foo: 1
+
+production:
+  "foo,bar": 10
+
+development:
+  "foo,bar": 4
+  "baz": 23
+  
+test:
+  "bar": 5
+  "foo,bar": 3
+

data/spec/resque_pool_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+RSpec.configure do |config|
+  config.after {
+    Object.send(:remove_const, :RAILS_ENV) if defined? RAILS_ENV
+    ENV.delete 'RACK_ENV'
+    ENV.delete 'RAILS_ENV'
+    ENV.delete 'RESQUE_ENV'
+  }
+end
+
+describe Resque::Pool, "when loading a simple pool configuration" do
+  let(:config) do
+    { 'foo' => 1, 'bar' => 2, 'foo,bar' => 3, 'bar,foo' => 4, }
+  end
+  subject { Resque::Pool.new(config) }
+
+  context "when ENV['RACK_ENV'] is set" do
+    before { ENV['RACK_ENV'] = 'development' }
+
+    it "should load the values from the Hash" do
+      subject.config["foo"].should == 1
+      subject.config["bar"].should == 2
+      subject.config["foo,bar"].should == 3
+      subject.config["bar,foo"].should == 4
+    end
+  end
+
+end
+
+describe Resque::Pool, "when loading the pool configuration from a Hash" do
+
+  let(:config) do
+    {
+      'foo' => 8,
+      'test'        => { 'bar' => 10, 'foo,bar' => 12 },
+      'development' => { 'baz' => 14, 'foo,bar' => 16 },
+    }
+  end
+
+  subject { Resque::Pool.new(config) }
+
+  context "when RAILS_ENV is set" do
+    before { RAILS_ENV = "test" }
+
+    it "should load the default values from the Hash" do
+      subject.config["foo"].should == 8
+    end
+
+    it "should merge the values for the correct RAILS_ENV" do
+      subject.config["bar"].should == 10
+      subject.config["foo,bar"].should == 12
+    end
+
+    it "should not load the values for the other environments" do
+      subject.config["foo,bar"].should == 12
+      subject.config["baz"].should be_nil
+    end
+
+  end
+
+  context "when ENV['RESQUE_ENV'] is set" do
+    before { ENV['RESQUE_ENV'] = 'development' }
+    it "should load the config for that environment" do
+      subject.config["foo"].should == 8
+      subject.config["foo,bar"].should == 16
+      subject.config["baz"].should == 14
+      subject.config["bar"].should be_nil
+    end
+  end
+
+  context "when there is no environment" do
+    it "should load the default values only" do
+      subject.config["foo"].should == 8
+      subject.config["bar"].should be_nil
+      subject.config["foo,bar"].should be_nil
+      subject.config["baz"].should be_nil
+    end
+  end
+
+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") }
+
+  context "when RAILS_ENV is set" do
+    before { RAILS_ENV = "test" }
+
+    it "should load the default YAML" do
+      subject.config["foo"].should == 1
+    end
+
+    it "should merge the YAML for the correct RAILS_ENV" do
+      subject.config["bar"].should == 5
+      subject.config["foo,bar"].should == 3
+    end
+
+    it "should not load the YAML for the other environments" do
+      subject.config["foo"].should == 1
+      subject.config["bar"].should == 5
+      subject.config["foo,bar"].should == 3
+      subject.config["baz"].should be_nil
+    end
+
+  end
+
+  context "when ENV['RACK_ENV'] is set" do
+    before { ENV['RACK_ENV'] = 'development' }
+    it "should load the config for that environment" do
+      subject.config["foo"].should == 1
+      subject.config["foo,bar"].should == 4
+      subject.config["baz"].should == 23
+      subject.config["bar"].should be_nil
+    end
+  end
+
+  context "when there is no environment" do
+    it "should load the default values only" do
+      subject.config["foo"].should == 1
+      subject.config["bar"].should be_nil
+      subject.config["foo,bar"].should be_nil
+      subject.config["baz"].should be_nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+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'

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification 
+name: vitobotta-resque-pool
+version: !ruby/object:Gem::Version 
+  prerelease: 6
+  version: 0.3.0.dev
+platform: ruby
+authors: 
+- nicholas a. evans
+- Vito Botta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: resque
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.13"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.16"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        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 
+        version: 0.3.2
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+  type: :development
+  version_requirements: *id007
+description: "    quickly and easily fork a pool of resque workers,\n    saving memory (w/REE) and monitoring their uptime\n"
+email: 
+- nick@ekenosen.net
+- vito@botta.name
+executables: 
+- resque-pool
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/resque-pool
+- Changelog.md
+- config/alternate.yml
+- config/cucumber.yml
+- examples/chef_cookbook/recipes/default.rb
+- examples/chef_cookbook/templates/default/initd.erb
+- examples/chef_cookbook/templates/default/monitrc.erb
+- examples/Gemfile
+- examples/Gemfile.lock
+- examples/rails-resque.rake
+- examples/Rakefile
+- examples/resque-pool.yml
+- features/basic_daemon_config.feature
+- features/step_definitions/daemon_steps.rb
+- features/step_definitions/resque-pool_steps.rb
+- features/support/aruba_daemon_support.rb
+- features/support/env.rb
+- Gemfile
+- lib/resque/pool/cli.rb
+- lib/resque/pool/logging.rb
+- lib/resque/pool/pooled_worker.rb
+- lib/resque/pool/tasks.rb
+- lib/resque/pool/version.rb
+- lib/resque/pool.rb
+- LICENSE.txt
+- Rakefile
+- README.md
+- resque-pool.gemspec
+- spec/mock_config.rb
+- spec/resque-pool.yml
+- spec/resque_pool_spec.rb
+- spec/spec_helper.rb
+- tmp/aruba/Rakefile
+has_rdoc: true
+homepage: https://github.com/vitobotta/resque-pool
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: quickly and easily fork a pool of resque workers
+test_files: 
+- spec/mock_config.rb
+- spec/resque_pool_spec.rb
+- spec/spec_helper.rb
+- spec/resque-pool.yml
+- features/step_definitions/daemon_steps.rb
+- features/step_definitions/resque-pool_steps.rb
+- features/support/aruba_daemon_support.rb
+- features/support/env.rb
+- features/basic_daemon_config.feature