msgr 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a4c0e2fbb4ebe739cd8441da5136c32974e33e3
-  data.tar.gz: 8cd8950010d87d4c3a4c90fa26a2f4544bfd1908
+  metadata.gz: e8d6c4cc8a9208899a92286b5ee2be798aceb0bd
+  data.tar.gz: 5c3c2a20221a8da75f8aa4ab81e0e792daf15ab3
 SHA512:
-  metadata.gz: 6b8268da9f156fa7be5b4da0768e766d90242d60186aa7a79d9d229270ac5957bf0e498c5edbb963bc8d0abb759e91545536e23444ff4ce6ab25bc8931518c96
-  data.tar.gz: 5af9d36176f5b99c4249c89a2819d4ab3682c90320d44a0c219b077ed2d3d4f7d9f6dd6e0899452d7d1c3b390ea89a2fdf53f9f2e41c91cb9cd58b55c24598db
+  metadata.gz: 48370c17631a999f1bf475ec869944d95868486d68d7e28cc3020947fa064592c8d0f98c5072acc285af13cad4624524ca66616af5ecadf964ce7bca7da73eac
+  data.tar.gz: 35bf1311b013e5a5a15ec733a0daa343b83bca70b2fd7b49700b4988afc94c233cec0fd25a7afbf324dc633ed300e4580cf8b3494a622c38fff98aa8856e449a

data/.gitignore

@@ -20,4 +20,10 @@ pmip
 *.iml
 .rbx
 .rspec
-log/*.log
+*.log
+spec/integration/dummy/db/*.sqlite3
+spec/integration/dummy/db/*.sqlite3-journal
+spec/integration/dummy/tmp
+spec/integration/dummy/.sass-cache
+spec/integration/dummy/.generators
+spec/integration/dummy/.rakeTasks

data/.travis.yml

@@ -1,14 +1,16 @@
 language: ruby
 bundler_args: --without development
+services:
+  - rabbitmq
 rvm:
   - 2.0.0
   - 1.9.3
   - jruby
   - rbx-19mode
-
 gemfile:
   - gemfiles/Gemfile.rails-3-2
   - gemfiles/Gemfile.rails-4-0
 
-services:
-  - rabbitmq
+script:
+  - bundle exec rake spec:msgr
+  - bundle exec rake spec:integration

data/Gemfile

@@ -1,4 +1,29 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in msgr.gemspec
-gemspec
+# Development gems
+#
+gem 'rake'
+gem 'rspec'
+gem 'rspec-message-within', '>= 1.1.1'
+gem 'fuubar'
+gem 'coveralls'
+
+# Doc
+group :development do
+  gem 'yard', '~> 0.8.6'
+  gem 'listen'
+  gem 'guard-yard'
+  gem 'guard-rspec'
+  gem 'redcarpet', platform: :ruby
+end
+
+group :rails do
+  gem 'rails'
+  gem 'rspec-rails'
+  gem 'sqlite3', platform: :ruby
+  gem 'activerecord-jdbcsqlite3-adapter', platform: :jruby
+end
+
+# Specify your gem's dependencies in acfs.gemspec
+gemroot = File.dirname File.absolute_path __FILE__
+gemspec path: gemroot

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})          { |m| "spec/#{m[1]}_spec.rb" }
+
+  watch('spec/spec_helper.rb')       { 'spec' }
+  watch(%r{^spec/support/(.+)\.rb$}) { 'spec' }
+end
+
+guard 'yard' do
+  watch(%r{lib/.+\.rb})
+end

data/README.md

@@ -1,14 +1,14 @@
-# Msgr - *A Rails-like Messaging Framework*
+# Msgr: *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)
+[![RubyDoc Documentation](https://raw.github.com/jgraichen/shields/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.
+You know it and you like it. Using Rails you can just declare your routes and
+create a controller. That's all you need to process requests.
 
 With *Msgr* you can do the same for asynchronous AMQP messaging. Just define
 your routes, create your consumer and watch you app processing messages.
@@ -31,7 +31,58 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+After adding 'msgr' to your gemfile create a `config/rabbitmq.yml` like this:
+
+```yaml
+common: &common
+  uri: amqp://localhost/
+
+test:
+  <<: *common
+
+development:
+  <<: *common
+
+production:
+  <<: *common
+```
+
+Specify your messaging routes in `config/msgr.rb`:
+
+```ruby
+route 'local.test.index', to: 'test#index'
+route 'local.test.another_action', to: 'test#another_action'
+```
+
+Create your consumer in `app/consumers`:
+
+```ruby
+class TestConsumer < ApplicationConsumer
+  def index
+    data = { fuubar: 'abc' }
+
+    publish data, to: 'local.test.another_action'
+  end
+
+  def another_action
+    puts "#{payload.inspect}"
+  end
+end
+```
+
+Use `Msgr.publish` in to publish a message:
+
+```ruby
+class TestController < ApplicationController
+  def index
+    @data = { abc: 'abc' }
+
+    Msgr.publish @data, to: 'local.test.index'
+
+    render nothing: true
+  end
+end
+```
 
 ## Contributing
 

data/Rakefile

@@ -8,10 +8,36 @@ require 'rake'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
-task 'default' => 'ci'
-task 'ci' => 'spec'
+# Delegate spec task task to spec:all to run all specs.
+task :spec => 'spec:all'
 
 desc 'Run all specs'
-RSpec::Core::RakeTask.new('spec') do |t|
-  t.pattern = 'spec/msgr/**/*_spec.rb'
+namespace :spec do
+
+  desc 'Run all msgr specs and all integration specs.'
+  task :all => [ :msgr, :integration ]
+
+  desc 'Run all unit specs.'
+  RSpec::Core::RakeTask.new(:msgr) do |t|
+    t.ruby_opts="#{ENV['CI'] ? '' : '-w -W2'} -Ispec/support -rsetup -Ispec/msgr"
+    t.pattern = 'spec/msgr/**/*_spec.rb'
+  end
+
+  desc 'Run all integration specs.'
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.ruby_opts="#{ENV['CI'] ? '' : '-w -W2'} -Ispec/support -rsetup -Ispec/integration"
+    t.pattern = 'spec/integration/**/*_spec.rb'
+  end
+end
+
+begin
+  require 'yard'
+  require 'yard/rake/yardoc_task'
+
+  YARD::Rake::YardocTask.new do |t|
+    t.files = %w(lib/**/*.rb)
+    t.options = %w(--output-dir doc/)
+  end
+rescue LoadError
+  nil
 end

data/lib/msgr/binding.rb

@@ -1,28 +1,33 @@
 module Msgr
   # A single binding
   class Binding
-    attr_reader :connection, :route, :subscription, :dispatcher
+    include Logging
+    attr_reader :connection, :route, :subscription, :dispatcher, :queue
 
     def initialize(connection, route, dispatcher)
       @connection = connection
       @route      = route
       @dispatcher = dispatcher
 
-      queue    = connection.queue route.name
+      exchange  = connection.exchange
+      @queue    = connection.queue route.name
 
-      queue.bind connection.exchange, routing_key: route.key
+      route.keys.each do |key|
+        log(:debug) { "Bind #{key} to #{@queue.name}." }
 
-      @subscription = queue.subscribe ack: true, &method(:call)
+        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)
-      message = Message.new(connection, info, metadata, payload, route)
-      dispatcher.dispatch :call, message
+      dispatcher.dispatch Message.new(connection, info, metadata, payload, route)
     rescue => error
-      Msgr.logger.warn(self) { "Error received within bunny subscribe handler: #{error.inspect}." }
+      log(:error) { "Error received within subscribe handler: #{error.inspect}\n#{error.backtrace.join("\n  ")}" }
     end
 
     # Cancel subscription to not receive any more messages.
@@ -30,5 +35,27 @@ module Msgr
     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/client.rb

@@ -6,22 +6,22 @@ module Msgr
     include Celluloid
     include Logging
 
-    attr_reader :pool, :uri
+    attr_reader :uri
 
-    def initialize(config)
+    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[:pass] ||= @uri.password
 
