fluffle 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07e464b97aa56f6a1cac97589bb1552250ae0554
-  data.tar.gz: f8ac0063ee89fa55bff06fa26919697dc7385136
+  metadata.gz: 9edeb50743d908defa90bd84bd3eb7fdb4e758d7
+  data.tar.gz: 08e15dce619174c1d68a8cad7ef9f4594db34de7
 SHA512:
-  metadata.gz: bc1577fe0a41bbefeae03a2abceba360ccddfa5ffb0b6cb4a0245056ac5a1adb7b4b98ec4f43381567ec2dc5f91726514109c518469c4a718d0869220fd386a3
-  data.tar.gz: 8858820d0c5ad70f8427474bb1c6ac7bf462278b1f4fe7d00ec915bf5d8de094be3d712158bd488599ec6b2ea9dc874af60398ed501d2fe6312748fbc0dc1877
+  metadata.gz: 39a86ec46f7a0de63792e1331980fda6f0938fa14e465e69b08e12f8a50133b69bf072db4c1db73324fc201c8a9ac073cde88e65c0b43e195f03a5e4c5782725
+  data.tar.gz: 16faf0e8c3196225712ada026f3bc6975f3c0fac79d38b9ebc93f509e898f82d020575b69867107ad0240f57b662b003e024919fa104a5d24f058b8a63f4f4e4

data/examples/client.rb

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'fluffle'
 
-client = Fluffle::Client.new url: 'amqp://localhost', confirms: true
+client = Fluffle::Client.new url: 'amqp://localhost', confirms: true, mandatory: true
 # You can also pass `connection:` to use an existing Bunny connection:
 #   Fluffle::Client.new(connection: Bunny.new('amqp://localhost', heartbeat: 2))
 

data/examples/server.rb

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'fluffle'
 
-server = Fluffle::Server.new url: 'amqp://localhost', concurrency: 5
+server = Fluffle::Server.new url: 'amqp://localhost', concurrency: 5, confirms: true
 
 server.drain do |dispatcher|
   dispatcher.handle('foo') { 'bar' }

data/lib/fluffle.rb

@@ -3,10 +3,12 @@ require 'logger'
 
 require 'fluffle/version'
 require 'fluffle/client'
+require 'fluffle/confirmer'
 require 'fluffle/errors'
 require 'fluffle/handlers/base'
 require 'fluffle/handlers/delegator'
 require 'fluffle/handlers/dispatcher'
+require 'fluffle/middleware_stack'
 require 'fluffle/server'
 
 module Fluffle

data/lib/fluffle/client.rb

@@ -10,13 +10,15 @@ module Fluffle
     include Connectable
 
     attr_reader :confirms
+    attr_reader :mandatory
     attr_accessor :default_timeout
     attr_accessor :logger
 
-    def initialize(url: nil, connection: nil, confirms: false)
+    def initialize(url: nil, connection: nil, confirms: false, mandatory: false)
       self.connect(url || connection)
 
       @confirms        = confirms
+      @mandatory       = mandatory
       @default_timeout = 5
       @logger          = Fluffle.logger
 
@@ -29,8 +31,12 @@ module Fluffle
       @prng = Random.new
 
       if confirms
-        @pending_confirms = Concurrent::Map.new
-        confirm_select
+        @confirmer = Fluffle::Confirmer.new channel: @channel
+        @confirmer.confirm_select
+      end
+
+      if mandatory
+        handle_returns
       end
 
       @pending_responses = Concurrent::Map.new
@@ -51,20 +57,18 @@ module Fluffle
       end
     end
 
-    def confirm_select
-      handle_confirm = ->(tag, _multiple, nack) do
-        ivar = @pending_confirms.delete tag
+    def handle_returns
+      @exchange.on_return do |return_info, properties, payload|
+        id   = properties[:correlation_id]
+        ivar = @pending_responses.delete id
 
         if ivar
-          ivar.set nack
-        else
-          self.logger.error "Missing confirm IVar: tag=#{tag}"
+          message = Kernel.sprintf "Received return from exchange for routing key `%s' (%d %s)", return_info.routing_key, return_info.reply_code, return_info.reply_text
+
+          error = Fluffle::Errors::ReturnError.new message
+          ivar.set error
         end
       end
-
-      # Set the channel in confirmation mode so that we can receive confirms
-      # of published messages
-      @channel.confirm_select handle_confirm
     end
 
     # Fetch and set the `IVar` with a response from the server. This method is
@@ -129,14 +133,27 @@ module Fluffle
       response_ivar = Concurrent::IVar.new
       @pending_responses[id] = response_ivar
 
+      stack = Fluffle::MiddlewareStack.new
+
       if confirms
-        with_confirmation(timeout: timeout) { publish payload, queue: queue }
-      else
+        stack.push ->(publish) do
+          @confirmer.with_confirmation timeout: timeout, &publish
+        end
+      end
+
+      stack.call do
         publish payload, queue: queue
       end
 
       response = response_ivar.value timeout
-      raise_incomplete(payload, 'response') if response_ivar.incomplete?
+
+      if response_ivar.incomplete?
+        raise Errors::TimeoutError.new("Timed out waiting for response to `#{describe_payload(payload)}'")
+      elsif response.is_a? StandardError
+        # Exchange returns will preempt the response and set it to an error
+        # that we can raise
+        raise response
+      end
 
       return response
     ensure
@@ -153,35 +170,12 @@ module Fluffle
       "#{method}/#{arity}"
     end
 
-    # Wraps a block (which should publish a message) with a blocking check
-    #   that the client received a confirmation from the RabbitMQ server
-    #   that the message that was received and routed successfully
-    def with_confirmation(timeout:)
-      tag = @channel.next_publish_seq_no
-      confirm_ivar = Concurrent::IVar.new
-      @pending_confirms[tag] = confirm_ivar
-
-      yield
-
-      nack = confirm_ivar.value timeout
-      if confirm_ivar.incomplete?
-        raise_incomplete payload, 'confirm'
-      elsif nack
-        raise Errors::NackError.new('Received nack from confirmation')
-      end
-    end
-
-    # event_name - String describing what we timed out waiting for, should
-    #   be 'response' or 'confirm'
-    def raise_incomplete(payload, event_name)
-      raise Errors::TimeoutError.new("Timed out waiting for #{event_name} to `#{describe_payload(payload)}'")
-    end
-
     def publish(payload, queue:)
       opts = {
         routing_key: Fluffle.request_queue_name(queue),
         correlation_id: payload['id'],
-        reply_to: @reply_queue.name
+        reply_to: @reply_queue.name,
+        mandatory: @mandatory,
       }
 
       @exchange.publish Oj.dump(payload), opts

data/lib/fluffle/confirmer.rb

@@ -0,0 +1,49 @@
+module Fluffle
+  class Confirmer
+    attr_reader :channel
+
+    def initialize(channel:)
+      @channel = channel
+
+      @pending_confirms = Concurrent::Map.new
+    end
+
+    # Enables confirms on the channel and sets up callback to receive and
+    # unblock corresponding `with_confirmation` call.
+    def confirm_select
+      handle_confirm = ->(tag, _multiple, nack) do
+        ivar = @pending_confirms.delete tag
+
+        if ivar
+          ivar.set nack
+        else
+          self.logger.error "Missing confirm IVar: tag=#{tag}"
+        end
+      end
+
+      # Set the channel in confirmation mode so that we can receive confirms
+      # of published messages
+      @channel.confirm_select handle_confirm
+    end
+
+    # Wraps a block (which should publish a message) with a blocking check
+    # that it received a confirmation from the RabbitMQ server that the
+    # message that was received and routed successfully.
+    def with_confirmation(timeout:)
+      tag = @channel.next_publish_seq_no
+      confirm_ivar = Concurrent::IVar.new
+      @pending_confirms[tag] = confirm_ivar
+
+      result = yield
+
+      nack = confirm_ivar.value timeout
+      if confirm_ivar.incomplete?
+        raise Errors::TimeoutError.new('Timed out waiting for confirm')
+      elsif nack
+        raise Errors::NackError.new('Received nack from confirmation')
+      end
+
+      result
+    end
+  end
+end

data/lib/fluffle/errors.rb

@@ -13,6 +13,10 @@ module Fluffle
     class TimeoutError < StandardError
     end
 
+    # Raised if it received a return from the server
+    class ReturnError < StandardError
+    end
+
     # Raise this within your own code to get an error that will be faithfully
     # translated into the code, message, and data member fields of the
     # spec's `Error` response object

data/lib/fluffle/middleware_stack.rb

@@ -0,0 +1,34 @@
+module Fluffle
+  class MiddlewareStack
+    def initialize
+      @stack = []
+    end
+
+    def push(middleware)
+      @stack << middleware
+      self
+    end
+
+    alias_method :<<, :push
+
+    # Calls the stack in FIFO order with the callable (passed as an object
+    # receiving `#call` or an `&block`) being called last.
+    #
+    # For example:
+    #   stack.push 1
+    #   stack.push 2
+    #   stack.call 3
+    #
+    # Will be evaluated 1 -> 2 -> 3 -> 2 -> 1.
+    def call(callable = nil, &block)
+      callable ||= block
+
+      @stack
+        .reverse
+        .inject(callable) { |previous, middleware|
+          ->{ middleware.call(previous) }
+        }
+        .call
+    end
+  end
+end

data/lib/fluffle/server.rb

@@ -1,15 +1,23 @@
+require 'concurrent'
+require 'oj'
+
 module Fluffle
   class Server
     include Connectable
 
-    attr_reader :connection, :handlers, :handler_pool
+    attr_reader :confirms, :connection, :handlers, :handler_pool
+    attr_accessor :publish_timeout
 
     # url:         - Optional URL to pass to `Bunny.new` to immediately connect
     # concurrency: - Number of threads to handle messages on (default: 1)
-    def initialize(url: nil, connection: nil, concurrency: 1)
+    # confirms:    - Whether or not to use RabbitMQ confirms
+    def initialize(url: nil, connection: nil, concurrency: 1, confirms: false)
       url_or_connection = url || connection
       self.connect(url_or_connection) if url_or_connection
 
+      @confirms        = confirms
+      @publish_timeout = 5
+
       @handlers     = {}
       @handler_pool = Concurrent::FixedThreadPool.new concurrency
 
@@ -27,13 +35,22 @@ module Fluffle
 
       handler = Fluffle::Handlers::Dispatcher.new(&block) if block
 
+      raise ArgumentError, 'Handler cannot be nil' if handler.nil?
+
       @handlers[queue.to_s] = handler
     end
 
     def start
+      @handlers.freeze
+
       @channel  = @connection.create_channel
       @exchange = @channel.default_exchange
 
+      if confirms
+        @confirmer = Fluffle::Confirmer.new channel: @channel
+        @confirmer.confirm_select
+      end
+
       raise 'No handlers defined' if @handlers.empty?
 
       @handlers.each do |name, handler|
@@ -102,8 +119,18 @@ module Fluffle
         }
       end
 
-      @exchange.publish Oj.dump(response), routing_key: reply_to,
-                                           correlation_id: response['id']
+      stack = Fluffle::MiddlewareStack.new
+
+      if confirms
+        stack.push ->(publish) {
+          @confirmer.with_confirmation timeout: publish_timeout, &publish
+        }
+      end
+
+      stack.call do
+        @exchange.publish Oj.dump(response), routing_key: reply_to,
+                                             correlation_id: response['id']
+      end
     end
 
     # handler - Instance of a `Handler` that may receive `#call`

data/lib/fluffle/testing.rb

@@ -167,6 +167,9 @@ module Fluffle
         def publish(payload, opts)
           @channel.publish payload, opts
         end
+
+        def on_return(&block)
+        end
       end
 
       class Queue

data/lib/fluffle/version.rb

@@ -1,3 +1,3 @@
 module Fluffle
-  VERSION = '0.6.3'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluffle
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.0
 platform: ruby
 authors:
 - Dirk Gadsden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-28 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -129,11 +129,13 @@ files:
 - fluffle.jpg
 - lib/fluffle.rb
 - lib/fluffle/client.rb
+- lib/fluffle/confirmer.rb
 - lib/fluffle/connectable.rb
 - lib/fluffle/errors.rb
 - lib/fluffle/handlers/base.rb
 - lib/fluffle/handlers/delegator.rb
 - lib/fluffle/handlers/dispatcher.rb
+- lib/fluffle/middleware_stack.rb
 - lib/fluffle/railtie.rb
 - lib/fluffle/server.rb
 - lib/fluffle/testing.rb