msgr 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c7b66e79b0bc86ea60a569f091bb1552a82ed4f
-  data.tar.gz: 3eccf709cf43f74f17898de8340a10456f76f4a9
+  metadata.gz: ddae04ef1c28f7eb451ee8988da5949ab0c97d6e
+  data.tar.gz: 12490c056d64088711f79d9ddc2d8c227015efc0
 SHA512:
-  metadata.gz: 409a4007b8329b9d4952ee58cbc80f637669af1701bcd664401b365b4bf0c34a95a052b89da567487e7051b2ff075a67ea6b92016bff023c8fbd65912a4fce69
-  data.tar.gz: 4cae8599276ef6e5fc7732fa216a63872cb87ed682dfcb497d4c0a47910c94a3e66469eed1c2fa162eca42684f4676cacedb70907357eea3aeee463d92c5533c
+  metadata.gz: 984436fe6ac5ce0783c6a8fabd2039c1d119dcc7c62cb749493818c44c3f6c6c2c6e350efd0555933012b74637e61b140d3dfbf8cf5c7981d2912248eb580e62
+  data.tar.gz: 1fc475e7d83893f7129e4fd6b42736d647cac8b74cd03e93fc1167a331398d44c07ed3964e139e708ff66a19a22e89b17271c066c025b937a3eff07ce1bdd747

data/lib/msgr.rb

@@ -1,22 +1,18 @@
 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 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/keys'
-require 'json'
 
 require 'msgr/logging'
-require 'msgr/binding'
 require 'msgr/client'
 require 'msgr/connection'
 require 'msgr/consumer'
 require 'msgr/dispatcher'
 require 'msgr/errors'
 require 'msgr/message'
-require 'msgr/pool'
 require 'msgr/route'
 require 'msgr/routes'
 
@@ -49,16 +45,8 @@ module Msgr
       @logger = logger
     end
 
-    def after_load(&block)
-      @after_load_callbacks ||= []
-      @after_load_callbacks << block
-    end
-
     def start
       client.start
-      (@after_load_callbacks || []).each do |callback|
-        callback.call client
-      end
       client
     end
   end

data/lib/msgr/client.rb

@@ -1,126 +1,119 @@
-require 'bunny'
-
 module Msgr
 
   class Client
-    include Celluloid
     include Logging
-
-    attr_reader :uri
+    attr_reader :uri, :config
 
     def initialize(config = {})
-      @uri = URI.parse config[:uri] ? config.delete(:uri) : 'amqp://localhost/'
+      @uri          = ::URI.parse config[:uri] ? config.delete(:uri) : 'amqp://localhost/'
       config[:pass] ||= @uri.password
 
-      @uri.user   = config[:user]  ||= @uri.user || 'guest'
-      @uri.scheme = (config[:ssl]  ||= @uri.scheme.to_s.downcase == 'amqps') ? 'amqps' : 'amqp'
-      @uri.host   = config[:host]  ||= @uri.host || '127.0.0.1'
-      @uri.port   = config[:port]  ||= @uri.port
+      @uri.user   = config[:user] ||= @uri.user || 'guest'
+      @uri.scheme = (config[:ssl] ||= @uri.scheme.to_s.downcase == 'amqps') ? 'amqps' : 'amqp'
+      @uri.host   = config[:host] ||= @uri.host || '127.0.0.1'
+      @uri.port   = config[:port] ||= @uri.port
       @uri.path   = config[:vhost] ||= @uri.path.present? ? @uri.path : '/'
-      config.reject! { |_,v| v.nil? }
+      config.reject! { |_, v| v.nil? }
 
       @config = config
-    end
+      @config[:max] ||= 2
 
-    def running?; @running end
-    def log_name; self.class.name end
+      @mutex  = ::Mutex.new
+      @routes = Routes.new
+      @pid    ||= ::Process.pid
 
-    def routes
-      @routes ||= Routes.new
+      log(:info) { "Created new client on process ##{@pid}..." }
     end
 
-    def new_connection
-      @connection = Connection.new @bunny, routes, @pool, prefix: @config[:prefix]
-    end
-
-    def reload
-      raise StandardError.new 'Client not running.' unless running?
-      log(:info) { 'Reload client.' }
-
-      @connection.release
-      @connection.terminate
-
-      log(:debug) { 'Create new connection.' }
-      new_connection
-
-      log(:info) { 'Client reloaded.' }
+    def running?
+      mutex.synchronize do
+        check_process!
+        connection.running?
+      end
     end
 
     def start
-      log(:info) { "Start client to #{uri}" }
+      mutex.synchronize do
+        check_process!
+        return if connection.running?
 
-      init
-      launch
+        log(:info) { "Start on #{uri}..." }
 
-      log(:info) { 'Client started.' }
+        @routes << config[:routing_file] if config[:routing_file].present?
+        @routes.reload
+        connection.bind(@routes)
+      end
     end
 
-    def stop(opts = {})
-      return unless running?
-      opts.reverse_merge! timeout: 10, delete: false
+    def stop
+      mutex.synchronize do
+        check_process!
 
-      stop_connection opts
+        log(:info) { "Stop on #{uri}..." }
 
-      @running = false
-      wait_for_graceful_shutdown opts if opts[:timeout]
+        return unless connection.running?
 
-      log(:debug) { 'Terminating...' }
+        connection.release
+        connection.close
+        dispatcher.shutdown
 
-      if opts[:delete]
-        log(:debug) { 'Delete connection.' }
-        @connection.delete
+        reset
       end
-      @connection.terminate
-      @bunny.stop
-
-      log(:info) { 'Terminated.' }
     end
 
     def publish(payload, opts = {})
-      opts[:routing_key] = opts.delete(:to) if opts[:to]
-      @connection.publish payload, opts
+      mutex.synchronize do
+        check_process!
+        connection.publish payload, opts
+      end
     end
 
-    private
-    def stop_connection(opts)
-      timeout = [opts[:wait_empty].to_i, 1].max
-
-      begin
-        if opts[:wait_empty]
-          log(:info) { "Shutdown requested: Wait until all queues are empty. (TIMEOUT: #{timeout}s)" }
-          @connection.future(:release, true).value timeout
-        else
-          @connection.future(:release).value timeout
-        end
-      rescue TimeoutError
-        log(:warn) { "Could release connection within #{timeout} seconds." }
+    def routes
+      mutex.synchronize do
+        @routes
+      end
+    end
+
+    def release
+      mutex.synchronize do
+        check_process!
+        return unless running?
+
+        connection.release
       end
     end
 
-    def wait_for_graceful_shutdown(opts)
-      timeout = [opts[:timeout].to_i, 0].max
-      log(:info) { "Attempting graceful shutdown within #{timeout} seconds..." }
+    private
+    def mutex
+      @mutex
+    end
+
+    def check_process!
+      unless ::Process.pid == @pid
+        log(:warn) { 'Fork detected. Reset internal state...' }
 
-      @pool.future(:stop).value timeout
-    rescue TimeoutError
-      log(:warn) { "Could not shutdown pool within #{timeout} seconds." }
+        reset
+        @pid           = ::Process.pid
+      end
     end
 
-    def init
-      @bunny = Bunny.new @config
-      @pool  = Pool.new Dispatcher, size: @config[:size]
-      if @config[:routing_file]
-        routes.files << @config[:routing_file]
+    def connection
+      @connection ||= Connection.new(uri, config, dispatcher).tap do
+        log(:debug) { 'Created new connection..' }
       end
+    end
 
-      routes.reload
+    def dispatcher
+      @dispatcher ||= Dispatcher.new(config).tap do
+        log(:debug) { 'Created new dispatcher..' }
+      end
     end
 
-    def launch
-      @bunny.start
-      @pool.start
-      @running = true
-      new_connection
+    def reset
+      @connection    = nil
+      @pool          = nil
+      @channel       = nil
+      @subscriptions = nil
     end
   end
 end

data/lib/msgr/connection.rb

@@ -1,125 +1,125 @@
+require 'bunny'
+require 'multi_json'
+
 module Msgr
 
   class Connection
-    include Celluloid
     include Logging
 
-    attr_reader :conn, :dispatcher, :routes, :opts
-    finalizer :close
-
-    def initialize(conn, routes, dispatcher, opts = {})
-      @conn       = conn
-      @dispatcher = dispatcher
-      @routes     = routes
-      @opts       = opts
+    EXCHANGE_NAME = 'msgr'
 
-      @channel = conn.create_channel
-      @channel.prefetch(10)
+    attr_reader :uri, :config
 
-      bind
+    def initialize(uri, config, dispatcher)
+      @uri        = uri
+      @config     = config
+      @dispatcher = dispatcher
     end
 
-    def rebind
-      release
-      bind
+    def running?
+      subscriptions.any?
     end
 
-    def bind
-      # Create new bindings
-      routes.each { |route| bindings << Binding.new(Actor.current, route, dispatcher) }
+    def publish(payload, opts = {})
+      opts[:routing_key] = opts.delete(:to) if opts[:to]
+
+      begin
+        payload = MultiJson.dump(payload)
+        exchange.publish payload, opts.merge(persistent: true, content_type: 'application/json')
+      rescue => error
+        exchange.publish payload.to_s, opts.merge(persistent: true, content_type: 'application/text')
+      end
 
-      log(:debug) { 'New routes bound.' }
+      log(:debug) { "Published message to #{opts[:routing_key]}" }
     end
 
-    def prefix(name = '')
-      opts[:prefix] ? "#{opts[:prefix]}-#{name}" : name
+    def connection
+      @connection ||= ::Bunny.new(config).tap { |b| b.start }
     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 ||= []
+    def channel
+      @channel ||= connection.create_channel
     end
 
-    def queue(name)
-      @channel.queue(prefix(name), durable: true).tap do |queue|
-        log(:debug) { "Create queue #{queue.name} (durable: #{queue.durable?}, auto_delete: #{queue.auto_delete?})" }
-      end
+    def release
+      subscriptions.each { |subscription| subscription.cancel }
     end
 
-    def exchange
-      unless @exchange
-        @exchange = @channel.topic prefix('msgr'), durable: true
+    def subscriptions
+      @subscription ||= []
+    end
 
-        log(:debug) { "Created exchange #{@exchange.name} (type: #{@exchange.type}, durable: #{@exchange.durable?}, auto_delete: #{@exchange.auto_delete?})" }
+    def prefix(name)
+      if config[:prefix].present?
+        "#{config[:prefix]}-#{name}"
+      else
+        name
       end
-
-      @exchange
     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(wait = false)
-      return unless bindings.any?
-
-      log(:debug) { "Release all bindings#{wait ? ' after queues are empty': ''}..." }
-
-      if wait
-        binds = bindings.dup
-        while binds.any?
-          binds.reject! { |b| b.release_if_empty }
-          sleep 1
+    def exchange
+      @exchange ||= channel.topic(prefix(EXCHANGE_NAME), durable: true).tap do |ex|
+        log(:debug) do
+          "Created exchange #{ex.name} (type: #{ex.type}, " \
+              "durable: #{ex.durable?}, auto_delete: #{ex.auto_delete?})"
         end
-      else
-        bindings.each &:release
       end
-
-      log(:debug) { 'All bindings released.' }
     end
 
-    def delete
-      return unless bindings.any?
-
-      log(:debug) { 'Delete all bindings and exchange.' }
-
-      bindings.each { |binding| binding.delete }
-      bindings.clear
-
-      @exchange.delete if @exchange
+    def queue(name)
+      channel.queue(prefix(name), durable: true).tap do |queue|
+        log(:debug) do
+          "Create queue #{queue.name} (durable: #{queue.durable?}, " \
+          "auto_delete: #{queue.auto_delete?})"
+        end
+      end
     end
 
-    def publish(payload, opts = {})
-      opts[:routing_key] ||= opts[:to]
-      raise ArgumentError, 'Missing routing key.' unless opts[:routing_key]
-
-      log(:debug) { "Publish message to #{opts[:routing_key]}" }
-
-      begin
-        payload = JSON.generate(payload)
-        exchange.publish payload, opts.merge(persistent: true, content_type: 'application/json')
-      rescue => error
-        exchange.publish payload.to_s, opts.merge(persistent: true, content_type: 'application/text')
+    def bind(routes)
+      if routes.empty?
+        log(:warn) { "No routes to bound to. Bind will have no effect. (#{routes.inspect})" }
+      else
+        bind_all(routes)
       end
     end
 
     def ack(delivery_tag)
-      log(:debug) { "Ack message: #{delivery_tag}" }
-      @channel.ack delivery_tag
+      channel.ack delivery_tag
+      log(:debug) { "Acked message: #{delivery_tag}" }
     end
 
     def reject(delivery_tag, requeue = true)
-      log(:debug) { "Reject message: #{delivery_tag}" }
-      @channel.reject delivery_tag, requeue
+      channel.reject delivery_tag, requeue
+      log(:debug) { "Rejected message: #{delivery_tag}" }
     end
 
     def close
-      @channel.close if @channel.open?
-      log(:debug) { 'Connection closed.' }
+      channel.close    if @channel && @channel.open?
+      connection.close if @connection
+      log(:debug) { 'Closed.' }
+    end
+
+    private
+    def bind_all(routes)
+      routes.each do |route|
+        queue = queue(route.name)
+
+        route.keys.each do |key|
+          log(:debug) { "Bind #{key} to #{queue.name}." }
+
+          queue.bind exchange, routing_key: key
+        end
+
+        subscriptions << queue.subscribe(ack: true) do |*args|
+          begin
+            @dispatcher.call Message.new(self, *args, route)
+          rescue => err
+            log(:error) do
+              "Rescued error from subscribe: #{err.class.name}: #{err}\n#{err.backtrace.join("\n")}"
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/msgr/dispatcher.rb

@@ -1,3 +1,5 @@
+require 'concurrent/cached_thread_pool'
+
 module Msgr
 
   # The Dispatcher receives incoming messages,
@@ -7,13 +9,18 @@ module Msgr
   class Dispatcher
     include Logging
 
-    def call(message)
-      dispatch message
+    attr_reader :pool
 
-      # Acknowledge message unless it is already acknowledged.
-      message.ack unless message.acked?
+    def initialize(config)
+      log(:info) { "Initialize new dispatcher (#{Rails.env})..." }
 
-      log(:warn) { "Message not acked!" } unless message.acked?
+      @pool = ::Concurrent::CachedThreadPool.new(max: config[:max])
+    end
+
+    def call(message)
+      pool.post(message) do |message|
+        dispatch message
+      end
     end
 
     def dispatch(message)
@@ -22,8 +29,18 @@ module Msgr
       log(:debug) { "Dispatch message to #{consumer_class.name}" }
 
       consumer_class.new.dispatch message
+
+      # Acknowledge message unless it is already acknowledged.
+      message.ack unless message.acked?
     rescue => error
-      log(:error) { error }
+      log(:error) do
+        "Dispatcher error: #{error.class.name}: #{error}\n" +
+            error.backtrace.join("\n")
+      end
+    end
+
+    def shutdown
+
     end
 
     def to_s

data/lib/msgr/logging.rb

@@ -2,11 +2,11 @@ module Msgr
 
   module Logging
     def log(level)
-      Msgr.logger.send(level, self.log_name) { yield } if Msgr.logger
+      Msgr.logger.send(level) { "#{self.log_name} #{yield}" } if Msgr.logger
     end
 
     def log_name
-      "[#{Thread.current.object_id}] #{self.to_s}"
+      "[#{Thread.current.object_id.to_s(16)}] <#{self.class.name}[#{object_id.to_s(16)}]>"
     end
   end
 end

data/lib/msgr/message.rb

@@ -1,9 +1,6 @@
 module Msgr
 
-  require 'msgr/message/acknowledge'
-
   class Message
-    include Acknowledge
     attr_reader :delivery_info, :metadata, :payload, :route
 
     def initialize(connection, delivery_info, metadata, payload, route)
@@ -14,12 +11,34 @@ module Msgr
       @route         = route
 
       if content_type == 'application/json'
-        @payload = JSON[payload].symbolize_keys
+        @payload = MultiJson.load(payload)
+        @payload.symbolize_keys! if @payload.respond_to? :symbolize_keys!
       end
     end
 
     def content_type
       @metadata.content_type
     end
+
+    # Check if message is already acknowledged.
+    #
+    # @return [Boolean] True if message is acknowledged, false otherwise.
+    # @api public
+    #
+    def acked?
+      @acked ? true : false
+    end
+
+    # Send message acknowledge to broker unless message is
+    # already acknowledged.
+    #
+    # @api public
+    #
+    def ack
+      unless acked?
+        @acked = true
+        @connection.ack(delivery_info.delivery_tag)
+      end
+    end
   end
 end

data/lib/msgr/railtie.rb

@@ -16,7 +16,6 @@ module Msgr
     initializer 'msgr.start' do
       config.after_initialize do |app|
         Msgr.logger = app.config.msgr.logger
-        Celluloid.logger = app.config.msgr.logger
 
         self.class.load app.config.msgr
       end
