fleck 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5454dfcbd47d6772c526a087805a390bfdbd3d4
-  data.tar.gz: 69e60a050d19f5885dcddf3f675daf371589a713
+  metadata.gz: da4bc26b24264aa2f53ee7c9a7c5635e33b82dea
+  data.tar.gz: 5d0cef36b2f1ccdf1a28165656137d5500289e6a
 SHA512:
-  metadata.gz: 0227d8e60ffb297daa8d7b614ea592017fa02b6ffc5b8dfa41e95f5453abbf97d3208144e11db1500f5d356ccaa7ca6bfdc9405fb2880014b922f8527e998d34
-  data.tar.gz: f65dcf475be639faa1cf1df2a51d3dc22ef5d738c69e1189cf1efd10b3f122450bc212eb4a35ce8658279769d1ce94f7e4e904a7bb303ceea8867d6c8e11f3ce
+  metadata.gz: ce5817faf826334632d2d49ff11feb49692efc7917a22ff01e914f8bc7f26fa0b0c78d39b8ab927945888b1a5980cfa50350414b397c14f4f875d85a35e6eda9
+  data.tar.gz: 67f734fcc912163bc900b52808fe0e995647e43dddc29441f8ddf4859800c13ec13ba1414f26ef40e1d3e2ff20c326c702598275717eeb898a0c6d6e54bc14fb

data/CHANGELOG.md

@@ -1,6 +1,25 @@
 # CHANGELOG #
 
 ## develop ##
+  - **NEW** Added `:autostart` option to `Fleck::Consumer` configuration, so that the developer could decide to start the consumer manually or automatically. By default
+            the consumer will start automatically.
+  - **NEW** Implemented the feature that allows to define an initialization block for `Fleck::Consumer`. This feature should be used to initialize consumer instance
+            variables so that it is not necessary to overwrite `Fleck::Consumer#initialize` method.
+  - **NEW** Implemented the feature that allows to define a map of actions to consumer methods, so that requests actions are automatically mapped to
+            consumer methods.
+  - **NEW** Implemented `#expired?` method for `Fleck::Client::Request`, that tells if the request is expired or not. It makes possible to
+            distinguish service unavailable responses from expired requests.
+  - **NEW** Added `:concurrency` option to `Fleck::Client`, that allows to specify the concurrency level for responses parsing.
+  - **NEW** Add `:version` option to `Fleck::Client#request` and implement `#version` method for `Fleck::Consumer::Request`.
+  - **NEW** Implemented `#request` and `#response` methods for `Fleck::Consumer`, so that you don't have to pass them as argument every time you
+            delegate the logic to a different method.
+  - **NEW** Implemented the feature that allows to deprecate actions within a consumer. Now you can call `deprecated!` inside a consumer to
+            reply with a response that is marked as **deprecated**.
+  - **NEW** Add `app_name` configuration, that allows to configure the default `app_id` to set for RabbitMQ messages.
+  - **NEW** Add process ID to logs, so that if you have multiple instances of the same application writting to the same log file, you'll be able to filter logs by process ID. Also changed logs format.
+
+## v0.4.1 (18 April 2016) ##
+  - **FIX** Fixed a bug of `Fleck::Consumer::Request` class, that was causing errors when RabbitMQ message header wasn't set.
 
 ## v0.4.0 (15 April 2016) ##
   - **NEW** Support different types of exchanges in both `Fleck::Client` and `Fleck::Consumer`.

data/README.md

@@ -148,20 +148,19 @@ To use `Fleck::Consumer` all you need is to inherit it by an another class:
 class MyConsumer < Fleck::Consumer
   configure queue: 'my.queue', concurrency: 2
 
-  def on_message(request, response)
-    logger.debug "HEADERS: #{request.headers}"
-    logger.debug "PARAMS: #{request.params}"
-
-    case request.action
-    when 'random'
-      if rand > 0.1
-        response.status = 200
-        response.body = {x: rand, y: rand}
-      else
-        response.render_error(500, 'Internal Server Error (just a joke)')
-      end
+  actions :random
+
+  initialize do
+    # initialization stuff
+    @my_message = "Hi! :)"
+  end
+
+  def random
+    if rand > 0.1
+      response.status = 200 # this is not strictly necessary (200 is the default status)
+      response.body = {x: rand, y: rand, message: @my_message}
     else
-      response.not_found
+      response.render_error(500, 'Internal Server Error (just a joke)')
     end
   end
 end
@@ -183,16 +182,10 @@ can specify it in consumer configuration.
 class MyConsumer < Fleck::Consumer
   configure queue: '', concurrency: 1, exchange_type: :fanout, exchange_name: 'my.fanout.exchange'
 
-  def on_message(request, response)
-    logger.debug "HEADERS: #{request.headers}"
-    logger.debug "PARAMS: #{request.params}"
+  actions :status
 
-    case request.action
-    when 'status'
-      response.body = {status: 'up & running'}
-    else
-      response.not_found
-    end
+  def status
+    response.body = {status: 'up & running'}
   end
 end
 ```

data/examples/actions.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).to_i
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
+client = Fleck::Client.new(connection, "actions.example.queue", concurrency: CONCURRENCY.to_i)
+
+class MyConsumer < Fleck::Consumer
+  configure queue: 'actions.example.queue', concurrency: CONCURRENCY.to_i
+  actions :hello, ciao: 'my_custom_method', aloha: 'my_aloha'
+
+  def hello
+    response.body = "Hello!"
+  end
+
+  def my_custom_method
+    response.body = "Ciao!"
+  end
+
+  def my_aloha
+    response.body = "Aloha!"
+  end
+
+  def not_an_action
+    logger.warn("I'm not an action, so you should not be able to call me!")
+  end
+end
+
+actions = [:hello, :ciao, :aloha, :not_an_action]
+
+SAMPLES.to_i.times do |num|
+  action = actions[(rand * actions.size).to_i]
+  client.request(action: action, params: {num: num}, timeout: 5) do |request, response|
+    if response.status == 200
+      Fleck.logger.info "ACTION: (#{action.inspect}) #{response.body}"
+    else
+      Fleck.logger.error "ACTION: (#{action.inspect}) #{response.errors.join(", ")}"
+    end
+  end
+end

data/examples/consumer_initialization.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).to_i
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
+client = Fleck::Client.new(connection, "consumer.initialization.example.queue", concurrency: CONCURRENCY.to_i)
+
+class MyConsumer < Fleck::Consumer
+  configure queue: 'consumer.initialization.example.queue', concurrency: CONCURRENCY.to_i
+  actions :hello
+
+  initialize do
+    @value = "MY CONSUMER :) #{self.object_id}"
+  end
+
+  def hello
+    response.body = "#{@value} Hello!"
+  end
+end
+
+SAMPLES.to_i.times do |num|
+  client.request(action: 'hello', params: {num: num}, timeout: 5) do |request, response|
+    if response.status == 200
+      Fleck.logger.info response.body
+    else
+      Fleck.logger.error response.errors.join(", ")
+    end
+  end
+end

data/examples/deprecation.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).to_i
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
+client = Fleck::Client.new(connection, "deprecation.example.queue", concurrency: CONCURRENCY.to_i)
+
+class MyConsumer < Fleck::Consumer
+  configure queue: 'deprecation.example.queue', concurrency: CONCURRENCY.to_i
+
+  def on_message(request, response)
+    case request.action
+    when 'hello' then hello
+    else
+      response.not_found!
+    end
+  end
+
+  def hello
+    version = request.version || 'v1'
+    case version.to_s
+    when 'v1' then hello_v1
+    when 'v2' then hello_v2
+    else
+      response.not_found!
+    end
+  end
+
+  private
+
+  def hello_v1
+    deprecated!
+    response.body = "#{request.params[:num]}. Hello V1!"
+  end
+
+  def hello_v2
+    response.body = "#{request.params[:num] + 1}. Hello V2!"
+  end
+end
+
+SAMPLES.to_i.times do |num|
+  response = client.request(action: 'hello', version: (rand >= 0.5 ? 'v2' : 'v1'), params: {num: num}, timeout: 5)
+  puts (response.deprecated? ? "DEPRECATED: #{response.body}" : response.body)
+end

data/{example.rb → examples/example.rb}

@@ -1,3 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
 require 'fleck'
 
 user        = ENV['USER']        || 'guest'
@@ -13,7 +16,7 @@ Fleck.configure do |config|
 end
 
 connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
-client = Fleck::Client.new(connection, "example.queue")
+client = Fleck::Client.new(connection, "example.queue", concurrency: CONCURRENCY.to_i)
 
 count   = 0
 success = 0
@@ -42,7 +45,7 @@ end
 
 Thread.new do
   SAMPLES.times do |i|
-    client.request(action: 'incr', params: {num: i}, async: true, timeout: 1, rmq_options: {app_id: 'My App', priority: (rand * 9).round(0)}) do |request, response|
+    client.request(action: 'incr', params: {num: i}, async: true, timeout: 1, rmq_options: { priority: (rand * 9).round(0), mandatory: false}) do |request, response|
       if response.status == 200
         request.logger.debug response.body
       else

data/examples/expired.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).to_i
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
+client = Fleck::Client.new(connection, "expiration.example.queue", concurrency: CONCURRENCY.to_i)
+success_probability = 0.8
+
+count   = 0
+success = 0
+failure = 0
+
+mutex = Mutex.new
+lock  = Mutex.new
+condition = ConditionVariable.new
+
+class MyConsumer < Fleck::Consumer
+  configure queue: 'expiration.example.queue', concurrency: CONCURRENCY.to_i
+
+  def on_message(request, response)
+    case request.action
+    when 'hello' then hello
+    else
+      response.not_found!
+    end
+  end
+
+  def hello
+    sleep rand
+    response.body = "#{request.params[:num] + 1}. Hello!"
+  end
+end
+
+SAMPLES.to_i.times do |num|
+  client.request(action: 'hello', params: {num: num}, async: true, timeout: (success_probability * SAMPLES.to_f)/CONCURRENCY.to_f) do |request, response|
+    if request.expired?
+      puts "EXPIRED: #{response.inspect}"
+    elsif response.status == 200
+      puts "SUCCESS: #{response.body}"
+    else
+      puts "ERROR: #{response.inspect}"
+    end
+
+    mutex.synchronize do
+      count += 1
+      if response.status == 200
+        success += 1
+      else
+        failure += 1
+      end
+
+      lock.synchronize { condition.signal } if count >= SAMPLES
+    end
+  end
+end
+
+at_exit do
+  puts "Ztimer: (count: #{Ztimer.count}, jobs: #{Ztimer.jobs_count})"
+  puts "Total: #{count}, Success: #{success}, Failure: #{failure}"
+end
+
+lock.synchronize { condition.wait(lock) }
+exit

data/examples/fanout.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 10).to_i
+SAMPLES     = (ENV['SAMPLES']     || 1_000).to_i
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
+client = Fleck::Client.new(connection, "example.queue", concurrency: CONCURRENCY.to_i, exchange_type: :fanout, exchange_name: 'fanout.example.queue', multiple_responses: true)
+
+count   = 0
+success = 0
+failure = 0
+
+mutex = Mutex.new
+lock  = Mutex.new
+condition = ConditionVariable.new
+
+class First < Fleck::Consumer
+  configure queue: "example.queue", concurrency: CONCURRENCY.to_i, exchange_type: :fanout, exchange_name: 'fanout.example.queue'
+
+  def on_message(request, response)
+    if request.action == "incr"
+      response.body = "#{request.params[:num].to_i + 1}. Hello, World!"
+    else
+      response.not_found
+    end
+  end
+end
+
+Thread.new do
+  SAMPLES.times do |i|
+    client.request(action: 'incr', params: {num: i}, timeout: 60) do |request, response|
+      request.logger.debug response.body
+      mutex.synchronize do
+        count += 1
+        if response.status == 200
+          success += 1
+        else
+          failure += 1
+        end
+
+        lock.synchronize { condition.signal } if count >= SAMPLES
+      end
+    end
+  end
+end
+
+at_exit do
+  puts "Total: #{count}, Success: #{success}, Failure: #{failure}"
+end
+
+lock.synchronize { condition.wait(lock) }
+exit

data/examples/no_autostart.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).to_i
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
+client = Fleck::Client.new(connection, "no.autostart.example.queue", concurrency: CONCURRENCY.to_i)
+
+class MyConsumer < Fleck::Consumer
+  configure queue: 'no.autostart.example.queue', concurrency: CONCURRENCY.to_i, autostart: false
+  actions :hello
+
+  initialize do
+    @value = "MY CONSUMER :) #{self.object_id}"
+  end
+
+  def hello
+    response.body = "#{@value} Hello!"
+  end
+end
+
+MyConsumer.start # IMPORTANT: you have to explicitly start the consumer
+
+SAMPLES.to_i.times do |num|
+  client.request(action: 'hello', params: {num: num}, timeout: 5) do |request, response|
+    if response.status == 200
+      Fleck.logger.info response.body
+    else
+      Fleck.logger.error response.errors.join(", ")
+    end
+  end
+end

data/fleck.gemspec

@@ -32,5 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency             "bunny", "~> 2.2"
   spec.add_dependency             "thread_safe", "~> 0.3"
   spec.add_dependency             "oj", "~> 2.14"
-  spec.add_dependency             "ztimer", "~> 0.3"
+  spec.add_dependency             "ztimer", "~> 0.4"
 end

data/lib/fleck/client/request.rb

@@ -3,29 +3,38 @@ module Fleck
   class Client::Request
     include Fleck::Loggable
 
-    attr_reader :id, :response, :completed
+    attr_reader :id, :response, :completed, :expired
 
-    def initialize(client, routing_key, reply_to, action: nil, headers: {}, params: {}, timeout: nil, rmq_options: {}, &callback)
+    def initialize(client, routing_key, reply_to, action: nil, version: nil, headers: {}, params: {}, timeout: nil, multiple_responses: false, rmq_options: {}, &callback)
       @id              = SecureRandom.uuid
       logger.progname += " #{@id}"
 
       logger.debug "Preparing new request"
 
-      @client      = client
-      @response    = nil
-      @lock        = Mutex.new
-      @condition   = ConditionVariable.new
-      @callback    = callback
-      @started_at  = nil
-      @ended_at    = nil
-      @completed   = false
-      @async       = false
+      @client             = client
+      @response           = nil
+      @lock               = Mutex.new
+      @condition          = ConditionVariable.new
+      @callback           = callback
+      @started_at         = nil
+      @ended_at           = nil
+      @completed          = false
+      @async              = false
+      @action             = action  || headers[:action]  || headers['action']
+      @version            = version || headers[:version] || headers['version']
+      @routing_key        = routing_key
+      @timeout            = (timeout * 1000).to_i unless timeout.nil?
+      @multiple_responses = multiple_responses
+      @ztimer_slot        = nil
+      @expired            = false
+
+      headers[:version] = @version
 
       @options = {
-        routing_key:      routing_key,
+        routing_key:      @routing_key,
         reply_to:         reply_to,
         correlation_id:   @id,
-        type:             action || headers[:action] || headers['action'],
+        type:             action,
         headers:          headers,
         mandatory:        rmq_options[:mandatory]  || true,
         persistent:       rmq_options[:persistent] || false,
@@ -33,8 +42,8 @@ module Fleck
         content_encoding: 'UTF-8'
       }
       @options[:priority]   = rmq_options[:priority] unless rmq_options[:priority].nil?
-      @options[:app_id]     = rmq_options[:app_id]   unless rmq_options[:app_id].nil?
-      @options[:expiration] = (timeout * 1000).to_i  unless timeout.nil?
+      @options[:app_id]     = rmq_options[:app_id] || Fleck.config.app_name
+      @options[:expiration] = @timeout
 
       @message = Oj.dump({headers: headers, params: params}, mode: :compat)
 
@@ -45,7 +54,9 @@ module Fleck
       logger.debug "Response: #{value.inspect}"
       raise ArgumentError.new("Invalid response type: #{value.class}") unless value.is_a?(Fleck::Client::Response)
       @response = value
+      deprecated! if @response.deprecated?
       @callback.call(self, value) if @callback
+      complete! unless @multiple_responses
       return value
     end
 
@@ -54,6 +65,10 @@ module Fleck
       @async = async
       logger.debug("Sending request with (options: #{@options}, message: #{@message})")
 
+      if @timeout
+        @ztimer_slot = Ztimer.after(@timeout){ expire! }
+      end
+
       @client.publish(@message, @options)
 
       @lock.synchronize do
@@ -66,18 +81,43 @@ module Fleck
     end
 
     def complete!
+      @ztimer_slot.cancel! if @ztimer_slot
       @lock.synchronize do
         @completed = true
         @ended_at  = Time.now.to_f
         logger.debug "Done #{@async ? 'async' : 'synchronized'} in #{((@ended_at - @started_at).round(5) * 1000).round(2)} ms"
         @condition.signal unless @async
+        @client.remove_request(@id)
       end
     end
 
     def cancel!
       logger.warn "Request canceled!"
       self.response = Fleck::Client::Response.new(Oj.dump({status: 503, errors: ['Service Unavailable'], body: nil} , mode: :compat))
-      complete!
+    end
+
+    def expire!
+      if @multiple_responses
+        if @completed
+          complete!
+        else
+          @expired = true
+          cancel!
+        end
+      elsif !@completed
+        @expired = true
+        cancel!
+      end
+    end
+
+    def expired?
+      return @expired
+    end
+
+    protected
+
+    def deprecated!
+      logger.warn("DEPRECATION: the method `#{@action}` of version '#{@version.inspect}' on queue '#{@routing_key}' is going to be deprecated. Please, consider using a newer version of this method.")
     end
   end
 end

data/lib/fleck/client/response.rb

@@ -3,13 +3,18 @@ module Fleck
   class Client::Response
     include Fleck::Loggable
 
-    attr_accessor :status, :headers, :body, :errors
+    attr_accessor :status, :headers, :body, :errors, :deprecated
     def initialize(payload)
-      @data    = Oj.load(payload, mode: :compat).to_hash_with_indifferent_access
-      @status  = @data["status"]
-      @headers = @data["headers"] || {}
-      @body    = @data["body"]
-      @errors  = @data["errors"] || []
+      @data       = Oj.load(payload, mode: :compat).to_hash_with_indifferent_access
+      @status     = @data["status"]
+      @headers    = @data["headers"] || {}
+      @body       = @data["body"]
+      @errors     = @data["errors"] || []
+      @deprecated = !!@data["deprecated"]
+    end
+
+    def deprecated?
+      @deprecated
     end
   end
 end

data/lib/fleck/client.rb

@@ -3,12 +3,14 @@ module Fleck
   class Client
     include Fleck::Loggable
 
-    def initialize(connection, queue_name = "", exchange_type: :direct, exchange_name: "", multiple_responses: false)
+    def initialize(connection, queue_name = "", exchange_type: :direct, exchange_name: "", multiple_responses: false, concurrency: 1)
       @connection         = connection
       @queue_name         = queue_name
       @multiple_responses = multiple_responses
       @default_timeout    = multiple_responses ? 60 : nil
+      @concurrency        = [concurrency.to_i, 1].max
       @requests           = ThreadSafe::Hash.new
+      @subscriptions      = ThreadSafe::Array.new
       @terminated         = false
       @mutex              = Mutex.new
 
@@ -18,7 +20,7 @@ module Fleck
       @reply_queue = @channel.queue("", exclusive: true, auto_delete: true)
 
       handle_returned_messages!
-      handle_responses!
+      @concurrency.times { handle_responses! }
 
       logger.debug("Client initialized!")
 
@@ -27,53 +29,46 @@ module Fleck
       end
     end
 
-    def request(action: nil, headers: {}, params: {}, async: @multiple_responses || false, timeout: @default_timeout, queue: @queue_name, rmq_options: {}, &block)
+    def request(action: nil, version: nil, headers: {}, params: {}, async: @multiple_responses || false, timeout: @default_timeout, queue: @queue_name, rmq_options: {}, &block)
+
       if @terminated
         return Fleck::Client::Response.new(Oj.dump({status: 503, errors: ['Service Unavailable'], body: nil} , mode: :compat))
       end
 
-      request = Fleck::Client::Request.new(self, queue, @reply_queue.name, action: action, headers: headers, params: params, timeout: timeout, rmq_options: rmq_options, &block)
-      @requests[request.id] = request
-      if timeout && !async
-        begin
-          Timeout.timeout(timeout.to_f) do
-            request.send!(false)
-          end
-        rescue Timeout::Error
-          logger.warn "Failed to get any response in #{timeout} seconds for request #{request.id.to_s.color(:red)}! The request will be canceled."
-          request.cancel!
-          @requests.delete request.id
-        end
-      elsif timeout && async
-        request.send!(async)
-        Ztimer.after(timeout * 1000) do |slot|
-          if @multiple_responses && !request.response.nil?
-            request.complete!
-            @requests.delete request.id
-          end
+      request = Fleck::Client::Request.new(
+        self, queue, @reply_queue.name,
+        action:             action,
+        version:            version,
+        headers:            headers,
+        params:             params,
+        timeout:            timeout,
+        multiple_responses: @multiple_responses,
+        rmq_options:        rmq_options,
+        &block
+      )
 
-          unless request.completed
-            logger.warn "TIMEOUT #{request.id} (#{((slot.executed_at - slot.enqueued_at) / 1000.to_f).round(2)} ms)"
-            request.cancel!
-            @requests.delete request.id
-          end
-        end
-      else
-        request.send!(async)
-      end
+      @requests[request.id] = request
+      request.send!(async)
 
       return request.response
     end
 
+
     def publish(data, options)
       return if @terminated
       @mutex.synchronize { @publisher.publish(data, options) }
     end
 
+
+    def remove_request(request_id)
+      @requests.delete request_id
+    end
+
+
     def terminate
       @terminated = true
       logger.info "Unsubscribing from #{@reply_queue.name}"
-      @subscription.cancel # stop receiving new messages
+      @subscriptions.map(&:cancel) # stop receiving new messages
       logger.info "Canceling pending requests"
       # cancel pending requests
       while item = @requests.shift do
@@ -95,7 +90,6 @@ module Fleck
           request = @requests[metadata[:correlation_id]]
           if request
             request.cancel!
-            @requests.delete metadata[:correlation_id]
           end
         rescue => e
           logger.error e.inspect + "\n" + e.backtrace.join("\n")
@@ -104,13 +98,12 @@ module Fleck
     end
 
     def handle_responses!
-      @subscription = @reply_queue.subscribe do |delivery_info, metadata, payload|
+      @subscriptions << @reply_queue.subscribe do |delivery_info, metadata, payload|
         begin
           logger.debug "Response received: #{payload}"
-          request = @multiple_responses ? @requests[metadata[:correlation_id]] : @requests.delete(metadata[:correlation_id])
+          request = @requests[metadata[:correlation_id]]
           if request
             request.response = Fleck::Client::Response.new(payload)
-            request.complete! unless @multiple_responses
           else
             logger.warn "Request #{metadata[:correlation_id]} not found!"
           end

data/lib/fleck/configuration.rb

@@ -3,12 +3,13 @@ module Fleck
   class Configuration
 
     attr_reader :logfile, :loglevel, :progname
-    attr_accessor :default_user, :default_pass, :default_host, :default_port, :default_vhost, :default_queue
+    attr_accessor :default_user, :default_pass, :default_host, :default_port, :default_vhost, :default_queue, :app_name
 
     def initialize
       @logfile       = STDOUT
       @loglevel      = ::Logger::INFO
       @progname      = "Fleck"
+      @app_name      = $0
       @default_host  = "127.0.0.1"
       @default_port  = 5672
       @default_user  = nil
@@ -99,7 +100,8 @@ module Fleck
         else
           color = "#00BCD4"
         end
-        "[#{datetime.strftime('%F %T.%L')}]".color(:cyan) + (progname ? " #{progname}".color(:yellow) : "") + " #{severity} ".color(color) + "#{msg}\n"
+        "[#{datetime.strftime('%F %T.%L')}]".color(:cyan) + "(#{$$})".color(:blue) + "|#{severity}|".color(color) +
+        (progname ? "<#{progname}>".color(:yellow) : "")  + " #{msg}\n"
       end
 
       return @formatter

data/lib/fleck/consumer/request.rb

@@ -3,20 +3,23 @@ module Fleck
   class Consumer::Request
     include Fleck::Loggable
 
-    attr_reader :id, :metadata, :payload, :action, :data, :headers, :action, :params, :status, :errors
+    attr_reader :id, :metadata, :payload, :action, :data, :headers, :action, :version, :params, :status, :errors
 
-    def initialize(metadata, payload)
+    def initialize(metadata, payload, delivery_info)
       @id              = metadata.correlation_id
       logger.progname += " #{@id}"
 
-      @metadata = metadata
-      @payload  = payload
-      @data     = {}
-      @headers  = (@metadata.headers || {}).to_hash_with_indifferent_access
-      @action   = @metadata.type
-      @params   = {}
-      @status   = 200
-      @errors   = []
+      @metadata      = metadata
+      @payload       = payload
+      @exchange      = delivery_info.exchange.inspect
+      @queue         = delivery_info.routing_key.inspect
+      @data          = {}
+      @headers       = (@metadata.headers || {}).to_hash_with_indifferent_access
+      @action        = @metadata.type
+      @version       = nil
+      @params        = {}
+      @status        = 200
+      @errors        = []
 
       parse_request!
     end
@@ -24,13 +27,14 @@ module Fleck
     protected
 
     def parse_request!
-      logger.debug "Parsing request (options: #{@metadata}, message: #{@payload})"
+      logger.debug "Parsing request (exchange: #{@exchange}, queue: #{@queue}, options: #{@metadata}, message: #{@payload})"
 
       @data = Oj.load(@payload, mode: :compat).to_hash_with_indifferent_access
       @headers.merge!(@data["headers"] || {})
 
       @action            ||= @headers["action"]
       @headers["action"] ||= @action
+      @version             = @headers["version"]
       @params              = @data["params"] || {}
     rescue Oj::ParseError => e
       logger.error(e.inspect + "\n" + e.backtrace.join("\n"))

data/lib/fleck/consumer/response.rb

@@ -9,12 +9,13 @@ module Fleck
       @id = request_id
       logger.progname += " #{@id}"
 
-      @status   = 200
-      @errors   = []
-      @headers  = {}
-      @body     = nil
-      @rejected = false
-      @requeue  = false
+      @status     = 200
+      @errors     = []
+      @headers    = {}
+      @body       = nil
+      @rejected   = false
+      @requeue    = false
+      @deprecated = false
     end
 
     def reject!(requeue: false)
@@ -30,6 +31,10 @@ module Fleck
       return @requeue
     end
 
+    def deprecated!
+      @deprecated = true
+    end
+
     def not_found(msg = nil)
       @status = 404
       @errors << 'Resource Not Found'
@@ -47,10 +52,11 @@ module Fleck
 
     def to_json
       return Oj.dump({
-        "status"  => @status,
-        "errors"  => @errors,
-        "headers" => @headers,
-        "body"    => @body
+        "status"     => @status,
+        "errors"     => @errors,
+        "headers"    => @headers,
+        "body"       => @body,
+        "deprecated" => @deprecated
       }, mode: :compat)
     rescue => e
       logger.error e.inspect + "\n" + e.backtrace.join("\n")

data/lib/fleck/consumer.rb

@@ -2,7 +2,7 @@
 module Fleck
   class Consumer
     class << self
-      attr_accessor :logger, :configs, :consumers
+      attr_accessor :logger, :configs, :actions_map, :consumers, :initialize_block
     end
 
     def self.inherited(subclass)
@@ -17,14 +17,43 @@ module Fleck
       logger.debug "Consumer configurations updated."
     end
 
+    def self.actions(*args)
+      args.each do |item|
+        case item
+        when Hash
+          item.each do |k,v|
+            self.register_action(k.to_s, v.to_s)
+          end
+        else
+          self.register_action(item.to_s, item.to_s)
+        end
+      end
+    end
+
+    def self.register_action(action, method_name)
+      self.actions_map[action.to_s] = method_name.to_s
+    end
+
+    def self.initialize(&block)
+      self.initialize_block = block
+    end
+
+    def self.start
+      self.consumers.each do |consumer|
+        consumer.start
+      end
+    end
+
     def self.init_consumer(subclass)
       subclass.logger          = Fleck.logger.clone
       subclass.logger.progname = subclass.to_s
 
       subclass.logger.debug "Setting defaults for #{subclass.to_s.color(:yellow)} consumer"
 
-      subclass.configs   = Fleck.config.default_options
-      subclass.consumers = []
+      subclass.configs     = Fleck.config.default_options
+      subclass.configs[:autostart] = true if subclass.configs[:autostart].nil?
+      subclass.actions_map = {}
+      subclass.consumers   = []
     end
 
     def self.autostart(subclass)
@@ -46,6 +75,8 @@ module Fleck
       @__thread_id    = thread_id
       @__connection   = nil
       @__consumer_tag = nil
+      @__request      = nil
+      @__response     = nil
 
       @__host          = configs[:host]
       @__port          = configs[:port]
@@ -55,26 +86,40 @@ module Fleck
       @__exchange_type = configs[:exchange_type] || :direct
       @__exchange_name = configs[:exchange_name] || ""
       @__queue_name    = configs[:queue]
+      @__autostart     = configs[:autostart]
+
+      if self.class.initialize_block
+        self.instance_eval(&self.class.initialize_block)
+      end
 
       logger.info "Launching #{self.class.to_s.color(:yellow)} consumer ..."
 
-      connect!
-      create_channel!
-      subscribe!
+      start if @__autostart
 
       at_exit do
         terminate
       end
     end
 
+    def start
+      connect!
+      create_channel!
+      subscribe!
+    end
+
     def on_message(request, response)
-      raise NotImplementedError.new("You must implement #on_message(delivery_info, metadata, payload) method")
+      method_name = actions[request.action.to_s]
+      if method_name
+        self.send(method_name)
+      else
+        response.not_found
+      end
     end
 
     def terminate
       pause
-      unless @__channel.closed?
-        @__channel.close
+      unless channel.nil? || channel.closed?
+        channel.close
         logger.info "Consumer successfully terminated."
       end
     end
@@ -91,6 +136,10 @@ module Fleck
       @configs ||= self.class.configs
     end
 
+    def actions
+      @actions ||= self.class.actions_map
+    end
+
     def connection
       return @__connection
     end
@@ -116,14 +165,29 @@ module Fleck
     end
 
     def pause
-      cancel_ok = @__subscription.cancel
-      @__consumer_tag = cancel_ok.consumer_tag
+      if subscription
+        cancel_ok = subscription.cancel
+        @__consumer_tag = cancel_ok.consumer_tag
+      end
     end
 
     def resume
       subscribe!
     end
 
+    def request
+      @__request
+    end
+
+    def response
+      @__response
+    end
+
+    def deprecated!
+      logger.warn("DEPRECATION: the method `#{caller_locations(1,1)[0].label}` is going to be deprecated. Please, consider using a newer version of this method.")
+      @__response.deprecated! if @__response
+    end
+
     protected
 
     def connect!
@@ -155,31 +219,31 @@ module Fleck
       options[:consumer_tag] = @__consumer_tag if @__consumer_tag
 
       @__subscription = @__queue.subscribe(options) do |delivery_info, metadata, payload|
-        response = Fleck::Consumer::Response.new(metadata.correlation_id)
+        @__response = Fleck::Consumer::Response.new(metadata.correlation_id)
         begin
-          request  = Fleck::Consumer::Request.new(metadata, payload)
-          if request.errors.empty?
-            on_message(request, response)
+          @__request  = Fleck::Consumer::Request.new(metadata, payload, delivery_info)
+          if @__request.errors.empty?
+            on_message(@__request, @__response)
           else
-            response.status = request.status
-            response.errors += request.errors
+            @__response.status = @__request.status
+            @__response.errors += @__request.errors
           end
         rescue => e
           logger.error e.inspect + "\n" + e.backtrace.join("\n")
-          response.status = 500
-          response.errors << 'Internal Server Error'
+          @__response.status = 500
+          @__response.errors << 'Internal Server Error'
         end
 
-        if response.rejected?
+        if @__response.rejected?
           # the request was rejected, so we have to notify the reject
-          logger.warn "Request #{response.id} was rejected!"
-          @__channel.reject(delivery_info.delivery_tag, response.requeue?)
+          logger.warn "Request #{@__response.id} was rejected!"
+          @__channel.reject(delivery_info.delivery_tag, @__response.requeue?)
         else
-          logger.debug "Sending response: #{response}"
+          logger.debug "Sending response: #{@__response}"
           if @__channel.closed?
             logger.warn "Channel already closed! The response #{metadata.correlation_id} is going to be dropped."
           else
-            @__publisher.publish(response.to_json, routing_key: metadata.reply_to, correlation_id: metadata.correlation_id, mandatory: true)
+            @__publisher.publish(@__response.to_json, routing_key: metadata.reply_to, correlation_id: metadata.correlation_id, mandatory: true)
             @__channel.ack(delivery_info.delivery_tag)
           end
         end

data/lib/fleck/version.rb

@@ -1,3 +1,3 @@
 module Fleck
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fleck
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Groza Sergiu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-18 00:00:00.000000000 Z
+date: 2016-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
 description: "\n    Fleck is a library for syncronous and asyncronous communication
   over Message Queues services. Unlike a common\n    HTTP communication, Fleck requests
   and responses are pure JSON messages.\n  "
@@ -142,7 +142,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- example.rb
+- examples/actions.rb
+- examples/consumer_initialization.rb
+- examples/deprecation.rb
+- examples/example.rb
+- examples/expired.rb
+- examples/fanout.rb
+- examples/no_autostart.rb
 - fleck.gemspec
 - lib/fleck.rb
 - lib/fleck/client.rb