freddy-jruby 0.6.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bcd002e379a1f9326e97c95617e8027065403fcc
-  data.tar.gz: 2982e7fae24ee6ba8e763be8426d86806406e2da
+  metadata.gz: 4d8614a6a2bc844445d26bf035b0ecdbd5c2e12d
+  data.tar.gz: c64f8114a61bd258bef376c4927110b338041d44
 SHA512:
-  metadata.gz: d4f642d80cbb81bd9150c1cac643d4a919b18ada01cc40ad42e3c26cbc394d1f3491ac11a529243da39aeec7c1e4cc5c3d66699178ed4dc29cf6fdf4b36788be
-  data.tar.gz: d02a32438c611aea42a2d242b7d59d1abfa73fb42a7ac1f17ebb3542059eccffb341b6bc078a822900f9112ee30d6e9615a41d52322fdf88478b7e91681bf113
+  metadata.gz: 648e9031be023cab9fdce260b27925331444c8ca35d4dd8321d06df494f3f0f5730f0df68b54e1f9fcf667691ef311c669260da35b99bab2f9d408aa885bba67
+  data.tar.gz: a1d06a5f8361ea94c18b698a035bf643bc9858b4541de331bad0a670b2f17051c458bb1383d877c8afbcabe2a78c9f0502c9d279a7dc7b080c7113268c816d68

data/Gemfile

@@ -3,5 +3,6 @@ source 'https://rubygems.org'
 gem 'rspec'
 gem 'pry'
 gem 'codeclimate-test-reporter'
+gem 'hamster', '~> 3.0'
 
 gemspec

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,9 +8,9 @@ Gem::Specification.new do |spec|
   else
     spec.name          = "freddy"
   end
-  spec.version       = '0.6.0'
-  spec.authors       = ["Urmas Talimaa"]
-  spec.email         = ["urmas.talimaa@gmail.com"]
+  spec.version       = '0.7.2'
+  spec.authors       = ["Salemove TechMovers"]
+  spec.email         = ["techmovers@salemove.com"]
   spec.description   = %q{Messaging API}
   spec.summary       = %q{API for inter-application messaging supporting acknowledgements and request-response}
   spec.license       = "Private"
@@ -27,10 +27,9 @@ Gem::Specification.new do |spec|
     spec.add_dependency 'march_hare', '~> 2.12.0'
     spec.add_dependency 'symbolizer'
   else
-    spec.add_dependency "bunny", "~> 2.5.0"
+    spec.add_dependency "bunny", "~> 2.6"
     spec.add_dependency "oj", "~> 2.13"
   end
 
-  spec.add_dependency "hamster", "~> 1.0.1.pre.rc3"
-  spec.add_dependency "thread", "~> 0.2"
+  spec.add_dependency "thread", "~> 0.1"
 end

data/lib/freddy.rb

@@ -1,6 +1,6 @@
 require 'json'
 require 'thread/pool'
-require 'hamster/mutable_hash'
+require 'securerandom'
 
 Dir[File.dirname(__FILE__) + '/freddy/*.rb'].each(&method(:require))
 
@@ -18,6 +18,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]
   #
@@ -25,17 +26,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
@@ -73,12 +71,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
 
@@ -91,6 +94,10 @@ class Freddy
   # @param [String] pattern
   #   the destination pattern. Use `#` wildcard for matching 0 or more words.
   #   Use `*` to match exactly one word.
+  # @param [Hash] options
+  # @option options [String] :group
+  #   only one of the listeners in given group will receive a message. All
+  #   listeners will receive a message if the group is not specified.
   #
   # @yield [message] Yields received message to the block
   #
@@ -100,9 +107,17 @@ class Freddy
   #   freddy.tap_into 'notifications.*' do |message|
   #     puts "Notification showed #{message.inspect}"
   #   end
-  def tap_into(pattern, &callback)
+  def tap_into(pattern, options = {}, &callback)
     @logger.debug "Tapping into messages that match #{pattern}"
-    @tap_into_consumer.consume(pattern, @connection.create_channel, &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/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/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/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, &block)
-        queue = create_queue(pattern, channel)
+      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,18 +25,29 @@ class Freddy
 
       private
 
-      def create_queue(pattern, channel)
-        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)
 
-        channel
-          .queue('', exclusive: true)
-          .bind(topic_exchange, routing_key: pattern)
+        if group
+          @channel
+            .queue("groups.#{group}")
+            .bind(topic_exchange, routing_key: @pattern)
+        else
+          @channel
+            .queue('', exclusive: true)
+            .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/request_manager.rb

@@ -1,23 +1,31 @@
 class Freddy
   class RequestManager
     def initialize(logger)
-      @requests = Hamster.mutable_hash
+      @requests = ConcurrentHash.new
       @logger = logger
     end
 
     def no_route(correlation_id)
       if request = @requests[correlation_id]
-        @requests.delete correlation_id
+        delete(correlation_id)
         request[:callback].call({error: 'Specified queue does not exist'}, nil)
       end
     end
 
     def store(correlation_id, opts)
-      @requests.store(correlation_id, opts)
+      @requests[correlation_id] = opts
     end
 
     def delete(correlation_id)
       @requests.delete(correlation_id)
     end
+
+    class ConcurrentHash < Hash
+      # CRuby hash does not need any locks. Only adding when using JRuby.
+      if RUBY_PLATFORM == 'java'
+        require 'jruby/synchronized'
+        include JRuby::Synchronized
+      end
+    end
   end
 end

data/lib/freddy/sync_response_container.rb

@@ -1,4 +1,3 @@
-require 'thread'
 require 'timeout'
 
 class Freddy

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)

data/spec/integration/concurrency_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'hamster/experimental/mutable_set'
 
 describe 'Concurrency' do
   let(:freddy1) { Freddy.build(logger, config) }
@@ -88,7 +89,7 @@ describe 'Concurrency' do
   context 'concurrent executions of deliver_with_response' do
     let(:nr_of_threads) { 50 }
     let(:payload) { {pay: 'load'} }
-    let(:msg_counter) { Hamster.mutable_set }
+    let(:msg_counter) { Hamster::MutableSet[] }
     let(:queue_name) { random_destination }
 
     before do

data/spec/integration/tap_into_with_group_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'hamster/experimental/mutable_set'
+
+describe 'Tapping into with group identifier' do
+  let(:deliverer) { Freddy.build(logger, config) }
+  let(:responder1) { Freddy.build(logger, config) }
+  let(:responder2) { Freddy.build(logger, config) }
+
+  let(:destination)  { random_destination }
+
+  after { [deliverer, responder1, responder2].each(&:close) }
+
+  it 'receives a message once' do
+    msg_counter = Hamster::MutableSet[]
+
+    group_id = arbitrary_id
+    responder1.tap_into(destination, group: group_id) {|msg| msg_counter << 'r1' }
+    responder2.tap_into(destination, group: group_id) {|msg| msg_counter << 'r2' }
+    deliverer.deliver(destination, {})
+
+    default_sleep
+    expect(msg_counter.count).to eq(1)
+  end
+end

data/spec/spec_helper.rb

@@ -12,7 +12,6 @@ SimpleCov.start do
 end
 
 require 'pry'
-require 'securerandom'
 require 'freddy'
 require 'logger'
 require 'hamster/experimental/mutable_set'
@@ -29,6 +28,10 @@ def random_destination
   SecureRandom.hex
 end
 
+def arbitrary_id
+  SecureRandom.hex
+end
+
 def default_sleep
   sleep 0.05
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy-jruby
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.2
 platform: ruby
 authors:
-- Urmas Talimaa
+- Salemove TechMovers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2017-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -71,21 +71,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1.pre.rc3
-  name: hamster
-  prerelease: false
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.1.pre.rc3
-- !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.1'
   name: thread
   prerelease: false
   type: :runtime
@@ -93,10 +79,10 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.1'
 description: Messaging API
 email:
-- urmas.talimaa@gmail.com
+- techmovers@salemove.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -143,6 +129,7 @@ files:
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
 - spec/integration/reply_spec.rb
+- spec/integration/tap_into_with_group_spec.rb
 - spec/spec_helper.rb
 homepage:
 licenses:
@@ -164,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.8
+rubygems_version: 2.6.8
 signing_key:
 specification_version: 4
 summary: API for inter-application messaging supporting acknowledgements and request-response
@@ -178,4 +165,5 @@ test_files:
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
 - spec/integration/reply_spec.rb
+- spec/integration/tap_into_with_group_spec.rb
 - spec/spec_helper.rb