woodhouse 0.1.1

data/spec/layout_spec.rb

@@ -0,0 +1,143 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::Layout do
+
+  context "#add_node" do
+
+    it "should only accept Woodhouse::Node objects"
+
+  end
+
+  context "#frozen_clone" do
+      
+    it "should return a frozen copy where all sub-objects are also frozen copies"
+
+  end
+
+  context "#changes_from" do
+    
+    it "should return a Woodhouse::Layout::Changes object where this layout is the new one"
+
+  end
+
+end
+
+describe Woodhouse::Layout::Node do
+  it_should_behave_like "common"
+
+  context "#add_node" do
+    
+    it "should take a string or a symbol and create a node with that name" do
+      empty_layout.add_node :orz
+      empty_layout.add_node 'vux'
+      empty_layout.add_node Woodhouse::Layout::Node.new(:androsynth)
+      empty_layout.node(:orz).should be_kind_of(Woodhouse::Layout::Node)
+      empty_layout.node(:vux).should be_kind_of(Woodhouse::Layout::Node)
+      empty_layout.node(:androsynth).should be_kind_of(Woodhouse::Layout::Node)
+    end
+
+  end
+
+  context "#default_configuration!" do
+
+    it "should configure one worker thread for every job available" do
+      layout = empty_layout
+      config = common_config
+      config.registry = {
+        :FooBarWorker => FakeWorker,
+        :BarBazWorker => FakeWorker,
+        :BazBatWorker => FakeWorker
+      }
+      layout.add_node Woodhouse::Layout::Node.new(:default)
+      layout.node(:default).default_configuration! config
+      layout.node(:default).workers.should have(6).workers
+      # FooBar#foo, FooBar#bar, BarBaz#foo...
+    end
+
+    it "should pay attention to the config's default_threads" do
+      layout = empty_layout
+      config = common_config
+      config.default_threads = 10
+      config.registry = {
+        :OrzWorker => FakeWorker
+      }
+      layout.add_node :default
+      layout.node(:default).default_configuration! config
+      layout.node(:default).workers.should have(2).workers
+      layout.node(:default).workers.first.threads.should == 10
+    end
+
+  end
+
+end
+
+describe Woodhouse::Layout::Worker do
+
+  it "should default to 1 thread"
+
+  it "should default to a wide-open criteria"
+
+  it "should automatically convert the :only key to a Woodhouse::QueueCriteria"
+
+end
+
+describe Woodhouse::Layout::Changes do
+  it_should_behave_like "common"
+
+  context "when the new layout is empty" do
+
+    subject { Woodhouse::Layout::Changes.new(empty_layout, populated_layout, :default) }
+
+    it "should drop all workers and add none" do
+      subject.adds.should be_empty
+      subject.drops.should have(3).dropped_workers
+    end
+
+  end
+
+  context "when the old layout is empty" do
+
+    subject { Woodhouse::Layout::Changes.new(populated_layout, empty_layout, :default) }
+
+    it "should add all workers and drop none" do
+      subject.drops.should be_empty
+      subject.adds.should have(3).added_workers
+    end
+
+  end
+
+  context "when the new layout is nil" do
+    
+    subject { Woodhouse::Layout::Changes.new(nil, populated_layout, :default) }
+
+    it "should drop all workers and add none" do
+      subject.adds.should be_empty
+      subject.drops.should have(3).dropped_workers
+    end
+
+  end
+
+  context "when the old layout is nil" do
+
+    subject { Woodhouse::Layout::Changes.new(populated_layout, nil, :default) }
+
+    it "should add all workers and drop none" do
+      subject.drops.should be_empty
+      subject.adds.should have(3).added_workers
+    end
+
+  end
+
+  context "when both layouts are specified and they overlap" do
+
+    subject { Woodhouse::Layout::Changes.new(overlapping_layout, populated_layout, :default) }
+
+    it "should add some workers, drop some, and leave some alone" do
+      subject.drops.should have(1).dropped_worker
+      subject.adds.should have(1).added_worker
+    end
+
+  end
+
+end

data/spec/middleware_stack_spec.rb

@@ -0,0 +1,56 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::MiddlewareStack do
+  it_should_behave_like "common"
+
+  subject { Woodhouse::MiddlewareStack.new(common_config) }
+  let(:dummy) { MiddlewareDummy.new }
+
+  class MiddlewareDummy
+    attr_reader :was_called, :sent_item
+    def initialize
+      @was_called = false
+      @sent_item  = nil
+    end
+
+    def call(job)
+      @was_called = true
+      @sent_item = job
+      yield job
+    end
+
+  end
+
+  it "should work if empty" do
+    called = :not_called
+    subject.call("LANAAAA!") {|object|
+      object.should == "LANAAAA!"
+      called = :called
+    }
+    called.should == :called
+  end
+
+  it "should send #call to stack items which respond to that" do
+    subject << dummy
+    subject.call("is it not?") {|object| }
+    dummy.was_called.should be_true
+    dummy.sent_item.should == "is it not?"
+  end
+
+  it "should send #new to stack items which respond to that" do
+    fake_class = stub('mware item', :new => dummy)
+    subject << fake_class
+    subject.call("danger zone") {|object| }
+    dummy.was_called.should be_true
+    dummy.sent_item.should == "danger zone"
+  end
+
+  it "should complain with ArgumentError if entries respond to neither #call nor #new" do
+    subject << nil
+    expect do
+      subject.call("danger zone") {|object| }
+    end.to raise_error(ArgumentError)
+  end
+
+end

data/spec/mixin_registry_spec.rb

@@ -0,0 +1,15 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::MixinRegistry do
+
+  subject { Woodhouse::MixinRegistry.new }
+
+  it "should include all classes that include Woodhouse::Worker" do
+    ::SomeFakeNewClass = Class.new
+    SomeFakeNewClass.send(:include, Woodhouse::Worker)
+    subject[:SomeFakeNewClass].should be SomeFakeNewClass
+    Object.send :remove_const, :SomeFakeNewClass
+  end
+
+end

data/spec/node_configuration_spec.rb

@@ -0,0 +1,22 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::NodeConfiguration do
+  it_should_behave_like "common"
+
+  subject { Woodhouse::NodeConfiguration.new }
+
+  describe "server_info" do
+    
+    it "should default to an empty hash" do
+      subject.server_info.should == {}
+    end
+
+    it "should convert keys into symbols" do
+      subject.server_info = { "lana" => "LANAAAA" }
+      subject.server_info.should have_key(:lana)
+    end
+
+  end
+
+end

data/spec/progress_spec.rb

@@ -0,0 +1,40 @@
+require 'woodhouse/extensions/progress'
+
+describe Woodhouse::Progress do
+
+  describe "JobWithProgress" do
+    subject { Object.new.tap do |obj| obj.extend Woodhouse::Progress::JobWithProgress end }
+
+    it "should provide a method for creating a StatusTicker" do
+      subject.status_ticker("orz").should be_kind_of(Woodhouse::Progress::StatusTicker)
+    end
+
+  end
+
+  describe "StatusTicker" do
+    let(:sink) { double("progress sink") }
+    let(:job) { 
+      Object.new.tap do |obj|
+        obj.extend Woodhouse::Progress::JobWithProgress
+        obj.progress_sink = sink
+      end
+    }
+
+    it "should take initial status and tick arguments" do
+      ticker = job.status_ticker("orz", :top => 100, :start => 10, :status => "working")
+      ticker.to_hash.should == { "orz" => { "top" => 100, "current" => 10, "status" => "working" } }
+    end
+
+    context "#tick" do
+      
+      it "should send progress updates" do
+        ticker = job.status_ticker("orz")
+        sink.should_receive(:update_job).with(job, { "orz" => { "status" => "funky", "current" => 1 } })
+        ticker.tick(:status => "funky").value
+      end
+
+    end
+
+ end
+
+end

data/spec/queue_criteria_spec.rb

@@ -0,0 +1,11 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::QueueCriteria do
+  it_should_behave_like "common"
+  
+  it "should stringify keys and values" do
+    criteria = Woodhouse::QueueCriteria.new("abc" => :def, :fed => 1)
+    criteria.criteria.should == { "abc" => "def", "fed" => "1" }
+  end
+end

data/spec/scheduler_spec.rb

@@ -0,0 +1,41 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::Scheduler do
+  it_should_behave_like "common"
+
+  subject { Woodhouse::Scheduler.new(common_config) }
+
+  let(:worker) {
+    Woodhouse::Layout::Worker.new(:FooBarWorker, :foo)
+  }
+
+  let(:worker_2) {
+    Woodhouse::Layout::Worker.new(:FooBarWorker, :foo, :only => { :job => "big" })
+  } 
+
+  it "should create a new worker set when a new worker is sent to #start_worker" do
+    subject.start_worker worker
+    subject.should be_running_worker(worker)
+  end
+
+  it "should not create a new worker set when an existing worker is sent to #start_worker" do
+    subject.start_worker(worker).should be_true
+    subject.start_worker(worker).should be_false
+  end
+
+  it "should spin down and remove a worker set when a worker is sent to #stop_worker" do
+    subject.start_worker worker
+    subject.stop_worker worker, true
+    subject.should_not be_running_worker(worker)
+  end
+
+  it "should spin down and remove all worker sets when #spin_down is called" do
+    subject.start_worker worker
+    subject.start_worker worker_2
+    subject.spin_down
+    subject.should_not be_running_worker(worker)
+    subject.should_not be_running_worker(worker_2)
+  end
+
+end

data/spec/server_spec.rb

@@ -0,0 +1,72 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::Server do
+  it_should_behave_like "common"
+
+  subject { Woodhouse::Server.new }
+
+  it "should default to the :default node" do
+    subject.node.should == :default
+  end
+
+  it "should expect the value to #layout= to be nil or a Layout" do
+    subject.layout = Woodhouse::Layout.new
+    subject.layout.should be_kind_of Woodhouse::Layout
+    subject.layout = nil
+    subject.layout.should be_nil
+    if false # this craps out on JRuby
+      begin
+        oldlogger = Celluloid.logger
+        Celluloid.logger = nil # It's going to crash
+        expect do
+          subject.layout = "foo"
+        end.to raise_error
+      ensure
+        Celluloid.logger = oldlogger
+      end
+    end
+  end
+
+  it "should take a frozen clone of the layout" do
+    layout = Woodhouse::Layout.new
+    subject.layout = layout
+    subject.layout.should_not be layout
+    subject.layout.should be_frozen
+  end
+
+  context "#start" do
+    
+    it "should return false if a layout is not configured" do
+      subject.start.should be_false
+    end
+
+    it "should return false if the set node doesn't exist in the layout" do
+      subject.layout = populated_layout
+      subject.node = :foo_bar_baz
+      subject.start.should be_false
+    end
+
+    it "should return true and spin up workers if the node is valid" do
+      subject.layout = populated_layout
+      subject.start.should be_true
+      # TODO: test for workers starting up
+    end
+
+  end
+
+  context "#reload" do
+    
+    it "should shut down the server if a layout is not configured"
+
+    it "should shut down the server if the set node doesn't exist in the layout"
+
+    it "should shut down the server if the set node has no workers"
+
+    it "should spin up new workers if they have been added to the node"
+
+    it "should spin down workers if they have been removed from the node"
+
+  end
+
+end

data/spec/shared_contexts.rb

