shoryuken 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e3626c435f7da14e0880fabb7faf65e397aa82e0
-  data.tar.gz: 37461e552bc0566e3edd7a79a9dbbe92bbdbb5a2
+  metadata.gz: 53d21819575a7b12f3697e5c06b390519f164baa
+  data.tar.gz: 967d57ff341f98b950661ca8d249b90a044ca08a
 SHA512:
-  metadata.gz: 2a0b1138fcfaf8453e9ae9770dd8f70f4d5db75b81c5b66d5ca740cc92eefd585c7c396bce94a6401527c4465a5d8aa3bdfcfa00ab001567491a45c564e0d993
-  data.tar.gz: 64dfb7449d054cdee861632ca32cf09f47215f400b81025ae5d2481dbcc0ab062e780c6b9a47e23ffb0ae3bf697924b965b7a8e048a7b866535d5dc92021e6c0
+  metadata.gz: a00ede2ec62aa8be31528aed16634bd1e99f04d5be4345b36fd1fa0c9baf01131a45ad6559c87a5f37432c95ca21a8a0d00060b85c9c60b94d4a7c3e01e0f651
+  data.tar.gz: 1fe49809c4a90e468a945979aebb1407f55d32a681788e882c82d08482dd768c571fe8e229dc3677ae6aeece348477fbd944ff7d04f80bdae7f8e258a35a6de3

data/CHANGELOG.md

