lagomorph 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 483bc1b6e1a97b531654120b767eff3201166782
-  data.tar.gz: 07e0501db9e080fa6e60f619b5c976528b70f6b9
+  metadata.gz: b2d20cf2cb1f8a168b4ebb17fc72be5fbf8a0e50
+  data.tar.gz: 7031959395e7240bfa4949f36c882faf827cf500
 SHA512:
-  metadata.gz: 03b13faa49e5c457d4e79676a28e40ad8bde4d2c7ce0ed659504847490b5879398a3633ab770b9248fdb19733f3d3728d62d0a32556f02035c5d10b57cfc3c71
-  data.tar.gz: d175e19314090d8d766b40da4486026840c908213ce5ceb2fea927d0ceedb86ae66efcea25259fd16fdc64f2e61b1d01eca9c1778cc93aa393e7c47be456d89f
+  metadata.gz: 56c80bb6be3859710bbd42f5dec9476ab69e497f905bad332cbb2a77d4ed3e46f2753b5f9eb5507aebbed3bfe271acb0e0f4d2154fd64e017b3e542b8bce5db9
+  data.tar.gz: 147ec08b33614f341cda169b93adb711bea58d159fb79350a7c0e601effd4123142c597cae2f1d81e239a463c3218efb45916b4612edbd94f27465f3ad5c6b3e

data/README.md

@@ -1,6 +1,6 @@
 # Lagomorph
 
-[![Gem Version](https://badge.fury.io/rb/geokit.png)](http://badge.fury.io/rb/lagomorph)
+[![Gem Version](https://badge.fury.io/rb/lagomorph.png)](http://badge.fury.io/rb/lagomorph)
 [![Build Status](https://travis-ci.org/sealink/lagomorph.png?branch=master)](https://travis-ci.org/sealink/lagomorph)
 [![Coverage Status](https://coveralls.io/repos/sealink/lagomorph/badge.png)](https://coveralls.io/r/sealink/lagomorph)
 [![Dependency Status](https://gemnasium.com/sealink/lagomorph.png)](https://gemnasium.com/sealink/lagomorph)

data/lib/lagomorph/supervisor.rb

@@ -8,14 +8,17 @@ module Lagomorph
       @session = session
     end
 
-    def route(queue_name, worker_class)
-      prefetch = 10
-      durable  = false
+    def route(queue_name, worker_class, options = {})
+      prefetch    = options.fetch :prefetch,    10
+      durable     = options.fetch :durable,     false
+      subscribers = options.fetch :subscribers, 1
 
-      channel = @session.create_channel(prefetch)
-      queue   = QueueBuilder.new(channel).queue(queue_name, durable: durable)
+      subscribers.times.map do
+        channel = @session.create_channel(prefetch)
+        queue   = QueueBuilder.new(channel).queue(queue_name, durable: durable)
 
-      Subscriber.new(worker_class).subscribe(queue, channel)
+        Subscriber.new(worker_class).subscribe(queue, channel)
+      end
     end
 
   end

data/lib/lagomorph/version.rb

@@ -1,3 +1,3 @@
 module Lagomorph
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/spec/concurrency_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+require 'benchmark'
+
+require 'yaml'
+require 'lagomorph/session'
+require 'lagomorph/supervisor'
+require 'lagomorph/subscriber'
+require 'lagomorph/rpc_call'
+require 'lagomorph/exceptions'
+
+require 'pong_worker'
+
+describe 'a Lagomorph RPC process' do
+
+  let(:rabbitmq_config) {
+    YAML.load_file(
+      File.join(File.expand_path(File.dirname(__FILE__)),'rabbitmq.yml')
+    )
+  }
+
+  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' }
+
+    context 'with tasks of varying completion time' do
+      let(:queue)     { 'sleep' }
+      let!(:rpc_call) { Lagomorph::RpcCall.new(session) }
+      let!(:results)  { [] }
+      let(:threads) {
+        2.times.map {
+          Thread.new { results << rpc_call.dispatch(queue, 'nap', 1) }
+        }
+      }
+      let(:execution_time) {
+        Benchmark.realtime { threads.each(&:join) }
+      }
+
+      before do
+        supervisor.route queue, PongWorker, subscribers: number_subscribers
+      end
+
+      context 'with only one subscriber' do
+        let(:number_subscribers) { 1 }
+        it 'will return results after the sum of the execution time' do
+          expect(execution_time).to be > 2
+        end
+      end
+
+      context 'with multiple subscribers' do
+        let(:number_subscribers) { 2 }
+        it 'will return results before the sum of the execution time' do
+          expect(execution_time).to be < 2
+        end
+      end
+
+      after do
+        rpc_call.close_channel
+        session.close_connection
+      end
+    end
+
+    context 'when using 8 threads, with one instance per thread' do
+      before do
+        supervisor.route queue, PongWorker
+      end
+
+      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
+            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/lagomorph_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+
 require 'yaml'
 require 'lagomorph/session'
 require 'lagomorph/supervisor'
@@ -6,6 +7,8 @@ require 'lagomorph/subscriber'
 require 'lagomorph/rpc_call'
 require 'lagomorph/exceptions'
 
+require 'pong_worker'
+
 describe 'a Lagomorph RPC process' do
 
   let(:rabbitmq_config) {
@@ -14,20 +17,6 @@ describe 'a Lagomorph RPC process' do
     )
   }
 
-  class PongWorker  < Lagomorph::Worker
-    def pong
-      'pong'
-    end
-
-    def echo(request)
-      request
-    end
-
-    def generate_failure
-      fail 'Could not process request'
-    end
-  end
-
   context 'when supervising a PongWorker on the ping queue' do
     let(:connection_params) {
       {
@@ -47,58 +36,31 @@ describe 'a Lagomorph RPC process' do
       supervisor.route queue, PongWorker
     end
 
-    context 'and we have an rpc call' 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
-
-      context 'when a worker for an rpc call yields a nil result' do
-        let(:result) { rpc_call.dispatch(queue, 'echo', nil) }
-        it { expect(result).to eq nil }
-      end
+    let!(:rpc_call) { Lagomorph::RpcCall.new(session) }
 
-      context 'when a generate_failure rpc call is made on the ping queue' do
-        let(:result) { rpc_call.dispatch(queue, 'generate_failure') }
-        it { expect { result }.to raise_error Lagomorph::RpcError,
-                                              'Could not process request' }
-      end
-
-      after { rpc_call.close_channel }
+    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 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 }
+    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
 
-      let(:rpc_calls) {
-        1.upto(number_of_threads).map { Lagomorph::RpcCall.new(session) }
-      }
+    context 'when a worker for an rpc call yields a nil result' do
+      let(:result) { rpc_call.dispatch(queue, 'echo', nil) }
+      it { expect(result).to eq nil }
+    end
 
-      specify 'each thread will get the expected response' do
-        rpc_calls.map do |rpc_call|
-          Thread.new do
-            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
+    context 'when a method which fails is made on the ping queue' do
+      let(:result) { rpc_call.dispatch(queue, 'generate_failure') }
+      it { expect { result }.to raise_error Lagomorph::RpcError,
+                                            'Could not process request' }
     end
 
     after do
+      rpc_call.close_channel
       session.close_connection
     end
   end

data/spec/pong_worker.rb

@@ -0,0 +1,19 @@
+class PongWorker < Lagomorph::Worker
+  def pong
+    'pong'
+  end
+
+  def echo(request)
+    request
+  end
+
+  def nap(how_long)
+    sleep how_long
+    how_long
+  end
+
+  def generate_failure
+    fail 'Could not process request'
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lagomorph
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Alessandro Berardi
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-11-17 00:00:00.000000000 Z
+date: 2014-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -155,7 +155,9 @@ files:
 - lib/lagomorph/supervisor.rb
 - lib/lagomorph/version.rb
 - lib/lagomorph/worker.rb
+- spec/concurrency_spec.rb
 - spec/lagomorph_spec.rb
+- spec/pong_worker.rb
 - spec/rabbitmq.yml.example
 - spec/spec_helper.rb
 homepage: ''
@@ -183,6 +185,8 @@ signing_key:
 specification_version: 4
 summary: RPC Messaging pattern using RabbitMQ
 test_files:
+- spec/concurrency_spec.rb
 - spec/lagomorph_spec.rb
+- spec/pong_worker.rb
 - spec/rabbitmq.yml.example
 - spec/spec_helper.rb