freddy 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97120d29c1d86841e5dfc5158c31f14d54336387
-  data.tar.gz: 874dbaf996a7c8b77a6311e8689c991db17ecb9b
+  metadata.gz: 157ccf48c23813d9fdb90dd43aa3fc0e6ee8f1f0
+  data.tar.gz: 108c3d3d1f11e56fc09d71898d82a2339dffbdbe
 SHA512:
-  metadata.gz: b88611a8cfde225622dba6b36d024732f5eaf6d436cd933262d9e2dafd76f412cc535f0e0bc6ea6a8445c2270cfd17b99a3c910448e7fdf61bbed6fa02740e77
-  data.tar.gz: 0346023d9e030b033e32b14322694ed16c4c14fe465cf7d93f54d907308b8799aa64f493cfe36cecca04cb93da40c771008bc751e7fc0b172707605d14dc6b33
+  metadata.gz: e41fa3d55fbe4a56f796000e547b2c8764a6ad26e3520a42b5a139d22c60c84625d0659ae94071ea0ae5ddacbf55fb90c492499fefe73f40a9cbee709b214485
+  data.tar.gz: 44f2cc1f17506c03691cdf9cd429ddaba6e057c75e88c4375608be2dc05e9e7ba621e619f85763022913c9b48146f28145f192c6660ec2bc4ce70547806cfce3

data/README.md

@@ -138,10 +138,7 @@ responder_handler.shutdown
 
 ## Notes about concurrency
 
-The underlying bunny implementation uses 1 responder thread by default. This means that if there is a time-consuming process or a sleep call in a responder then other responders will not receive messages concurrently.
-To resolve this problem *freddy* uses a thread pool for running concurrent responders.
-The thread pool is shared between *tap_into* and *respond_to* callbacks and the default size is 4.
-The thread pool size can be configured by passing the configuration option *max_concurrency*.
+*freddy* uses a thread pool to run concurrent responders. The thread pool is unique for each *tap_into* and *respond_to* responder. Thread pool size can be configured by passing the configuration option *max_concurrency*. Its default value is 4. e.g. If your application has 2 *respond_to* responders and 1 *tap_into* responder with *max_concurrency* set to 3 then your application may process up to 9 messages in parallel.
 
 
 Note that while it is possible to use *deliver_with_response* inside a *respond_to* block,

data/freddy.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   else
     spec.name          = "freddy"
   end
-  spec.version       = '0.7.0'
+  spec.version       = '0.7.1'
   spec.authors       = ["Urmas Talimaa"]
   spec.email         = ["urmas.talimaa@gmail.com"]
   spec.description   = %q{Messaging API}

data/lib/freddy/adapters/bunny_adapter.rb

@@ -13,8 +13,10 @@ class Freddy
         @bunny = bunny
       end
 
-      def create_channel
-        Channel.new(@bunny.create_channel)
+      def create_channel(prefetch: nil)
+        bunny_channel = @bunny.create_channel
+        bunny_channel.prefetch(prefetch) if prefetch
+        Channel.new(bunny_channel)
       end
 
       def close
@@ -30,7 +32,7 @@ class Freddy
           @channel = channel
         end
 
-        def_delegators :@channel, :topic, :default_exchange, :consumers
+        def_delegators :@channel, :topic, :default_exchange, :consumers, :acknowledge
 
         def queue(*args)
           Queue.new(@channel.queue(*args))
@@ -46,10 +48,13 @@ class Freddy
       end
 
       class Queue < Shared::Queue
-        def subscribe(&block)
-          @queue.subscribe do |info, properties, payload|
+        def subscribe(manual_ack: false, &block)
+          @queue.subscribe(manual_ack: manual_ack) do |info, properties, payload|
             parsed_payload = Payload.parse(payload)
-            block.call(Delivery.new(parsed_payload, properties, info.routing_key))
+            delivery = Delivery.new(
+              parsed_payload, properties, info.routing_key, info.delivery_tag
+            )
+            block.call(delivery)
           end
         end
       end

data/lib/freddy/adapters/march_hare_adapter.rb

@@ -12,8 +12,10 @@ class Freddy
         @hare = hare
       end
 
-      def create_channel
-        Channel.new(@hare.create_channel)
+      def create_channel(prefetch: nil)
+        hare_channel = @hare.create_channel
+        hare_channel.basic_qos(prefetch) if prefetch
+        Channel.new(hare_channel)
       end
 
       def close
@@ -29,7 +31,7 @@ class Freddy
           @channel = channel
         end
 
-        def_delegators :@channel, :topic, :default_exchange, :consumers
+        def_delegators :@channel, :topic, :default_exchange, :consumers, :acknowledge
 
         def queue(*args)
           Queue.new(@channel.queue(*args))
@@ -45,10 +47,13 @@ class Freddy
       end
 
       class Queue < Shared::Queue
-        def subscribe(&block)
-          @queue.subscribe do |meta, payload|
+        def subscribe(manual_ack: false, &block)
+          @queue.subscribe(manual_ack: manual_ack) do |meta, payload|
             parsed_payload = Payload.parse(payload)
-            block.call(Delivery.new(parsed_payload, meta, meta.routing_key))
+            delivery = Delivery.new(
+              parsed_payload, meta, meta.routing_key, meta.delivery_tag
+            )
+            block.call(delivery)
           end
         end
       end

data/lib/freddy/adapters.rb

@@ -24,6 +24,10 @@ class Freddy
         def name
           @queue.name
         end
+
+        def message_count
+          @queue.message_count
+        end
       end
     end
   end

data/lib/freddy/consumers/respond_to_consumer.rb

@@ -1,16 +1,23 @@
 class Freddy
   module Consumers
     class RespondToConsumer
-      def initialize(consume_thread_pool, logger)
-        @consume_thread_pool = consume_thread_pool
+      def self.consume(*attrs, &block)
+        new(*attrs).consume(&block)
+      end
+
+      def initialize(logger:, thread_pool:, destination:, channel:, handler_adapter_factory:)
         @logger = logger
+        @consume_thread_pool = thread_pool
+        @destination = destination
+        @channel = channel
+        @handler_adapter_factory = handler_adapter_factory
       end
 
-      def consume(destination, channel, handler_adapter_factory, &block)
-        consumer = consume_from_destination(destination, channel) do |delivery|
-          Consumers.log_receive_event(@logger, destination, delivery)
+      def consume(&block)
+        consumer = consume_from_destination do |delivery|
+          Consumers.log_receive_event(@logger, @destination, delivery)
 
-          adapter = handler_adapter_factory.for(delivery)
+          adapter = @handler_adapter_factory.for(delivery)
 
           msg_handler = MessageHandler.new(adapter, delivery)
           block.call(delivery.payload, msg_handler)
@@ -21,15 +28,19 @@ class Freddy
 
       private
 
-      def consume_from_destination(destination, channel, &block)
-        channel.queue(destination).subscribe do |delivery|
+      def consume_from_destination(&block)
+        @channel.queue(@destination).subscribe(manual_ack: true) do |delivery|
           process_message(delivery, &block)
         end
       end
 
       def process_message(delivery, &block)
         @consume_thread_pool.process do
-          block.call(delivery)
+          begin
+            block.call(delivery)
+          ensure
+            @channel.acknowledge(delivery.tag, false)
+          end
         end
       end
     end

data/lib/freddy/consumers/response_consumer.rb

@@ -3,24 +3,20 @@ class Freddy
     class ResponseConsumer
       def initialize(logger)
         @logger = logger
-        @dedicated_thread_pool = Thread.pool(1)
       end
 
-      def consume(queue, &block)
+      def consume(channel, queue, &block)
         @logger.debug "Consuming messages on #{queue.name}"
-        consumer = queue.subscribe do |delivery|
-          process_message(queue, delivery, &block)
+        queue.subscribe do |delivery|
+          process_message(channel, queue, delivery, &block)
         end
-        ResponderHandler.new(consumer, @dedicated_thread_pool)
       end
 
       private
 
-      def process_message(queue, delivery, &block)
-        @dedicated_thread_pool.process do
-          Consumers.log_receive_event(@logger, queue.name, delivery)
-          block.call(delivery)
-        end
+      def process_message(channel, queue, delivery, &block)
+        Consumers.log_receive_event(@logger, queue.name, delivery)
+        block.call(delivery)
       end
     end
   end

data/lib/freddy/consumers/tap_into_consumer.rb

@@ -1,15 +1,22 @@
 class Freddy
   module Consumers
     class TapIntoConsumer
-      def initialize(consume_thread_pool, logger)
+      def self.consume(*attrs, &block)
+        new(*attrs).consume(&block)
+      end
+
+      def initialize(logger:, thread_pool:, pattern:, channel:, options:)
         @logger = logger
-        @consume_thread_pool = consume_thread_pool
+        @consume_thread_pool = thread_pool
+        @pattern = pattern
+        @channel = channel
+        @options = options
       end
 
-      def consume(pattern, channel, options, &block)
-        queue = create_queue(pattern, channel, options)
+      def consume(&block)
+        queue = create_queue
 
-        consumer = queue.subscribe do |delivery|
+        consumer = queue.subscribe(manual_ack: true) do |delivery|
           process_message(queue, delivery, &block)
         end
 
@@ -18,24 +25,29 @@ class Freddy
 
       private
 
-      def create_queue(pattern, channel, group: nil)
-        topic_exchange = channel.topic(Freddy::FREDDY_TOPIC_EXCHANGE_NAME)
+      def create_queue
+        topic_exchange = @channel.topic(Freddy::FREDDY_TOPIC_EXCHANGE_NAME)
+        group = @options.fetch(:group, nil)
 
         if group
-          channel
+          @channel
             .queue("groups.#{group}")
-            .bind(topic_exchange, routing_key: pattern)
+            .bind(topic_exchange, routing_key: @pattern)
         else
-          channel
+          @channel
             .queue('', exclusive: true)
-            .bind(topic_exchange, routing_key: pattern)
+            .bind(topic_exchange, routing_key: @pattern)
         end
       end
 
       def process_message(queue, delivery, &block)
         @consume_thread_pool.process do
-          Consumers.log_receive_event(@logger, queue.name, delivery)
-          block.call delivery.payload, delivery.routing_key
+          begin
+            Consumers.log_receive_event(@logger, queue.name, delivery)
+            block.call delivery.payload, delivery.routing_key
+          ensure
+            @channel.acknowledge(delivery.tag, false)
+          end
         end
       end
     end

data/lib/freddy/delivery.rb

@@ -1,11 +1,12 @@
 class Freddy
   class Delivery
-    attr_reader :routing_key, :payload
+    attr_reader :routing_key, :payload, :tag
 
-    def initialize(payload, metadata, routing_key)
+    def initialize(payload, metadata, routing_key, tag)
       @payload = payload
       @metadata = metadata
       @routing_key = routing_key
+      @tag = tag
     end
 
     def correlation_id

data/lib/freddy/producers/send_and_wait_response_producer.rb

@@ -19,7 +19,7 @@ class Freddy
         @response_queue = @channel.queue("", exclusive: true)
 
         @response_consumer = Consumers::ResponseConsumer.new(@logger)
-        @response_consumer.consume(@response_queue, &method(:handle_response))
+        @response_consumer.consume(@channel, @response_queue, &method(:handle_response))
       end
 
       def produce(destination, payload, timeout_in_seconds:, delete_on_timeout:, **properties)

data/lib/freddy.rb

@@ -17,6 +17,7 @@ class Freddy
   # @option config [Integer] :port (5672)
   # @option config [String] :user ('guest')
   # @option config [String] :pass ('guest')
+  # @option config [Integer] :max_concurrency (4)
   #
   # @return [Freddy]
   #
@@ -24,17 +25,14 @@ class Freddy
   #   Freddy.build(Logger.new(STDOUT), user: 'thumper', pass: 'howdy')
   def self.build(logger = Logger.new(STDOUT), max_concurrency: DEFAULT_MAX_CONCURRENCY, **config)
     connection = Adapters.determine.connect(config)
-    consume_thread_pool = Thread.pool(max_concurrency)
 
-    new(connection, logger, consume_thread_pool)
+    new(connection, logger, max_concurrency)
   end
 
-  def initialize(connection, logger, consume_thread_pool)
+  def initialize(connection, logger, max_concurrency)
     @connection = connection
     @logger = logger
-
-    @tap_into_consumer = Consumers::TapIntoConsumer.new(consume_thread_pool, @logger)
-    @respond_to_consumer = Consumers::RespondToConsumer.new(consume_thread_pool, @logger)
+    @prefetch_buffer_size = max_concurrency
 
     @send_and_forget_producer = Producers::SendAndForgetProducer.new(
       connection.create_channel, logger
@@ -72,12 +70,17 @@ class Freddy
   def respond_to(destination, &callback)
     @logger.info "Listening for requests on #{destination}"
 
-    channel = @connection.create_channel
+    channel = @connection.create_channel(prefetch: @prefetch_buffer_size)
     producer = Producers::ReplyProducer.new(channel, @logger)
     handler_adapter_factory = MessageHandlerAdapters::Factory.new(producer)
 
-    @respond_to_consumer.consume(
-      destination, channel, handler_adapter_factory, &callback
+    Consumers::RespondToConsumer.consume(
+      logger: @logger,
+      thread_pool: Thread.pool(@prefetch_buffer_size),
+      destination: destination,
+      channel: channel,
+      handler_adapter_factory: handler_adapter_factory,
+      &callback
     )
   end
 
@@ -105,7 +108,15 @@ class Freddy
   #   end
   def tap_into(pattern, options = {}, &callback)
     @logger.debug "Tapping into messages that match #{pattern}"
-    @tap_into_consumer.consume(pattern, @connection.create_channel, options, &callback)
+
+    Consumers::TapIntoConsumer.consume(
+      logger: @logger,
+      thread_pool: Thread.pool(@prefetch_buffer_size),
+      pattern: pattern,
+      channel: @connection.create_channel(prefetch: @prefetch_buffer_size),
+      options: options,
+      &callback
+    )
   end
 
   # Sends a message to given destination

data/spec/freddy/consumers/respond_to_consumer_spec.rb

@@ -1,24 +1,84 @@
 require 'spec_helper'
 
 describe Freddy::Consumers::RespondToConsumer do
-  let(:consumer) { described_class.new(thread_pool, logger) }
+  let(:consumer) do
+    described_class.new(
+      logger: logger,
+      thread_pool: thread_pool,
+      destination: destination,
+      channel: channel,
+      handler_adapter_factory: msg_handler_adapter_factory
+    )
+  end
 
-  let(:connection)  { Freddy::Adapters.determine.connect(config) }
-  let(:thread_pool) { Thread.pool(1) }
+  let(:connection) { Freddy::Adapters.determine.connect(config) }
   let(:destination) { random_destination }
-  let(:payload)     { {pay: 'load'} }
-  let(:msg_handler) { double }
+  let(:payload) { {pay: 'load'} }
+  let(:msg_handler_adapter_factory) { double(for: msg_handler_adapter) }
+  let(:msg_handler_adapter) { Freddy::MessageHandlerAdapters::NoOpHandler.new }
+  let(:prefetch_buffer_size) { 2 }
+  let(:thread_pool) { Thread.pool(prefetch_buffer_size) }
 
   after do
     connection.close
   end
 
-  it "doesn't call passed block without any messages" do
-    consumer.consume destination, connection.create_channel, msg_handler do
-      @message_received = true
+  context 'when no messages' do
+    let(:channel) { connection.create_channel }
+
+    it "doesn't call passed block" do
+      consumer.consume do
+        @message_received = true
+      end
+      default_sleep
+
+      expect(@message_received).to be_falsy
+    end
+  end
+
+  context 'when thread pool is full' do
+    let(:prefetch_buffer_size) { 1 }
+    let(:msg_count) { prefetch_buffer_size + 1 }
+    let(:channel) { connection.create_channel(prefetch: prefetch_buffer_size) }
+    let(:mutex) { Mutex.new }
+    let(:consume_lock) { ConditionVariable.new }
+    let(:queue) { channel.queue(destination) }
+
+    after do
+      # Release the final queued message before finishing the test to avoid
+      # bunny warnings.
+      process_message
     end
-    default_sleep
 
-    expect(@message_received).to be_falsy
+    it 'does not consume more messages' do
+      consumer.consume do
+        wait_until_released
+      end
+
+      msg_count.times { deliver_message }
+
+      sleep default_sleep
+      expect(queue.message_count).to eq(msg_count - prefetch_buffer_size)
+
+      process_message
+      expect(queue.message_count).to eq(0)
+    end
+
+    def process_message
+      release_consume_lock
+      sleep default_sleep
+    end
+
+    def deliver_message
+      channel.default_exchange.publish('{}', routing_key: destination)
+    end
+
+    def wait_until_released
+      mutex.synchronize { consume_lock.wait(mutex) }
+    end
+
+    def release_consume_lock
+      mutex.synchronize { consume_lock.broadcast }
+    end
   end
 end

data/spec/freddy/responder_handler_spec.rb

@@ -13,12 +13,12 @@ describe Freddy::ResponderHandler do
       count = 0
 
       consumer_handler = freddy.respond_to destination do
-        sleep 0.1
+        sleep 0.3
         count += 1
       end
       deliver
 
-      sleep 0.05
+      sleep 0.15
       consumer_handler.shutdown
 
       expect(count).to eq(1)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Urmas Talimaa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-14 00:00:00.000000000 Z
+date: 2017-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -151,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: API for inter-application messaging supporting acknowledgements and request-response