songkick_queue 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e8a5f871097112612e6bc9bc581afe8f7a1dcced
+  data.tar.gz: 983110a1e0eb96ea33c88584ba9bdeb198365acf
+SHA512:
+  metadata.gz: 0a78a279786c3ea6b30cb35e4b667a8dfa3d4c661bd930e2802c8ec0f2666e447ec38c00e567358cf45e960e377f8a1b5dd0d007f9bbd119db92e4443d6a6d04
+  data.tar.gz: 1bd3ae7c10e1c9913817aeaa06e3816c53911b1dd296549c234ac2668613e08ff298272fe844f0fbda99d720d2f3996b4ee4b85729ba923b44d77cd30d678f09

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+vendor/bundle

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+script: bundle exec rspec
+rvm:
+  - 2.2.0
+  - 2.1.0
+  - 2.0.0

data/.yardopts

@@ -0,0 +1 @@
+-M redcarpet bin/* lib/**/*.rb - README.md

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in songkick_queue.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Songkick.com Ltd
+
+MIT License
+
+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,154 @@
+# SongkickQueue
+
+A gem for processing tasks asynchronously, powered by RabbitMQ.
+
+[![Build status](https://travis-ci.org/songkick/queue.svg?branch=master)](https://travis-ci.org/songkick/queue)
+
+## Dependencies
+
+* Ruby 2.0+
+* RabbitMQ ~v2.8
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'songkick_queue'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install songkick_queue
+
+## Usage
+
+### Setup
+
+You must define both the AMQP URL and a logger instance:
+
+```ruby
+SongkickQueue.configure do |config|
+  config.amqp = 'amqp://localhost:5672'
+  config.logger = Logger.new(STDOUT)
+end
+```
+
+### Creating consumers
+
+To create a consumer simply construct a new class and include the `SongkickQueue::Consumer`
+module.
+
+Consumers must declare a queue name to consume from (by calling `consume_from_queue`) and
+and define a `#process` method which receives a message.
+
+For example:
+
+```ruby
+class TweetConsumer
+  include SongkickQueue::Consumer
+
+  consume_from_queue 'notifications-service.tweets'
+
+  def process(message)
+    logger.info "Received message: #{message.inspect}"
+
+    TwitterClient.send_tweet(message[:text], message[:user_id])
+  rescue TwitterClient::HttpError => e
+    logger.warn(e)
+  rescue StandardError => e
+    logger.error(e)
+  end
+end
+```
+
+Consumers have the logger you declared in the configuration available to them.
+
+### Running consumers
+
+Run the built in binary:
+
+```sh
+$ songkick_queue --help
+Usage: songkick_queue [options]
+    -r, --require LIBRARY            Path to require LIBRARY. Usually this will be a file that
+                                     requires some consumers
+    -c, --consumer CLASS_NAME        Register consumer with CLASS_NAME
+    -n, --name NAME                  Set the process name to NAME
+    -h, --help                       Show this message
+```
+
+Both the `--require` and `--consumer` arguments can be passed multiple times, enabling you to run
+multiple consumers in one process.
+
+Example usage:
+
+```sh
+$ songkick_queue -r ./lib/environment.rb -c TweetConsumer -n notifications_worker
+```
+
+```sh
+$ ps aux | grep 'notifications_worker'
+22320   0.0  0.3  2486900  25368 s001  S+    4:59pm   0:00.84 notifications_worker[idle]
+```
+
+NB. The `songkick_queue` process does not daemonize. We recommend running it using something like
+[supervisor](http://supervisord.org/) or [god](http://godrb.com/).
+
+### Publishing messages
+
+To publish messages for consumers, call the `#publish` method on `SongkickQueue`, passing in the
+name of the queue to publish to and the message to send.
+
+The queue name must match one declared in a consumer by calling `consume_from_queue`.
+
+The message can be any primitive Ruby object that can be serialized into JSON. Messages are
+serialized whilst enqueued and deserialized for being passed to the `#process` method in your
+consumer.
+
+```ruby
+SongkickQueue.publish('notifications-service.tweets', { text: 'Hello world', user_id: 57237722 })
+```
+
+## Tests
+
+See the current build status on Travis CI: https://travis-ci.org/songkick/queue
+
+The tests are written in RSpec. Run them by calling:
+
+```sh
+$ rspec
+```
+
+## Documentation
+
+Up to date docs are available on RubyDoc: http://www.rubydoc.info/github/songkick/queue
+
+The documentation is written inline in the source code and processed using YARD. To generate and
+view the documentation locally, run:
+
+```sh
+$ yardoc
+$ yard server --reload
+
+$ open http://localhost:8808/
+```
+
+## TODO
+
+* Add a message UUID when publishing (add to process name when processing)
+* Look at adding #requeue and #reject methods in consumer mixin
+
+## Contributing
+
+Pull requests are welcome!
+
+1. Fork it ( https://github.com/songkick/queue/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/songkick_queue

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/songkick_queue'
+
+SongkickQueue::CLI.new(ARGV).run

data/examples/environment.rb

@@ -0,0 +1,28 @@
+# Example environment file
+# Require this file when running `songkick_queue` like so:
+#
+#   $ bin/songkick_queue --require ./examples/environment.rb --consumer TweetConsumer
+#
+require_relative '../lib/songkick_queue'
+
+SongkickQueue.configure do |config|
+  config.amqp = 'amqp://localhost:5672'
+  config.logger = Logger.new(STDOUT)
+end
+
+class TweetConsumer
+  include SongkickQueue::Consumer
+
+  consume_from_queue 'notifications-service.tweets'
+
+  def process(payload)
+    puts "TweetConsumer#process(#{payload})"
+
+    10.times do
+      sleep 1
+      puts "Processing..."
+    end
+
+    puts "Done processing!"
+  end
+end

data/examples/producer.rb

@@ -0,0 +1,10 @@
+require_relative '../lib/songkick_queue'
+
+SongkickQueue.configure do |config|
+  config.amqp = 'amqp://localhost:5672'
+  config.logger = Logger.new(STDOUT)
+end
+
+3.times do
+  SongkickQueue.publish('notifications-service.tweets', { text: 'Hello world', user_id: 57237722 })
+end

data/lib/songkick_queue.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'bunny'
+
+require 'songkick_queue/version'
+require 'songkick_queue/client'
+require 'songkick_queue/consumer'
+require 'songkick_queue/producer'
+require 'songkick_queue/worker'
+require 'songkick_queue/cli'
+
+module SongkickQueue
+  Configuration = Struct.new(:amqp, :logger)
+  ConfigurationError = Class.new(StandardError)
+
+  # Retrieve configuration for SongkickQueue
+  #
+  # @return [Configuration]
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Yields a block, passing the memoized configuration instance
+  #
+  # @yield [Configuration]
+  def self.configure
+    yield(configuration)
+  end
+
+  # Publishes the given message to the given queue
+  #
+  # @param queue_name [String] to publish to
+  # @param message [#to_json] to serialize and enqueue
+  def self.publish(queue_name, message)
+    producer.publish(queue_name, message)
+  end
+
+  private
+
+  def self.producer
+    @producer ||= Producer.new
+  end
+end

data/lib/songkick_queue/cli.rb

@@ -0,0 +1,71 @@
+require 'optparse'
+require 'ostruct'
+
+module SongkickQueue
+  class CLI
+    attr_reader :options
+
+    # @param argv [Array<String>] of command line arguments
+    def initialize(argv)
+      @options = OpenStruct.new(
+        libraries: [],
+        consumers: [],
+        process_name: 'songkick_queue',
+      )
+
+      parse_options(argv)
+    end
+
+    # Parse the command line arguments using OptionParser
+    #
+    # @param argv [Array<String>] of command line arguments
+    def parse_options(argv)
+      option_parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: songkick_queue [options]'
+
+        opts.on('-r', '--require LIBRARY',
+                'Path to require LIBRARY. Usually this will be a file that ',
+                'requires some consumers') do |lib|
+          options.libraries << lib
+        end
+
+        opts.on('-c', '--consumer CLASS_NAME',
+                'Register consumer with CLASS_NAME') do |class_name|
+          options.consumers << class_name
+        end
+
+        opts.on('-n', '--name NAME',
+                'Set the process name to NAME') do |name|
+          options.process_name = name
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+
+      option_parser.parse!(argv)
+    end
+
+    # Instantiates and runs a new Worker for the parsed options. Calling this
+    # method blocks the main Thread. See Worker#run for more info
+    #
+    def run
+      options.libraries.each do |lib|
+        require lib
+      end
+
+      if options.consumers.empty?
+        puts 'No consumers provided, exiting. Run `songkick_queue --help` for more info.'
+        exit 1
+      end
+
+      consumers = options.consumers.map do |class_name|
+        Object.const_get(class_name)
+      end
+
+      Worker.new(options.process_name, consumers).run
+    end
+  end
+end

data/lib/songkick_queue/client.rb

@@ -0,0 +1,44 @@
+module SongkickQueue
+  class Client
+    def default_exchange
+      channel.default_exchange
+    end
+
+    # Creates a memoized channel for issuing RabbitMQ commands
+    #
+    # @return [Bunny::Channel]
+    def channel
+      @channel ||= begin
+        channel = connection.create_channel
+        channel.prefetch(1)
+
+        channel
+      end
+    end
+
+    # Creates a memoized connection to RabbitMQ
+    #
+    # @return [Bunny::Session]
+    def connection
+      @connection ||= begin
+        connection = Bunny.new(config_amqp)
+        connection.start
+
+        connection
+      end
+    end
+
+    private
+
+    # Retrieve the AMQP URL from the configuration
+    #
+    # @raise [ConfigurationError] if not defined
+    def config_amqp
+      config.amqp || fail(ConfigurationError, 'missing AMQP URL from config')
+    end
+
+    def config
+      SongkickQueue.configuration
+    end
+  end
+end

data/lib/songkick_queue/consumer.rb

@@ -0,0 +1,44 @@
+module SongkickQueue
+  module Consumer
+    attr_reader :delivery_info, :logger
+
+    module ClassMethods
+      # Define the name of the queue this consumer with process messages from
+      #
+      # @param queue_name [String]
+      def consume_from_queue(queue_name)
+        @queue_name = queue_name
+      end
+
+      # Return the quene name set by #consume_from_queue
+      #
+      # @raise [NotImplementedError] if queue name was not already defined
+      def queue_name
+        @queue_name || fail(NotImplementedError, 'you must declare a queue name to consume from ' +
+          'by calling #consume_from_queue in your consumer class. See README for more info.')
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # @param delivery_info [Bunny::DeliveryInfo#delivery_tag] to use for
+    #   acknowledgement and requeues, rejects etc...
+    # @param logger [Logger] to expose to the client consumer for logging
+    def initialize(delivery_info, logger)
+      @delivery_info = delivery_info
+      @logger        = logger
+    end
+
+    # Placeholder method to ensure each client consumer defines their own
+    # process message
+    #
+    # @param message [Object] to process
+    # @raise [NotImplementedError]
+    def process(message)
+      fail NotImplementedError, 'you must define a #process method in your ' +
+        'consumer class, see the README for more info.'
+    end
+  end
+end

data/lib/songkick_queue/producer.rb

@@ -0,0 +1,24 @@
+module SongkickQueue
+  class Producer
+    def initialize
+      @client = Client.new
+    end
+
+    # Serializes the given message and publishes it to the default RabbitMQ
+    # exchange
+    #
+    # @param queue_name [String] to publish to
+    # @param message [#to_json] to serialize and enqueue
+    def publish(queue_name, message)
+      payload = JSON.generate(message)
+
+      client
+        .default_exchange
+        .publish(payload, routing_key: String(queue_name))
+    end
+
+    private
+
+    attr_reader :client
+  end
+end

data/lib/songkick_queue/version.rb

@@ -0,0 +1,3 @@
+module SongkickQueue
+  VERSION = "0.1.0"
+end

data/lib/songkick_queue/worker.rb

@@ -0,0 +1,130 @@
+module SongkickQueue
+  class Worker
+    attr_reader :process_name, :consumer_classes
+
+    # @param process_name [String] of the custom process name to use
+    # @param consumer_classes [Array<Class>, Class] of consumer class names
+    def initialize(process_name, consumer_classes = [])
+      @process_name = process_name
+      @consumer_classes = Array(consumer_classes)
+
+      if @consumer_classes.empty?
+        fail ArgumentError, 'no consumer classes given to Worker'
+      end
+
+      @client = Client.new
+    end
+
+    # Subscribes the consumers classes to their defined message queues and
+    # blocks until all the work pool consumers have finished. Also sets up
+    # signal catching for graceful exits no interrupt
+    def run
+      set_process_name
+
+      consumer_classes.each do |consumer_class|
+        subscribe_to_queue(consumer_class)
+      end
+
+      setup_signal_catching
+      stop_if_signal_caught
+
+      channel.work_pool.join
+    end
+
+    private
+
+    attr_reader :client
+
+    def setup_signal_catching
+      trap('INT') { @shutdown = 'INT' }
+      trap('TERM') { @shutdown = 'TERM' }
+    end
+
+    # Checks for presence of @shutdown every 1 second and if found instructs
+    # all the channel's work pool consumers to shutdown. Each work pool thread
+    # will finish its current task and then join the main thread. Once all the
+    # threads have joined then `channel.work_pool.join` will cease blocking and
+    # return, causing the process to terminate.
+    def stop_if_signal_caught
+      Thread.new do
+        loop do
+          sleep 1
+
+          if @shutdown
+            logger.info "Recevied SIG#{@shutdown}, shutting down consumers"
+
+            @client.channel.work_pool.shutdown
+            @shutdown = nil
+          end
+        end
+      end
+    end
+
+    # Declare a queue and subscribe to it
+    #
+    # @param consumer_class [Class] to subscribe to
+    def subscribe_to_queue(consumer_class)
+      queue = channel.queue(consumer_class.queue_name, durable: true,
+        arguments: {'x-ha-policy' => 'all'})
+
+      queue.subscribe(manual_ack: true) do |delivery_info, properties, payload|
+        process_message(consumer_class, delivery_info, properties, payload)
+      end
+
+      logger.info "Subscribed #{consumer_class} to #{consumer_class.queue_name}"
+    end
+
+    # Handle receipt of a subscribed message
+    #
+    # @param consumer_class [Class] that was subscribed to
+    # @param delivery_info [Bunny::DeliveryInfo]
+    # @param properties [Bunny::MessageProperties]
+    # @param payload [String] to deserialize
+    def process_message(consumer_class, delivery_info, properties, payload)
+      logger.info "Processing message via #{consumer_class}..."
+
+      set_process_name(consumer_class)
+
+      message = JSON.parse(payload, symbolize_names: true)
+
+      consumer = consumer_class.new(delivery_info, logger)
+      consumer.process(message)
+    rescue Object => exception
+      logger.error(exception)
+    ensure
+      set_process_name
+      channel.ack(delivery_info.delivery_tag, false)
+    end
+
+    def channel
+      client.channel
+    end
+
+    # Retrieve the logger defined in the configuration
+    #
+    # @raise [ConfigurationError] if not defined
+    def logger
+      config.logger || fail(ConfigurationError, 'No logger configured, see README for more details')
+    end
+
+    def config
+      SongkickQueue.configuration
+    end
+
+    # Update the name of this process, as viewed in `ps` or `top`
+    #
+    # @example idle
+    #   set_process_name #=> "songkick_queue[idle]"
+    # @example consumer running
+    #   set_process_name(TweetConsumer) #=> "songkick_queue[tweet_consumer]"
+    # @param status [String] of the program
+    def set_process_name(status = 'idle')
+      formatted_status = String(status)
+        .gsub('::', '')
+        .gsub(/([A-Z]+)/) { "_#{$1.downcase}" }
+        .sub(/^_(\w)/) { $1 }
+
+      $PROGRAM_NAME = "#{process_name}[#{formatted_status}]"
+    end
+  end
+end

data/songkick_queue.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'songkick_queue/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "songkick_queue"
+  spec.version       = SongkickQueue::VERSION
+  spec.authors       = ["Dan Lucraft", "Paul Springett"]
+  spec.email         = ["dan.lucraft@songkick.com", "paul.springett@songkick.com"]
+  spec.summary       = %q{A gem for processing tasks asynchronously, powered by RabbitMQ.}
+  spec.description   = %q{A gem for processing tasks asynchronously, powered by RabbitMQ.}
+  spec.homepage      = "https://github.com/songkick/songkick_queue"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "yard"
+
+  # Used by yardoc for processing README.md code snippets
+  spec.add_development_dependency "redcarpet"
+
+  spec.add_dependency "bunny", "~> 1.2.1"
+end

data/spec/songkick_queue/cli_spec.rb

@@ -0,0 +1,69 @@
+require 'songkick_queue/cli'
+
+module SongkickQueue
+  RSpec.describe CLI do
+    describe "#initialize" do
+      it "should build an options object with defaults" do
+        cli = CLI.new([])
+        options = cli.options
+
+        expect(options.libraries).to eq []
+        expect(options.consumers).to eq []
+        expect(options.process_name).to eq 'songkick_queue'
+      end
+    end
+
+    describe "#parse_options" do
+      it "should parse required libraries" do
+        cli = CLI.new(%w[--require foo -r bar])
+        options = cli.options
+
+        expect(options.libraries).to eq ['foo', 'bar']
+      end
+
+      it "should parse consumers" do
+        cli = CLI.new(%w[--consumer FooConsumer -c BarConsumer])
+        options = cli.options
+
+        expect(options.consumers).to eq ['FooConsumer', 'BarConsumer']
+      end
+
+      it "should parse consumers" do
+        cli = CLI.new(%w[--name example_worker])
+        options = cli.options
+
+        expect(options.process_name).to eq 'example_worker'
+      end
+    end
+
+    describe "#run" do
+      it "should try and require given paths" do
+        cli = CLI.new(%w[--require path/to/app])
+
+        expect { cli.run }.to raise_error(LoadError, 'cannot load such file -- path/to/app')
+      end
+
+      it "should exit with useful message if no consumers given" do
+        cli = CLI.new([])
+
+        expect {
+          expect(STDOUT).to receive(:puts)
+            .with('No consumers provided, exiting. Run `songkick_queue --help` for more info.')
+
+          cli.run
+        }.to raise_error(SystemExit)
+      end
+
+      it "should build and run a Worker" do
+        ::ExampleConsumer = Class.new
+
+        worker = instance_double(Worker, run: :running)
+        cli = CLI.new(%w[--consumer ExampleConsumer --name example_worker])
+
+        expect(Worker).to receive(:new).with('example_worker', [ExampleConsumer]) { worker }
+
+        cli.run
+      end
+    end
+  end
+end

data/spec/songkick_queue/consumer_spec.rb

@@ -0,0 +1,49 @@
+require 'songkick_queue/consumer'
+
+module SongkickQueue
+  RSpec.describe Consumer do
+    describe ".from_queue" do
+      it "should fail if .consume_from_queue has not been called" do
+        class ExampleConsumer
+          include SongkickQueue::Consumer
+        end
+
+        expect { ExampleConsumer.queue_name }.to raise_error(NotImplementedError)
+      end
+
+      it "should return the queue name set by .consume_from_queue" do
+        class ExampleConsumer
+          include SongkickQueue::Consumer
+
+          consume_from_queue 'app.examples'
+        end
+
+        expect(ExampleConsumer.queue_name).to eq 'app.examples'
+      end
+    end
+
+    describe "#initialize" do
+      it "should pass a logger" do
+        class ExampleConsumer
+          include SongkickQueue::Consumer
+        end
+
+        consumer = ExampleConsumer.new(:delivery_info, :logger)
+
+        expect(consumer.logger).to eq :logger
+      end
+    end
+
+    describe "#process" do
+      it "should fail if not overridden" do
+        class ExampleConsumer
+          include SongkickQueue::Consumer
+        end
+
+        consumer = ExampleConsumer.new(:delivery_info, :logger)
+
+        expect { consumer.process(:message) }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+end

data/spec/songkick_queue/producer_spec.rb

@@ -0,0 +1,20 @@
+require 'songkick_queue/producer'
+
+module SongkickQueue
+  RSpec.describe Producer do
+    describe "#publish" do
+      it "should publish the message to the exchange as JSON, with the correct routing key" do
+        producer = Producer.new
+
+        exchange = double(:exchange, publish: :published)
+        client = instance_double(Client, default_exchange: exchange)
+        allow(producer).to receive(:client) { client }
+
+        expect(exchange).to receive(:publish)
+          .with('{"example":"message","value":true}', routing_key: 'queue_name')
+
+        producer.publish(:queue_name, { example: 'message', value: true })
+      end
+    end
+  end
+end

data/spec/songkick_queue/worker_spec.rb

@@ -0,0 +1,98 @@
+require 'songkick_queue/worker'
+
+module SongkickQueue
+  RSpec.describe Worker do
+    describe "#initialize" do
+      it "should set process_name" do
+        worker = Worker.new(:process_name, [:foo_consumer])
+
+        expect(worker.process_name).to eq :process_name
+      end
+
+      it "should set consumer_classes" do
+        worker = Worker.new(:process_name, [:foo_consumer, :bar_consumer])
+
+        expect(worker.consumer_classes).to eq [:foo_consumer, :bar_consumer]
+      end
+
+      it "should convert single consumer into array of consumers" do
+        worker = Worker.new(:process_name, :bar_consumer)
+
+        expect(worker.consumer_classes).to eq [:bar_consumer]
+      end
+
+      it "should fail if no consumer passed" do
+        expect { Worker.new(:process_name) }.to raise_error(ArgumentError,
+          'no consumer classes given to Worker')
+      end
+    end
+
+    describe "#run" do
+      it "should subscribe each given consumer" do
+        worker = Worker.new(:process_name, [:foo_consumer, :bar_consumer])
+
+        allow(worker).to receive(:set_process_name)
+        allow(worker).to receive(:setup_signal_catching)
+        allow(worker).to receive(:stop_if_signal_caught)
+
+        allow(worker).to receive_message_chain(:channel, :work_pool, :join)
+
+        expect(worker).to receive(:subscribe_to_queue).with(:foo_consumer)
+        expect(worker).to receive(:subscribe_to_queue).with(:bar_consumer)
+
+        worker.run
+      end
+    end
+
+    describe "#subscribe_to_queue" do
+      it "should declare the queue and subscribe" do
+        consumer_class = double(:consumer_class, queue_name: 'app.examples')
+        worker = Worker.new(:process_name, consumer_class)
+
+        queue = double(:queue, subscribe: :null)
+        channel = double(:channel, queue: queue)
+
+        allow(worker).to receive(:channel) { channel }
+        allow(worker).to receive(:logger) { double(:logger, info: :null) }
+
+        expect(channel).to receive(:queue).with('app.examples', durable: true,
+          arguments: {'x-ha-policy' => 'all'})
+
+        expect(queue).to receive(:subscribe)
+
+        worker.send(:subscribe_to_queue, consumer_class)
+      end
+    end
+
+    describe "#process_message" do
+      it "should instantiate the consumer and call #process" do
+        ::FooConsumer = Class.new
+        worker = Worker.new(:process_name, FooConsumer)
+
+        logger = double(:logger, info: :null)
+        allow(worker).to receive(:logger) { logger }
+
+        channel = double(:channel, ack: :null)
+        allow(worker).to receive(:channel) { channel }
+
+        delivery_info = double(:delivery_info, delivery_tag: 'tag')
+
+        consumer = double(FooConsumer, process: :null)
+
+        expect(FooConsumer).to receive(:new)
+          .with(delivery_info, logger) { consumer }
+
+        expect(consumer).to receive(:process)
+          .with({ example: 'message', value: true})
+
+        worker.send(:process_message, FooConsumer, delivery_info,
+          :properties, '{"example":"message","value":true}')
+
+        expect(logger).to have_received(:info)
+          .with('Processing message via FooConsumer...')
+
+        expect(channel).to have_received(:ack).with('tag', false)
+      end
+    end
+  end
+end

data/spec/songkick_queue_spec.rb

@@ -0,0 +1,22 @@
+require 'songkick_queue'
+
+RSpec.describe SongkickQueue do
+  describe "#configure" do
+    it "should yield instance of Configuration" do
+      expect { |b|
+        SongkickQueue.configure(&b)
+      }.to yield_with_args instance_of(SongkickQueue::Configuration)
+    end
+  end
+
+  describe "#publish" do
+    it "should call #publish on instance Producer" do
+      producer = instance_double(SongkickQueue::Producer)
+      allow(SongkickQueue).to receive(:producer) { producer }
+
+      expect(producer).to receive(:publish).with(:queue_name, :message)
+
+      SongkickQueue.publish(:queue_name, :message)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: songkick_queue
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dan Lucraft
+- Paul Springett
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+description: A gem for processing tasks asynchronously, powered by RabbitMQ.
+email:
+- dan.lucraft@songkick.com
+- paul.springett@songkick.com
+executables:
+- songkick_queue
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- .yardopts
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/songkick_queue
+- examples/environment.rb
+- examples/producer.rb
+- lib/songkick_queue.rb
+- lib/songkick_queue/cli.rb
+- lib/songkick_queue/client.rb
+- lib/songkick_queue/consumer.rb
+- lib/songkick_queue/producer.rb
+- lib/songkick_queue/version.rb
+- lib/songkick_queue/worker.rb
+- songkick_queue.gemspec
+- spec/songkick_queue/cli_spec.rb
+- spec/songkick_queue/consumer_spec.rb
+- spec/songkick_queue/producer_spec.rb
+- spec/songkick_queue/worker_spec.rb
+- spec/songkick_queue_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/songkick/songkick_queue
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: A gem for processing tasks asynchronously, powered by RabbitMQ.
+test_files:
+- spec/songkick_queue/cli_spec.rb
+- spec/songkick_queue/consumer_spec.rb
+- spec/songkick_queue/producer_spec.rb
+- spec/songkick_queue/worker_spec.rb
+- spec/songkick_queue_spec.rb
+- spec/spec_helper.rb
+has_rdoc: