pace 0.0.5

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+bench/*.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+# -*- mode: ruby; -*-
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT-License)
+
+Copyright (c) 2011 GroupMe
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,22 @@
+# Pace - A Resque Reactor #
+
+More docs to come...
+
+In short, the goals are:
+
+ * Performance
+ * Transparency via instrumentation (TODO)
+
+## Examples ##
+
+To have fun with the examples, fire one up and then start
+enqueuing Resque jobs:
+
+    $ rake examples:http
+
+    $ irb
+    > require "rubygems"
+    > require "resque"
+    > class MyJob; def self.queue; "normal"; end; end
+    > Resque.enqueue(MyJob)
+    > 10.times { |n| Resque.enqueue(MyJob, :n => n) }

data/Rakefile

@@ -0,0 +1,63 @@
+require 'bundler'
+require "resque/tasks"
+Bundler::GemHelper.install_tasks
+
+$: << File.join(File.dirname(__FILE__), "bench")
+$: << File.join(File.dirname(__FILE__), "examples")
+
+namespace :examples do
+  desc "Simply echo jobs to the console"
+  task :echo do
+    require "echo"
+  end
+
+  desc "Serial processing when the block doesn't defer"
+  task :sleep do
+    require "sleep"
+  end
+
+  desc "Concurrent processing using EM.defer"
+  task :defer do
+    require "defer"
+  end
+
+  desc "Concurrent processing by blocking on an HTTP connection"
+  task :http do
+    require "http"
+  end
+end
+
+namespace :bench do
+  desc "Fire up Pace for benchmarking"
+  task :pace do
+    ENV["PACE_QUEUE"] = "normal"
+    require "pace_http"
+  end
+
+  desc "Fire up Resque for benchmarking"
+  task :resque do
+    ENV["COUNT"]   = "10"
+    ENV["QUEUE"]   = "normal"
+    # ENV["VERBOSE"] = "1"
+
+    Rake::Task["resque:workers"].invoke
+  end
+
+  desc "Inject jobs for benchmarking"
+  task :jobs do
+    require "resque"
+    require "resque_http"
+
+    count = (ENV["COUNT"] || 100).to_i
+    count.times do |n|
+      Resque.enqueue(ResqueHttp, :n => n)
+    end
+  end
+end
+
+# For benchmark purposes
+namespace :resque do
+  task :setup do
+    require "resque_http"
+  end
+end

data/bench/pace_http.rb

@@ -0,0 +1,34 @@
+# Benchmark Pace
+#
+# Performed by running:
+#
+#     $ rake bench:pace
+#     $ COUNT=1000 rake bench:jobs
+#
+# This was setup to hit a dumb node.js server that simply responds with 200 OK.
+#
+# For 1000 jobs:
+#   1.783s (avg. 5 runs, 1.78ms/job)
+#
+# For 50,000 jobs:
+#   68.708s (avg. 5 runs, 1.37ms/job), memory topped out at a steady 21.3MB
+
+require "pace"
+
+Pace.logger = Logger.new(File.join(File.dirname(__FILE__), "pace.log"))
+Pace.log("Starting #{'%0.6f' % Time.now}")
+
+Pace.start do |job|
+  start_time = Time.now
+  args = job["args"][0].map { |k,v| "#{k}=#{v}" }
+  args = args.join("&")
+
+  http = EM::Protocols::HttpClient.request(
+    :host    => "localhost",
+    :port    => 9000,
+    :request => "/?#{args}"
+  )
+  http.callback do |r|
+    Pace.log("http://localhost:9000/?#{args}", start_time)
+  end
+end

data/bench/resque_http.rb

@@ -0,0 +1,41 @@
+# Benchmark Resque
+#
+# This was performed by running:
+#
+#     $ rake bench:resque
+#     $ COUNT=1000 rake bench:jobs
+#
+# By default, it spins up ten workers locally, logging to bench/resque.log. A dummy
+# node.js server was propped up to simply respond with 200 OK.
+#
+# For 1000 jobs:
+#   18.33s (avg. 5 runs, 18.33ms/job)
+#
+# For 50,000 jobs:
+#   870.81s (just 1 run, but I got stuff to do, 17.42ms/job),
+#     memory sitting at ~15MB per worker process (10 total)
+
+require "net/http"
+require "logger"
+
+class ResqueHttp
+  def self.queue
+    "normal"
+  end
+
+  def self.perform(args)
+    start_time = Time.now
+    args = args.map { |k,v| "#{k}=#{v}" }
+    args = args.join("&")
+
+    Net::HTTP.start("localhost", 9000) do |http|
+      http.get("/?#{args}")
+    end
+
+    logger.info "http://localhost:9000/?#{args} #{"(%0.6fs)" % (Time.now - start_time)}"
+  end
+
+  def self.logger
+    @logger ||= Logger.new(File.join(File.dirname(__FILE__), "resque.log"))
+  end
+end

data/examples/defer.rb

@@ -0,0 +1,17 @@
+# To gain concurrent processing on jobs that don't block on
+# sockets, we can use EM.defer to run in background threads.
+
+require "pace"
+
+Pace.start(:queue => (ENV["PACE_QUEUE"] || "normal")) do |job|
+  start_time = Time.now
+
+  operation = proc {
+    rand(10).times { sleep 0.1 }
+  }
+  callback = proc { |result|
+    Pace.log(job.inspect, start_time)
+  }
+
+  EM.defer operation, callback
+end

data/examples/echo.rb

@@ -0,0 +1,5 @@
+require "pace"
+
+Pace.start(:queue => (ENV["PACE_QUEUE"] || "normal")) do |job|
+  Pace.log(job.inspect, Time.now)
+end

data/examples/http.rb

@@ -0,0 +1,20 @@
+# Pace (and EventMachine) works best when your job can block
+# on a socket and proceed to process jobs (almost) concurrently.
+#
+# A good explanation can be found here:
+#   http://www.igvita.com/2008/05/27/ruby-eventmachine-the-speed-demon/
+
+require "pace"
+
+Pace.start(:queue => (ENV["PACE_QUEUE"] || "normal")) do |job|
+  start_time = Time.now
+
+  http = EM::Protocols::HttpClient.request(
+    :host    => "localhost",
+    :port    => 9000,
+    :request => "/"
+  )
+  http.callback do |r|
+    Pace.log(job.inspect, start_time)
+  end
+end

data/examples/sleep.rb

@@ -0,0 +1,13 @@
+# Our work in this example does not defer nor block on a socket,
+# so jobs will be processed serially, finishing one before starting
+# the next.
+#
+# This should be avoided.
+
+require "pace"
+
+Pace.start(:queue => (ENV["PACE_QUEUE"] || "normal")) do |job|
+  start_time = Time.now
+  rand(10).times { sleep 0.1 }
+  Pace.log(job.inspect, start_time)
+end

data/lib/pace.rb

@@ -0,0 +1,32 @@
+require "eventmachine"
+require "em-redis"
+require "json"
+require "uri"
+require "logger"
+require "pace/load_average"
+require "pace/worker"
+
+module Pace
+  def self.start(options = {}, &block)
+    worker = Pace::Worker.new(options)
+    worker.start(&block)
+  end
+
+  def self.log(message, start_time = nil)
+    if start_time
+      logger.info("%s (%0.6fs)" % [message, Time.now - start_time])
+    else
+      logger.info("%s" % message)
+    end
+  end
+
+  private
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def self.logger=(new_logger)
+    @logger = new_logger
+  end
+end

data/lib/pace/load_average.rb

@@ -0,0 +1,34 @@
+module Pace
+  module LoadAverage
+    INTERVAL  = 5.0 # sec
+    FSHIFT    = 11
+    FIXED_1   = 1 << FSHIFT
+    EXP_1     = 1884.0 # 1/exp(5sec/1min) as fixed-point
+    EXP_5     = 2014.0 # 1/exp(5sec/5min)
+    EXP_15    = 2037.0 # 1/exp(5sec/15min)
+    $ticks    = 0
+    $load     = [0.0, 0.0, 0.0, 0.0] # sec, min, 5 min, 15 min
+
+    class << self
+      def compute
+        per_second = $ticks / INTERVAL
+        $load[0] = per_second
+        $load[1] = average($load[1], EXP_1, per_second)
+        $load[2] = average($load[2], EXP_5, per_second)
+        $load[3] = average($load[3], EXP_15, per_second)
+        $ticks = 0
+        $load
+      end
+
+      def average(load, exp, n)
+        load *= exp
+        load += n*(FIXED_1-exp)
+        ((load * 1000).to_i >> FSHIFT) / 1000.0
+      end
+
+      def tick
+        $ticks += 1
+      end
+    end
+  end
+end

data/lib/pace/mock.rb

@@ -0,0 +1,63 @@
+# Ease testing by mocking the event loop
+#
+# Instead of having to detect and stop the event loop yourself, this helper
+# simply returns all jobs in the queue and shuts down the loop.
+#
+#     require "pace/mock"
+#
+#     # Fire it up
+#     Pace::Mock.enable
+#
+#     # Add some jobs
+#     Resque.enqueue(Work, ...)
+#     Resque.enqueue(Work, ...)
+#
+#     # Create a worker with a block that doesn't need to stop the loop
+#     worker = Pace::Worker.new(:queue => "queue")
+#     worker.start do |job|
+#       puts job.inspect
+#     end
+#
+#     # Turn it off when you're done
+#     Pace::Mock.disable
+#
+module Pace
+  module Mock
+    def self.enable
+      Pace.logger.info "Enabling Pace mock"
+
+      Pace::Worker.class_eval do
+        if instance_methods.include?(:start_with_mock)
+          alias :start :start_with_mock
+        else
+          def start_with_mock(&block)
+            jobs = nil
+
+            EM.run do
+              @redis = EM::Protocols::Redis.connect(@options)
+              @redis.lrange(queue, 0, -1) do |jobs|
+                jobs.each do |job|
+                  block.call JSON.parse(job)
+                end
+                @redis.del(queue) { EM.stop_event_loop }
+              end
+            end
+          end
+
+          alias :start_without_mock :start
+          alias :start :start_with_mock
+        end
+      end
+    end
+
+    def self.disable
+      Pace.logger.info "Disabling Pace mock"
+
+      Pace::Worker.class_eval do
+        if instance_methods.include?(:start_without_mock)
+          alias :start :start_without_mock
+        end
+      end
+    end
+  end
+end

data/lib/pace/version.rb

@@ -0,0 +1,3 @@
+module Pace
+  VERSION = "0.0.5"
+end

data/lib/pace/worker.rb

@@ -0,0 +1,91 @@
+module Pace
+  class Worker
+    attr_reader :redis, :queue
+
+    def initialize(options = {})
+      @options   = options.dup
+      @queue     = @options.delete(:queue) || ENV["PACE_QUEUE"]
+      @namespace = @options.delete(:namespace)
+
+      if @queue.nil? || @queue.empty?
+        raise ArgumentError.new("Queue unspecified -- pass a queue name or set PACE_QUEUE")
+      end
+
+      @queue = fully_qualified_queue(@queue)
+
+      url = URI(@options.delete(:url) || ENV["PACE_REDIS"] || "redis://127.0.0.1:6379/0")
+
+      @options[:host]     ||= url.host
+      @options[:port]     ||= url.port
+      @options[:password] ||= url.password
+      @options[:db]       ||= url.path[1..-1].to_i
+    end
+
+    def start(&block)
+      @block = block
+
+      Pace.logger.info "Starting up"
+      register_signal_handlers
+
+      EM.run do
+        EventMachine::add_periodic_timer(Pace::LoadAverage::INTERVAL) do
+          Pace::LoadAverage.compute
+          Pace.logger.info("load averages: #{$load.join(' ')}")
+        end
+
+        @redis = EM::Protocols::Redis.connect(@options)
+        fetch_next_job
+      end
+    end
+
+    def shutdown
+      Pace.logger.info "Shutting down"
+      EM.stop_event_loop
+    end
+
+    def on_error(&callback)
+      @error_callback = callback
+    end
+
+    def enqueue(queue, klass, *args, &block)
+      queue = fully_qualified_queue(queue)
+      job   = {:class => klass.to_s, :args => args}.to_json
+      @redis.rpush(queue, job, &block)
+    end
+
+    private
+
+    def fetch_next_job
+      @redis.blpop(queue, 0) do |queue, job|
+        EM.next_tick { fetch_next_job }
+
+        begin
+          @block.call JSON.parse(job)
+          Pace::LoadAverage.tick
+        rescue Exception => e
+          log_failed_job(job, e)
+          @error_callback.call(job, e) if @error_callback
+        end
+      end
+    end
+
+    def fully_qualified_queue(queue)
+      parts = [queue]
+      parts.unshift("resque:queue") unless queue.index(":")
+      parts.unshift(@namespace) unless @namespace.nil?
+      parts.join(":")
+    end
+
+    def register_signal_handlers
+      trap('TERM') { shutdown }
+      trap('QUIT') { shutdown }
+      trap('INT')  { shutdown }
+    end
+
+    def log_failed_job(job, exception)
+      message = "Job failed!\n#{job}\n#{exception.message}\n"
+      message << exception.backtrace.join("\n")
+      Pace.logger.error(message)
+    end
+  end
+end

data/pace.gemspec

@@ -0,0 +1,25 @@
+# -*- mode: ruby; encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pace/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pace"
+  s.version     = Pace::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dave Yeu"]
+  s.email       = ["daveyeu@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Resque-compatible job processing in an event loop}
+
+  s.rubyforge_project = "pace"
+
+  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) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "em-redis", ">= 0.3.0"
+
+  s.add_development_dependency "resque", "~> 1.17.1"
+  s.add_development_dependency "rspec",  "~> 2.6.0"
+end

data/spec/pace/mock_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+require "pace/mock"
+
+describe Pace::Mock do
+  class Work
+    def self.queue
+      "pace"
+    end
+  end
+
+  before do
+    Resque.dequeue(Work)
+  end
+
+  after do
+    Pace::Mock.disable
+  end
+
+  describe ".enable" do
+    it "sets up the mock, which simply passes down Resque jobs and closes the event loop" do
+      Pace::Mock.enable
+      Resque.enqueue(Work, :n => 1)
+      Resque.enqueue(Work, :n => 2)
+
+      results = []
+      worker = Pace::Worker.new(:queue => "pace")
+      worker.start { |job| results << job }
+      results.should == [
+        {"class" => "Work", "args" => [{"n" => 1}]},
+        {"class" => "Work", "args" => [{"n" => 2}]}
+      ]
+
+      # Clears out the queue
+      more_results = []
+      worker.start { |job| more_results << job }
+      more_results.should be_empty
+    end
+
+    it "works after disabling" do
+      Pace::Mock.enable
+      Pace::Mock.disable
+      Pace::Mock.enable
+
+      Resque.enqueue(Work, :n => 2)
+
+      results = []
+      worker = Pace::Worker.new(:queue => "pace")
+      worker.start do |job|
+        results << job
+      end
+      results.should == [{"class" => "Work", "args" => [{"n" => 2}]}]
+    end
+  end
+
+  describe ".disable" do
+    it "tears down the mock and re-institutes the event loop" do
+      Pace::Mock.enable
+      Pace::Mock.disable
+      Resque.enqueue(Work, :n => 1)
+      Resque.enqueue(Work, :n => 2)
+
+      results = []
+      worker = Pace::Worker.new(:queue => "pace")
+      worker.start do |job|
+        results << job
+        EM.stop_event_loop
+      end
+
+      results.should have(1).items
+    end
+  end
+end

data/spec/pace/worker_spec.rb

@@ -0,0 +1,271 @@
+require "spec_helper"
+
+describe Pace::Worker do
+  class Work
+    def self.queue
+      "pace"
+    end
+  end
+
+  before do
+    Resque.dequeue(Work)
+  end
+
+  describe "#initialize" do
+    describe "sets the Redis connection options" do
+      before do
+        @connection = double(EM::Connection)
+      end
+
+      it "uses 127.0.0.1:6379/0 by default" do
+        EM::Protocols::Redis.should_receive(:connect).with(
+          :host     => "127.0.0.1",
+          :port     => 6379,
+          :password => nil,
+          :db       => 0
+        ).and_return(@connection)
+
+        worker = Pace::Worker.new :queue => "normal"
+        worker.stub(:fetch_next_job).and_return { EM.stop_event_loop }
+        worker.start
+        worker.redis.should == @connection
+      end
+
+      it "can use a custom URL string" do
+        EM::Protocols::Redis.should_receive(:connect).with(
+          :host     => "some.host.local",
+          :port     => 9999,
+          :password => "secret",
+          :db       => 1
+        ).and_return(@connection)
+
+        worker = Pace::Worker.new :url => "redis://user:secret@some.host.local:9999/1", :queue => "normal"
+        worker.stub(:fetch_next_job).and_return { EM.stop_event_loop }
+        worker.start
+        worker.redis.should == @connection
+      end
+
+      it "can be set using the PACE_REDIS environment variable" do
+        original_redis = ENV["PACE_REDIS"]
+        ENV["PACE_REDIS"] = "redis://user:secret@some.host.local:9999/1"
+
+        EM::Protocols::Redis.should_receive(:connect).with(
+          :host     => "some.host.local",
+          :port     => 9999,
+          :password => "secret",
+          :db       => 1
+        ).and_return(@connection)
+
+        worker = Pace::Worker.new :queue => "normal"
+        worker.stub(:fetch_next_job).and_return { EM.stop_event_loop }
+        worker.start
+        worker.redis.should == @connection
+
+        ENV["PACE_REDIS"] = original_redis
+      end
+    end
+
+    describe "sets the queue_name" do
+      before do
+        EM::Protocols::Redis.stub(:connect).and_return(double(EM::Connection))
+      end
+
+      context "when the given name has no colons" do
+        it "prepends the Resque default queue 'namespace'" do
+          worker = Pace::Worker.new(:queue => "normal")
+          worker.queue.should == "resque:queue:normal"
+        end
+      end
+
+      context "when the given name has colons" do
+        it "does not prepend anything (absolute)" do
+          worker = Pace::Worker.new(:queue => "my:special:queue")
+          worker.queue.should == "my:special:queue"
+        end
+      end
+
+      context "when a namespace is provided" do
+        it "prepends the namespace in either case" do
+          worker = Pace::Worker.new(:queue => "normal", :namespace => "test")
+          worker.queue.should == "test:resque:queue:normal"
+
+          worker = Pace::Worker.new(:queue => "special:queue", :namespace => "test")
+          worker.queue.should == "test:special:queue"
+        end
+      end
+
+      context "when the queue argument is nil" do
+        before do
+          @pace_queue = ENV["PACE_QUEUE"]
+        end
+
+        after do
+          ENV["PACE_QUEUE"] = @pace_queue
+        end
+
+        it "falls back to the PACE_QUEUE environment variable" do
+          ENV["PACE_QUEUE"] = "high"
+          worker = Pace::Worker.new
+          worker.queue.should == "resque:queue:high"
+
+          ENV["PACE_QUEUE"] = "my:special:queue"
+          worker = Pace::Worker.new
+          worker.queue.should == "my:special:queue"
+        end
+
+        it "throws an exception if PACE_QUEUE is nil" do
+          ENV["PACE_QUEUE"] = nil
+          expect { Pace::Worker.new }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe "#start" do
+    before do
+      @worker = Pace::Worker.new(:queue => "pace")
+    end
+
+    it "yields a serialized Resque jobs" do
+      Resque.enqueue(Work, :foo => 1, :bar => 2)
+
+      @worker.start do |job|
+        job["class"].should == "Work"
+        job["args"].should == [{"foo" => 1, "bar" => 2}]
+        EM.stop_event_loop
+      end
+    end
+
+    it "continues to pop jobs until stopped" do
+      Resque.enqueue(Work, :n => 1)
+      Resque.enqueue(Work, :n => 2)
+      Resque.enqueue(Work, :n => 3)
+      Resque.enqueue(Work, :n => 4)
+      Resque.enqueue(Work, :n => 5)
+
+      results = []
+
+      @worker.start do |job|
+        n = job["args"].first["n"]
+        results << n
+        EM.stop_event_loop if n == 5
+      end
+
+      results.should == [1, 2, 3, 4, 5]
+    end
+
+    it "rescues any errors in the passed block" do
+      Resque.enqueue(Work, :n => 1)
+      Resque.enqueue(Work, :n => 2)
+      Resque.enqueue(Work, :n => 3)
+
+      results = []
+
+      @worker.start do |job|
+        n = job["args"].first["n"]
+
+        raise "FAIL" if n == 1
+        results << n
+        EM.stop_event_loop if n == 3
+      end
+
+      results.should == [2, 3]
+    end
+  end
+
+  describe "#on_error" do
+    it "creates a callback to run if there's an error while processing a job" do
+      Resque.enqueue(Work, :n => 1)
+      Resque.enqueue(Work, :n => 2)
+      exception = RuntimeError.new("FAIL")
+
+      worker = Pace::Worker.new(:queue => "pace")
+      worker.on_error do |job, error|
+        job.should == {"class" => "Work", "args" => [{"n" => 1}]}.to_json
+        error.should == exception
+      end
+
+      worker.start do |job|
+        n = job["args"].first["n"]
+        raise exception    if n == 1
+        EM.stop_event_loop if n == 2
+      end
+    end
+  end
+
+  describe "#shutdown" do
+    it "stops the event loop on the next attempt to fetch a job" do
+      Resque.enqueue(Work, :n => 1)
+      Resque.enqueue(Work, :n => 2)
+
+      results = []
+
+      worker = Pace::Worker.new(:queue => "pace")
+      worker.start do |job|
+        worker.shutdown
+        results << job["args"].first["n"]
+      end
+
+      # Never runs the second job
+      results.should == [1]
+    end
+  end
+
+  describe "#enqueue" do
+    class CallbackJob
+      def self.queue
+        "callback"
+      end
+    end
+
+    it "adds a new, Resque-compatible job into the specified queue" do
+      Resque.enqueue(Work)
+
+      options = {:x => 1, :y => 2}
+
+      worker = Pace::Worker.new(:queue => "pace")
+      worker.start do |job|
+        worker.enqueue(CallbackJob.queue, CallbackJob, options) {
+          EM.stop_event_loop
+        }
+      end
+
+      new_job = Resque.pop(CallbackJob.queue)
+      new_job.should == {
+        "class" => "CallbackJob",
+        "args"  => [{"x" => 1, "y" => 2}]
+      }
+
+      # It's identical to a job added w/ Resque (important!)
+      Resque.enqueue(CallbackJob, options)
+      resque_job = Resque.pop(CallbackJob.queue)
+      resque_job.should == new_job
+    end
+  end
+
+  describe "signal handling" do
+    before do
+      Resque.enqueue(Work, :n => 1)
+      Resque.enqueue(Work, :n => 2)
+      Resque.enqueue(Work, :n => 3)
+
+      @worker = Pace::Worker.new(:queue => "pace")
+    end
+
+    ["QUIT", "TERM", "INT"].each do |signal|
+      it "handles SIG#{signal}" do
+        results = []
+
+        @worker.start do |job|
+          n = job["args"].first["n"]
+          Process.kill(signal, $$) if n == 1
+          results << n
+        end
+
+        # trap seems to interrupt the event loop randomly, so it does not appear
+        # possible to determine exactly how many jobs will be processed
+        results.should_not be_empty
+      end
+    end
+  end
+end

data/spec/pace_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Pace do
+  describe ".start" do
+    it "is a shortcut for instantiating and running a Pace::Worker" do
+      expected_block = Proc.new {}
+
+      worker = double(Pace::Worker)
+      worker.should_receive(:start).with(&expected_block)
+      Pace::Worker.should_receive(:new).with(
+        :url   => "redis://127.0.0.1:6379/0",
+        :queue => "normal",
+      ).and_return(worker)
+
+      Pace.start(:url => "redis://127.0.0.1:6379/0", :queue => "normal", &expected_block)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require "rubygems"
+require "bundler"
+Bundler.require :default, :development
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Pace.stub(:logger).and_return(Logger.new("/dev/null"))
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: pace
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Dave Yeu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-22 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: em-redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: resque
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 81
+        segments: 
+        - 1
+        - 17
+        - 1
+        version: 1.17.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id003
+description: 
+email: 
+- daveyeu@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bench/pace_http.rb
+- bench/resque_http.rb
+- examples/defer.rb
+- examples/echo.rb
+- examples/http.rb
+- examples/sleep.rb
+- lib/pace.rb
+- lib/pace/load_average.rb
+- lib/pace/mock.rb
+- lib/pace/version.rb
+- lib/pace/worker.rb
+- pace.gemspec
+- spec/pace/mock_spec.rb
+- spec/pace/worker_spec.rb
+- spec/pace_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: pace
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Resque-compatible job processing in an event loop
+test_files: 
+- spec/pace/mock_spec.rb
+- spec/pace/worker_spec.rb
+- spec/pace_spec.rb
+- spec/spec_helper.rb