@@ -1,4 +1,9 @@
-## [v3.1.1] - 2017-07-02
+## [v3.1.2] - 2017-07-06
+
+- Fix stack level too deep on Ubuntu
+ - [#400](https://github.com/phstc/shoryuken/pull/400)
+
+## [v3.1.1] - 2017-07-05
 
 - Reduce log verbosity introduced in 3.1.0
  - [#397](https://github.com/phstc/shoryuken/pull/397)

data/lib/shoryuken/launcher.rb

@@ -62,8 +62,6 @@ module Shoryuken
     def initiate_stop
       logger.info { 'Shutting down' }
 
-      @managers.each(&:stop)
-
       stop_callback
     end
 
@@ -90,7 +88,8 @@ module Shoryuken
         Shoryuken::Manager.new(
           Shoryuken::Fetcher.new(group),
           Shoryuken.polling_strategy(group).new(options[:queues]),
-          options[:concurrency]
+          options[:concurrency],
+          executor
         )
       end
     end

data/lib/shoryuken/manager.rb

@@ -6,33 +6,37 @@ module Shoryuken
     # See https://github.com/phstc/shoryuken/issues/348#issuecomment-292847028
     MIN_DISPATCH_INTERVAL = 0.1
 
-    def initialize(fetcher, polling_strategy, concurrency)
+    def initialize(fetcher, polling_strategy, concurrency, executor)
       @fetcher          = fetcher
       @polling_strategy = polling_strategy
       @max_processors   = concurrency
       @busy_processors  = Concurrent::AtomicFixnum.new(0)
-      @done             = Concurrent::AtomicBoolean.new(false)
+      @executor         = executor
     end
 
     def start
-      dispatch
+      dispatch_loop
     end
 
-    def stop
-      @done.make_true
+    private
+
+    def running?
+      @executor.running?
     end
 
-    private
+    def dispatch_loop
+      return unless running?
 
-    def stopped?
-      @done.true?
+      Concurrent::Promise.execute(
+        executor: @executor
+      ) { dispatch }.then { dispatch_loop }.rescue { |ex| raise ex }
     end
 
     def dispatch
-      return if stopped?
+      return unless running?
 
       if ready <= 0 || (queue = @polling_strategy.next_queue).nil?
-        return dispatch_later
+        return sleep(MIN_DISPATCH_INTERVAL)
       end
 
       fire_event(:dispatch)
@@ -40,13 +44,6 @@ module Shoryuken
       logger.debug { "Ready: #{ready}, Busy: #{busy}, Active Queues: #{@polling_strategy.active_queues}" }
 
       batched_queue?(queue) ? dispatch_batch(queue) : dispatch_single_messages(queue)
-
-      dispatch
-    end
-
-    def dispatch_later
-      sleep(MIN_DISPATCH_INTERVAL)
-      dispatch
     end
 
     def busy
@@ -62,15 +59,15 @@ module Shoryuken
     end
 
     def assign(queue_name, sqs_msg)
-      return if stopped?
+      return unless running?
 
       logger.debug { "Assigning #{sqs_msg.message_id}" }
 
       @busy_processors.increment
 
-      Concurrent::Promise.execute {
-        Processor.new(queue_name, sqs_msg).process
-      }.then { processor_done }.rescue { processor_done }
+      Concurrent::Promise.execute(
+        executor: @executor
+      ) { Processor.process(queue_name, sqs_msg) }.then { processor_done }.rescue { processor_done }
     end
 
     def dispatch_batch(queue)

data/lib/shoryuken/processor.rb

@@ -4,6 +4,10 @@ module Shoryuken
 
     attr_reader :queue, :sqs_msg
 
+    def self.process(queue, sqs_msg)
+      new(queue, sqs_msg).process
+    end
+
     def initialize(queue, sqs_msg)
       @queue   = queue
       @sqs_msg = sqs_msg

data/lib/shoryuken/version.rb

@@ -1,3 +1,3 @@
 module Shoryuken
-  VERSION = '3.1.1'.freeze
+  VERSION = '3.1.2'.freeze
 end

data/spec/shoryuken/manager_spec.rb

@@ -13,8 +13,9 @@ RSpec.describe Shoryuken::Manager do
   let(:polling_strategy) { Shoryuken::Polling::WeightedRoundRobin.new(queues) }
   let(:fetcher) { double Shoryuken::Fetcher }
   let(:concurrency) { 1 }
+  let(:executor) { Concurrent::ImmediateExecutor.new }
 
-  subject { Shoryuken::Manager.new(fetcher, polling_strategy, concurrency) }
+  subject { Shoryuken::Manager.new(fetcher, polling_strategy, concurrency, executor) }
 
   before do
     allow(fetcher).to receive(:fetch).and_return([])
@@ -27,9 +28,9 @@ RSpec.describe Shoryuken::Manager do
 
   describe '#stop' do
     specify do
-      allow(subject).to receive(:stopped?).and_return(false, false, true)
-      expect(subject).to receive(:dispatch).thrice.and_call_original
-      expect(subject).to receive(:dispatch_later).once.and_call_original
+      allow(subject).to receive(:running?).and_return(true, true, false)
+      expect(subject).to receive(:dispatch).once.and_call_original
+      expect(subject).to receive(:dispatch_loop).twice.and_call_original
       subject.start
     end
   end
@@ -37,12 +38,12 @@ RSpec.describe Shoryuken::Manager do
   describe '#start' do
     before do
       # prevent dispatch loop
-      allow(subject).to receive(:stopped?).and_return(false, true)
+      allow(subject).to receive(:running?).and_return(true, true, false)
     end
 
     it 'pauses when there are no active queues' do
       expect(polling_strategy).to receive(:next_queue).and_return(nil)
-      expect(subject).to receive(:dispatch_later)
+      expect(subject).to receive(:dispatch).and_call_original
       subject.start
     end
 
@@ -59,24 +60,36 @@ RSpec.describe Shoryuken::Manager do
   end
 
   describe '#dispatch' do
-    it 'fires a dispatch event' do
-      # prevent dispatch loop
-      allow(subject).to receive(:stopped?).and_return(false, true)
+    before do
+      allow(subject).to receive(:running?).and_return(true, true, false)
+    end
 
+    specify do
+      message  = ['test1']
+      messages = [message]
+      q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
+
+      expect(fetcher).to receive(:fetch).with(q, concurrency).and_return(messages)
       expect(subject).to receive(:fire_event).with(:dispatch)
+      expect(Shoryuken::Processor).to receive(:process).with(q, message)
       expect(Shoryuken.logger).to_not receive(:info)
 
       subject.send(:dispatch)
     end
-  end
 
-  describe '#dispatch_batch' do
-    it 'assings batch as a single message' do
-      q = polling_strategy.next_queue
-      messages = [1, 2, 3]
-      expect(fetcher).to receive(:fetch).with(q, described_class::BATCH_LIMIT).and_return(messages)
-      expect_any_instance_of(described_class).to receive(:assign).with(q.name, messages)
-      subject.send(:dispatch_batch, q)
+    context 'when batch' do
+      specify do
+        messages = %w(test1 test2 test3)
+        q = Shoryuken::Polling::QueueConfiguration.new(queue, {})
+
+        expect(fetcher).to receive(:fetch).with(q, described_class::BATCH_LIMIT).and_return(messages)
+        expect(subject).to receive(:fire_event).with(:dispatch)
+        allow(subject).to receive(:batched_queue?).with(q).and_return(true)
+        expect(Shoryuken::Processor).to receive(:process).with(q, messages)
+        expect(Shoryuken.logger).to_not receive(:info)
+
+        subject.send(:dispatch)
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shoryuken
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
 - Pablo Cantero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-05 00:00:00.000000000 Z
+date: 2017-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler