fleck 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a342aa3de500e0ece6c60e76e57122a869c5e74
-  data.tar.gz: 5256c6fcebf654fc57e86189b6c1023b54d6e742
+  metadata.gz: a11a477a98c5158a25c1c7063ff34394815c3a1e
+  data.tar.gz: e16d6089f7856a9ec393e427fd892bb399b820a6
 SHA512:
-  metadata.gz: ec260bbe626542c479ab2dc5e3fd78baa44b9cda4b521ae5cfe8f8a07e4c8090c1cae76081cf07e21af13249595e9ebd48dd39ad254a8f94db3ab700e13fb56c
-  data.tar.gz: 23b1e4c40ad25edaa644e920f288a0fb38784a07cf6d327dde7727394f10e6c5fe1eff773c8a89f52d80dfbf47d69cc337f4a9f5bca91dbe20c72463a5bf2139
+  metadata.gz: c1fd9222f3ab6a8dd0f256a1ef37eae64e77105e5ba39cf61c9f6adc19455e8b2c0c77a0676bb69a54e421ff3fcb1ea8e2c3dc7f1c25b94e47cc7354d7a80c75
+  data.tar.gz: f4fb7a2f47d32f8496ebea65ac2ec9da2c4be939a32de3da2d1eed9c3e90c618d4dbfb252eac9a3d59f3966bddbfcbce266e5e45dbf747ab9de87687a971ce3f

data/CHANGELOG.md

@@ -1,6 +1,17 @@
-# CHANGELOG
+# CHANGELOG #
 
-## (develop)
+## develop ##
+
+## v0.4.0 (15 April 2016) ##
+  - **NEW** Support different types of exchanges in both `Fleck::Client` and `Fleck::Consumer`.
+  - **FIX** Use `auto_delete` queue for `Fleck::Client`, so that it is deleted when the client is terminated.
+  - **NEW** Add `:rmq_options` option to `Fleck::Client::Request`, which can be used to pass options like `:persistent`, `mandatory`, etc. 
+            to RabbitMQ message on publish.
+  - **NEW** Store `:headers` attribute of `Fleck::Client::Request` into RabbitMQ message `:headers`, so that in the future only
+            `:params` option will be converted to JSON.
+  - **NEW** Add `:action` option to `Fleck::Client::Request`, which will replace the action passed within `:headers` hash.
+
+## v0.3.0 (1 April 2016)
   - **FIX** Use `:compat` mode when using `Oj` gem to dump/load JSON content.
   - **FIX** Prevent unnecessary `Fleck::Request` lock for response reception if the response already received.
   - **NEW** Implemented a timeout functionality for asynchronous request, so that if the request isn't completed within that timeout, it will be canceled and removed from

data/README.md

@@ -47,6 +47,7 @@ end
 You could use **Fleck** for both making requests and consuming requests from the queues. Now we are going to see how to enqueue a request to a specific queue:
 
 ```ruby
+ACTION  = 'do_something'              # the action to be executed by the consumer
 QUEUE   = 'my.queue'                  # the name of the queue where to enqueue the request
 HEADERS = {my_header: 'a header'}     # the headers of the request
 PARAMS  = {parameter: 'a parameter'}  # the parameters of the request
@@ -55,7 +56,7 @@ ASYNC   = false                       # a flag to indicate if the request is asy
 
 connection = Fleck.connection(host: '127.0.0.1', port: 5672, user: 'guest', pass: 'guest', vhost: '/')
 client = Fleck::Client.new(connection, QUEUE)
-response = client.request(headers: HEADERS, params: PARAMS, async: ASYNC)
+response = client.request(action: ACTION, headers: HEADERS, params: PARAMS, async: ASYNC)
 
 response.status  # => returns the status code of the response
 response.headers # => returns the headers Hash of the response
@@ -64,11 +65,12 @@ response.errors  # => returns the Array of errors
 ```
 
 All the options of the requests are optional. The available options for request are:
-  - `headers:` - (default: `{}`) - allows to set headers for the request
-  - `params`   - (default: `{}`) - allows to set the parameters of the request
-  - `async`    - (default: `false`) - indicates if the request should be executed asynchronously
-  - `timeout`  - (default: `nil`) - when set, indicates the request timeout in seconds after which the request will be canceled
-  - `queue`    - (default: `<client queue>`) - allows to specify a different queue where to enqueue the request
+  - `action`  - (default: nil)  - used to indicate the action to be executed by the consumer
+  - `headers` - (default: `{}`) - allows to set headers for the request
+  - `params`  - (default: `{}`) - allows to set the parameters of the request
+  - `async`   - (default: `false`) - indicates if the request should be executed asynchronously
+  - `timeout` - (default: `nil`) - when set, indicates the request timeout in seconds after which the request will be canceled
+  - `queue`   - (default: `<client queue>`) - allows to specify a different queue where to enqueue the request
 
 #### Request with block
 
@@ -76,7 +78,7 @@ You might want to process the response of asynchronous requests when the respons
 so that the block is called when the response is completed:
 
 ```ruby
-client.request(headers: {}, params: {param1: 'myparam'}, async: true) do |request, response|
+client.request(action: 'do_something', headers: {}, params: {param1: 'myparam'}, async: true) do |request, response|
   if response.status == 200
     puts "#{response.status} #{response.body}"
   else
@@ -86,6 +88,58 @@ end
 ```
 
 
+#### Exchage type ####
+
+By default `Fleck::Client` will use the default exchage, which is a `:direct` exchange named `""`. But, if you need a different type of exchage,
+you could specify it by setting `:exchange_type` amd `:exchange_name` options when creating the client.
+
+```ruby
+connection = Fleck.connection(host: '127.0.0.1', port: 5672, user: 'guest', pass: 'guest', vhost: '/')          # get a connection
+client = Fleck::Client.new(connection, 'my.queue', exchange_type: :fanout, exchange_name: 'my.fanout.exchange') # create a new client
+
+# make a request
+client.request(action: 'task', params: {x: 1, y: 2}, async: true, timeout: 5) do |request, response|
+  if response.status == 200
+    # we did it!
+    puts response.body
+  else
+    # something went wrong
+    puts "Something went wrong!"
+  end
+end
+```
+
+
+#### Multiple responses ####
+
+Sometimes you might need to receive multiple responses to a single request, for example if you're using a `:fanout` exchange, and
+there're multiple consumer that will respond to your request. The common `request <--> response` model won't match this situation,
+because after the first response the request will be terminated, that will cause a warning message for each response received after
+the first response. To solve this problem you could use the `:multiple_responses` option on client creation (by default is set to `false`),
+so that the client will be able to manage multiple responses.
+
+```ruby
+connection = Fleck.connection(host: '127.0.0.1', port: 5672, user: 'guest', pass: 'guest', vhost: '/')                                    # get a connection
+client = Fleck::Client.new(connection, 'my.queue', exchange_type: :fanout, exchange_name: 'my.fanout.exchange', multiple_responses: true) # create a new client
+
+# make a request
+client.request(action: 'status', timeout: 5) do |request, response|
+  # this block will be executed for each received response
+  if response.status == 200
+    # we did it!
+    puts response.body
+  else
+    # something went wrong
+    puts "Something went wrong!"
+  end
+end
+```
+
+**NOTE**: when you enable the `:multiple_responses` option, this will forse `async: true` for each request. Furthermore, this will set a default
+timeout to `60` seconds, in order to prevent requests that are never completed, which may result in a memory leak. But if you need a request that
+is never completed, you could set `timeout: nil` when making the request.
+
+
 ### Fleck::Consumer
 
 To use `Fleck::Consumer` all you need is to inherit it by an another class:
@@ -98,11 +152,16 @@ class MyConsumer < Fleck::Consumer
     logger.debug "HEADERS: #{request.headers}"
     logger.debug "PARAMS: #{request.params}"
 
-    if rand > 0.1
-      response.status = 200
-      response.body = {x: rand, y: rand}
+    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
     else
-      response.render_error(500, 'Internal Server Error (just a joke)')
+      response.not_found
     end
   end
 end
@@ -112,7 +171,31 @@ This code will automatically automatically start `N` instances of MyConsumer in
 messages from `my.queue` and will respond with a 200 status when the randomly generated number is greater than `0.1` and with a 500 otherwise.
 
 **NOTE**: the default status code of the response is 200, but if any uncaught exception is raised from within `#on_message` method, the status
- will automatically change to 500 and will add `"Internal Server Error"` message to response errors array.
+will automatically change to 500 and will add `"Internal Server Error"` message to response errors array.
+
+
+#### Exchange type for consumers ####
+
+By default `Fleck::Consumer` will use the default exchange to consume messages from a queue. But if you need a different type of exchange, you
+can specify it in consumer configuration.
+
+```ruby
+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}"
+
+    case request.action
+    when 'status'
+      response.body = {status: 'up & running'}
+    else
+      response.not_found
+    end
+  end
+end
+```
 
 
 ## Contributing

data/example.rb

@@ -42,7 +42,7 @@ end
 
 Thread.new do
   SAMPLES.times do |i|
-    client.request(headers: {action: :incr}, params: {num: i}, async: true, timeout: 1) do |request, response|
+    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|
       if response.status == 200
         request.logger.debug response.body
       else

data/lib/fleck/client/request.rb

@@ -5,18 +5,13 @@ module Fleck
 
     attr_reader :id, :response, :completed
 
-    def initialize(client, routing_key, reply_to, headers: {}, params: {}, timeout: nil, &callback)
+    def initialize(client, routing_key, reply_to, action: nil, headers: {}, params: {}, timeout: nil, rmq_options: {}, &callback)
       @id              = SecureRandom.uuid
       logger.progname += " #{@id}"
 
       logger.debug "Preparing new request"
 
       @client      = client
-      @routing_key = routing_key
-      @reply_to    = reply_to
-      @params      = params
-      @headers     = headers
-      @timeout     = timeout
       @response    = nil
       @lock        = Mutex.new
       @condition   = ConditionVariable.new
@@ -26,6 +21,23 @@ module Fleck
       @completed   = false
       @async       = false
 
+      @options = {
+        routing_key:      routing_key,
+        reply_to:         reply_to,
+        correlation_id:   @id,
+        type:             action || headers[:action] || headers['action'],
+        headers:          headers,
+        mandatory:        rmq_options[:mandatory]  || true,
+        persistent:       rmq_options[:persistent] || false,
+        content_type:     'application/json',
+        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?
+
+      @message = Oj.dump({headers: headers, params: params}, mode: :compat)
+
       logger.debug "Request prepared"
     end
 
@@ -40,16 +52,9 @@ module Fleck
     def send!(async = false)
       @started_at = Time.now.to_f
       @async = async
-      data = Oj.dump({
-        headers: @headers,
-        params:  @params
-      }, mode: :compat)
-      logger.debug("Sending request with data: #{data}")
-
-      options = { routing_key: @routing_key, reply_to: @reply_to, correlation_id: @id, mandatory: true }
-      options[:expiration] = (@timeout * 1000).to_i unless @timeout.nil?
+      logger.debug("Sending request with (options: #{@options}, message: #{@message})")
 
-      @client.publish(data, options)
+      @client.publish(@message, @options)
 
       @lock.synchronize do
         unless @async || @completed

data/lib/fleck/client.rb

@@ -3,43 +3,22 @@ module Fleck
   class Client
     include Fleck::Loggable
 
-    def initialize(connection, queue_name)
-      @connection  = connection
-      @queue_name  = queue_name
+    def initialize(connection, queue_name = "", exchange_type: :direct, exchange_name: "", multiple_responses: false)
+      @connection         = connection
+      @queue_name         = queue_name
+      @multiple_responses = multiple_responses
+      @default_timeout    = multiple_responses ? 60 : nil
+      @requests           = ThreadSafe::Hash.new
+      @terminated         = false
+      @mutex              = Mutex.new
+
       @channel     = @connection.create_channel
       @exchange    = @channel.default_exchange
-      @reply_queue = @channel.queue("", exclusive: true)
-      @requests    = ThreadSafe::Hash.new
-      @terminated  = false
-      @mutex       = Mutex.new
+      @publisher   = Bunny::Exchange.new(@channel, exchange_type, exchange_name)
+      @reply_queue = @channel.queue("", exclusive: true, auto_delete: true)
 
-      @exchange.on_return do |return_info, metadata, content|
-        begin
-          logger.warn "Request #{metadata[:correlation_id]} returned"
-          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")
-        end
-      end
-
-      @subscription = @reply_queue.subscribe do |delivery_info, metadata, payload|
-        begin
-          logger.debug "Response received: #{payload}"
-          request = @requests.delete metadata[:correlation_id]
-          if request
-            request.response = Fleck::Client::Response.new(payload)
-            request.complete!
-          else
-            logger.warn "Request #{metadata[:correlation_id]} not found!"
-          end
-        rescue => e
-          logger.error e.inspect + "\n" + e.backtrace.join("\n")
-        end
-      end
+      handle_returned_messages!
+      handle_responses!
 
       logger.debug("Client initialized!")
 
@@ -48,12 +27,12 @@ module Fleck
       end
     end
 
-    def request(headers: {}, params: {}, async: false, timeout: nil, queue: @queue_name, &block)
+    def request(action: 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, headers: headers, params: params, timeout: timeout, &block)
+      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
@@ -68,6 +47,11 @@ module Fleck
       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
+
           unless request.completed
             logger.warn "TIMEOUT #{request.id} (#{((slot.executed_at - slot.enqueued_at) / 1000.to_f).round(2)} ms)"
             request.cancel!
@@ -83,7 +67,7 @@ module Fleck
 
     def publish(data, options)
       return if @terminated
-      @mutex.synchronize { @exchange.publish(data, options) }
+      @mutex.synchronize { @publisher.publish(data, options) }
     end
 
     def terminate
@@ -100,6 +84,41 @@ module Fleck
         end
       end
     end
+
+
+    protected
+
+    def handle_returned_messages!
+      @exchange.on_return do |return_info, metadata, content|
+        begin
+          logger.warn "Request #{metadata[:correlation_id]} returned"
+          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")
+        end
+      end
+    end
+
+    def handle_responses!
+      @subscription = @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])
+          if request
+            request.response = Fleck::Client::Response.new(payload)
+            request.complete! unless @multiple_responses
+          else
+            logger.warn "Request #{metadata[:correlation_id]} not found!"
+          end
+        rescue => e
+          logger.error e.inspect + "\n" + e.backtrace.join("\n")
+        end
+      end
+    end
   end
 end
 

data/lib/fleck/consumer/request.rb

@@ -3,7 +3,7 @@ module Fleck
   class Consumer::Request
     include Fleck::Loggable
 
-    attr_reader :id, :metadata, :payload, :data, :headers, :action, :params, :status, :errors
+    attr_reader :id, :metadata, :payload, :action, :data, :headers, :action, :params, :status, :errors
 
     def initialize(metadata, payload)
       @id              = metadata.correlation_id
@@ -12,8 +12,8 @@ module Fleck
       @metadata = metadata
       @payload  = payload
       @data     = {}
-      @headers  = {}
-      @action   = nil
+      @headers  = @metadata.headers.to_hash_with_indifferent_access
+      @action   = @metadata.type
       @params   = {}
       @status   = 200
       @errors   = []
@@ -24,11 +24,14 @@ module Fleck
     protected
 
     def parse_request!
-      logger.debug "Parsing request: #{@payload}"
-      @data    = Oj.load(@payload, mode: :compat).to_hash_with_indifferent_access
-      @headers = @data["headers"] || {}
-      @action  = @headers["action"]
-      @params  = @data["params"] || {}
+      logger.debug "Parsing request (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
+      @params              = @data["params"] || {}
     rescue Oj::ParseError => e
       logger.error(e.inspect + "\n" + e.backtrace.join("\n"))
       @status = 400

data/lib/fleck/consumer.rb

@@ -47,12 +47,14 @@ module Fleck
       @__connection   = nil
       @__consumer_tag = nil
 
-      @__host       = configs[:host]
-      @__port       = configs[:port]
-      @__user       = configs[:user]     || 'guest'
-      @__pass       = configs[:password] || configs[:pass]
-      @__vhost      = configs[:vhost]    || "/"
-      @__queue_name = configs[:queue]
+      @__host          = configs[:host]
+      @__port          = configs[:port]
+      @__user          = configs[:user]          || 'guest'
+      @__pass          = configs[:password]      || configs[:pass]
+      @__vhost         = configs[:vhost]         || "/"
+      @__exchange_type = configs[:exchange_type] || :direct
+      @__exchange_name = configs[:exchange_name] || ""
+      @__queue_name    = configs[:queue]
 
       logger.info "Launching #{self.class.to_s.color(:yellow)} consumer ..."
 
@@ -105,6 +107,10 @@ module Fleck
       return @__exchange
     end
 
+    def publisher
+      return @__publisher
+    end
+
     def subscription
       return @__subscription
     end
@@ -133,8 +139,13 @@ module Fleck
       logger.debug "Creating a new channel for #{self.class.to_s.color(:yellow)} consumer"
       @__channel  = @__connection.create_channel
       @__channel.prefetch(1) # prevent from dispatching a new RabbitMQ message, until the previous message is not processed
-      @__queue    = @__channel.queue(@__queue_name, auto_delete: false)
-      @__exchange = @__channel.default_exchange
+      @__publisher = @__channel.default_exchange
+      if @__exchange_type == :direct && @__exchange_name == ""
+        @__queue = @__channel.queue(@__queue_name, auto_delete: false)
+      else
+        @__exchange  = Bunny::Exchange.new(@__channel, @__exchange_type, @__exchange_name)
+        @__queue = @__channel.queue("", exclusive: true, auto_delete: true).bind(@__exchange, routing_key: @__queue_name)
+      end
     end
 
     def subscribe!
@@ -168,7 +179,7 @@ module Fleck
           if @__channel.closed?
             logger.warn "Channel already closed! The response #{metadata.correlation_id} is going to be dropped."
           else
-            @__exchange.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.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fleck
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Groza Sergiu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-01 00:00:00.000000000 Z
+date: 2016-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler