process_handler 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3025924d4d9d6aabf01d20bb1fe3517f3d20ef1d
-  data.tar.gz: 55fb26289828ad292043ae2eb2ca1657d59286b4
+  metadata.gz: 5b3e99c6bdab6b69d12a5a474666c512174360e0
+  data.tar.gz: 3424ff7f14a8c0e219fd4dded8bde82e480f04ff
 SHA512:
-  metadata.gz: 9907397cf94e2c1e5c92881645bb6efd826bf0ccbcd831f59c5b964ac6f723dbfaf39c4e59d27c8b6f3b42287a737eead053f9924b710983db1c31321f5eb6c0
-  data.tar.gz: 745805dfd41786a6d69b5c1aaa667fa13e99bb1a76676b0abd53905bc5b32848e02b7d6d58b0f626259af24582fa1adaca528f89e77a05b42ce8475c302acce2
+  metadata.gz: dac9142e911cb9a56f1b877b6a8ec888521effd2201240bbffa58054ac8813a4280d1b8726924dd0a85cb3ecf4aa5653a9408f8f15903f3dccee38057e1af0fb
+  data.tar.gz: 07cd4ae7c681df57c7da57fc428e731404e05ada1666cf7a279ca7e26a8918d74c95b655ea77accdba97255094b9adab2ff59570b75e04445c702533a93b1da9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    process_handler (0.1.0)
+    process_handler (0.1.3)
       airbrake
       sucker_punch (~> 1.1)
 

data/lib/salemove/process_handler/pivot_process.rb

@@ -32,19 +32,79 @@ module Salemove
       def spawn(service, blocking: true)
         @process_monitor.start
 
-        @service_thread = ServiceSpawner.spawn(service, @messenger, @exception_notifier)
+        @service_threads = spawn_queue_threads(service).concat(spawn_tap_threads(service))
         blocking ? wait_for_monitor : Thread.new { wait_for_monitor }
       end
 
+      def spawn_queue_threads(service)
+        if service.class.const_defined?(:QUEUE)
+          [ServiceSpawner.spawn(service, @messenger, @exception_notifier)]
+        else
+          []
+        end
+      end
+
+      def spawn_tap_threads(service)
+        if service.class.const_defined?(:TAPPED_QUEUES)
+          service.class::TAPPED_QUEUES.map do |queue|
+            spawner = TapServiceSpawner.new(service, @messenger, @exception_notifier)
+            spawner.spawn(queue)
+          end
+        else
+          []
+        end
+      end
+
       private
 
+      def self.benchmark(input, &block)
+        type = input[:type] if input.is_a?(Hash)
+        result = nil
+
+        bm = Benchmark.measure { result = block.call }
+        if defined?(Logasm) && PivotProcess.logger.is_a?(Logasm)
+          PivotProcess.logger.debug "Execution time",
+            type: type, real: bm.real, user: bm.utime, system: bm.stime
+        end
+        result
+      end
+
       def wait_for_monitor
         sleep 1 while @process_monitor.running?
-        @service_thread.shutdown
-        @service_thread.join
+        @service_threads.each do |service_thread|
+          service_thread.shutdown
+          service_thread.join
+        end
         @process_monitor.shutdown
       end
 
+      class TapServiceSpawner
+        def initialize(service, messenger, exception_notifier)
+          @service = service
+          @messenger = messenger
+          @exception_notifier = exception_notifier
+        end
+
+        def spawn(queue)
+          @messenger.tap_into(queue) do |input|
+            delegate_to_service(input.merge(type: queue))
+          end
+        end
+
+        def delegate_to_service(input)
+          PivotProcess.benchmark(input) { @service.call(input) }
+        rescue => exception
+          handle_exception(exception, input)
+        end
+
+        def handle_exception(e, input)
+          PivotProcess.logger.error(e.inspect + "\n" + e.backtrace.join("\n"))
+          if @exception_notifier
+            @exception_notifier.notify_or_ignore(e, cgi_data: ENV.to_hash, parameters: input)
+          end
+        end
+      end
+
       class ServiceSpawner
         def self.spawn(service, messenger, exception_notifier)
           new(service, messenger, exception_notifier).spawn
@@ -100,7 +160,7 @@ module Salemove
         end
 
         def delegate_to_service(input)
-          result = benchmark(input) { @service.call(input) }
+          result = PivotProcess.benchmark(input) { @service.call(input) }
           PivotProcess.logger.info "Result: #{result.inspect}"
           result
         end
@@ -112,19 +172,6 @@ module Salemove
           end
           { success: false, error: e.message }
         end
-
-        def benchmark(input, &block)
-          type = input[:type] if input.is_a?(Hash)
-          result = nil
-
-          bm = Benchmark.measure { result = block.call }
-          if defined?(Logasm) && PivotProcess.logger.is_a?(Logasm)
-            PivotProcess.logger.debug "Execution time",
-              type: type, real: bm.real, user: bm.utime, system: bm.stime
-          end
-
-          result
-        end
       end
     end
   end

data/lib/salemove/process_handler/version.rb

@@ -1,5 +1,5 @@
 module Salemove
   module ProcessHandler
-    VERSION = '0.1.1'
+    VERSION = '0.1.3'
   end
 end

data/spec/process_handler/pivot_process_spec.rb

@@ -2,27 +2,15 @@ require 'logasm'
 require 'spec_helper'
 require 'salemove/process_handler/pivot_process'
 
-class ResultService
-  QUEUE = 'Dummy'
-end
-
 describe ProcessHandler::PivotProcess do
   let(:monitor)   { double('Monitor') }
   let(:messenger) { double('Messenger') }
   let(:handler)   { double('Handler') }
   let(:thread)    { double('Thread') }
-
-  subject { process.spawn(service) }
-  let(:service) { ResultService.new }
-
   let(:process) { ProcessHandler::PivotProcess.new(messenger, process_params) }
   let(:process_params) {{ process_monitor: monitor , notifier_factory: notifier_factory, env: 'test' }}
   let(:notifier_factory) { double('NotifierFactory') }
   let(:responder) { double(shutdown: true, join: true) }
-
-  let(:input) {{}}
-  let(:result) { {success: true, result: 'RESULT'} }
-
   let(:logger) { Logasm.new([]) }
 
   def expect_monitor_to_behave
@@ -31,155 +19,244 @@ describe ProcessHandler::PivotProcess do
     expect(monitor).to receive(:shutdown)
   end
 
-  def expect_message
-    expect(messenger).to receive(:respond_to) {|destination, &callback|
-      callback.call(input, handler)
-    }.and_return(responder)
-  end
-
-  def expect_handler_thread_to_behave
-    allow(handler).to receive(:success) { thread }
-    allow(handler).to receive(:error) { thread }
-    expect(responder).to receive(:shutdown)
-    expect(responder).to receive(:join)
-  end
-
   before do
     ProcessHandler::PivotProcess.logger = logger
     allow(notifier_factory).to receive(:get_notifier) { nil }
     expect_monitor_to_behave
-    expect_message
-    expect_handler_thread_to_behave
-    allow(service).to receive(:call).with(input) { result }
   end
 
-  describe 'when service responds correctly' do
 
-    it 'can be executed with logger' do
-      expect(handler).to receive(:success).with(result)
-      expect(service).to receive(:call).with(input)
-      subject()
+  describe 'responding services' do
+    class ResultService
+      QUEUE = 'Dummy'
     end
 
-  end
+    subject { process.spawn(service) }
+    let(:service) { ResultService.new }
 
-  describe 'when service responds with an error' do
-    let(:result) { { success: false, error: 'hey' } }
+    let(:input) {{}}
+    let(:result) { {success: true, result: 'RESULT'} }
 
-    before do
-      expect(service).to receive(:call).with(input) { result }
+    def expect_handler_thread_to_behave
+      allow(handler).to receive(:success) { thread }
+      allow(handler).to receive(:error) { thread }
+      expect(responder).to receive(:shutdown)
+      expect(responder).to receive(:join)
     end
 
-    it 'acks the message properly' do
-      expect(handler).to receive(:error).with(result)
-      subject()
-    end
-  end
 
-  shared_examples 'an error_handler' do
+    def expect_message
+      expect(messenger).to receive(:respond_to) {|destination, &callback|
+        callback.call(input, handler)
+      }.and_return(responder)
+    end
 
-    it 'logs error' do
-      expect(logger).to receive(:error)
-      subject()
+    before do
+      expect_message
+      expect_handler_thread_to_behave
+      allow(service).to receive(:call).with(input) { result }
     end
 
-    describe 'with exception_notifier' do
+    describe 'when service responds correctly' do
 
-      let(:exception_notifier) { double('Airbrake') }
+      it 'can be executed with logger' do
+        expect(handler).to receive(:success).with(result)
+        expect(service).to receive(:call).with(input)
+        subject()
+      end
+
+    end
+
+    describe 'when service responds with an error' do
+      let(:result) { { success: false, error: 'hey' } }
 
       before do
-        allow(notifier_factory).to receive(:get_notifier) { exception_notifier }
+        expect(service).to receive(:call).with(input) { result }
       end
 
-      it 'triggers exception_notifier' do
-        expect(exception_notifier).to receive(:notify_or_ignore)
+      it 'acks the message properly' do
+        expect(handler).to receive(:error).with(result)
         subject()
       end
     end
 
-  end
+    shared_examples 'an error_handler' do
 
-  describe 'when service raises exception' do
+      it 'logs error' do
+        expect(logger).to receive(:error)
+        subject()
+      end
 
-    let(:result) { { success: false, error: exception } }
-    let(:exception) { "what an unexpected exception!" }
+      describe 'with exception_notifier' do
 
-    before do
-      expect(service).to receive(:call).with(input) { raise exception }
-    end
+        let(:exception_notifier) { double('Airbrake') }
 
-    it 'acks the message properly' do
-      expect(handler).to receive(:error).with(result)
-      subject()
-    end
+        before do
+          allow(notifier_factory).to receive(:get_notifier) { exception_notifier }
+        end
 
-    it_behaves_like 'an error_handler'
+        it 'triggers exception_notifier' do
+          expect(exception_notifier).to receive(:notify_or_ignore)
+          subject()
+        end
+      end
 
-  end
+    end
 
-  describe 'when exception raises after service call' do
+    describe 'when service raises exception' do
 
-    let(:result) { { success: false, output: exception } }
-    let(:exception) { "no no no ... no inspect for you!" }
+      let(:result) { { success: false, error: exception } }
+      let(:exception) { "what an unexpected exception!" }
 
-    before do
-      expect(result).to receive(:inspect) { raise exception }
-    end
+      before do
+        expect(service).to receive(:call).with(input) { raise exception }
+      end
 
-    it 'still acks the message properly' do
-      subject()
-    end
+      it 'acks the message properly' do
+        expect(handler).to receive(:error).with(result)
+        subject()
+      end
 
-    it_behaves_like 'an error_handler'
+      it_behaves_like 'an error_handler'
 
-  end
+    end
 
-  describe 'when result is fulfillable' do
-    let(:result) { double }
+    describe 'when exception raises after service call' do
 
-    context 'and its already fulfilled' do
-      let(:value) { { success: true, output: { result: 'R'} } }
+      let(:result) { { success: false, output: exception } }
+      let(:exception) { "no no no ... no inspect for you!" }
 
       before do
-        allow(result).to receive(:fulfilled?) { true }
-        allow(result).to receive(:value) { value }
+        expect(result).to receive(:inspect) { raise exception }
       end
 
-      it 'responds immediately' do
-        expect(handler).to receive(:success).with(value)
+      it 'still acks the message properly' do
         subject()
       end
+
+      it_behaves_like 'an error_handler'
+
     end
 
-    context 'and its fulfilled later' do
-      let(:value) { { success: true, output: { result: 'R'} } }
+    describe 'when result is fulfillable' do
+      let(:result) { double }
 
-      before do
-        allow(result).to receive(:fulfilled?) { false }
-        Thread.new do
-          sleep 0.005
+      context 'and its already fulfilled' do
+        let(:value) { { success: true, output: { result: 'R'} } }
+
+        before do
           allow(result).to receive(:fulfilled?) { true }
           allow(result).to receive(:value) { value }
         end
+
+        it 'responds immediately' do
+          expect(handler).to receive(:success).with(value)
+          subject()
+        end
+      end
+
+      context 'and its fulfilled later' do
+        let(:value) { { success: true, output: { result: 'R'} } }
+
+        before do
+          allow(result).to receive(:fulfilled?) { false }
+          Thread.new do
+            sleep 0.005
+            allow(result).to receive(:fulfilled?) { true }
+            allow(result).to receive(:value) { value }
+          end
+        end
+
+        it 'responds when fulfilled' do
+          expect(handler).to receive(:success).with(value)
+          subject()
+        end
+      end
+
+      context 'and its never fulfilled' do
+        before do
+          allow(result).to receive(:fulfilled?) { false }
+          allow(result).to receive(:timeout) { 0.001 }
+        end
+
+        it 'responds with timeout error' do
+          expect(handler).to receive(:error).with(success: false, error: "Fulfillable response was not fulfilled")
+          subject
+        end
       end
+    end
+  end
 
-      it 'responds when fulfilled' do
-        expect(handler).to receive(:success).with(value)
+  describe 'tapping services' do
+    class TappingService
+      TAPPED_QUEUES = [
+        'one',
+        'two'
+      ]
+    end
+
+    subject { process.spawn(service) }
+    let(:service) { TappingService.new }
+    let(:tap_count) { TappingService::TAPPED_QUEUES.count }
+
+    let(:input) {{}}
+
+    def expect_tap_into
+      expect(messenger).to receive(:tap_into) do |destination, &callback|
+        callback.call(input)
+      end
+        .exactly(tap_count).times
+        .and_return(responder)
+    end
+
+    before do
+      expect_tap_into
+      expect(responder).to receive(:shutdown)
+      expect(responder).to receive(:join)
+      allow(service).to receive(:call).with(input)
+    end
+
+
+    describe 'when service handles the input correctly' do
+      it 'can be executed' do
+        expect(service).to receive(:call).with(input.merge(type: 'one'))
+        expect(service).to receive(:call).with(input.merge(type: 'two'))
         subject()
       end
     end
 
-    context 'and its never fulfilled' do
-      before do
-        allow(result).to receive(:fulfilled?) { false }
-        allow(result).to receive(:timeout) { 0.001 }
+    shared_examples 'an error_handler' do
+      it 'logs error' do
+        expect(logger).to receive(:error)
+        subject()
       end
 
-      it 'responds with timeout error' do
-        expect(handler).to receive(:error).with(success: false, error: "Fulfillable response was not fulfilled")
-        subject
+      describe 'with exception_notifier' do
+
+        let(:exception_notifier) { double('Airbrake') }
+
+        before do
+          allow(notifier_factory).to receive(:get_notifier) { exception_notifier }
+        end
+
+        it 'triggers exception_notifier' do
+          expect(exception_notifier).to receive(:notify_or_ignore)
+          subject()
+        end
       end
+
     end
-  end
 
+    describe 'when service raises exception' do
+      let(:exception) { "what an unexpected exception!" }
+
+      before do
+        expect(service).to receive(:call).with(input.merge(type: 'one')) {}
+        expect(service).to receive(:call).with(input.merge(type: 'two')) { raise exception }
+      end
+
+      it_behaves_like 'an error_handler'
+    end
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: process_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Indrek Juhkam
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-12 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: airbrake