qusion 0.1.1

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem "rake",             ">= 0.8.7"
+gem "bundler",          "~> 1.0.0"
+gem "amqp",             "0.6.7",   :require => 'mq'
+
+group :development do
+  gem "jeweler",        "~> 1.5.1" # adds Bundler support for gemspec generation
+  gem "cucumber",       ">=0.9.4"
+  gem "rspec",          "~>1.3.0"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    amqp (0.6.7)
+      eventmachine (>= 0.12.4)
+    builder (3.0.0)
+    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)
+    eventmachine (0.12.10)
+    gherkin (2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    git (1.2.5)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.4.6)
+    rake (0.8.7)
+    rspec (1.3.1)
+    term-ansicolor (1.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  amqp (= 0.6.7)
+  bundler (~> 1.0.0)
+  cucumber (>= 0.9.4)
+  jeweler (~> 1.5.1)
+  rake (>= 0.8.7)
+  rspec (~> 1.3.0)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2011 Daniel DeLeo, CustomInk, LLC
+
+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.rdoc

@@ -0,0 +1,132 @@
+= Qusion
+
+Qusion makes AMQP[http://github.com/tmm1/amqp] work with your webserver with
+no fuss. It offers three features:
+* It sets up the required callbacks and/or worker threads so that AMQP will work with Passenger, Thin, or Mongrel. WEBrick, SCGI, and Evented Mongrel are experimentally supported, but not heavily tested.
+* A Channel Pool. You can cause problems for yourself if you create new channels (with MQ.new) for every request. The pool sets up a few of these when your app starts and reuses them.
+* YAML configuration files. In Rails, create config/amqp.yml then fill in the details for development, test and production. Use Qusion.start() in your environment.rb file (or an initializer) and you're good to go.
+
+= This fork of Qusion
+
+This is a fork of James Tucker's fork[https://github.com/raggi/qusion] of
+Dan DeLeo's original version[https://github.com/danielsdeleo/qusion]. Tucker
+did a fair amount of cleanup, mostly to the threading logic, so I went with his
+fork. Improvements I've made include:
+* Conversion from a Rails plugin to this gem.
+* Support for Rails 3.
+* Removed support for Merb (it complicated the code and tests; just use Rails 3).
+
+= Before You Start
+
+Qusion makes it easy to just install and start using AMQP in your application.
+But there are many ways to use background jobs within a Rails app, so it's
+worth taking some time to consider the tradeoffs of each approach.
+
+* If your background job needs are simple and you're using a relational database, Delayed::Job[http://github.com/tobi/delayed_job/] lets you schedule background tasks through the database. You won't need to run another application (the AMQP Broker) to keep your app running.
+* The 0.6.x version of the Ruby amqp library may drop messages when the AMQP broker goes down. Pivotal Labs has discussed this problem on their blog[http://pivots.pivotallabs.com/users/will/blog/articles/966-how-to-not-test-rabbitmq-part-1]. This issue will likely be addressed in the 0.7.0 release of amqp, but can be avoided entirely using a synchronous amqp library such as bunny[http://github.com/celldee/bunny]. For a ready-made background job solution using Bunny to publish jobs to the queue, see Minion[http://github.com/orionz/minion/].
+* Qusion runs EventMachine in a separate thread on Phusion Passenger, Mongrel, and other non-evented servers. There are some inefficiencies in Ruby 1.8's threading model that make running EM in a thread quite slow. Joe Damato and Aman Gupta have created a patch[http://github.com/ice799/matzruby/tree/heap_stacks] for the problem which is included in an experimental branch of REE. You can learn more about the patch from Phusion's Blog[http://blog.phusion.nl/2009/12/15/google-tech-talk-on-ruby-enterprise-edition/].
+
+= Getting Started
+
+First you'll need the amqp library and a working RabbitMQ installation. This
+entails:
+
+* Install Erlang for your platform
+* Install RabbitMQ for your platform
+* On OSX, use Homebrew to install Erlang and RabbitMQ: brew install rabbitmq
+* Install bundler: http://gembundler.com/
+== Install Qusion
+Include the qusion gem in your Gemfile:
+
+  gem "qusion"
+
+Create an initializer (e.g. config/initializers/qusion.rb) and add:
+  Qusion.start
+
+  EM.next_tick do
+    # do some AMQP stuff
+  end
+
+And that's it! This will set up AMQP for any ruby app server (tested on
+mongrel, thin, and passenger). Now, you can use all of AMQP's functionality as
+normal. In your controllers or models, you might have:
+
+  MQ.new.queue("my-work-queue").publish("do work, son!")
+
+and it should just work.
+
+= Channel Pools
+
+It's considered bad practice to use MQ.new over and over, as it creates a new
+AMQP channel, and that creates a new Erlang process in RabbitMQ. Erlang
+processes are super light weight, but you'll be wasting them and causing the
+Erlang VM GC headaches if you create them wantonly. So don't do that. Instead,
+use the channel pool provided by Qusion. It's simple: wherever you'd normally
+put MQ.new, just replace it with Qusion.channel. Examples:
+
+  # Create a queue:
+  Qusion.channel.queue("my-worker-queue")
+  # Topics:
+  Qusion.channel.topic("my-topic-exchange")
+  # etc.
+
+This feature is a bit experimental, so the optimal pool size isn't known yet.
+The default is 5. You can change it by adding something like the following to
+your environment.rb:
+
+  Qusion.channel_pool_size(3)
+
+= Configuration
+
+You can put your AMQP server details in config/amqp.yml and Qusion will load
+it when you call Qusion.start(). Example:
+
+  # Put this in config/amqp.yml
+  default: &default
+    host: localhost
+    port: 5672
+    user: guest
+    pass: guest
+    vhost: /
+    timeout: 3600 # seconds
+    logging: false
+    ssl: false
+
+  development:
+    <<: *default
+
+  test:
+    <<: *default
+
+If you're too hardcore for Rails (maybe you're using Sinatra or Ramaze), you
+can still use a YAML config file, but there's no support for different
+environments. So do something like this:
+
+  # Tell Qusion where your config file is:
+  Qusion.start("/path/to/amqp.yml")
+
+  # Your configuration looks like this:
+  application:
+    host: localhost
+    port: 5672
+    ...
+
+If you just want to get started without configuring anything, Qusion.start()
+will use the default options if it can't find a config file. And, finally, you
+can give options directly to Qusion.start() like this:
+
+  Qusion.start(:host => "my-amqp-broker.mydomain.com", :user => "me", :pass => "am_I_really_putting_this_in_VCS?")
+
+
+= Bugs? Hacking?
+
+If you find any bugs, or feel the need to add a feature, fork away. You can
+also contact me directly via the email address in my profile if you have any
+questions.
+
+= Shouts
+* Qusion's code for Phusion Passenger's starting_worker_process event was originally posted by Aman Gupta (tmm1[http://github.com/tmm1]) on the AMQP list[http://groups.google.com/group/ruby-amqp]
+* Brightbox's Warren[http://github.com/brightbox/warren] library provides some similar functionality. It doesn't support webserver-specific EventMachine setup, but it does have built-in encryption and support for the synchronous (non-EventMachine) Bunny[http://github.com/celldee/bunny] AMQP client.
+
+Original author: dan@kallistec.com
+Forked by: cmurphy@customink.com

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rubygems'
+require 'bundler'
+require "spec/rake/spectask"
+require "cucumber"
+require "cucumber/rake/task"
+
+desc 'Default: run specs.'
+task :default => :spec
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "qusion"
+    gem.summary = "Makes AMQP work with Ruby on Rails with no fuss."
+    gem.description = %Q{See the README for more details.}
+    gem.email = "cmurphy@customink.com"
+    gem.homepage = "http://github.com/customink/qusion"
+    gem.authors = ["Dan DeLeo", "Christopher R. Murphy"]
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+desc "Run Cucumber Features"
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "-c -n"
+end
+
+desc "Run all of the specs"
+Spec::Rake::SpecTask.new do |t|
+  t.ruby_opts << '-rubygems'
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.fail_on_error = false
+end
+
+namespace :spec do
+  desc "Generate HTML report for failing examples"
+  Spec::Rake::SpecTask.new('report') do |t|
+    t.ruby_opts << '-rubygems'
+    t.spec_files = FileList['failing_examples/**/*.rb']
+    t.spec_opts = ["--format", "html:doc/tools/reports/failing_examples.html", "--diff", '--options', '"spec/spec.opts"']
+    t.fail_on_error = false
+  end
+
+  desc "Run all spec with RCov"
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.ruby_opts << '-rubygems'
+    t.rcov = true
+    t.rcov_dir = 'doc/tools/coverage/'
+    t.rcov_opts = ['--exclude', 'spec']
+  end
+end
+
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "qusion #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/qusion.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+require "eventmachine"
+require "mq"
+
+require "qusion/channel_pool"
+require "qusion/amqp_config"
+
+module Qusion
+  class << self
+    attr_reader :thread
+  end
+
+  def self.start(*opts)
+    amqp_opts = AmqpConfig.new(*opts).config_opts
+    start_amqp_dispatcher(amqp_opts)
+  end
+
+  def self.start_amqp_dispatcher(amqp_settings={})
+    AMQP.settings.merge!(amqp_settings)
+
+    if defined?(::PhusionPassenger) && ::PhusionPassenger.respond_to?(:on_event)
+      ::PhusionPassenger.on_event(:starting_worker_process) do |forked| 
+        if forked
+          EM.stop if EM.reactor_running?
+          thread && thread.join
+          Thread.current[:mq] = nil
+          AMQP.instance_variable_set(:@conn, nil)
+        end
+        start_in_background
+        die_gracefully_on_signal
+      end
+      return
+    end
+
+    start_in_background
+    die_gracefully_on_signal
+  end
+
+  def self.die_gracefully_on_signal
+    Signal.trap("INT")  { graceful_stop }
+    Signal.trap("TERM") { graceful_stop }
+  end
+
+  def self.channel
+    ChannelPool.instance.channel
+  end
+
+  def self.channel_pool_size(new_pool_size)
+    ChannelPool.pool_size = new_pool_size
+  end
+
+  def self.start_in_background
+    if EM.reactor_running?
+      raise ArgumentError, 'AMQP already connected' if ready_to_dispatch?
+      AMQP.start
+    else
+      raise ArgumentError, 'Qusion already started' if thread && thread.alive?
+      @thread = Thread.new do
+        EM.run { AMQP.start }
+        raise "Premature AMQP shutdown" unless @graceful_stop
+      end
+      thread.abort_on_exception = true
+      thread.join(0.1) until ready_to_dispatch?
+    end
+  end
+
+  def self.graceful_stop
+    EM.schedule do
+      @graceful_stop = true
+      AMQP.stop { EM.stop }
+    end
+    thread && thread.join
+  end
+
+  def self.ready_to_dispatch?
+    EM.reactor_running? && AMQP.conn && AMQP.conn.connected?
+  end
+end

data/lib/qusion/amqp_config.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+require 'yaml'
+
+module Qusion
+
+  class AmqpConfig
+    attr_reader :config_path, :framework_env
+
+    def initialize(opts=nil)
+      if opts && opts.respond_to?(:keys)
+        @config_path = nil
+        @config_opts = opts
+      elsif opts
+        @config_path = opts
+      else
+        load_framework_config
+      end
+    end
+
+    def load_framework_config
+      @config_path = Rails.root + "/config/amqp.yml"
+      @framework_env = Rails.env
+    end
+
+    def config_opts
+      @config_opts ||= load_config_opts
+    end
+
+    def load_config_opts
+      if config_path && config_from_yaml = load_amqp_config_file
+        if framework_env
+          framework_amqp_opts(config_from_yaml)
+        else
+          amqp_opts(config_from_yaml)
+        end
+      else
+        {}
+      end
+    end
+
+    def framework_amqp_opts(config_hash)
+      symbolize_keys(config_hash[framework_env.to_s])
+    end
+
+    def amqp_opts(config_hash)
+      symbolize_keys(config_hash.first.last)
+    end
+
+    def symbolize_keys(config_hash)
+      symbolized_hsh = {}
+      config_hash.each {|option, value| symbolized_hsh[option.to_sym] = value }
+      symbolized_hsh
+    end
+
+    def load_amqp_config_file
+      begin
+        YAML.load_file(config_path)
+      rescue Errno::ENOENT
+      end
+    end
+
+  end
+end

data/lib/qusion/channel_pool.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+require "singleton"
+
+module Qusion
+  
+  # ChannelPool maintains a pool of AMQP channel objects that can be reused.
+  # The motivation behind this is that if you were to use MQ.new to create a 
+  # new channel for every request, your AMQP broker could be swamped trying to
+  # maintain a bunch of channels that you're only using once.
+  #
+  # To use the channel pool, just replace <tt>MQ.new</tt> in your code with <tt>Qusion.channel</tt>
+  # 
+  #   # Instead of this:
+  #   MQ.new.queue("my-worker-queue")
+  #   # Do this:
+  #   Qusion.channel.queue("my-worker-queue")
+  #
+  # By default, ChannelPool maintains a pool of 5 channels. This can be adjusted with
+  # <tt>ChannelPool.pool_size=()</tt> or <tt>Qusion.channel_pool_size()</tt>
+  # The optimal pool size is not yet known, but I suspect you might need a 
+  # larger value if using Thin in production, and a smaller value otherwise.
+  class ChannelPool
+    include Singleton
+    
+    class << self
+      
+      def pool_size=(new_pool_size)
+        reset
+        @pool_size = new_pool_size
+      end
+      
+      def pool_size
+        @pool_size ||= 5
+      end
+      
+      def reset
+        @pool_size = nil
+        instance.reset
+      end
+      
+    end
+    
+    attr_reader :pool
+    
+    def channel
+      @i ||= 1
+      @i = (@i + 1) % pool_size
+      pool[@i]
+    end
+    
+    def pool
+      @pool ||= Array.new(pool_size) { MQ.new }
+    end
+    
+    def reset
+      @pool = nil
+    end
+    
+    def pool_size
+      self.class.pool_size
+    end
+    
+  end
+end

data/qusion.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{qusion}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dan DeLeo", "Christopher R. Murphy"]
+  s.date = %q{2010-12-09}
+  s.description = %q{See the README for more details.}
+  s.email = %q{cmurphy@customink.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/qusion.rb",
+    "lib/qusion/amqp_config.rb",
+    "lib/qusion/channel_pool.rb",
+    "qusion.gemspec",
+    "spec/fixtures/framework-amqp.yml",
+    "spec/fixtures/hardcoded-amqp.yml",
+    "spec/mock_rails.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb",
+    "spec/unit/amqp_config_spec.rb",
+    "spec/unit/channel_pool_spec.rb",
+    "spec/unit/qusion_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/customink/qusion}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Makes AMQP work with Ruby on Rails with no fuss.}
+  s.test_files = [
+    "spec/mock_rails.rb",
+    "spec/spec_helper.rb",
+    "spec/unit/amqp_config_spec.rb",
+    "spec/unit/channel_pool_spec.rb",
+    "spec/unit/qusion_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rake>, [">= 0.8.7"])
+      s.add_runtime_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_runtime_dependency(%q<amqp>, ["= 0.6.7"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.1"])
+      s.add_development_dependency(%q<cucumber>, [">= 0.9.4"])
+      s.add_development_dependency(%q<rspec>, ["~> 1.3.0"])
+    else
+      s.add_dependency(%q<rake>, [">= 0.8.7"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<amqp>, ["= 0.6.7"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
+      s.add_dependency(%q<cucumber>, [">= 0.9.4"])
+      s.add_dependency(%q<rspec>, ["~> 1.3.0"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0.8.7"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<amqp>, ["= 0.6.7"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
+    s.add_dependency(%q<cucumber>, [">= 0.9.4"])
+    s.add_dependency(%q<rspec>, ["~> 1.3.0"])
+  end
+end
+

data/spec/fixtures/framework-amqp.yml

@@ -0,0 +1,28 @@
+development:
+  host: localhost
+  port: 5672
+  user: guest
+  pass: guest
+  vhost: /
+  timeout: 600
+  logging: false
+  ssl: false
+  
+test:
+  host: localhost
+  port: 5672
+  user: guest
+  pass: guest
+  vhost: /
+  logging: false
+  ssl: false
+  
+production:
+  host: localhost
+  port: 5672
+  user: guest
+  pass: guest
+  vhost: /
+  timeout: 3600
+  logging: false
+  ssl: false

data/spec/fixtures/hardcoded-amqp.yml

@@ -0,0 +1,9 @@
+application:
+  host: localhost
+  port: 5672
+  user: guest
+  pass: guest
+  vhost: /
+  timeout: 600
+  logging: false
+  ssl: false

data/spec/mock_rails.rb

@@ -0,0 +1,14 @@
+class Rails
+  module VERSION
+    MAJOR = 3
+  end
+
+  def self.env
+    # ActiveSupport::StringInquirer.new("test")
+    "test"
+  end
+
+  def self.root
+    "/path/to/rails"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+-f specdoc -c -t 2

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+require 'spec/autorun'
+require 'qusion'
+include Qusion

data/spec/unit/amqp_config_spec.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+require File.dirname(__FILE__) + "/../../spec_helper"
+require File.dirname(__FILE__) + "/../../mock_rails"
+
+describe AmqpConfig do
+
+  it "should use #{Rails.root}/config/amqp.yml" do
+    AmqpConfig.new.config_path.should == "/path/to/rails/config/amqp.yml"
+  end
+
+  it "should use the provided path no matter what" do
+    path = AmqpConfig.new("/custom/path/to/amqp.yml").config_path
+    path.should == "/custom/path/to/amqp.yml"
+  end
+
+  it "should use a provided options hash if given" do
+    conf = AmqpConfig.new(:host => "my-broker.mydomain.com")
+    conf.config_path.should be_nil
+    conf.config_opts.should == {:host => "my-broker.mydomain.com"}
+  end
+
+  it "should use the default amqp options in rails if amqp.yml doesn't exist" do
+    Rails.stub!(:root).and_return(File.dirname(__FILE__) + '/../')
+    AmqpConfig.new.config_opts.should == {}
+  end
+
+  it "should load a YAML file when using a framework" do
+    conf = AmqpConfig.new
+    conf.stub!(:config_path).and_return(File.dirname(__FILE__) + "/../fixtures/framework-amqp.yml")
+    conf.stub!(:framework_env).and_return("production")
+    conf.config_opts.should == {:host => 'localhost',:port => 5672,
+                                :user => 'guest', :pass => 'guest',
+                                :vhost => '/', :timeout => 3600,
+                                :logging => false, :ssl => false}
+  end
+
+  it "should use the first set of opts when given a explicit file path" do
+    conf = AmqpConfig.new
+    conf.stub!(:config_path).and_return(File.dirname(__FILE__) + "/../fixtures/hardcoded-amqp.yml")
+    conf.stub!(:framework_env).and_return(nil)
+    p conf.config_opts
+    conf.config_opts.should == {:host => 'localhost',:port => 5672,
+                                :user => 'guest', :pass => 'guest',
+                                :vhost => '/', :timeout => 600,
+                                :logging => false, :ssl => false}
+  end
+
+end

data/spec/unit/channel_pool_spec.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe ChannelPool do
+  MQ = Object.new
+
+  before(:each) do
+    ChannelPool.reset
+    @channel_pool = ChannelPool.instance
+  end
+
+  it "should be singleton" do
+    lambda { ChannelPool.new }.should raise_error
+  end
+
+  it "should adjust the pool size" do
+    ChannelPool.pool_size = 5
+    ChannelPool.pool_size.should == 5
+  end
+
+  it "should reset itself when the pool size is set" do
+    ChannelPool.should_receive(:reset)
+    ChannelPool.pool_size = 23
+  end
+
+  it "should create a pool of AMQP channels" do
+    ChannelPool.pool_size = 3
+    ::MQ.should_receive(:new).exactly(3).times
+    @channel_pool.pool
+  end
+
+  it "should default to a pool size of 5" do
+    ::MQ.should_receive(:new).exactly(5).times.and_return("swanky")
+    @channel_pool.pool
+    @channel_pool.instance_variable_get(:@pool).should == %w{ swanky swanky swanky swanky swanky}
+  end
+
+  it "should return a channel in a round-robin" do
+    @channel_pool.instance_variable_set(:@pool, [1,2,3,4,5])
+    @channel_pool.channel.should == 3
+    @channel_pool.channel.should == 4
+    @channel_pool.channel.should == 5
+    @channel_pool.channel.should == 1
+    @channel_pool.channel.should == 2
+    @channel_pool.channel.should == 3
+  end
+
+end

data/spec/unit/qusion_spec.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe "Qusion Convenience Methods" do
+
+  it "should get a channel from the pool" do
+    channel_pool = mock("channel pool")
+    ChannelPool.should_receive(:instance).and_return(channel_pool)
+    channel_pool.should_receive(:channel)
+    Qusion.channel
+  end
+
+  it "should set the channel pool size" do
+    ChannelPool.should_receive(:pool_size=).with(7)
+    Qusion.channel_pool_size(7)
+  end
+
+  it "should load the configuration and setup AMQP for the webserver" do
+    config = mock("config")
+    AmqpConfig.should_receive(:new).and_return(config)
+    config.should_receive(:config_opts).and_return(:config => :opts)
+    Qusion.should_receive(:start_amqp_dispatcher).with(:config => :opts)
+    Qusion.start
+  end
+
+end
+
+describe Qusion, 'amqp startup' do
+
+  before do
+    AMQP.stub!(:settings).and_return({})
+  end
+
+  after(:each) do
+    Object.send(:remove_const, :PhusionPassenger) if defined? ::PhusionPassenger
+    Object.send(:remove_const, :Thin) if defined? ::Thin
+    Object.send(:remove_const, :Mongrel) if defined? ::Mongrel
+  end
+
+  it "should kill the reactor and start a new AMQP connection when forked in Passenger" do
+    Qusion.should_receive(:die_gracefully_on_signal).once
+    ::PhusionPassenger = Module.new
+    forked = mock("starting_worker_process_callback_obj")
+    ::PhusionPassenger.should_receive(:on_event).with(:starting_worker_process).and_yield(forked)
+    EM.should_receive(:reactor_running?).exactly(3).times.and_return(true)
+    amqp_conn = mock('amqp_conn')
+    amqp_conn.should_receive(:connected?).and_return(false)
+    AMQP.should_receive(:conn).any_number_of_times.and_return(amqp_conn)
+    EM.should_receive(:stop)
+    AMQP.should_receive(:start).once
+    Qusion.start_amqp_dispatcher
+  end
+
+  it "should set AMQP's connection settings when running under Thin" do
+    Qusion.should_receive(:die_gracefully_on_signal)
+    Qusion.should_receive(:start_in_background)
+    ::Thin = Module.new
+    Qusion.start_amqp_dispatcher(:cookie => "yummy")
+    AMQP.settings[:cookie].should == "yummy"
+  end
+
+  it "should start a worker thread when running under Mongrel" do
+    Qusion.should_receive(:die_gracefully_on_signal)
+    mock_thread = mock('thread')
+    mock_thread.should_receive(:abort_on_exception=).with(true)
+    Qusion.should_receive(:ready_to_dispatch?).twice.and_return(false, true)
+    mock_thread.should_receive(:join)
+    Thread.should_receive(:new).and_return(mock_thread)
+    ::Mongrel = Module.new
+    Qusion.start_amqp_dispatcher
+  end
+
+  it "should be ready to dispatch when the reactor is running and amqp is connected" do
+    EM.should_receive(:reactor_running?).and_return(true)
+    amqp_conn = mock('amqp_conn')
+    amqp_conn.should_receive(:connected?).and_return(true)
+    AMQP.should_receive(:conn).any_number_of_times.and_return(amqp_conn)
+    Qusion.ready_to_dispatch?.should == true
+  end
+
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification 
+name: qusion
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Dan DeLeo
+- Christopher R. Murphy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-09 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: amqp
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 7
+        version: 0.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 4
+        version: 0.9.4
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+description: See the README for more details.
+email: cmurphy@customink.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/qusion.rb
+- lib/qusion/amqp_config.rb
+- lib/qusion/channel_pool.rb
+- qusion.gemspec
+- spec/fixtures/framework-amqp.yml
+- spec/fixtures/hardcoded-amqp.yml
+- spec/mock_rails.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/amqp_config_spec.rb
+- spec/unit/channel_pool_spec.rb
+- spec/unit/qusion_spec.rb
+has_rdoc: true
+homepage: http://github.com/customink/qusion
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 2610415720212610617
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Makes AMQP work with Ruby on Rails with no fuss.
+test_files: 
+- spec/mock_rails.rb
+- spec/spec_helper.rb
+- spec/unit/amqp_config_spec.rb
+- spec/unit/channel_pool_spec.rb
+- spec/unit/qusion_spec.rb