lagomorph 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6cff4cf7c784a64394cd23dd70849e382667df5f
+  data.tar.gz: 21739a5e5f83a0be0ea5f4179f6f2dad7e4682d0
+SHA512:
+  metadata.gz: 3057276adb863de048a1b80a54f059b2359a326fbfe9d01f64b05c14caeb2349968c2fbe8ad2e186fc0104be3c69e70e9647620c2858766929bcc1c77b9c44ee
+  data.tar.gz: 79fc5bf8130caa38e2343e0a9f235bb7d1e5ddea4a3a2d20e28b36684ac39e02b260f6b0758cdfabd839756fbf62ed98d4dcb549c923ec28e4438b05ed3fdb6e

data/.gitignore

@@ -0,0 +1,16 @@
+/vendor/
+/.idea/
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+jruby-1.7.16

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lagomorph.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alessandro Berardi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# Lagomorph
+
+RPC Messaging pattern using RabbitMQ
+
+Lagomorph is a mammal of the order Lagomorpha, which comprises the hares, rabbits, and pikas.
+
+It's also a gem that implements the RPC pattern over AMPQ using RabbitMQ.
+In this case, it can work with either MRI (through the bunny gem) or jRuby 
+(via the march_hare gem).
+
+## Installation
+
+Add this to your application's Gemfile if you're on jruby:
+
+```ruby
+gem 'march_hare'
+gem 'lagomorph'
+```
+
+...and if you're on MRI, or rubinius:
+
+```ruby
+gem 'bunny'
+gem 'lagomorph'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lagomorph
+
+## Usage
+
+Lagomorph tries to maintain a healthy distance from your code. It wants
+you to be in control.
+
+Let's say you have a complicated bit of work, that looks like this:
+
+```ruby
+  class PongWorker
+    def ponger
+      'pong'
+    end
+  end
+```
+
+Then, you could set it going in a super micro-service type of way with
+this bootup:
+
+```ruby
+  connection_params = {} # passed along to RabbitMQ connect
+  session    = Lagomorph::Session.connect(connection_params)
+  supervisor = Lagomorph::Supervisor.new(session)
+  supervisor.route 'ping', PongWorker
+
+  trap("SIGINT") { puts "Bye!"; exit! }
+
+  # Let the supervisor run in the background,
+  # while the main thread does nothing
+  sleep
+```
+
+Now to utilise this amazing service, we would use the rpc call client:
+
+```ruby
+  connection_params = {} # passed along to RabbitMQ connect
+  session    = Lagomorph::Session.connect(connection_params)
+
+  rpc_call = Lagomorph::RpcCall.new(session)
+  result   = rpc_call.dispatch(queue, 'ponger')
+
+  puts "The result should be 'pong'.  Is it: #{result}?"
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/lagomorph/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/lagomorph.gemspec

@@ -0,0 +1,47 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lagomorph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lagomorph"
+  spec.version       = Lagomorph::VERSION
+  spec.authors       = ["Alessandro Berardi", "Adam Davies"]
+  spec.email         = ["berardialessandro@gmail.com", "adzdavies@gmail.com"]
+  spec.summary       = %q{RPC Messaging pattern using RabbitMQ}
+  spec.description   = %q{
+    Lagomorph is a mammal of the order Lagomorpha, which comprises the hares, rabbits, and pikas.
+
+    It's also a gem that implements the RPC pattern over AMPQ using RabbitMQ.
+    In this case, it can work with either MRI (through the bunny gem) or jRuby 
+    (via the march_hare gem).
+  }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # You'll have to include one of these when you use it
+  # since gem-build will include one or both...
+  #  if RUBY_PLATFORM == 'java' # jruby
+  #    spec.add_dependency 'march_hare'
+  #  else # mri
+  #    spec.add_dependency 'bunny'
+  #  end
+  spec.add_dependency 'json'
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+
+  # Switch your platform when spec'ing...
+  if RUBY_PLATFORM == 'java' # jruby
+    spec.add_development_dependency 'march_hare'
+  else # mri
+    spec.add_development_dependency 'bunny'
+  end
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+
+end

data/lib/lagomorph.rb

@@ -0,0 +1,32 @@
+require 'lagomorph/version'
+
+module Lagomorph
+
+  def self.using_march_hare?
+    using? 'march_hare'
+  end
+
+
+  def self.using_bunny?
+    using? 'bunny'
+  end
+
+
+  private
+
+  def self.using?(gem_name)
+    !Gem.loaded_specs[gem_name].nil?
+  end
+
+end
+
+if Lagomorph.using_bunny?
+  require 'bunny'
+else
+  require 'march_hare'
+end
+
+require 'lagomorph/session'
+require 'lagomorph/subscriber'
+require 'lagomorph/supervisor'
+require 'lagomorph/rpc_call'

data/lib/lagomorph/json_parser.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module Lagomorph
+  class JsonParser
+
+    def parse_request(payload)
+      request_message = JSON.parse(payload)
+      method          = request_message.fetch('method')
+      params          = request_message.fetch('params', [])
+      return method, params
+    end
+
+    def parse_response(response)
+      JSON.parse(response)
+    end
+
+    def build_request(method, *params)
+      JSON.generate('method' => method, 'params' => params)
+    end
+
+    def build_response(result)
+      JSON.generate('result' => result)
+    end
+
+    def build_error(error)
+      JSON.generate('error' => error)
+    end
+
+  end
+end

data/lib/lagomorph/metadata_adapter.rb

@@ -0,0 +1,17 @@
+module Lagomorph
+  MetadataAdapter = Struct.new(:delivery_info, :properties) do
+
+    def delivery_tag
+      delivery_info.delivery_tag
+    end
+
+    def reply_to
+      properties.reply_to
+    end
+
+    def correlation_id
+      properties.correlation_id
+    end
+
+  end
+end

data/lib/lagomorph/queue_adapter.rb

@@ -0,0 +1,22 @@
+require 'lagomorph/metadata_adapter'
+
+module Lagomorph
+  QueueAdapter = Struct.new(:queue) do
+
+    def subscribe(options = {}, &block)
+      if Lagomorph.using_bunny?
+        queue.subscribe(options) do |delivery_info, properties, payload|
+          metadata = MetadataAdapter.new(delivery_info, properties)
+          block.call(metadata, payload)
+        end
+      else
+        queue.subscribe(options, &block)
+      end
+    end
+
+    def name
+      queue.name
+    end
+
+  end
+end

data/lib/lagomorph/queue_builder.rb

@@ -0,0 +1,15 @@
+require 'lagomorph/queue_adapter'
+require 'lagomorph/metadata_adapter'
+
+module Lagomorph
+  QueueBuilder = Struct.new(:channel) do
+    def queue(name, opts={})
+      QueueAdapter.new(channel.queue(name, opts))
+    end
+
+    # Build a reply queue
+    def reply_queue
+      queue('', exclusive: true)
+    end
+  end
+end

data/lib/lagomorph/rpc_call.rb

@@ -0,0 +1,84 @@
+require 'lagomorph/queue_adapter'
+require 'lagomorph/json_parser'
+require 'securerandom'
+
+module Lagomorph
+  class RpcCall
+
+    def initialize(session)
+      @session = session
+      @results = {}
+      @mutex = Monitor.new
+    end
+
+    def dispatch(queue_name, method, *params)
+      @queue_name = queue_name
+
+      correlation_id = calculate_correlation_id
+      @mutex.synchronize do
+        @results[correlation_id] = ::Queue.new
+      end
+
+      prepare_channel
+      payload = prepare_payload(method, *params)
+      publish_rpc_call(payload, correlation_id)
+      response = block_till_receive_response(correlation_id)
+
+      response['result'] || (fail response.fetch('error'))
+    end
+
+    def close_channel
+      @channel.close
+      @prepared_channel = false
+    end
+
+    private
+
+    def prepare_channel
+      return if @prepared_channel
+
+      @channel = @session.create_channel(1)
+
+      @exchange    = @channel.default_exchange
+      @reply_queue = QueueBuilder.new(@channel).reply_queue
+
+      listen_for_responses
+
+      @prepared_channel = true
+    end
+
+    def publish_rpc_call(request, correlation_id)
+      @exchange.publish(request, routing_key:    @queue_name,
+                                 correlation_id: correlation_id,
+                                 reply_to:       @reply_queue.name
+      )
+    end
+
+    def prepare_payload(method, *params)
+      JsonParser.new.build_request(method, *params)
+    end
+
+    def calculate_correlation_id
+      SecureRandom.uuid
+    end
+
+    def listen_for_responses
+      @reply_queue.subscribe(block: false) do |metadata, payload|
+        @results[metadata.correlation_id].push(payload)
+      end
+    end
+
+    def block_till_receive_response(correlation_id)
+      raw_response = @results[correlation_id].pop # blocks until can pop
+      response = parse_response(raw_response)
+      @results.delete(correlation_id)
+
+      response
+    end
+
+    def parse_response(response)
+      JsonParser.new.parse_response(response)
+    end
+
+  end
+end

data/lib/lagomorph/session.rb

@@ -0,0 +1,55 @@
+module Lagomorph
+  class Session
+
+    CONNECTION_PARAM_KEYS = [
+      :host,
+      :heartbeat_interval,
+      :username,
+      :password,
+      :port
+    ]
+
+
+    def self.connect(connection_params)
+      new(connection_params).tap(&:open_connection)
+    end
+
+
+    def initialize(connection_params)
+      @connection_params = connection_params.select { |key,_|
+        CONNECTION_PARAM_KEYS.include?(key)
+      }
+      @mutex = Monitor.new
+    end
+
+    def open_connection
+      @mutex.synchronize do
+        @connection ||= if Lagomorph.using_bunny?
+                          ::Bunny.new(@connection_params).tap(&:start)
+                        else
+                          ::MarchHare.connect(@connection_params)
+                        end
+      end
+    end
+
+    def close_connection
+      return if @connection.nil? || @connection.closed?
+      @mutex.synchronize do
+        @connection.close
+      end
+    end
+
+    def create_channel(prefetch = nil)
+      @mutex.synchronize do
+        channel = @connection.create_channel
+        if Lagomorph.using_bunny?
+          channel.prefetch(prefetch)
+        else
+          channel.prefetch = prefetch
+        end
+        channel
+      end
+    end
+
+  end
+end

data/lib/lagomorph/subscriber.rb

@@ -0,0 +1,42 @@
+require 'lagomorph/json_parser'
+
+module Lagomorph
+  class Subscriber
+
+    def initialize(worker_class)
+      @worker_class = worker_class
+    end
+
+    def subscribe(queue, channel)
+      queue.subscribe(manual_ack: true, block: false) do |metadata, payload|
+        result   = process_request(payload)
+        response = build_response(result)
+        channel.ack(metadata.delivery_tag)
+        publish_response(channel, metadata, response)
+      end
+    end
+
+
+    private
+
+    def process_request(request)
+      method, params = parse_request(request)
+      @worker_class.new.send(method, *params)
+    end
+
+    def publish_response(channel, metadata, payload)
+      channel.default_exchange.publish(payload,
+                                       routing_key:    metadata.reply_to,
+                                       correlation_id: metadata.correlation_id)
+    end
+
+    def parse_request(payload)
+      JsonParser.new.parse_request(payload)
+    end
+
+    def build_response(result)
+      JsonParser.new.build_response(result)
+    end
+
+  end
+end

data/lib/lagomorph/supervisor.rb

@@ -0,0 +1,22 @@
+require 'lagomorph/queue_builder'
+require 'lagomorph/json_parser'
+
+module Lagomorph
+  class Supervisor
+
+    def initialize(session)
+      @session = session
+    end
+
+    def route(queue_name, worker_class)
+      prefetch = 10
+      durable  = false
+
+      channel = @session.create_channel(prefetch)
+      queue   = QueueBuilder.new(channel).queue(queue_name, durable: durable)
+
+      Subscriber.new(worker_class).subscribe(queue, channel)
+    end
+
+  end
+end

data/lib/lagomorph/version.rb

@@ -0,0 +1,3 @@
+module Lagomorph
+  VERSION = "0.0.1"
+end

data/spec/lagomorph_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'yaml'
+require 'lagomorph/session'
+require 'lagomorph/supervisor'
+require 'lagomorph/subscriber'
+require 'lagomorph/rpc_call'
+
+describe 'a Lagomorph RPC process' do
+
+  let(:rabbitmq_config) {
+    YAML.load_file(
+      File.join(File.expand_path(File.dirname(__FILE__)),'rabbitmq.yml')
+    )
+  }
+
+  class PongWorker
+    def pong
+      'pong'
+    end
+
+    def echo(request)
+      request
+    end
+  end
+
+  context 'when supervising a PongWorker on the ping queue' do
+    let(:connection_params) {
+      {
+        host:     rabbitmq_config.fetch('host'),
+        username: rabbitmq_config.fetch('username'),
+        password: rabbitmq_config.fetch('password')
+      }
+    }
+
+    let(:session) { Lagomorph::Session.connect(connection_params) }
+
+    let(:supervisor) { Lagomorph::Supervisor.new(session) }
+
+    let(:queue) { 'ping' }
+
+    before do
+      supervisor.route queue, PongWorker
+    end
+
+    context 'and we have an rpc call manager thingy' do
+      let!(:rpc_call) { Lagomorph::RpcCall.new(session) }
+
+      context 'when a pong rpc call is made on the ping queue' do
+        let(:result) { rpc_call.dispatch(queue, 'pong') }
+        it { expect(result).to eq 'pong' }
+      end
+
+      context 'when an echo rpc call is made on the ping queue' do
+        let(:result) { rpc_call.dispatch(queue, 'echo', 'test') }
+        it { expect(result).to eq 'test' }
+      end
+      after { rpc_call.close_channel }
+    end
+
+    context 'when using 8 threads, with one instance per thread' do
+      let(:number_of_threads) { 8 }
+      let(:total_calls) { 800 }
+      let(:calls_per_thread) { (total_calls / number_of_threads).ceil }
+
+      let(:rpc_calls) {
+        1.upto(number_of_threads).map { Lagomorph::RpcCall.new(session) }
+      }
+
+      specify 'each thread will get the expected response' do
+        rpc_calls.map do |rpc_call|
+          Thread.new do
+            thread_results = calls_per_thread.times.map { |call_index|
+              rpc_call.dispatch(queue, 'echo', call_index).tap { |result|
+                expect(result).to eq call_index
+              }
+            }
+          end
+        end.each(&:join)
+
+        rpc_calls.each(&:close_channel)
+      end
+    end
+
+    after do
+      session.close_connection
+    end
+  end
+
+end

data/spec/rabbitmq.yml.example

@@ -0,0 +1,3 @@
+host:     '127.0.0.1'
+username: 'guest'
+password: 'guest'

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'lagomorph'

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: lagomorph
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alessandro Berardi
+- Adam Davies
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: json
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: march_hare
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n    Lagomorph is a mammal of the order Lagomorpha, which comprises\
+  \ the hares, rabbits, and pikas.\n\n    It's also a gem that implements the RPC\
+  \ pattern over AMPQ using RabbitMQ.\n    In this case, it can work with either MRI\
+  \ (through the bunny gem) or jRuby \n    (via the march_hare gem).\n  "
+email:
+- berardialessandro@gmail.com
+- adzdavies@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lagomorph.gemspec
+- lib/lagomorph.rb
+- lib/lagomorph/json_parser.rb
+- lib/lagomorph/metadata_adapter.rb
+- lib/lagomorph/queue_adapter.rb
+- lib/lagomorph/queue_builder.rb
+- lib/lagomorph/rpc_call.rb
+- lib/lagomorph/session.rb
+- lib/lagomorph/subscriber.rb
+- lib/lagomorph/supervisor.rb
+- lib/lagomorph/version.rb
+- spec/lagomorph_spec.rb
+- spec/rabbitmq.yml.example
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: RPC Messaging pattern using RabbitMQ
+test_files:
+- spec/lagomorph_spec.rb
+- spec/rabbitmq.yml.example
+- spec/spec_helper.rb