@@ -0,0 +1,70 @@
+#Celluloid.logger = nil
+
+class FakeWorker
+
+  class << self
+    attr_accessor :last_worker
+    attr_accessor :jobs
+  end
+
+  self.jobs ||= []
+
+  def initialize
+    FakeWorker.last_worker = self
+    FakeWorker.jobs ||= []
+  end
+
+  def foo(args)
+    FakeWorker.jobs << args
+  end
+
+  def bar(args)
+    FakeWorker.jobs << args
+  end
+
+end
+
+Woodhouse.configure do |config|
+  config.registry = { :FooBarWorker => FakeWorker }
+  config.runner_type = :dummy
+  config.dispatcher_type = :local
+  config.logger = Logger.new("/dev/null")
+end
+
+shared_examples_for "common" do
+
+  let(:empty_layout) {
+    Woodhouse::Layout.new
+  }
+
+  let(:populated_layout) {
+    Woodhouse::Layout.new.tap do |layout|
+      layout.add_node Woodhouse::Layout::Node.new(:default)
+      layout.node(:default).tap do |default|
+        default.add_worker Woodhouse::Layout::Worker.new(:FooWorker, :foo)
+        default.add_worker Woodhouse::Layout::Worker.new(:FooWorker, :foo, :only => { :size => "huge" })
+        default.add_worker Woodhouse::Layout::Worker.new(:FooWorker, :bar, :threads => 3)
+      end
+      layout.add_node Woodhouse::Layout::Node.new(:other)
+      layout.node(:other).tap do |default|
+        default.add_worker Woodhouse::Layout::Worker.new(:OtherWorker, :bat)
+      end
+    end
+  }
+
+  let(:overlapping_layout) {
+    Woodhouse::Layout.new.tap do |layout|
+      layout.add_node Woodhouse::Layout::Node.new(:default)
+      layout.node(:default).tap do |default|
+        default.add_worker Woodhouse::Layout::Worker.new(:FooWorker, :foo)
+        default.add_worker Woodhouse::Layout::Worker.new(:FooWorker, :bar, :threads => 3)
+        default.add_worker Woodhouse::Layout::Worker.new(:BarWorker, :baz)
+      end
+    end
+  }
+
+  let!(:common_config) {
+    Woodhouse.global_configuration
+  }
+
+end

data/spec/worker_spec.rb

@@ -0,0 +1,28 @@
+require 'woodhouse'
+require File.dirname(File.expand_path(__FILE__)) + '/shared_contexts'
+
+describe Woodhouse::Worker do
+
+  subject {
+    Class.new do
+      include Woodhouse::Worker
+      def fake_job(*); end
+    end
+  }
+
+  it "should provide class-level async_ convenience methods" do
+    lambda do
+      subject.async_fake_job
+    end.should_not raise_error(NoMethodError)
+    lambda do
+      subject.async_something_else
+    end.should raise_error(NoMethodError)
+    lambda do
+      subject.blah_blah_blah
+    end.should raise_error(NoMethodError)
+    lambda do
+      subject.async_method # Don't want inherited methods to work
+    end.should raise_error(NoMethodError)
+  end
+
+end

data/woodhouse.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "woodhouse/version"
+
+Gem::Specification.new do |s|
+  s.name        = "woodhouse"
+  s.version     = Woodhouse::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Matthew Boeh"]
+  s.email       = ["matt@crowdcompass.com", "matthew.boeh@gmail.com"]
+  s.homepage    = "http://github.com/mboeh/woodhouse"
+  s.summary     = %q{An AMQP-based background worker system for Ruby 1.8 and 1.9}
+  s.description = %q{An AMQP-based background worker system for Ruby 1.8 and 1.9 designed to make managing heterogenous tasks relatively easy.
+  
+  The use case for Woodhouse is for reliable and sane performance in situations where jobs on a single queue may vary significantly in length. The goal is to permit large numbers of quick jobs to be serviced even when many slow jobs are in the queue. A secondary goal is to provide a sane way for jobs on a given queue to be given special priority or dispatched to a server more suited to them.
+  
+  Clients (i.e., your application) may be using either Ruby 1.8 or 1.9 in any VM. Worker processes currently only support JRuby in 1.8 or 1.9 mode efficiently. MRI 1.9 and Rubinius support is planned.}
+
+  s.rubyforge_project = "woodhouse"
+
+  s.add_dependency 'fiber18', '>= 1.0.1'
+  s.add_dependency 'celluloid'
+  s.add_dependency 'bunny', "~> 0.9.0.pre4"
+  s.add_dependency 'connection_pool'
+  s.add_dependency 'json'
+
+  s.add_development_dependency 'rspec', '~> 1.3.1'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'mocha'
+
+  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"]
+end