henchman 0.0.1

data/.em-console.rc

@@ -0,0 +1,3 @@
+
+require 'bundler/setup'
+require File.expand_path('lib/henchman')

data/.gitignore

@@ -0,0 +1,3 @@
+*~
+henchman-*.gem
+Gemfile.lock

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@henchman --create

data/Gemfile

@@ -0,0 +1,12 @@
+
+source 'http://rubygems.org/'
+
+gemspec
+
+group :dev do
+  gem 'em-console', :git => 'git://github.com/ProjectDaisy/em-console.git'
+end
+
+group :test do
+  gem 'rspec'
+end

data/README.md

@@ -0,0 +1,90 @@
+# henchman
+
+A thin wrapper around [amqp](https://github.com/ruby-amqp/amqp).
+
+## Installation
+
+### Ruby
+
+We use Ruby 1.9.3. 
+
+To install and run on your local machine use [RVM](https://rvm.beginrescueend.com/). 
+For Mac machines make sure you compile with gcc-4.2 (because the compiler from Xcode doesn't compile Ruby 1.9.3 properly). 
+Download and install gcc from https://github.com/kennethreitz/osx-gcc-installer 
+
+    $ gem install rvm
+    $ rvm install 1.9.3
+
+And for Macs
+
+    $ rvm install 1.9.3 --with-gcc=gcc-4.2
+
+### Rubygems
+
+Use [Bundler](http://gembundler.com/) to install the gems needed by Herdis
+
+    $ bundle install
+
+### RabbitMQ
+
+henchman naturally needs [RabbitMQ](http://www.rabbitmq.com/) to run. Install it and run it with default options.
+
+## Using
+
+### Queues
+
+To enqueue jobs that will only be consumed by a single consumer, you 
+
+    EM.synchrony do
+      Henchman.enqueue("test", {:time => Time.now.to_s})
+    end
+
+To consume jobs enqueued this way
+
+    EM.synchrony do
+      Henchman::Worker.new("test") do
+        puts message.inspect
+        puts headers
+      end.consume!
+    end
+
+The `script/enqueue` and `script/consume` scripts provide a test case as simple as possible.
+
+If you want a global error handler for the all consumers in your Ruby environment
+
+    EM.synchrony do
+      Henchman.error do
+        global_error_handler(exception)
+      end
+    end
+
+### Broadcasts
+
+To publish jobs that will be consumed by every consumer listening to your exchange, you
+
+    EM.synchrony do
+      Henchman.publish("testpub", {:time => Time.now.to_s})
+    end
+
+To consume jobs published this way
+
+    EM.synchrony do
+      Henchman::Worker.new("test") do
+        puts message.inspect
+        puts headers
+      end.subscribe!
+    end
+
+The `script/publish` and `script/receive` scripts provide a test case as simple as possible.
+
+Error handling is done the exact same way as with the single consumer case.
+
+## Test suite
+
+    $ rake
+
+## Console
+
+To run an eventmachine-friendly console to test your servers from IRB
+
+    $ bundle exec em-console

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+
+require 'rspec/core/rake_task'
+
+task :default => [:spec]
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--color'
+  t.pattern = 'spec/**/*_spec.rb'
+end
+  

data/henchman.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "henchman"
+  s.version     = "0.0.1"
+  s.authors     = ["Martin Bruse"]
+  s.email       = ["martin@oort.se"]
+  s.homepage    = "https://github.com/zond/henchman"
+  s.summary     = %q{A maximally simple amqp wrapper}
+  s.description = %q{A maximally simple amqp wrapper}
+
+  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 'amqp'
+  s.add_dependency 'em-synchrony'
+  s.add_dependency 'multi_json'
+
+end

data/lib/henchman.rb

@@ -0,0 +1,292 @@
+
+require 'em-synchrony'
+require 'amqp'
+require 'multi_json'
+
+require 'henchman/worker'
+
+#
+# Thin wrapper around AMQP
+#
+module Henchman
+
+  extend self
+
+  @@connection = nil
+  @@channel = nil
+  @@error_handler = Proc.new do
+    STDERR.puts("consume(#{queue_name.inspect}, #{headers.inspect}, #{message.inspect}): #{exception.message}")
+    STDERR.puts(exception.backtrace.join("\n"))
+  end
+  @@logger = Proc.new do |msg|
+    puts msg
+  end
+
+  #
+  # Define a log handler.
+  #
+  # @param [Proc] block the block that handles log messages.
+  #
+  def logger(&block)
+    @@logger = block
+  end
+  
+  #
+  # Log a message.
+  #
+  # @param [String] msg the message to log.
+  #
+  def log(msg)
+  end
+
+  #
+  # @return [Proc] the error handler
+  #
+  def self.error_handler
+    @@error_handler
+  end
+  
+  #
+  # Define an error handler.
+  #
+  # @param [Proc] block the block that handles errors.
+  #
+  def error(&block)
+    @@error_handler = block
+  end
+  
+  #
+  # Will return a URL to the AMQP broker to use. Will get this from the <code>ENV</code> variable <code>AMQP_URL</code> if present.
+  #
+  # @return [String] a URL to an AMQP broker.
+  #
+  def amqp_url
+    ENV["AMQP_URL"] || "amqp://localhost/"
+  end
+
+  #
+  # Will return the default options when connecting to the AMQP broker.
+  #
+  # Uses the URL from {#amqp_url} to construct these options.
+  #
+  # @return [Hash] a {::Hash} of options to AMQP.connect.
+  #
+  def amqp_options
+    uri = URI.parse(amqp_url)
+    {
+      :vhost => uri.path,
+      :host => uri.host,
+      :user => uri.user || "guest",
+      :port => uri.port || 5672,
+      :pass => uri.password || "guest"
+    }
+  rescue Object => e
+    raise "invalid AMQP_URL: #{uri.inspect} (#{e})"
+  end
+
+  #
+  # Will return the default options to use when creating queues.
+  #
+  # If you change the returned {::Hash} the changes will persist in this instance, so use this to configure stuff.
+  #
+  # @return [Hash] a {::Hash} of options to use when creating queues.
+  #
+  def queue_options
+    @queue_options ||= {
+      :durable => true,
+      :auto_delete => true
+    }
+  end
+
+  #
+  # Will return the default options to use when creating exchanges.
+  #
+  # If you change the returned {::Hash} the changes will persist in this instance, so use this to configure stuff.
+  #
+  # @return [Hash] a {::Hash} of options to use when creating exchanges.
+  #
+  def exchange_options
+    @exchange_options ||= {
+      :auto_delete => true
+    }
+  end
+
+  #
+  # Will return the default options to use when creating channels.
+  #
+  # If you change the returned {::Hash} the changes will persist in this instance, so use this to configure stuff.
+  #
+  # @return [Hash] a {::Hash} of options to use when creating channels.
+  #
+  def channel_options
+    @channel_options ||= {
+      :prefetch => 1,
+      :auto_recovery => true
+    }
+  end
+  
+  #
+  # Will stop and deactivate {::Henchman}.
+  #
+  def stop!
+    with_channel do |channel|
+      channel.close
+    end
+    @@channel = nil
+    with_connection do |connection|
+      connection.close
+    end
+    @@connection = nil
+    AMQP.stop
+  end
+
+  #
+  # Will yield an open and ready connection.
+  #
+  # @param [Proc] block a {::Proc} to yield an open and ready connection to.
+  #
+  def with_connection(&block)
+    @@connection = AMQP.connect(amqp_options) if @@connection.nil? || @@connection.status == :closed
+    @@connection.on_tcp_connection_loss do
+      log("#{self} reconnecting")
+      @@connection.reconnect
+    end
+    @@connection.on_recovery do
+      log("#{self} reconnected!")
+    end 
+    @@connection.on_error do |connection, connection_close|
+      raise "#{connection}: #{connection_close.reply_text}"
+    end
+    @@connection.on_open do 
+      yield @@connection
+    end
+  end
+
+  #
+  # Will yield an open and ready channel.
+  #
+  # @param [Proc] block a {::Proc} to yield an open and ready channel to.
+  #
+  def with_channel(&block)
+    with_connection do |connection|
+      @@channel = AMQP::Channel.new(connection, channel_options) if @@channel.nil? || @@channel.status == :closed
+      @@channel.on_error do |channel, channel_close|
+        log("#{self} reinitializing #{channel} due to #{channel_close}")
+        channel.reuse
+      end
+      @@channel.once_open do 
+        yield @@channel
+      end
+    end
+  end
+
+  #
+  # Will yield an open and ready direct exchange.
+  #
+  # @param [Proc] block a {::Proc} to yield an open and ready direct exchange to.
+  #
+  def with_direct_exchange(&block)
+    with_channel do |channel|
+      channel.direct(AMQ::Protocol::EMPTY_STRING, exchange_options, &block)
+    end
+  end
+
+  #
+  # Will yield an open and ready fanout exchange.
+  #
+  # @param [String] exchange_name the name of the exchange to create or find.
+  # @param [Proc] block a {::Proc} to yield an open and ready fanout exchange to.
+  #
+  def with_fanout_exchange(exchange_name, &block)
+    with_channel do |channel|
+      channel.fanout(exchange_name, exchange_options, &block)
+    end
+  end
+
+  #
+  # Will yield an open and ready queue bound to an open and ready fanout exchange.
+  #
+  # @param [String] exchange_name the name of the exchange to create or find
+  # @param [Proc] block the {::Proc} to yield an open and ready queue bound to the found exchange to.
+  #
+  def with_fanout_queue(exchange_name, &block)
+    with_channel do |channel|
+      with_fanout_exchange(exchange_name) do |exchange|
+        channel.queue do |queue|
+          queue.bind(exchange) do
+            yield queue
+          end
+        end
+      end
+    end
+  end
+
+  #
+  # Will yield an open and ready queue.
+  #
+  # @param [Proc] block a {::Proc} to yield an open and ready queue to.
+  #
+  def with_queue(queue_name, &block)
+    with_channel do |channel|
+      channel.queue(queue_name, queue_options) do |queue|
+        yield queue
+      end
+    end
+  end
+
+  #
+  # Enqueue a message synchronously.
+  #
+  # @param [String] queue_name the name of the queue to enqueue on.
+  # @param [Object] message the message to enqueue.
+  #
+  def enqueue(queue_name, message)
+    EM::Synchrony.sync(aenqueue(queue_name, message))
+  end
+
+  #
+  # Enqueue a message asynchronously.
+  #
+  # @param (see #publish)
+  #
+  # @return [EM::Deferrable] a deferrable that will succeed when the publishing is done.
+  #
+  def aenqueue(queue_name, message)
+    deferrable = EM::DefaultDeferrable.new
+    with_direct_exchange do |exchange|
+      exchange.publish(MultiJson.encode(message), :routing_key => queue_name) do
+        deferrable.set_deferred_status :succeeded
+      end
+    end
+    deferrable
+  end
+
+  #
+  # Publish a a message to multiple consumers synchronously.
+  #
+  # @param [String] exchange_name the name of the exchange to publish on.
+  # @param [Object] message the object to publish
+  #
+  def publish(exchange_name, message)
+    EM::Synchrony.sync(apublish(exchange_name, message))
+  end
+  
+  #
+  # Publish a message to multiple consumers asynchronously.
+  #
+  # @param (see #publish)
+  #
+  # @return [EM::Deferrable] a deferrable that will succeed when the publishing is done.
+  #
+  def apublish(exchange_name, message)
+    deferrable = EM::DefaultDeferrable.new
+    with_fanout_exchange(exchange_name) do |exchange|
+      exchange.publish(MultiJson.encode(message)) do
+        deferrable.set_deferred_status :succeeded
+      end
+    end
+    deferrable
+  end
+
+end
+

data/lib/henchman/worker.rb

@@ -0,0 +1,187 @@
+
+module Henchman
+
+  #
+  # A class that handles incoming messages.
+  #
+  class Worker
+
+    #
+    # The handling of an incoming message.
+    #
+    class Task
+
+      #
+      # [AMQP::Header] The metadata of the message.
+      #
+      attr_accessor :headers
+
+      #
+      # [Object] The message itself
+      attr_accessor :message
+
+      #
+      # [Henchman::Worker] the {::Henchman::Worker} this {::Henchman::Worker::Task} belongs to.
+      #
+      attr_accessor :worker
+
+      #
+      # [Exception] any {::Exception} this {::Henchman::Worker::Task} has fallen victim to.
+      #
+      attr_accessor :exception
+
+      #
+      # [Object] the result of executing this {::Henchman::Worker::Task}.
+      #
+      attr_accessor :result
+
+      #
+      # Create a {::Henchman::Worker::Task} for a given {::Henchman::Worker}.
+      #
+      # @param [Henchman::Worker] worker the {::Henchman::Worker} creating this {::Henchman::Worker::Task}.
+      # @param [AMQP::Header] header the {::AMQP::Header} being handled.
+      # @param [Object] message the {::Object} being handled.
+      #
+      def initialize(worker, headers, message)
+        @worker = worker
+        @headers = headers
+        @message = message
+      end
+
+      #
+      # Call this {::Henchman::Worker::Task}.
+      #
+      def call
+        begin
+          @result = instance_eval(&(worker.block))
+        rescue Exception => e
+          @exception = e
+          @result = instance_eval(&(Henchman.error_handler))
+        ensure
+          headers.ack if headers.respond_to?(:ack)
+        end
+      end
+
+      #
+      # Enqueue something on another queue.
+      #
+      # @param [String] queue_name the name of the queue on which to publish.
+      # @param [Object] message the message to publish-
+      #
+      def enqueue(queue_name, message)
+        Fiber.new do
+          Henchman.enqueue(queue_name, message)
+        end.resume
+      end
+
+      #
+      # Unsubscribe the {::Henchman::Worker} of this {::Henchman::Worker::Task} from the queue it subscribes to.
+      # 
+      def unsubscribe!
+        worker.unsubscribe!
+      end
+    end
+
+    #
+    # [String] the name of the queue this {::Henchman::Worker} listens to.
+    #
+    attr_accessor :queue_name
+
+    #
+    # [AMQP::Consumer] the consumer feeding this {::Henchman::Worker} with messages.
+    #
+    attr_accessor :consumer
+
+    #
+    # [Proc] the {::Proc} handling the messages for this {::Henchman::Worker}.
+    #
+    attr_accessor :block
+
+    #
+    # @param [String] queue_name the name of the queue this worker listens to.
+    # @param [Symbol] exchange_type the type of exchange this worker will connect its queue to.
+    # @param [Proc] block the {::Proc} that will handle the messages for this {::Henchman::Worker}.
+    #
+    def initialize(queue_name, &block)
+      @block = block
+      @queue_name = queue_name
+    end
+
+    #
+    # Subscribe this {::Henchman::Worker} to a queue.
+    #
+    # @param [AMQP::Queue] queue the {::AMQP::Queue} to subscribe the {::Henchman::Worker} to.
+    # @param [EM::Deferrable] deferrable an {::EM::Deferrable} that will succeed with the subscription is done.
+    #
+    def subscribe_to(queue, deferrable)
+      Henchman.with_channel do |channel|
+        @consumer = AMQP::Consumer.new(channel, 
+                                      queue, 
+                                      queue.generate_consumer_tag(queue.name), # consumer_tag
+                                      false, # exclusive
+                                      false) # no_ack
+        consumer.on_delivery do |headers, data|
+          if queue.channel.status == :opened
+            begin
+              call(MultiJson.decode(data), headers)
+            rescue Exception => e
+              STDERR.puts e
+              STDERR.puts e.backtrace.join("\n")
+            end
+          end
+        end
+        consumer.consume do 
+          deferrable.set_deferred_status :succeeded
+        end
+      end
+    end
+
+    #
+    # Make this {::Henchman::Worker} subscribe to a fanout exchange.
+    #
+    def subscribe!
+      deferrable = EM::DefaultDeferrable.new
+      Henchman.with_fanout_queue(queue_name) do |queue|
+        subscribe_to(queue, deferrable)
+      end
+      EM::Synchrony.sync deferrable
+    end
+
+    #
+    # Make this {::Henchman::Worker} subscribe to a direct exchange.
+    #
+    def consume!
+      deferrable = EM::DefaultDeferrable.new
+      Henchman.with_queue(queue_name) do |queue|
+        subscribe_to(queue, deferrable)
+      end
+      EM::Synchrony.sync deferrable
+    end
+
+    #
+    # Call this worker with some data.
+    #
+    # @param [AMQP::Header] headers the headers to handle.
+    # @param [Object] message the message to handle.
+    #
+    # @return [Henchman::Worker::Task] a {::Henchman::Worker::Task} for this {::Henchman::Worker}.
+    #
+    def call(message, headers = nil)
+      Task.new(self, headers, message).call
+    end
+
+    #
+    # Unsubscribe this {::Henchman::Worker} from its queue.
+    #
+    def unsubscribe!
+      deferrable = EM::DefaultDeferrable.new
+      consumer.cancel do
+        deferrable.set_deferred_status :succeeded
+      end
+      Fiber.new do
+        EM::Synchrony.sync deferrable
+      end.resume
+    end
+  end
+
+end

data/script/consume

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'henchman'
+
+EM.synchrony do
+  Henchman::Worker.new("test") do
+    puts message.inspect
+    puts headers
+  end.consume!
+end

data/script/enqueue

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'henchman'
+
+EM.synchrony do
+  10.times do
+    Henchman.enqueue("test", {:time => Time.now.to_s})
+    EM::Synchrony.sleep 0.5
+  end
+  EM.stop
+end

data/script/publish

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'henchman'
+
+EM.synchrony do
+  10.times do
+    Henchman.publish("testpub", {:time => Time.now.to_s})
+    EM::Synchrony.sleep 0.5
+  end
+  EM.stop
+end

data/script/subscribe

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'henchman'
+
+EM.synchrony do
+  Henchman::Worker.new("testpub") do
+    puts message.inspect
+    puts headers
+  end.subscribe!
+end

data/spec/henchman_spec.rb

@@ -0,0 +1,193 @@
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'henchman'
+
+require 'rspec'
+
+describe Henchman do
+
+  context 'without amqp running' do
+
+    it 'allows testing of workers' do
+      val = rand(1 << 32)
+      found = nil
+      worker = Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          found = val
+        end
+      end
+      worker.call("val" => val)
+      found.should == val
+    end
+
+  end
+  
+  context 'with amqp running' do
+
+    around :each do |example|
+      EM.synchrony do
+        example.run
+        Henchman.stop!
+        EM.stop
+      end
+    end
+
+    it 'should consume jobs' do
+      val = rand(1 << 32)
+      found = nil
+      deferrable = EM::DefaultDeferrable.new
+      Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          found = val
+          deferrable.set_deferred_status :succeeded
+        end
+        nil
+      end.consume!
+      Henchman.enqueue("test.queue", :val => val)
+      EM::Synchrony.sync deferrable
+      found.should == val
+    end
+
+    it 'should forward consumed jobs if they ask for it' do
+      val = rand(1 << 32)
+      found = nil
+      deferrable = EM::DefaultDeferrable.new
+      Henchman::Worker.new("test.queue2") do
+        if message["val"] == val
+          found = val
+          deferrable.set_deferred_status :succeeded
+        end
+        nil
+      end.consume!
+      Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          enqueue("test.queue2", "val" => val)
+        else
+          nil
+        end
+      end.consume!
+      Henchman.enqueue("test.queue", :val => val, :bajs => "hepp")
+      EM::Synchrony.sync deferrable
+      found.should == val
+    end
+
+    it 'should be able to unsubscribe' do
+      val = rand(1 << 32)
+      found = 0
+      deferrable = EM::DefaultDeferrable.new
+      Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          found += 1
+          unsubscribe!
+          deferrable.set_deferred_status :succeeded
+        end
+        nil
+      end.consume!
+      Henchman.enqueue("test.queue", :val => val)
+      Henchman.enqueue("test.queue", :val => val)
+      EM::Synchrony.sync deferrable
+      EM::Synchrony.sleep 0.2
+      found.should == 1
+    end
+    
+    it 'handles errors with a global error handler' do
+      val = rand(1 << 32)
+      error = nil
+      deferrable = EM::DefaultDeferrable.new
+      Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          raise "error!"
+        end
+        nil
+      end.consume!
+      Henchman.error do
+        if exception.message == "error!"
+          error = exception
+          deferrable.set_deferred_status :succeeded
+        end
+      end
+      Henchman.enqueue("test.queue", :val => val)
+      EM::Synchrony.sync deferrable
+      error.message.should == "error!"
+    end
+
+    it 'should let many consumers consume off the same queue' do
+      consumers = Set.new
+      found = 0
+      val = rand(1 << 32)
+      deferrable = EM::DefaultDeferrable.new
+      Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          consumers << "1"
+          found += 1
+          deferrable.set_deferred_status :succeeded if found == 10
+        end
+        nil
+      end.consume!
+      Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          consumers << "2"
+          found += 1
+          deferrable.set_deferred_status :succeeded if found == 10
+        end
+        nil
+      end.consume!
+      Henchman::Worker.new("test.queue") do
+        if message["val"] == val
+          consumers << "3"
+          found += 1
+          deferrable.set_deferred_status :succeeded if found == 10
+        end
+        nil
+      end.consume!
+      10.times do
+        Henchman.enqueue("test.queue", :val => val)
+      end
+      EM::Synchrony.sync deferrable
+      consumers.should == Set.new(["1", "2", "3"])
+      found.should == 10
+    end
+
+    it 'should let many consumers consume off the same fanout' do
+      consumers = Set.new
+      found = 0
+      val = rand(1 << 32)
+      deferrable = EM::DefaultDeferrable.new
+      Henchman::Worker.new("test.exchange") do
+        if message["val"] == val
+          consumers << "1"
+          found += 1
+          deferrable.set_deferred_status :succeeded if found == 30
+        end
+        nil
+      end.subscribe!
+      Henchman::Worker.new("test.exchange") do
+        if message["val"] == val
+          consumers << "2"
+          found += 1
+          deferrable.set_deferred_status :succeeded if found == 30
+        end
+        nil
+      end.subscribe!
+      Henchman::Worker.new("test.exchange") do
+        if message["val"] == val
+          consumers << "3"
+          found += 1
+          deferrable.set_deferred_status :succeeded if found == 30
+        end
+        nil
+      end.subscribe!
+      10.times do |n|
+        Henchman.publish("test.exchange", :val => val, :n => n)
+      end
+      EM::Synchrony.sync deferrable
+      consumers.should == Set.new(["1", "2", "3"])
+      found.should == 30
+    end
+
+  end
+
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: henchman
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Martin Bruse
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: &70332933283000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70332933283000
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: &70332933282540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70332933282540
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70332933281980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70332933281980
+description: A maximally simple amqp wrapper
+email:
+- martin@oort.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .em-console.rc
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- henchman.gemspec
+- lib/henchman.rb
+- lib/henchman/worker.rb
+- script/consume
+- script/enqueue
+- script/publish
+- script/subscribe
+- spec/henchman_spec.rb
+homepage: https://github.com/zond/henchman
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A maximally simple amqp wrapper
+test_files:
+- spec/henchman_spec.rb