-      @config  = config
-      @bunny   = Bunny.new @uri.to_s
-      @pool    = Pool.new Dispatcher, autostart: false
+      @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? }
 
-      @uri.password = nil
+      @config  = config
+      @bunny   = Bunny.new config
+      @pool    = Pool.new Dispatcher, size: config[:size]
     end
 
     def running?; @running end
@@ -31,6 +31,10 @@ module Msgr
       @routes ||= Routes.new
     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.' }
@@ -39,8 +43,7 @@ module Msgr
       @connection.terminate
 
       log(:debug) { 'Create new connection.' }
-
-      @connection = Connection.new @bunny, routes, pool
+      new_connection
 
       log(:info) { 'Client reloaded.' }
     end
@@ -50,26 +53,28 @@ module Msgr
 
       @bunny.start
       @pool.start
+      @running = true
+      new_connection
 
-      @running    = true
-      @connection = Connection.new @bunny, routes, pool
-
-      log(:info) { "Client started. pool: #{pool.size}" }
+      log(:info) { 'Client started.' }
     end
 
-    def stop
+    def stop(opts = {})
       return unless running?
+      opts.reverse_merge! timeout: 10, delete: false
 
-      @running = false
-      log(:info) { 'Graceful shutdown client...' }
+      stop_connection opts
 
-      @connection.release
-      @pool.stop
+      @running = false
+      wait_for_graceful_shutdown opts if opts[:timeout]
 
       log(:debug) { 'Terminating...' }
 
+      if opts[:delete]
+        log(:debug) { 'Delete connection.' }
+        @connection.delete
+      end
       @connection.terminate
-      @pool.terminate
       @bunny.stop
 
       log(:info) { 'Terminated.' }
@@ -78,5 +83,30 @@ module Msgr
     def publish(routing_key, payload)
       @connection.publish payload, routing_key: routing_key
     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." }
+      end
+    end
+
+    def wait_for_graceful_shutdown(opts)
+      timeout = [opts[:timeout].to_i, 0].max
+      log(:info) { "Attempting graceful shutdown within #{timeout} seconds..." }
+
+      @pool.future(:stop).value timeout
+    rescue TimeoutError
+      log(:warn) { "Could not shutdown pool within #{timeout} seconds." }
+    end
   end
 end

data/lib/msgr/connection.rb

@@ -4,32 +4,37 @@ module Msgr
     include Celluloid
     include Logging
 
-    attr_reader :conn, :pool, :routes
+    attr_reader :conn, :dispatcher, :routes, :opts
     finalizer :close
 
-    def initialize(conn, routes, pool)
-      @conn   = conn
-      @pool   = pool
-      @routes = routes
+    def initialize(conn, routes, dispatcher, opts = {})
+      @conn       = conn
+      @dispatcher = dispatcher
+      @routes     = routes
+      @opts       = opts
 
       @channel = conn.create_channel
       @channel.prefetch(10)
 
-      rebind
+      bind
     end
 
-    def rebind(routes = nil)
-      routes = self.routes unless routes
-
-      # First release old bindings
+    def rebind
       release
+      bind
+    end
 
+    def bind
       # Create new bindings
-      routes.each { |route| bindings << Binding.new(Actor.current, route, pool) }
+      routes.each { |route| bindings << Binding.new(Actor.current, route, dispatcher) }
 
       log(:debug) { 'New routes bound.' }
     end
 
+    def prefix(name = '')
+      opts[:prefix] ? "#{opts[:prefix]}-#{name}" : name
+    end
+
     # Used to store al bindings. Allows use to
     # release bindings when receiver should not longer
     # receive messages but channel need to be open
@@ -40,36 +45,78 @@ module Msgr
     end
 
     def queue(name)
-      @channel.queue name, durable: true
+      @channel.queue(prefix(name), durable: true).tap do |queue|
+        log(:debug) { "Create queue #{queue.name} (durable: #{queue.durable?}, auto_delete: #{queue.auto_delete?})" }
+      end
     end
 
     def exchange
-      @exchange ||= @channel.topic 'msgr', durable: true
+      unless @exchange
+        @exchange = @channel.topic prefix('msgr'), durable: true
+
+        log(:debug) { "Created exchange #{@exchange.name} (type: #{@exchange.type}, durable: #{@exchange.durable?}, auto_delete: #{@exchange.auto_delete?})" }
+      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
+    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
+        end
+      else
+        bindings.each &:release
+      end
+
+      log(:debug) { 'All bindings released.' }
+    end
+
+    def delete
       return unless bindings.any?
 
-      log(:debug) { 'Release all bindings.' }
+      log(:debug) { 'Delete all bindings and exchange.' }
 
-      bindings.each { |binding| binding.release }
+      bindings.each { |binding| binding.delete }
       bindings.clear
+
+      @exchange.delete if @exchange
     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]}" }
 
-      exchange.publish payload, opts.merge(persistent: true)
+      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')
+      end
     end
 
     def ack(delivery_tag)
+      log(:debug) { "Ack message: #{delivery_tag}" }
       @channel.ack delivery_tag
     end
 
+    def reject(delivery_tag, requeue = true)
+      log(:debug) { "Reject message: #{delivery_tag}" }
+      @channel.reject delivery_tag, requeue
+    end
+
     def close
       @channel.close if @channel.open?
       log(:debug) { 'Connection closed.' }

data/lib/msgr/consumer.rb

@@ -0,0 +1,28 @@
+module Msgr
+
+  class Consumer
+    include Logging
+
+    attr_reader :message
+    delegate :payload, to: :@message
+    delegate :action, to: :'@message.route'
+    delegate :consumer, to: :'@message.consumer'
+
+    def dispatch(message)
+      @message = message
+
+      action = message.route.action.to_sym
+      raise Msgr::NoAction.new "No action `#{action}` for `#{self.class.name}`." unless respond_to? action
+
+      log(:debug) { "Invoke action #{action.inspect}." }
+
+      send action
+
+      log(:debug) { "Action #{action.inspect} done." }
+    end
+
+    def publish(data, opts = {})
+      Msgr.client.publish(data, opts)
+    end
+  end
+end

data/lib/msgr/dispatcher.rb

@@ -7,16 +7,23 @@ module Msgr
   class Dispatcher
     include Logging
 
-    def initialize
+    def call(message)
+      dispatch message
+
+      # Acknowledge message unless it is already acknowledged.
+      message.ack unless message.acked?
 
+      log(:warn) { "Message not acked!" } unless message.acked?
     end
 
-    def call(message)
-      log(:debug) { "Receive dispatched message: #{message.payload}" }
+    def dispatch(message)
+      consumer_class = Object.const_get message.route.consumer
 
-      message.ack
+      log(:debug) { "Dispatch message to #{consumer_class.name}" }
 
-      log(:debug) { 'Dispatched message acknowledged.' }
+      consumer_class.new.dispatch message
+    rescue => error
+      log(:error) { error }
     end
 
     def to_s

data/lib/msgr/logging.rb

@@ -2,7 +2,7 @@ module Msgr
 
   module Logging
     def log(level)
-      Msgr.logger.send(level, self.log_name) { yield }
+      Msgr.logger.send(level, self.log_name) { yield } if Msgr.logger
     end
 
     def log_name

data/lib/msgr/message/acknowledge.rb

@@ -0,0 +1,30 @@
+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/message.rb

@@ -1,7 +1,10 @@
 module Msgr
 
+  require 'msgr/message/acknowledge'
+
   class Message
-    attr_reader :delivery_info, :metadata, :payload
+    include Acknowledge
+    attr_reader :delivery_info, :metadata, :payload, :route
 
     def initialize(connection, delivery_info, metadata, payload, route)
       @connection    = connection
@@ -9,10 +12,14 @@ module Msgr
       @metadata      = metadata
       @payload       = payload
       @route         = route
+
+      if content_type == 'application/json'
+        @payload = JSON[payload].symbolize_keys
+      end
     end
 
-    def ack
-      @connection.ack delivery_info.delivery_tag
+    def content_type
+      @metadata.content_type
     end
   end
 end