clamour 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c538fa93962a76a40adc4ec472568e4031afc62e
+  data.tar.gz: 8baedf6473d5583de04104b7d06c499a1ce91433
+SHA512:
+  metadata.gz: b0e515196e09c2fc221fbdb7f3b7bee9299b3744cbaa68a45f0463ab6b3d469575cf062f90793c0ff6911c19d00c0f02c16d6ddd1c41d21b5f483cdd860ce019
+  data.tar.gz: e3f23238c4be0da7773f3509be978c04f8bc1f5a72c8b07858d336d326302ddaeea2af2d261f903c1a3af709c2e8240c9df19472896aa7f866015e97135894b0

data/.gitignore

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

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/EXAMPLE.md

@@ -0,0 +1,49 @@
+# End-to-end example
+
+The first thing you need to do is to declare a message class, and a handler class.
+Let's assume the handler writes a file in /tmp based on a message.
+
+Here is a message, that is sent by an exquisitely sophisticated blog application:
+
+```
+require 'clamour'
+
+module Blog
+  module Post
+    class Added
+      include Clamour::Message
+      
+      attribute :name, String
+      attribute :content, String
+    end
+  end
+end
+```
+
+To publish it run in ruby console:
+
+    message = Blog::Post::Added.new(name: 'My first blog post!', content: 'I am proud')
+    message.publish
+    
+Make sure the command does not hang.
+
+First, make sure the message is received where you expect it to be. Try to receive what is wired through the rabbitmq.
+Open a terminal, and type:
+
+    require 'clamour'
+    bus = Clamour::Bus.new
+    bus.subscribe do |delivery|
+        puts delivery.inspect
+    end
+    
+Next open another terminal, and publish the message as shown above. You should expect a message json to appear.
+
+Then open another terminal, and start "subscription", i.e. process of enqueuing handler as a Sidekiq job:
+
+    require 'clamour'
+    Clamour::Subscription.new.perform
+    
+Then open yet another terminal, and run sidekiq there.
+
+Now, if you publish the message again, you should see the handler as a sidekiq job, and a file in /tmp folder.
+

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sergey Ukustov
+
+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,211 @@
+# Clamour
+
+Fancy messaging library for Ruby. It could, and should be used as a basis for asynchronous systems written in Ruby.
+It uses [RabbitMQ](http://www.rabbitmq.com/) as a transport mechanism, and [Sidekiq](http://mperham.github.io/sidekiq/)
+as a substrate to run message handlers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem 'clamour'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install clamour
+
+## Configuration
+
+Configuration of the messaging system is contained in an instance of `Clamour::Configuration` class.
+You could instantiate it using a hash of parameters:
+
+```
+configuration = Clamour::Configuration.new(logger: MonoLogger.new(STDERR), enable_connection: false)
+```
+
+or you could use accessors:
+
+```
+configuration = Clamour::Configuration.new
+configuration.exchange = 'com.example.exchange'
+```
+
+If you intend to use the default Clamour configuration stored in `Clamour.configuration`, you could use a shortcut:
+
+```
+Clamour.configure do |config|
+    config.rabbit_mq.host = '127.0.0.1'
+    config.rabbit_mq.user = 'admin'
+    config.rabbit_mq.pass = 'Ad$1n'
+    config.exchange = 'com.example.exchange'
+end
+```
+
+You could put configuration code like this in a Rails initializer.
+
+NB. By default connection to RabbitMQ is disabled when Rails is in test mode.
+
+## Usage
+
+### Send a message
+
+`Clamour::Message` is just a fancy hash serialized into 
+JSON (using fabulous [Oj](https://github.com/ohler55/oj) gem) to be sent over RabbitMQ.
+A message has a special attribute `_type` which distinguishes different
+messages, and is added to a hash of message attributes. By default it is set to a snake cased,
+dot delimited message class name. For example,
+
+```
+class Foo::Blah
+  include Clamour::Message
+  attribute :bar, String
+end
+foo = Foo::Blah.new(bar: 'baz')
+Oj.dump(foo, mode: :compat)
+# => {"_type":"foo.blah","bar":"baz"}
+```
+
+To publish a message, call `#publish` on it. By default the method uses global configuration in `Clamour.configuration`.
+If you want to publish the message to somewhere special, pass an additional parameter to call:
+
+```
+foo.publish
+# is equal to
+foo.publish(Clamour.configuration)
+# but a call below is different:
+foo.publish(white_rabbit_mq_configuration)
+```
+
+The method `#publish` here really wraps an original message into a message of class Clamour::Message::Sent.
+Only latter is really serialized and sent over the wire. So, effectively `foo.publish` would send JSON like this:
+
+```
+{"_type":"clamour.message.sent","payload":{"_type":"foo.blah","bar":"baz"}}
+```
+
+To set attributes, please, see documentation on [Virtus](https://github.com/solnic/virtus). If you intend to use
+more complex object as an attribute value than a String, Fixnum, or Boolean, make sure the value can be serialized to JSON.
+You can check it by doing something like this:
+```
+complex_object = ExtraComplexObject.new
+Oj.dump(complex_object, mode: :compat)
+```
+For specific criteria making an object serializable, refer to [Oj](https://github.com/ohler55/oj) documentation.
+
+### Receive a message
+
+To decide what action should be run when a message comes, `Clamour::Registry` is used.
+Effectively it maps message type to an array of handler classes.
+
+To register a handler for a message one could use method `#on`:
+
+```
+Clamour.registry.on Foo::Blah => Foo::Blah::Receive
+```
+
+or employ a shortcut for mass-registration:
+
+```
+Clamour.registry.change do
+  on Foo::Blah => Foo::Blah::Receive
+  on Rabbit::White::Appeared => Rabbit::White::Follow
+end
+```
+
+Handler registration could be put inside Rails initializer.
+
+`Clamour::Bus#subscribe` gets every JSON delivery from RabbitMQ, and sends it to a provided block.
+Registry is then used to determine what handler to invoke:
+
+```
+bus.subscribe do |delivered_hash|
+  message_type = delivered_hash[:_type]
+  registry.route(message_tye) do |handler_class, message_class|
+    # Instantiate handler and pass message
+  end
+end
+```
+
+### Do something
+
+An actual handler must run independently of the subscription process. For this few instruments could be used.
+Clamour offloads handler running to Sidekiq. The previous code example effectively turns into
+
+```
+bus.subscribe do |delivered_hash|
+  message_type = delivered_hash[:_type]
+  registry.route(message_tye) do |handler_class, message_class|
+    handler_class.perform_async(message_class.new(delivered_hash) # Kind of
+  end
+end
+```
+
+Real code is different, because of fancy fractal structure of the library: a message that you publish really is wrapped
+inside `Clamour::Message::Sent`, and intercepted later by a handler of class `Clamour::Message::Receive`. The latter
+routes wrapped message to an actual handler. You do not have to worry about it though.
+
+A handler is a class that implements method `on_message(message)`, and includes module `Clamour::Handler`. You should expect `message` argument to
+be an instance of the message class that you set in registry. For a registry
+
+```
+Clamour.registry.change do
+  on Messaging::Foo::Done => Messaging::Blah::Do
+end
+
+class Messaging::Blah::Do
+  include Clamour::Handler
+  
+  # @param [Messaging::Foo::Done] message
+  def on_message(message)
+    # Do Something
+  end
+end
+```
+
+### And now all together
+
+If you use the gem inside a Rails application, create an initializer, for example in
+"config/initializers/clamour.rb" to set up Clamour to accept message `Messaging::Foo::Done` and pass it to a handler
+`Messaging::Blah::Do`:
+
+```
+require 'clamour'
+
+Clamour.configure do |config|
+ config.exchange = 'special'
+ # And other changes to default configuration
+end
+
+Clamour.registry.change do 
+ on Messaging::Foo::Done => Messaging::Blah::Do
+end
+```
+
+Then you have to start a subsription process. If you use Rails, Sidekiq, and Foreman,
+all you need to do is to add a line to your Procfile:
+
+```
+subscriber: bundle exec rake clamour:subscribe
+```
+
+If the technological stack is different, you could figure out what to do just by looking at `clamour:subscribe`
+rake task source code.
+
+## TODO
+
+* More testing.
+* Scheduled messages: send message in the future.
+
+## Contributing
+
+1. Fork it ( https://github.com/provectus/caruso/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,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = 'test/*_test.rb'
+end
+
+task :default => :test

data/clamour.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clamour/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'clamour'
+  spec.version       = Clamour::VERSION
+  spec.authors       = ['Sergey Ukustov']
+  spec.email         = ['sergey@ukstv.me']
+  spec.summary       = %q{Fancy messaging library}
+  spec.description   = %q{Fancy messaging library for Ruby}
+  spec.homepage      = ''
+  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_runtime_dependency 'amqp'
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'oj'
+  spec.add_runtime_dependency 'virtus'
+  spec.add_runtime_dependency 'mono_logger'
+  spec.add_runtime_dependency 'sidekiq'
+
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/foo_handler.rb

@@ -0,0 +1,23 @@
+require 'clamour'
+
+class Foo
+  include Clamour::Message
+
+  attribute :blah, String
+end
+
+f = Foo.new(blah: 'yaa')
+f.publish
+
+class FooHandler
+  include Clamour::Handler
+
+  # @param [Foo] foo
+  def on_message(foo)
+    File.open('/tmp/a.txt', 'w') do |f|
+      f.puts Time.now.to_s
+      f.puts foo.blah
+      f.puts '----' * 10
+    end
+  end
+end

data/lib/clamour.rb

@@ -0,0 +1,49 @@
+require 'clamour/version'
+require 'active_support/dependencies/autoload'
+
+module Clamour
+  extend ActiveSupport::Autoload
+
+  autoload :Bus
+  autoload :Configuration
+  autoload :Handler
+  autoload :Message
+  autoload :Registry
+  autoload :Message
+  autoload :Subscription
+
+  # Clamour-wide configuration.
+  #
+  # @return [Clamour::Configuration]
+  def self.configuration
+    @configuration ||= Clamour::Configuration.new
+  end
+
+  # Shortcut for Clamour-wide configuration.
+  # @yield [Clamour::Configuration]
+  #
+  # @example
+  #     Clamour.configure do |config|
+  #       config.exchange = 'com.example.exchange'
+  #       config.logger = MonoLogger.new(STDOUT)
+  #     end
+  # @see Clamour::Configuration
+  def self.configure(&block)
+    block.call(configuration) if block_given?
+  end
+
+  # Clamour-wide message handlers registry.
+  #
+  # @example To add handlers
+  #     Clamour.registry.change do
+  #       on Social::User::New => Social::User::Greeting::Send
+  #     end
+  # @see Clamour::Registry
+  def self.registry
+    @registry ||= Clamour::Registry.new do
+      on Clamour::Message::Sent => Clamour::Message::Receive
+    end
+  end
+end
+
+require 'clamour/railtie' if defined?(Rails)

data/lib/clamour/bus.rb

@@ -0,0 +1,134 @@
+require 'amqp'
+require 'active_support/core_ext/hash'
+require 'active_support/hash_with_indifferent_access'
+require 'oj'
+
+class Clamour::Bus
+
+  class WrongContentTypeError < RuntimeError
+    # If not JSON.
+  end
+
+  # @return [Clamour::Configuration]
+  attr_reader :configuration
+
+  # @return [Hash]
+  attr_reader :connection_settings
+
+  # @return [String]
+  attr_reader :exchange_name
+
+  # @return [Logger]
+  attr_reader :logger
+
+  # @param [Clamour::Configuration] configuration
+  def initialize(configuration = Clamour.configuration)
+    @configuration = configuration
+    @connection_settings = configuration.rabbit_mq.to_hash
+    @exchange_name = configuration.exchange
+    @logger = configuration.logger
+  end
+
+  # @param [Clamour::Message] message
+  def publish(message)
+    if EM.reactor_running?
+      em_publish(message)
+    else
+      EM.run do
+        em_publish(message) do
+          EM.stop
+        end
+      end
+    end
+  end
+
+  def subscribe(&block)
+    if EM.reactor_running?
+      em_subscribe(&block)
+    else
+      EM.run do
+        em_subscribe(&block)
+      end
+    end
+  end
+
+  # @param [Clamour::Message] message
+  def em_publish(message, &block)
+    logger.debug "Message #{message.inspect} is going to be published"
+    if configuration.enable_connection?
+      AMQP.connect(connection_settings) do |connection|
+        AMQP::Channel.new(connection) do |channel|
+          channel.fanout(exchange_name, durable: true) do |exchange|
+            options = { content_type: 'application/json' }
+            exchange.publish(dump_json(message), options) do
+              logger.debug "Message #{message.inspect} is published to #{exchange_name}"
+              connection.disconnect do
+                block.call if block_given?
+              end
+            end
+          end
+        end
+      end
+    else
+      logger.debug "Connection is disabled. Message #{message.inspect} is not really published"
+      block.call if block_given?
+    end
+  end
+
+  def em_subscribe(&block)
+    raise ArgumentError.new('You have to provide a block') unless block_given?
+
+    if configuration.enable_connection?
+      AMQP.connect(connection_settings) do |connection|
+        before_shutdown do
+          connection.close do
+            EM.stop
+          end
+        end
+
+        AMQP::Channel.new(connection) do |channel|
+          channel.fanout(exchange_name, durable: true) do |exchange|
+            EM.schedule do
+              channel.queue('', exclusive: true) do |queue|
+                queue.bind(exchange).subscribe do |header, delivery|
+                  message_hash =
+                      case header.content_type
+                        when 'application/json'
+                          ActiveSupport::HashWithIndifferentAccess.new(load_json(delivery))
+                        else
+                          raise WrongContentTypeError.new("Got #{delivery.inspect} for content type #{header.content_type}")
+                      end
+                  logger.debug "Got hash #{message_hash}"
+                  block.call(message_hash)
+                end
+              end
+            end
+          end
+        end
+      end
+    else
+      logger.info 'Connection is disabled. Doing nothing...'
+      before_shutdown { EM.stop }
+    end
+  end
+
+  # Do something gentle on SIGINT
+  def before_shutdown(&block)
+    Signal.trap('INT') do
+      logger.info 'Shutting down on SIGINT...'
+      block.call if block_given?
+    end
+  end
+
+  # @param [Clamour::Message] message
+  # @return [String]
+  def dump_json(message)
+    Oj.dump(message, mode: :compat)
+  end
+
+  # @param [String] json
+  # @return [Hash]
+  def load_json(json)
+    Oj.load(json)
+  end
+end

data/lib/clamour/configuration.rb

@@ -0,0 +1,32 @@
+require 'clamour/version'
+require 'active_support/dependencies/autoload'
+require 'mono_logger'
+
+class Clamour::Configuration
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :RabbitMqConfiguration
+
+  include Clamour::Configuration::Base
+
+  attribute :rabbit_mq, RabbitMqConfiguration, default: RabbitMqConfiguration.new
+  attribute :exchange, String, default: 'clamour.exchange'
+  attribute :logger, Logger, default: :default_logger
+  attribute :enable_connection, Boolean, default: :default_enable_connection
+
+  # @return [Logger]
+  def default_logger
+    MonoLogger.new(STDERR)
+  end
+
+  # @return [Boolean]
+  def default_enable_connection
+    !(defined?(Rails) && Rails.env.test?)
+  end
+
+  # @return [Boolean]
+  def enable_connection?
+    enable_connection
+  end
+end

data/lib/clamour/configuration/base.rb

@@ -0,0 +1,15 @@
+require 'virtus'
+
+module Clamour::Configuration::Base
+  include Virtus.module
+
+  # @return [Boolean]
+  def eql?(other)
+    other.respond_to?(:attributes) && attributes.eql?(other.attributes)
+  end
+
+  # @return [Fixnum]
+  def hash
+    attributes.hash
+  end
+end

data/lib/clamour/configuration/rabbit_mq_configuration.rb

@@ -0,0 +1,9 @@
+class Clamour::Configuration::RabbitMqConfiguration
+  include Clamour::Configuration::Base
+
+  attribute :host, String, default: 'localhost'
+  attribute :port, Fixnum, default: 5672
+  attribute :user, String, default: 'guest'
+  attribute :pass, String, default: 'guest'
+  attribute :vhost, String, default: '/'
+end

data/lib/clamour/handler.rb

@@ -0,0 +1,52 @@
+require 'sidekiq'
+require 'active_support/concern'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/string'
+
+module Clamour::Handler
+  extend ActiveSupport::Concern
+
+  included do
+    include Sidekiq::Worker
+  end
+
+  module ClassMethods
+
+    # Special thing for internal purposes only. Just implement +on_message(message)+ method.
+    #
+    # @param [Clamour::Message] message
+    # @param [Clamour::Subscription] subscription
+    def perform(message, subscription)
+      perform_async(message.class.to_s, message.to_hash)
+    end
+  end
+
+  # Like a usual Sidekiq job.
+  #
+  # @param [String] message_class_name
+  # @param [Hash] message_attributes
+  def perform(message_class_name, message_attributes)
+    message = restore_message(message_class_name, message_attributes)
+    on_message(message)
+  end
+
+  # @abstract You must use +on_message+ method to act on a message.
+  # @param [Clamour::Message] message
+  def on_message(message)
+    raise NotImplementedError.new('You must override "on_message" method to act on a message')
+  end
+
+  protected
+
+  # Deserialize message of Sidekiq-passed parameters.
+  #
+  # @param [String] message_class_name
+  # @param [Hash] message_attributes
+  # @return [Clamour::Message]
+  def restore_message(message_class_name, message_attributes)
+    message_class = message_class_name.constantize
+    message_class.new(message_attributes)
+  end
+
+end

data/lib/clamour/message.rb

@@ -0,0 +1,44 @@
+require 'active_support/inflector'
+require 'active_support/concern'
+require 'active_support/dependencies/autoload'
+require 'virtus'
+
+# What is sent over the wire.
+module Clamour::Message
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+  include Virtus.module
+
+  autoload :Sent
+  autoload :Receive
+
+  module ClassMethods
+    # Voluntarily set message type.
+    #
+    # @param [String] new_value
+    # @example
+    #     class Parcel < Clamour::Message
+    #       of_type 'snail.mail'
+    #     end
+    def of_type(new_value = nil)
+      @type = new_value.to_s
+    end
+
+    # Message type. By default it is snake cased class name.
+    #
+    # @return [String]
+    def type
+      @type ||= ActiveSupport::Inflector.underscore(to_s).gsub('/', '.')
+    end
+  end
+
+  # It is highly unlikely someone would use `_type` as a name, so we use it to store service information,
+  # namely message type.
+  attribute :_type, String, default: ->(message, _) { message.class.type }
+
+  def publish(configuration = Clamour.configuration)
+    bus = Clamour::Bus.new(configuration)
+    sent_message = Clamour::Message::Sent.new(payload: self)
+    bus.publish(sent_message)
+  end
+end

data/lib/clamour/message/receive.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/hash'
+require 'active_support/hash_with_indifferent_access'
+
+# Unpack message and reroute it using the same {Clamour::Subscription}.
+class Clamour::Message::Receive
+  include Clamour::Handler
+
+  # @param [Clamour::Message::Sent] wired
+  # @param [Clamour::Subscription] subscription
+  def self.perform(wired, subscription)
+    attributes = ActiveSupport::HashWithIndifferentAccess.new(wired.payload)
+    type = attributes[:_type]
+    subscription.route(type, attributes)
+  end
+end

data/lib/clamour/message/sent.rb

@@ -0,0 +1,5 @@
+class Clamour::Message::Sent
+  include Clamour::Message
+
+  attribute :payload, Object
+end

data/lib/clamour/railtie.rb

@@ -0,0 +1,5 @@
+class Clamour::Railtie < Rails::Railtie
+  rake_tasks do
+    load 'tasks/clamour_subscribe.rake'
+  end
+end

data/lib/clamour/registry.rb

@@ -0,0 +1,47 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/array'
+
+class Clamour::Registry
+
+  # @return [Hash<Set<Class>>] store handler classes
+  attr_reader :handlers
+
+  # @return [Hash]
+  attr_reader :message_classes
+
+  def initialize(&block)
+    @handlers = Hash.new { |mapping, type| mapping[type] = Set.new }
+    @message_classes = Hash.new
+    change(&block) if block_given?
+  end
+
+  def route(type, &block)
+    raise ArgumentError.new('Something has to be routed') if type.blank?
+    message_class = message_classes[type]
+    found_handlers = handlers[type]
+    if message_class.present? && found_handlers.present?
+      found_handlers.each do |handler|
+        block.call(handler, message_class)
+      end
+    else
+      puts "Could not find message class or handler for #{type}"
+    end
+  end
+
+  def change(&block)
+    instance_eval(&block)
+    self
+  end
+
+  def on(mappings = {})
+    mappings.each do |message_class, handlers_list|
+      raise ArgumentError.new("#{message_class} must include Clamour::Message") unless message_class < Clamour::Message
+      Array.wrap(handlers_list).flatten.compact.each do |handler|
+        raise ArgumentError.new("Handler #{handler} must be a class") unless handler.is_a?(Class)
+        message_type = message_class.type
+        message_classes[message_type] = message_class
+        handlers[message_type].add(handler)
+      end
+    end
+  end
+end

data/lib/clamour/subscription.rb

@@ -0,0 +1,36 @@
+class Clamour::Subscription
+  # @return [Clamour::Configuration]
+  attr_reader :configuration
+
+  # @return [Logger]
+  attr_reader :logger
+
+  # @return [Clamour::Registry]
+  attr_reader :registry
+
+  # @param [Clamour::Configuration] configuration
+  def initialize(configuration = Clamour.configuration, registry = Clamour.registry)
+    @configuration = configuration
+    @logger = configuration.logger
+    @registry = registry
+  end
+
+  def perform
+    bus.subscribe do |received_hash|
+      type = received_hash[:_type]
+      route(type, received_hash)
+    end
+  end
+
+  # @param [String] type
+  # @param [Hash] attributes
+  def route(type, attributes)
+    registry.route(type) do |handler_class, message_class|
+      handler_class.perform(message_class.new(attributes), self)
+    end
+  end
+
+  def bus
+    @bus ||= Clamour::Bus.new(configuration)
+  end
+end

data/lib/clamour/version.rb

@@ -0,0 +1,3 @@
+module Clamour
+  VERSION = '0.0.3'
+end

data/lib/tasks/clamour_subscribe.rake

@@ -0,0 +1,7 @@
+namespace :clamour do
+  desc 'Subscribe for Clamour messages'
+  task :subscribe => :environment do
+    require 'clamour'
+    Clamour::Subscription.new.perform
+  end
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: clamour
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Sergey Ukustov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: amqp
+  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: 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: oj
+  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: virtus
+  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: mono_logger
+  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: sidekiq
+  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: 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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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'
+description: Fancy messaging library for Ruby
+email:
+- sergey@ukstv.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- EXAMPLE.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- clamour.gemspec
+- foo_handler.rb
+- lib/clamour.rb
+- lib/clamour/bus.rb
+- lib/clamour/configuration.rb
+- lib/clamour/configuration/base.rb
+- lib/clamour/configuration/rabbit_mq_configuration.rb
+- lib/clamour/handler.rb
+- lib/clamour/message.rb
+- lib/clamour/message/receive.rb
+- lib/clamour/message/sent.rb
+- lib/clamour/railtie.rb
+- lib/clamour/registry.rb
+- lib/clamour/subscription.rb
+- lib/clamour/version.rb
+- lib/tasks/clamour_subscribe.rake
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Fancy messaging library
+test_files: []
+has_rdoc: