fluffle 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c192b7069e5371d2a5d9dfa867030ace9a8a0b90
-  data.tar.gz: 4c53d4d29dc63263d475538aa6683581cb6c4b9d
+  metadata.gz: 2de3913524a4ba8c3270b96d5272f806c1b307e1
+  data.tar.gz: f2d2d81a77fed5dd7ed95a79e70e986c53c5bca4
 SHA512:
-  metadata.gz: 1634ca417c9043b76ec5d6349a6a395f4412014519317bf39b54c8ebbbb0dbe0c9d7a80a6d73f1301d627d7a34525397af9921fa72520c1009e5aaf3b7309f98
-  data.tar.gz: 2ccac8567795f76520072b914764f6620c9dd8f49182b4e6d7df72fbe0f98535d9acf4d5edff6817f4988ec8cd7c8cad4f35fcc945fbc7a3021b6b355a311645
+  metadata.gz: b33a3af2b4958527059766387e030d491d56ee05dbfc6e3141f57255f0c664680e575319fd2aa4cd38bbe7ae1466e6e00da17d82c111c81fc29bfa7c33b9a263
+  data.tar.gz: a92a7984a455c82071dd492b50fa87ad9d81aa86bb7a6059fdc51a707a056e4fc9b505aa62678d2c1689cfad228cbb1a1953459f01143a93fa55ae5fdae32032

data/.travis.yml

@@ -2,9 +2,8 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.2.1
-  - 2.2.2
-  - 2.2.3
+  - 2.1.10
+  - 2.2.5
   - 2.3.0
   - 2.3.1
 services:

data/README.md

@@ -1,5 +1,7 @@
 # fluffle
 
+[![Build Status](https://travis-ci.org/Everlane/fluffle.svg?branch=master)](https://travis-ci.org/Everlane/fluffle)
+
 An implementation of [JSON-RPC][] over RabbitMQ through the [Bunny][] library. Provides both a client and server.
 
 ![](fluffle.jpg)

data/fluffle.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.homepage = 'https://github.com/Everlane/fluffle'
   s.license  = 'MIT'
 
-  s.required_ruby_version = '>= 2.0'
+  s.required_ruby_version = '>= 2.1'
 
   s.add_dependency 'bunny',           '~> 2.5.0'
   s.add_dependency 'concurrent-ruby', '~> 1.0.2'

data/lib/fluffle/client.rb

@@ -90,8 +90,9 @@ module Fluffle
     # After publishing it waits for the `IVar` to be set with the response.
     # It also clears that `IVar` if it times out to avoid leaking.
     #
-    # Returns a Hash from the JSON response from the server
-    # Raises TimeoutError if server failed to respond in time
+    # Returns a `Hash` from the JSON response from the server
+    # Raises `Fluffle::Errors::TimeoutError` if the server failed to respond
+    #   within the given time in `timeout:`
     def publish_and_wait(payload, queue:, timeout:)
       id = payload['id']
 
@@ -104,7 +105,7 @@ module Fluffle
 
       if ivar.incomplete?
         method = payload['method']
-        arity  = payload['params']&.length || 0
+        arity  = (payload['params'] && payload['params'].length) || 0
         raise Errors::TimeoutError.new("Timed out waiting for response to `#{method}/#{arity}'")
       end
 

data/lib/fluffle/connectable.rb

@@ -14,7 +14,7 @@ module Fluffle
     end
 
     def connected?
-      @connection&.connected?
+      @connection && @connection.connected?
     end
   end
 end

data/lib/fluffle/railtie.rb

@@ -0,0 +1,8 @@
+module Fluffle
+  class Railtie < Rails::Railtie
+    # Inherit the application's logger
+    initializer 'fluffle.configure_logger', after: 'initialize_logger' do |app|
+      Fluffle.logger = app.config.logger
+    end
+  end
+end

data/lib/fluffle/server.rb

@@ -2,13 +2,15 @@ module Fluffle
   class Server
     include Connectable
 
-    attr_reader :connection, :handlers
+    attr_reader :connection, :handlers, :handler_pool
 
-    def initialize(url: nil)
+    # 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, concurrency: 1)
       self.connect(url) if url
 
-      @handlers = {}
-      @queues   = {}
+      @handlers     = {}
+      @handler_pool = Concurrent::FixedThreadPool.new concurrency
 
       self.class.default_server ||= self
     end
@@ -31,38 +33,102 @@ module Fluffle
       @channel  = @connection.create_channel
       @exchange = @channel.default_exchange
 
+      raise 'No handlers defined' if @handlers.empty?
+
       @handlers.each do |name, handler|
         qualified_name = Fluffle.request_queue_name name
         queue          = @channel.queue qualified_name
 
-        queue.subscribe do |delivery_info, properties, payload|
-          self.handle_request queue_name: name,
-                              handler: handler,
-                              delivery_info: delivery_info,
-                              properties: properties,
-                              payload: payload
+        queue.subscribe do |_delivery_info, properties, payload|
+          @handler_pool.post do
+            self.handle_request handler: handler,
+                                properties: properties,
+                                payload: payload
+          end
+        end
+      end
+
+      self.wait_for_signal
+    end
+
+    # NOTE: Keeping this in its own method so its functionality can be more
+    #   easily overwritten by `Fluffle::Testing`.
+    def wait_for_signal
+      signal_read, signal_write = IO.pipe
+
+      %w[INT TERM].each do |signal|
+        Signal.trap(signal) do
+          signal_write.puts signal
         end
       end
 
-      @channel.work_pool.join
+      # Adapted from Sidekiq:
+      #   https://github.com/mperham/sidekiq/blob/e634177/lib/sidekiq/cli.rb#L94-L97
+      while io = IO.select([signal_read])
+        readables = io.first
+        signal    = readables.first.gets.strip
+
+        Fluffle.logger.info "Received #{signal}; shutting down..."
+        @channel.work_pool.shutdown
+
+        return
+      end
     end
 
-    def handle_request(queue_name:, handler:, delivery_info:, properties:, payload:)
-      id       = nil
+    def handle_request(handler:, properties:, payload:)
       reply_to = properties[:reply_to]
 
+      responses = []
+
       begin
-        id, method, params = self.decode payload
+        decoded = self.decode payload
+
+        requests =
+          if decoded.is_a? Hash
+            [ decoded ] # Single request
+          elsif decoded.is_a? Array
+            decoded # Batch request
+          else
+            raise Errors::InvalidRequestError.new('Payload was neither an Array nor an Object')
+          end
+
+        requests.each do |request|
+          response = self.call_handler handler: handler,
+                                       request: request
+
+          responses << response
+        end
+      rescue => err
+        responses << {
+          'jsonrpc' => '2.0',
+          'id'      => nil,
+          'error'   => self.build_error_response(err)
+        }
+      end
 
-        validate_request method: method
+      responses.each do |response|
+        @exchange.publish Oj.dump(response), routing_key: reply_to,
+                                             correlation_id: response['id']
+      end
+    end
+
+    # handler - Instance of a `Handler` that may receive `#call`
+    # request - `Hash` representing a decoded Request
+    def call_handler(handler:, request:)
+      begin
+        # We don't yet know if it's valid, so we have to be as cautious as
+        # possible about getting the ID
+        id = begin request['id']; rescue; nil end
+
+        self.validate_request request
 
         result = handler.call id: id,
-                              method: method,
-                              params: params,
-                              meta: {
-                                reply_to: reply_to
-                              }
+                              method: request['method'],
+                              params: request['params'],
+                              meta: {}
       rescue => err
+        log_error(err) if Fluffle.logger.error?
+
         error = self.build_error_response err
       end
 
@@ -74,25 +140,43 @@ module Fluffle
         response['result'] = result
       end
 
-      @exchange.publish Oj.dump(response), routing_key: reply_to,
-                                           correlation_id: id
+      response
     end
 
-    protected
-
+    # Deserialize a JSON payload and extract its 3 members: id, method, params
+    #
+    # payload - `String` of the payload from the queue
+    #
+    # Returns a `Hash` from parsing the JSON payload (keys should be `String`)
     def decode(payload)
-      payload = Oj.load payload
-
-      id     = payload['id']
-      method = payload['method']
-      params = payload['params']
-
-      [id, method, params]
+      Oj.load payload
     end
 
-    # Raises if elements of the request do not comply with the spec
+    # Raises if elements of the request payload do not comply with the spec
+    #
+    # payload - Decoded `Hash` of the payload (`String` keys)
     def validate_request(request)
-      raise Errors::InvalidRequestError.new("Missing `method' Request object member") unless request[:method]
+      raise Errors::InvalidRequestError.new("Improperly formatted Request (expected `Hash', got `#{request.class}')") unless request && request.is_a?(Hash)
+      raise Errors::InvalidRequestError.new("Missing `method' Request object member") unless request['method']
+    end
+
+    protected
+
+    # Logs a nicely-formmated error to `Fluffle.logger` with the class,
+    # message, and backtrace (if available)
+    def log_error(err)
+      backtrace = Array(err.backtrace).flatten.compact
+
+      backtrace =
+        if backtrace.empty?
+          ''
+        else
+          prefix = "\n  "
+          prefix + backtrace.join(prefix)
+        end
+
+      message = "#{err.class}: #{err.message}#{backtrace}"
+      Fluffle.logger.error message
     end
 
     # Convert a Ruby error into a hash complying with the JSON-RPC spec
@@ -107,7 +191,7 @@ module Fluffle
       else
         response = {
           'code' => 0,
-          'message' => err.message
+          'message' => "#{err.class}: #{err.message}"
         }
 
         response['data'] = err.data if err.respond_to? :data

data/lib/fluffle/testing.rb

@@ -2,6 +2,20 @@ require 'concurrent'
 
 module Fluffle
   module Testing
+    def self.setup!
+      # Inject our own custom `Connectable` implementation
+      [Fluffle::Client, Fluffle::Server].each do |mod|
+        mod.include Connectable
+      end
+
+      Fluffle::Server.class_eval do
+        # Overwriting this so that we don't actually block waiting for signal
+        def wait_for_signal
+          # pass
+        end
+      end
+    end
+
     # Patch in a new `#connect` method that injects the loopback
     module Connectable
       def self.included(klass)
@@ -15,12 +29,6 @@ module Fluffle
       end
     end
 
-    def self.inject_connectable
-      [Fluffle::Client, Fluffle::Server].each do |mod|
-        mod.include Connectable
-      end
-    end
-
     # Fake RabbitMQ server presented through a subset of the `Bunny`
     # library's interface
     class Loopback
@@ -119,14 +127,8 @@ module Fluffle
         end
       end
 
-      class WorkPool
-        # No-op in testing
-        def join
-        end
-      end
-
     end # class LoopbackServer
   end # module Testing
 end # module Fluffle
 
-Fluffle::Testing.inject_connectable
+Fluffle::Testing.setup!

data/lib/fluffle/version.rb

@@ -1,3 +1,3 @@
 module Fluffle
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/fluffle.rb

@@ -10,16 +10,22 @@ require 'fluffle/handlers/dispatcher'
 require 'fluffle/server'
 
 module Fluffle
-  # Expand a short name into a fully-qualified one
-  def self.request_queue_name(name)
-    "fluffle.requests.#{name}"
-  end
+  class << self
+    attr_writer :logger
 
-  def self.response_queue_name(name)
-    "fluffle.responses.#{name}"
-  end
+    def logger
+      @logger ||= Logger.new $stdout
+    end
 
-  def self.logger
-    @logger ||= Logger.new $stdout
+    # Expand a short name into a fully-qualified one
+    def request_queue_name(name)
+      "fluffle.requests.#{name}"
+    end
+
+    def response_queue_name(name)
+      "fluffle.responses.#{name}"
+    end
   end
 end
+
+require 'fluffle/railtie' if defined? Rails

data/spec/server_spec.rb

@@ -36,9 +36,7 @@ describe Fluffle::Server do
       payload['method']  = method unless payload.key? 'method'
       payload['params']  = params unless payload.key? 'params'
 
-      subject.handle_request queue_name: 'fakequeue',
-                             handler: handler,
-                             delivery_info: double('DeliveryInfo'),
+      subject.handle_request handler: handler,
                              properties: { reply_to: reply_to },
                              payload: Oj.dump(payload)
     end
@@ -69,7 +67,7 @@ describe Fluffle::Server do
           id: id,
           method: method,
           params: params,
-          meta: { reply_to: reply_to }
+          meta: {}
         })
 
         result
@@ -80,6 +78,37 @@ describe Fluffle::Server do
       expect_response payload: { 'result' => result }
     end
 
+    it 'responds with the correct individual results for a batch request' do
+      payload = [
+        { 'jsonrpc' => '2.0', 'id' => 'first',  'method' => 'multiply', 'params' => [1] },
+        { 'jsonrpc' => '2.0', 'id' => 'second', 'method' => 'multiply', 'params' => [2] }
+      ]
+
+      handler = double 'Handler'
+      expect(handler).to receive(:call).twice do |args|
+        expect(args).to include({
+          id: anything,
+          method: 'multiply'
+        })
+
+        args[:params].first * 2
+      end
+
+      responses = []
+
+      allow(@exchange_spy).to receive(:publish).ordered do |payload_json, _opts|
+        responses << Oj.load(payload_json)
+      end
+
+      subject.handle_request handler: handler,
+                             properties: { reply_to: reply_to },
+                             payload: Oj.dump(payload)
+
+      expect(responses.length).to eq 2
+      expect(responses[0]).to include('id' => 'first',  'result' => 2)
+      expect(responses[1]).to include('id' => 'second', 'result' => 4)
+    end
+
     it 'responds with the appropriate code and message when method not found' do
       @method = 'notfound'
 

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
 require 'bundler/setup'
+require 'pry'
 
 require 'fluffle'
+
+Fluffle.logger.level = Logger::Severity::FATAL

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluffle
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Dirk Gadsden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-11 00:00:00.000000000 Z
+date: 2016-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -134,6 +134,7 @@ files:
 - lib/fluffle/handlers/base.rb
 - lib/fluffle/handlers/delegator.rb
 - lib/fluffle/handlers/dispatcher.rb
+- lib/fluffle/railtie.rb
 - lib/fluffle/server.rb
 - lib/fluffle/testing.rb
 - lib/fluffle/version.rb
@@ -152,7 +153,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="