@@ -28,26 +27,6 @@ module Msgr
         return unless cfg # no config given -> does not load Msgr
 
         Msgr.config = cfg
-
-        # later loading for e.g. unicorn
-        if Rails.env.development?
-          Msgr.after_load do |client|
-            setup_autoreload client
-          end
-        end
-
-        Msgr.start if cfg[:autostart]
-      end
-
-      def setup_autoreload(client)
-        reloader = ActiveSupport::FileUpdateChecker.new client.routes.files do
-          client.routes.reload
-          client.reload
-        end
-
-        ActionDispatch::Reloader.to_prepare do
-          reloader.execute_if_updated
-        end
       end
 
       def parse_config(cfg)

data/lib/msgr/routes.rb

@@ -1,14 +1,16 @@
 module Msgr
 
   class Routes
+    include Logging
     attr_reader :routes
-    delegate :each, to: :@routes
+    delegate :each, :empty?, :size, :any?, to: :@routes
 
     def initialize
       @routes = []
     end
 
     def configure(&block)
+      blocks << block
       instance_eval &block
     end
 
@@ -16,17 +18,27 @@ module Msgr
       @files ||= []
     end
 
+    def blocks
+      @blocks ||= []
+    end
+
     def files=(files)
       @files = Array files
     end
 
+    def <<(file)
+      files << file
+    end
+
     def reload
       routes.clear
+      blocks.each { |block| instance_eval(&block) }
+      files.uniq!
       files.each do |file|
         if File.exists? file
           load file
         else
-          Msgr.logger.warn "Routes file `#{file}` does not exists (anymore)."
+          log(:warn) { "Routes file `#{file}` does not exists (anymore)." }
         end
       end
     end

data/lib/msgr/version.rb

@@ -1,8 +1,8 @@
 module Msgr
   module VERSION
     MAJOR = 0
-    MINOR = 4
-    PATCH = 1
+    MINOR = 5
+    PATCH = 0
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.')
 

data/msgr.gemspec

@@ -20,7 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activesupport'
   spec.add_dependency 'bunny', '~> 1.0'
-  spec.add_dependency 'celluloid'
+  spec.add_dependency 'concurrent-ruby'
+  spec.add_dependency 'multi_json'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
 end

data/spec/msgr/msgr_spec.rb

@@ -8,7 +8,7 @@ end
 
 describe Msgr do
   before do
-    Msgr.logger = nil;
+    Msgr.logger = nil
     Msgr.logger.level = Logger::Severity::DEBUG if Msgr.logger
   end
 
@@ -23,22 +23,14 @@ describe Msgr do
   end
 
   after do
-    client.stop timeout: 10, delete: true, wait_empty: 10
+    client.stop
   end
 
   it 'should dispatch published methods to consumer' do
-    expect_any_instance_of(TestConsumer).to receive(:index).within(10).seconds.and_call_original
+    expect_any_instance_of(TestConsumer).to receive(:index).seconds.and_call_original
 
     client.publish 'Payload', to: 'routing.key'
 
-    sleep 10
-  end
-
-  describe '.after_load' do
-    before { allow_any_instance_of(Msgr::Client).to receive(:launch) }
-
-    it 'should yield the given block when Msgr.start is called' do
-      expect { |cb| Msgr.after_load &cb; Msgr.start }.to yield_with_args
-    end
+    sleep 4
   end
 end

data/spec/msgr/spec_helper.rb

@@ -22,12 +22,6 @@ RSpec.configure do |config|
   end
 
   config.before do
-    Celluloid.logger = nil
-
-    Celluloid.shutdown
-    Celluloid.boot
-
-    Celluloid.logger = nil
     Msgr.logger = false
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msgr
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-18 00:00:00.000000000 Z
+date: 2014-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -39,7 +39,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: celluloid
+  name: concurrent-ruby
+  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: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -84,7 +98,6 @@ files:
 - 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/consumer.rb
@@ -92,8 +105,6 @@ files:
 - lib/msgr/errors.rb
 - lib/msgr/logging.rb
 - lib/msgr/message.rb
-- lib/msgr/message/acknowledge.rb
-- lib/msgr/pool.rb
 - lib/msgr/railtie.rb
 - lib/msgr/route.rb
 - lib/msgr/routes.rb
@@ -148,10 +159,8 @@ files:
 - spec/integration/msgr/railtie_spec.rb
 - spec/integration/msgr_spec.rb
 - spec/integration/spec_helper.rb
-- spec/msgr/msgr/client_spec.rb
 - spec/msgr/msgr/connection_spec.rb
 - spec/msgr/msgr/consumer_spec.rb
-- spec/msgr/msgr/pool_spec.rb
 - spec/msgr/msgr/route_spec.rb
 - spec/msgr/msgr/routes_spec.rb
 - spec/msgr/msgr_spec.rb
@@ -231,10 +240,8 @@ test_files:
 - spec/integration/msgr/railtie_spec.rb
 - spec/integration/msgr_spec.rb
 - spec/integration/spec_helper.rb
-- spec/msgr/msgr/client_spec.rb
 - spec/msgr/msgr/connection_spec.rb
 - spec/msgr/msgr/consumer_spec.rb
-- spec/msgr/msgr/pool_spec.rb
 - spec/msgr/msgr/route_spec.rb
 - spec/msgr/msgr/routes_spec.rb
 - spec/msgr/msgr_spec.rb

data/lib/msgr/binding.rb

@@ -1,61 +0,0 @@
-module Msgr
-  # A single binding
-  class Binding
-    include Logging
-    attr_reader :connection, :route, :subscription, :dispatcher, :queue
-
-    def initialize(connection, route, dispatcher)
-      @connection = connection
-      @route      = route
-      @dispatcher = dispatcher
-
-      exchange  = connection.exchange
-      @queue    = connection.queue route.name
-
-      route.keys.each do |key|
-        log(:debug) { "Bind #{key} to #{@queue.name}." }
-
-        queue.bind exchange, routing_key: key
-      end
-
-      @subscription = queue.subscribe(ack: true) { |*args| call *args }
-    end
-
-    # Called from Bunny Thread Pool. Will create message object from
-    # provided bunny data and dispatch message to connection.
-    #
-    def call(info, metadata, payload)
-      dispatcher.dispatch Message.new(connection, info, metadata, payload, route)
-    rescue => error
-      log(:error) { "Error received within subscribe handler: #{error.inspect}\n#{error.backtrace.join("\n  ")}" }
-    end
-
-    # Cancel subscription to not receive any more messages.
-    #
-    def release
-      subscription.cancel if subscription
-    end
-
-    def release_if_empty
-      if queue_empty?
-        release
-        true
-      else
-        false
-      end
-    end
-
-    def queue_empty?
-      @queue.message_count == 0
-    end
-
-    def delete
-      release
-      queue.delete
-    end
-
-    def purge
-      queue.purge
-    end
-  end
-end

data/lib/msgr/message/acknowledge.rb

@@ -1,30 +0,0 @@
-module Msgr
-  class Message
-
-    #
-    #
-    module Acknowledge
-
-      # Check if message is already acknowledged.
-      #
-      # @return [Boolean] True if message is acknowledged, false otherwise.
-      # @api public
-      #
-      def acked?
-        @acked ? true : false
-      end
-
-      # Send message acknowledge to broker unless message is
-      # already acknowledged.
-      #
-      # @api public
-      #
-      def ack
-        unless acked?
-          @acked = true
-          @connection.future(:ack, delivery_info.delivery_tag).value
-        end
-      end
-    end
-  end
-end

data/lib/msgr/pool.rb

@@ -1,165 +0,0 @@
-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
-
-      raise ArgumentError.new 'Pool size must be greater zero.' if @size <= 0
-
-      log(:debug) { "Inialize size => #{@size}" }
-
-      every([opts.fetch(:stats_interval, 30).to_i, 1].max) { 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) { 'Pool ready.' }
-    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
-    alias_method :shutdown, :stop
-
-    # 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(*args)
-      log(:debug) { 'Dispatch message to worker.' }
-
-      fetch_idle_worker.future :dispatch, args
-    end
-
-    # Return an idle worker.
-    #
-    def fetch_idle_worker
-      if (worker = idle.shift)
-        busy << worker
-        worker
-      else
-        wait :worker_done
-        fetch_idle_worker
-      end
-    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
-        after(0) { signal :worker_done }
-      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 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(args)
-        log(:debug) { "Dispatch to runner: #{runner.class.name}" }
-
-        # Send method to custom runner.
-        runner.send :call, *args
-
-      rescue => error
-        log(:error) { "Received error from runner: #{error.message}\n#{error.backtrace.join("    \n")}" }
-      ensure
-        if pool.alive?
-          pool.executed Actor.current
-        else
-          terminate
-        end
-      end
-
-      def to_s
-        "#{@poolname}[##{index}]"
-      end
-    end
-  end
-end

data/spec/msgr/msgr/client_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Msgr::Client do
-
-  describe '#start' do
-    let(:params) { [] }
-    let(:client) { Msgr::Client.new *params }
-    before { allow_any_instance_of(Msgr::Client).to receive(:launch) }
-
-    context 'with URI' do
-      it 'should pass URI options to bunny (I)' do
-        expect(Bunny).to receive(:new)
-                         .with(pass: 'guest', user: 'guest', ssl: false, host: 'localhost', vhost: '/')
-
-        Msgr::Client.new(uri: 'amqp://guest:guest@localhost/').start
-      end
-
-      it 'should pass URI options to bunny (II)' do
-        expect(Bunny).to receive(:new)
-                         .with(pass: 'msgr', user: 'abc', ssl: true, host: 'bogus.example.org', vhost: '/rabbit')
-
-        Msgr::Client.new(uri: 'amqps://abc:msgr@bogus.example.org/rabbit').start
-      end
-    end
-
-    context 'with options' do
-      it 'should pass options to bunny' do
-        expect(Bunny).to receive(:new)
-                         .with(pass: 'guest', user: 'guest', ssl: false, host: 'localhost', vhost: '/')
-
-        Msgr::Client.new(pass: 'guest', user: 'guest', ssl: false, host: 'localhost', vhost: '/').start
-      end
-    end
-
-    context 'with URI and options' do
-      it 'should pass merged options to bunny' do
-        expect(Bunny).to receive(:new)
-                         .with(pass: 'msgr', user: 'abc', ssl: false, host: 'localhost', vhost: '/joghurt')
-
-        Msgr::Client.new(uri: 'ampq://abc@localhost', pass: 'msgr', vhost: '/joghurt').start
-      end
-
-      it 'should pass prefer hash option' do
-        expect(Bunny).to receive(:new)
-                         .with(ssl: true, host: 'a.example.org', vhost: '/', user: 'guest')
-
-        Msgr::Client.new(uri: 'ampq://localhost', ssl: true, host: 'a.example.org').start
-      end
-    end
-
-    context 'routes' do
-      let(:params) { [ routing_file: 'config/msgr.rb']}
-      before { client.start }
-      subject { client.routes }
-      its(:files) { should eq ['config/msgr.rb'] }
-    end
-  end
-end

data/spec/msgr/msgr/pool_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-$shutdown_test_graceful_down = false
-
-class Runner
-  def call(*_) end
-
-  def shutdown_test
-    sleep 2
-    $shutdown_test_graceful_down = true
-  end
-end
-
-describe Msgr::Pool do
-  let(:pool) { Msgr::Pool.new Runner }
-
-  describe '#initialize' do
-    let(:opts) { {} }
-    let(:pool) { Msgr::Pool.new Runner, opts }
-
-    context 'pool size' do
-      let(:opts) { {size: 4} }
-      before { pool }
-
-      it 'should define number of worker actors' do
-        expect(pool.size).to eq 4
-      end
-    end
-  end
-
-  describe '#start' do
-    let!(:pool) { Msgr::Pool.new Runner, size: 4 }
-
-    it 'should start worker actors' do
-      expect { pool.start }.to change { Celluloid::Actor.all.size }.by(4)
-    end
-  end
-
-  describe '#size' do
-    it 'should default to number of available cores' do
-      expect(pool.size).to eq Celluloid.cores
-    end
-  end
-
-  describe '#dispatch' do
-    let!(:pool) { Msgr::Pool.new Runner, size: 4 }
-    before { pool.start }
-
-    it 'should dispatch message to runner' do
-      expect_any_instance_of(Runner).to receive(:call).within(10).seconds.once
-      pool.dispatch 5, 3.2, 'hello'
-    end
-  end
-
-  describe '#shutdown' do
-    let!(:pool) { Msgr::Pool.new Runner, size: 1 }
-    before do
-      pool.start
-      $shutdown_test_graceful_down = false
-    end
-
-    it 'should do a graceful shutdown of all worker' do
-      pool.dispatch :shutdown_test
-      pool.shutdown
-      expect($shutdown_test_graceful_down).to be_false
-    end
-  end
-end