msgr 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a4c0e2fbb4ebe739cd8441da5136c32974e33e3
+  data.tar.gz: 8cd8950010d87d4c3a4c90fa26a2f4544bfd1908
+SHA512:
+  metadata.gz: 6b8268da9f156fa7be5b4da0768e766d90242d60186aa7a79d9d229270ac5957bf0e498c5edbb963bc8d0abb759e91545536e23444ff4ce6ab25bc8931518c96
+  data.tar.gz: 5af9d36176f5b99c4249c89a2819d4ab3682c90320d44a0c219b077ed2d3d4f7d9f6dd6e0899452d7d1c3b390ea89a2fdf53f9f2e41c91cb9cd58b55c24598db

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+pmip
+*.iml
+.rbx
+.rspec
+log/*.log

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+bundler_args: --without development
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - jruby
+  - rbx-19mode
+
+gemfile:
+  - gemfiles/Gemfile.rails-3-2
+  - gemfiles/Gemfile.rails-4-0
+
+services:
+  - rabbitmq

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jan Graichen
+
+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,42 @@
+# Msgr - *A Rails-like Messaging Framework*
+
+[![Gem Version](https://badge.fury.io/rb/msgr.png)](http://badge.fury.io/rb/msgr)
+[![Build Status](https://travis-ci.org/jgraichen/msgr.png?branch=master)](https://travis-ci.org/jgraichen/msgr)
+[![Coverage Status](https://coveralls.io/repos/jgraichen/msgr/badge.png?branch=master)](https://coveralls.io/r/jgraichen/msgr)
+[![Code Climate](https://codeclimate.com/github/jgraichen/msgr.png)](https://codeclimate.com/github/jgraichen/msgr)
+[![Dependency Status](https://gemnasium.com/jgraichen/msgr.png)](https://gemnasium.com/jgraichen/msgr)
+[![RubyDoc Documentation](https://raw.github.com/jgraichen/msgr/master/rubydoc.png)](http://rubydoc.info/github/jgraichen/msgr/master/frames)
+
+You know it and ou like it. Using Rails you can just declare your routes and
+create a controller. Now it just works.
+
+With *Msgr* you can do the same for asynchronous AMQP messaging. Just define
+your routes, create your consumer and watch you app processing messages.
+
+*Note: Msgr is still under heavy development.*
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'msgr'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install msgr
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task 'default' => 'ci'
+task 'ci' => 'spec'
+
+desc 'Run all specs'
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = 'spec/msgr/**/*_spec.rb'
+end

data/gemfiles/Gemfile.rails-3-2

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Load root Gemfile
+self.instance_eval Bundler.read_file 'Gemfile'
+
+gem 'activesupport', '~> 3.2.0'

data/gemfiles/Gemfile.rails-4-0

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Load root Gemfile
+self.instance_eval Bundler.read_file 'Gemfile'
+
+gem 'activesupport', '~> 4.0.0'

data/lib/msgr.rb

@@ -0,0 +1,36 @@
+require 'msgr/version'
+require 'celluloid'
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/string/inflections'
+
+require 'msgr/logging'
+require 'msgr/binding'
+require 'msgr/client'
+require 'msgr/connection'
+require 'msgr/dispatcher'
+require 'msgr/errors'
+require 'msgr/message'
+require 'msgr/pool'
+require 'msgr/route'
+require 'msgr/routes'
+
+module Msgr
+
+  class << self
+    def logger
+      @logger ||= Logger.new($stdout).tap do |logger|
+        logger.level = Logger::Severity::INFO
+      end
+    end
+
+    def start
+      # stub
+    end
+
+    def publish
+      # stub
+    end
+  end
+end

data/lib/msgr/binding.rb

@@ -0,0 +1,34 @@
+module Msgr
+  # A single binding
+  class Binding
+    attr_reader :connection, :route, :subscription, :dispatcher
+
+    def initialize(connection, route, dispatcher)
+      @connection = connection
+      @route      = route
+      @dispatcher = dispatcher
+
+      queue    = connection.queue route.name
+
+      queue.bind connection.exchange, routing_key: route.key
+
+      @subscription = queue.subscribe ack: true, &method(:call)
+    end
+
+    # Called from Bunny Thread Pool. Will create message object from
+    # provided bunny data and dispatch message to connection.
+    #
+    def call(info, metadata, payload)
+      message = Message.new(connection, info, metadata, payload, route)
+      dispatcher.dispatch :call, message
+    rescue => error
+      Msgr.logger.warn(self) { "Error received within bunny subscribe handler: #{error.inspect}." }
+    end
+
+    # Cancel subscription to not receive any more messages.
+    #
+    def release
+      subscription.cancel if subscription
+    end
+  end
+end

data/lib/msgr/client.rb

@@ -0,0 +1,82 @@
+require 'bunny'
+
+module Msgr
+
+  class Client
+    include Celluloid
+    include Logging
+
+    attr_reader :pool, :uri
+
+    def initialize(config)
+      @uri = URI.parse config[:uri] ? config.delete(:uri) : 'amqp://localhost/'
+      @uri.protocol = 'amqps'                   if config[:secure]
+      @uri.user     = config.delete :user       if config[:user]
+      @uri.password = config.delete :password   if config[:password]
+      @uri.host     = config.delete :host       if config[:host]
+      @uri.port     = config.delete(:port).to_i if config[:port]
+      @uri.path     = "/#{config.delete :vhost}".gsub /\/+/, '/' if config[:vhost]
+
+      @config  = config
+      @bunny   = Bunny.new @uri.to_s
+      @pool    = Pool.new Dispatcher, autostart: false
+
+      @uri.password = nil
+    end
+
+    def running?; @running end
+    def log_name; self.class.name end
+
+    def routes
+      @routes ||= Routes.new
+    end
+
+    def reload
+      raise StandardError.new 'Client not running.' unless running?
+      log(:info) { 'Reload client.' }
+
+      @connection.release
+      @connection.terminate
+
+      log(:debug) { 'Create new connection.' }
+
+      @connection = Connection.new @bunny, routes, pool
+
+      log(:info) { 'Client reloaded.' }
+    end
+
+    def start
+      log(:info) { "Start client to #{uri}" }
+
+      @bunny.start
+      @pool.start
+
+      @running    = true
+      @connection = Connection.new @bunny, routes, pool
+
+      log(:info) { "Client started. pool: #{pool.size}" }
+    end
+
+    def stop
+      return unless running?
+
+      @running = false
+      log(:info) { 'Graceful shutdown client...' }
+
+      @connection.release
+      @pool.stop
+
+      log(:debug) { 'Terminating...' }
+
+      @connection.terminate
+      @pool.terminate
+      @bunny.stop
+
+      log(:info) { 'Terminated.' }
+    end
+
+    def publish(routing_key, payload)
+      @connection.publish payload, routing_key: routing_key
+    end
+  end
+end

data/lib/msgr/connection.rb

@@ -0,0 +1,78 @@
+module Msgr
+
+  class Connection
+    include Celluloid
+    include Logging
+
+    attr_reader :conn, :pool, :routes
+    finalizer :close
+
+    def initialize(conn, routes, pool)
+      @conn   = conn
+      @pool   = pool
+      @routes = routes
+
+      @channel = conn.create_channel
+      @channel.prefetch(10)
+
+      rebind
+    end
+
+    def rebind(routes = nil)
+      routes = self.routes unless routes
+
+      # First release old bindings
+      release
+
+      # Create new bindings
+      routes.each { |route| bindings << Binding.new(Actor.current, route, pool) }
+
+      log(:debug) { 'New routes bound.' }
+    end
+
+    # Used to store al bindings. Allows use to
+    # release bindings when receiver should not longer
+    # receive messages but channel need to be open
+    # to allow further acknowledgments.
+    #
+    def bindings
+      @bindings ||= []
+    end
+
+    def queue(name)
+      @channel.queue name, durable: true
+    end
+
+    def exchange
+      @exchange ||= @channel.topic 'msgr', durable: true
+    end
+
+    # Release all bindings but do not close channel. Will not
+    # longer receive any message but channel can be used to
+    # acknowledge currently processing messages.
+    #
+    def release
+      return unless bindings.any?
+
+      log(:debug) { 'Release all bindings.' }
+
+      bindings.each { |binding| binding.release }
+      bindings.clear
+    end
+
+    def publish(payload, opts = {})
+      log(:debug) { "Publish message to #{opts[:routing_key]}" }
+
+      exchange.publish payload, opts.merge(persistent: true)
+    end
+
+    def ack(delivery_tag)
+      @channel.ack delivery_tag
+    end
+
+    def close
+      @channel.close if @channel.open?
+      log(:debug) { 'Connection closed.' }
+    end
+  end
+end

data/lib/msgr/dispatcher.rb

@@ -0,0 +1,26 @@
+module Msgr
+
+  # The Dispatcher receives incoming messages,
+  # process them through a middleware stack and
+  # delegate them to a new and fresh consumer instance.
+  #
+  class Dispatcher
+    include Logging
+
+    def initialize
+
+    end
+
+    def call(message)
+      log(:debug) { "Receive dispatched message: #{message.payload}" }
+
+      message.ack
+
+      log(:debug) { 'Dispatched message acknowledged.' }
+    end
+
+    def to_s
+      self.class.name
+    end
+  end
+end

data/lib/msgr/errors.rb

@@ -0,0 +1,21 @@
+module Msgr
+
+  # Abstract error base class
+  class CausedByError < StandardError
+    attr_accessor :cause
+
+    def initialize(*args)
+      opts = args.extract_options!
+      @cause = opts.delete(:cause)
+      super
+    end
+
+    def message
+      cause ? "#{super}\n  caused by:\n#{cause.to_s}" : super
+    end
+  end
+
+  class ConnectionError < CausedByError
+
+  end
+end

data/lib/msgr/logging.rb

@@ -0,0 +1,12 @@
+module Msgr
+
+  module Logging
+    def log(level)
+      Msgr.logger.send(level, self.log_name) { yield }
+    end
+
+    def log_name
+      "[#{Thread.current.object_id}] #{self.to_s}"
+    end
+  end
+end

data/lib/msgr/message.rb

@@ -0,0 +1,18 @@
+module Msgr
+
+  class Message
+    attr_reader :delivery_info, :metadata, :payload
+
+    def initialize(connection, delivery_info, metadata, payload, route)
+      @connection    = connection
+      @delivery_info = delivery_info
+      @metadata      = metadata
+      @payload       = payload
+      @route         = route
+    end
+
+    def ack
+      @connection.ack delivery_info.delivery_tag
+    end
+  end
+end

data/lib/msgr/pool.rb

@@ -0,0 +1,165 @@
+module Msgr
+
+  class Pool
+    include Celluloid
+    include Logging
+    attr_reader :size
+
+    def initialize(runner_klass, opts = {})
+      @runner_klass = runner_klass
+      @runner_args  = opts[:args] ? Array(opts[:args]) : []
+      @size         = (opts[:size] || Celluloid.cores).to_i
+      @running      = false
+
+      log(:debug) { "Inialize size => #{@size}" }
+
+      start if opts[:autostart].nil? || opts[:autostart]
+      every(30) { log_status } if opts[:nostats].nil? || opts[:nostats]
+    end
+
+    def running?
+      @running
+    end
+
+    def idle; @idle ||= [] end
+    def busy; @busy ||= [] end
+
+    def start
+      return if running?
+
+      log(:debug) { 'Spin up worker pool' }
+      @running = true
+
+      idle.clear
+      busy.clear
+
+      @size.times.map do |index|
+        idle << Worker.new_link(Actor.current, index, @runner_klass, @runner_args)
+      end
+
+      log(:debug) { 'Startup done. Invoke worker polling.' }
+
+      idle.each { |worker| async.poll worker }
+    end
+
+    def log_status
+      log(:info) { "[STATUS] Idle: #{idle.size} Busy: #{busy.size}" }
+    end
+
+    # Request a graceful shutdown of all pool workers.
+    #
+    def stop
+      log(:debug) { 'Graceful shutdown requested.' }
+
+      @running = false
+      idle.each { |worker| worker.terminate }
+      idle.clear
+
+      if busy.any?
+        log(:debug) { "Wait for #{busy.size} workers to terminate." }
+
+        wait :shutdown
+      end
+
+      log(:debug) { 'Graceful shutdown done.' }
+    end
+
+    # Check if a worker is available.
+    #
+    # @return [Boolean] True if at least on idle worker is available, false otherwise.
+    #
+    def available?
+      idle.any?
+    end
+
+    def messages
+      @message ||= []
+    end
+
+    # Dispatch given message to a worker.
+    #
+    def dispatch(message, *args)
+      messages.push [message, args]
+      after(0) { signal :dispatch }
+    end
+
+    # Called by worker to indicated it has finished processing.
+    #
+    # @param [Pool::Worker] worker Worker that finished processing.
+    #
+    def executed(worker)
+      busy.delete worker
+
+      if running?
+        idle << worker
+        poll worker
+      else
+        log(:debug) { "Terminate worker. Still #{busy.size} to go..." }
+
+        worker.terminate if worker.alive?
+        if busy.empty?
+          log(:debug) { 'All worker down. Signal :shutdown.' }
+          after(0) { signal :shutdown }
+        end
+      end
+    end
+
+    def poll(worker)
+      return unless worker.alive?
+
+      if running?
+        if (message = exclusive { messages.shift })
+          idle.delete worker
+          busy << worker
+
+          worker.dispatch message[0], message[1]
+        else
+          after(1) { poll worker }
+        end
+      else
+        worker.terminate if worker.alive?
+        after(0) { signal(:shutdown) } if @busy.empty?
+      end
+    end
+
+    def to_s
+      "#{self.class.name}[#{@runner_klass}]<#{object_id}>"
+    end
+
+    # Worker actor capsuling worker logic and dispatching
+    # tasks to custom runner object.
+    #
+    class Worker
+      include Celluloid
+      include Logging
+      attr_reader :pool, :index, :runner
+
+      def initialize(pool, index, runner_klass, runner_args)
+        @pool     = pool
+        @poolname = pool.to_s
+        @index    = index
+        @runner   = runner_klass.new *runner_args
+
+        log(:debug) { 'Worker ready.' }
+      end
+
+      # Dispatch given method and argument to custom runner.
+      # Arguments are used to call `#send` on runner instance.
+      #
+      def dispatch(method, args)
+        log(:debug) { "Dispatch to runner: #{runner.class.name}##{method.to_s}" }
+
+        # Send method to custom runner.
+        runner.send method, *args
+      rescue => error
+        log(:error) { "Received error from runner: #{error.message}\n#{error.backtrace.join("    \n")}" }
+      ensure
+        pool.executed Actor.current
+      end
+
+      def to_s
+        "#{@poolname}[##{index}]"
+      end
+    end
+  end
+end

data/lib/msgr/route.rb

@@ -0,0 +1,26 @@
+module Msgr
+
+  class Route
+    attr_reader :consumer, :action, :opts, :key
+    alias_method :routing_key, :key
+
+    def initialize(key, opts = {})
+      @key  = key.to_s
+      @opts = opts
+
+      raise ArgumentError.new 'Routing key required.' unless @key.present?
+      raise ArgumentError.new 'Missing `to` options.' unless @opts[:to]
+
+      if (match = /\A(?<consumer>\w+)#(?<action>\w+)\z/.match(opts[:to].strip.to_s))
+        @consumer = "#{match[:consumer].camelize}Consumer"
+        @action   = match[:action].underscore
+      else
+        raise ArgumentError.new "Invalid consumer format: #{opts[:to].strip.to_s.inspect}. Must be `consumer_class#action`."
+      end
+    end
+
+    def name
+      "msgr.consumer-#{key}//#{consumer}##{action}"
+    end
+  end
+end

data/lib/msgr/routes.rb

@@ -0,0 +1,18 @@
+module Msgr
+
+  class Routes
+    delegate :each, to: :@routes
+
+    def routes
+      @routes ||= []
+    end
+
+    def configure(&block)
+      instance_eval &block
+    end
+
+    def route(key, opts = {})
+      routes << Msgr::Route.new(key, opts)
+    end
+  end
+end

data/lib/msgr/version.rb

@@ -0,0 +1,11 @@
+module Msgr
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 0
+    STAGE = nil
+    STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.')
+
+    def self.to_s; STRING end
+  end
+end

data/msgr.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'msgr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'msgr'
+  spec.version       = Msgr::VERSION
+  spec.authors       = ['Jan Graichen']
+  spec.email         = ['jg@altimos.de']
+  spec.description   = %q{}
+  spec.summary       = %q{}
+  spec.homepage      = 'https://github.com/jgraichen/msgr'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency 'activesupport'
+  spec.add_dependency 'bunny', '~> 0.10.0'
+  spec.add_dependency 'celluloid'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'coveralls'
+end

data/scripts/simple_test.rb

@@ -0,0 +1,114 @@
+require 'msgr'
+
+Msgr.logger.level = Logger::Severity::DEBUG
+
+@client = Msgr::Client.new uri: 'amqp://msgr:msgr@localhost'
+
+@client.routes.configure do
+  route 'abc.#', to: 'test#index'
+  route 'cde.#', to: 'test#index'
+  route '#', to: 'test#another_action'
+end
+
+@client.start
+
+10.times do |i|
+  @client.publish 'abc.XXX', "Message #{i} #{rand}"
+end
+
+sleep 5
+
+@client.routes.configure do
+  route 'abc.#', to: 'test#index'
+end
+
+@client.reload
+
+10.times do |i|
+  @client.publish 'abc.XXX', "Message #{i} #{rand}"
+end
+
+begin
+  sleep
+rescue Interrupt
+  @client.stop
+end
+
+#class Dispatcher
+#  include Msgr::Logging
+#
+#  def call(message)
+#    log(:info) { message }
+#    sleep 5 * rand
+#    log(:info) { 'Done' }
+#  end
+#end
+#
+#pool = Msgr::Pool.new Dispatcher, size: 10
+#pool.start
+#
+#100.times do |i|
+#  pool.dispatch(:call, "Message ##{i}")
+#end
+#
+#sleep 5
+#
+#pool.stop
+#pool.terminate
+#
+#Msgr.logger.info('[ROOT]') { 'Pool terminated.' }
+
+#require 'celluloid'
+#
+#class Worker
+#  include Celluloid
+#
+#  def do_work
+#    sleep 15
+#  end
+#end
+#
+#logger = Logger.new $stdout
+#
+#pool = Worker.pool
+#
+#logger.info 'Start work'
+#
+#4.times do |i|
+#  pool.async.do_work
+#end
+#
+#logger.info 'Wait'
+#
+#sleep 5
+#
+#logger.info 'Terminate'
+#
+#pool.terminate
+#
+#logger.info 'Done.'
+
+
+#require 'bunny'
+#
+#bunny = Bunny.new 'amqp://msgr:msgr@localhost'
+#bunny.start
+#
+#channel  = bunny.create_channel
+#exchange = channel.topic 'msgr.topic'
+#queue    = channel.queue 'msgr.test.single-queue'
+#
+#queue.bind(exchange, routing_key: 'a.b.#')
+#queue.bind(exchange, routing_key: 'a.c.#')
+#queue.subscribe do |delivery_info, metadata, payload|
+#  puts "#{delivery_info.routing_key} #{payload}"
+#end
+#
+#sleep 1
+#
+#10.times { |i| exchange.publish "Message ##{i}", routing_key: [ 'a.b.c', 'a.c.d', 'a.b', 'a' ].sample; sleep 0.2 }
+#
+#sleep 10
+#
+#channel.close
+#bunny.close

data/spec/msgr/client_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Msgr::Client do
+
+end

data/spec/msgr/consumer_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+# describe Msgr::Consumer do
+#
+# end

data/spec/msgr/route_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Msgr::Route do
+  let(:routing_key) { 'routing.key.#' }
+  let(:options) { {to: 'test#index'} }
+  let(:args) { [routing_key, options] }
+  let(:route) { Msgr::Route.new *args }
+  subject { route }
+
+  describe '#initialize' do
+    it 'should require `to` option' do
+      expect {
+        Msgr::Route.new(routing_key, {})
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should require routing_key' do
+      expect {
+        Msgr::Route.new nil, options
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should require not empty routing_key' do
+      expect {
+        Msgr::Route.new '', options
+      }.to raise_error ArgumentError, /routing key required/i
+    end
+
+    it 'should require `to: "consumer#action` format' do
+      expect {
+        Msgr::Route.new routing_key, to: 'abc'
+      }.to raise_error ArgumentError, /invalid consumer format/i
+    end
+  end
+
+  describe '#consumer' do
+    it 'should return consumer class name' do
+      expect(route.consumer).to eq 'TestConsumer'
+    end
+
+    context 'with underscore consumer name' do
+      let(:options) { super().merge to: 'test_resource_foo#index' }
+
+      it 'should return camelized method name' do
+        expect(route.consumer).to eq 'TestResourceFooConsumer'
+      end
+    end
+  end
+
+  describe '#action' do
+    it 'should return action method name' do
+      expect(route.action).to eq 'index'
+    end
+
+    context 'with camelCase action name' do
+      let(:options) { super().merge to: 'test#myActionMethod' }
+
+      it 'should return underscore method name' do
+        expect(route.action).to eq 'my_action_method'
+      end
+    end
+  end
+end

data/spec/msgr/routes_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Msgr::Routes do
+  let(:routes) { Msgr::Routes.new }
+
+  describe '#configure' do
+    let(:block) { Proc.new{} }
+
+    it 'should evaluate given block within instance context' do
+      expect(routes).to receive(:instance_eval).with { |p| p == block }
+
+      routes.configure &block
+    end
+
+    it 'should allow to call instance method in gven block' do
+      expect(routes).to receive(:test_instance_method).with(:abc)
+
+      routes.configure do
+        test_instance_method :abc
+      end
+    end
+  end
+
+  describe '#each' do
+    before do
+      routes.configure do
+        route 'abc.#', to: 'test#index'
+        route 'edf.#', to: 'test#index'
+      end
+    end
+
+    let(:each) { routes.each }
+
+    it 'should iterate over configured routes' do
+      expect(each).to have(2).items
+
+      expect(each.map(&:routing_key)).to be == %w(abc.# edf.#)
+      expect(each.map(&:consumer)).to be == %w(TestConsumer TestConsumer)
+      expect(each.map(&:action)).to be == %w(index index)
+    end
+  end
+
+  describe '#route' do
+    let(:subject) { -> { routes.route 'routing.key', to: 'test2#index2' } }
+    let(:last_route) { routes.routes.last }
+
+    it 'should add a new route' do
+      expect { subject.call }.to change{ routes.routes.size }.from(0).to(1)
+    end
+
+    it 'should add given route' do
+      subject.call
+
+      expect(last_route.routing_key).to eq 'routing.key'
+      expect(last_route.consumer).to eq 'Test2Consumer'
+      expect(last_route.action).to eq 'index2'
+    end
+  end
+end

data/spec/msgr_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Msgr do
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# Coverage
+require 'coveralls'
+Coveralls.wear! do
+  add_filter 'spec'
+end
+
+require 'rspec/autorun'
+require 'msgr'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.expect_with :rspec do |c|
+    # Only allow expect syntax
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: msgr
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Jan Graichen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: coveralls
+  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'
+description: ''
+email:
+- jg@altimos.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemfiles/Gemfile.rails-3-2
+- gemfiles/Gemfile.rails-4-0
+- lib/msgr.rb
+- lib/msgr/binding.rb
+- lib/msgr/client.rb
+- lib/msgr/connection.rb
+- lib/msgr/dispatcher.rb
+- lib/msgr/errors.rb
+- lib/msgr/logging.rb
+- lib/msgr/message.rb
+- lib/msgr/pool.rb
+- lib/msgr/route.rb
+- lib/msgr/routes.rb
+- lib/msgr/version.rb
+- msgr.gemspec
+- scripts/simple_test.rb
+- spec/msgr/client_spec.rb
+- spec/msgr/consumer_spec.rb
+- spec/msgr/route_spec.rb
+- spec/msgr/routes_spec.rb
+- spec/msgr_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jgraichen/msgr
+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.0.6
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- spec/msgr/client_spec.rb
+- spec/msgr/consumer_spec.rb
+- spec/msgr/route_spec.rb
+- spec/msgr/routes_spec.rb
+- spec/msgr_spec.rb
+- spec/spec_helper.rb