roundhouse-x 0.1.0

data/test/test_exception_handler.rb

@@ -0,0 +1,55 @@
+require_relative 'helper'
+require 'roundhouse/exception_handler'
+require 'stringio'
+require 'logger'
+
+ExceptionHandlerTestException = Class.new(StandardError)
+TEST_EXCEPTION = ExceptionHandlerTestException.new("Something didn't work!")
+
+class Component
+  include Roundhouse::ExceptionHandler
+
+  def invoke_exception(args)
+    raise TEST_EXCEPTION
+  rescue ExceptionHandlerTestException => e
+    handle_exception(e,args)
+  end
+end
+
+class TestExceptionHandler < Roundhouse::Test
+  describe "with mock logger" do
+    before do
+      @old_logger = Roundhouse.logger
+      @str_logger = StringIO.new
+      Roundhouse.logger = Logger.new(@str_logger)
+    end
+
+    after do
+      Roundhouse.logger = @old_logger
+    end
+
+    it "logs the exception to Roundhouse.logger" do
+      Component.new.invoke_exception(:a => 1)
+      @str_logger.rewind
+      log = @str_logger.readlines
+      assert_match(/a=>1/, log[0], "didn't include the context")
+      assert_match(/Something didn't work!/, log[1], "didn't include the exception message")
+      assert_match(/test\/test_exception_handler.rb/, log[2], "didn't include the backtrace")
+    end
+
+    describe "when the exception does not have a backtrace" do
+      it "does not fail" do
+        exception = ExceptionHandlerTestException.new
+        assert_nil exception.backtrace
+
+        begin
+          Component.new.handle_exception exception
+          pass
+        rescue StandardError
+          flunk "failed handling a nil backtrace"
+        end
+      end
+    end
+  end
+
+end

data/test/test_fetch.rb

@@ -0,0 +1,206 @@
+require_relative 'helper'
+require 'roundhouse/fetch'
+require 'roundhouse/monitor'
+require 'roundhouse/api'
+
+class TestFetcher < Roundhouse::Test
+  describe 'fetcher' do
+    before do
+      Roundhouse.redis = { :url => REDIS_URL, :namespace => 'fuzzy' }
+      Roundhouse.redis { |conn| conn.flushdb }
+    end
+
+    after do
+      Roundhouse.redis = REDIS
+    end
+
+    describe '#retrieve_work' do
+      describe 'when nominal' do
+        before do
+          Roundhouse.redis do |conn|
+            conn.lpush(Roundhouse::Monitor::SEMAPHORE, 100)
+            conn.hset(Roundhouse::Monitor.status_bucket(100), 100, Roundhouse::Monitor::ACTIVE)
+            conn.lpush("#{Roundhouse::Monitor::QUEUE}:100", 'msg')
+          end
+        end
+
+        it 'retrieves' do
+          fetch = Roundhouse::RoundRobinFetch.new
+          uow = fetch.retrieve_work
+          refute_nil uow
+          assert_equal '100', uow.queue_id
+          assert_equal 'msg', uow.message
+          q = Roundhouse::Queue.new(100)
+          assert_equal 0, q.size
+          uow.requeue
+          assert_equal 1, q.size
+          assert_nil uow.acknowledge
+        end
+      end
+
+      describe 'with empty status' do
+        before do
+          Roundhouse.redis do |conn|
+            conn.lpush(Roundhouse::Monitor::SEMAPHORE, 100)
+            conn.lpush(Roundhouse::Monitor::SEMAPHORE, 200)
+            conn.hset(Roundhouse::Monitor.status_bucket(100), 100, Roundhouse::Monitor::EMPTY)
+            conn.hset(Roundhouse::Monitor.status_bucket(200), 200, Roundhouse::Monitor::ACTIVE)
+            conn.lpush("#{Roundhouse::Monitor::QUEUE}:200", 'msg-200')
+          end
+        end
+
+        it 'skips queues with empty status' do
+          fetch = Roundhouse::RoundRobinFetch.new
+          uow = fetch.retrieve_work
+          refute_nil uow
+          assert_equal '200', uow.queue_id
+          assert_equal 'msg-200', uow.message
+          q = Roundhouse::Queue.new(200)
+          assert_equal 0, q.size
+          uow.requeue
+          assert_equal 1, q.size
+          assert_nil uow.acknowledge
+        end
+      end
+
+      describe 'with active status and empty queue' do
+        before do
+          Roundhouse.redis do |conn|
+            conn.lpush(Roundhouse::Monitor::SEMAPHORE, 100)
+            conn.lpush(Roundhouse::Monitor::SEMAPHORE, 200)
+            conn.hset(Roundhouse::Monitor.status_bucket(100), 100, Roundhouse::Monitor::ACTIVE)
+            conn.hset(Roundhouse::Monitor.status_bucket(200), 200, Roundhouse::Monitor::ACTIVE)
+            conn.lpush("#{Roundhouse::Monitor::QUEUE}:200", 'msg-200')
+          end
+        end
+
+        it 'skips queues with empty status' do
+          empty_queue = Roundhouse::Queue.new(100)
+          assert_equal 0, empty_queue.size
+          assert_equal :active, empty_queue.status
+
+          fetch = Roundhouse::RoundRobinFetch.new
+          uow = fetch.retrieve_work
+          refute_nil uow
+          assert_equal '200', uow.queue_id
+          assert_equal 'msg-200', uow.message
+
+          # After fetching, should set the active status
+          # of an empty queue to empty
+          assert_equal :empty, empty_queue.status
+
+          # The filled queue should act as normal
+          q = Roundhouse::Queue.new(200)
+          assert_equal 0, q.size
+          uow.requeue
+          assert_equal 1, q.size
+          assert_nil uow.acknowledge
+        end
+      end
+
+      describe 'with suspended status' do
+        before do
+          Roundhouse.redis do |conn|
+            conn.lpush(Roundhouse::Monitor::SEMAPHORE, 100)
+            conn.lpush(Roundhouse::Monitor::SEMAPHORE, 200)
+            conn.hset(Roundhouse::Monitor.status_bucket(100), 100, Roundhouse::Monitor::SUSPENDED)
+            conn.hset(Roundhouse::Monitor.status_bucket(200), 200, Roundhouse::Monitor::ACTIVE)
+            conn.lpush("#{Roundhouse::Monitor::QUEUE}:100", 'msg-100')
+            conn.lpush("#{Roundhouse::Monitor::QUEUE}:200", 'msg-200')
+          end
+        end
+
+        it 'skips queues with suspended status' do
+          fetch = Roundhouse::RoundRobinFetch.new
+          uow = fetch.retrieve_work
+          refute_nil uow
+          assert_equal '200', uow.queue_id
+          assert_equal 'msg-200', uow.message
+
+          # Should not touch the work in suspended queue
+          suspended_q = Roundhouse::Queue.new(100)
+          assert_equal 1, suspended_q.size
+
+          q = Roundhouse::Queue.new(200)
+          assert_equal 0, q.size
+          uow.requeue
+          assert_equal 1, q.size
+          assert_nil uow.acknowledge
+        end
+      end
+
+    end
+
+    it 'bulk requeues' do
+      q1 = Roundhouse::Queue.new(1000)
+      q2 = Roundhouse::Queue.new(2000)
+      assert_equal 0, q1.size
+      assert_equal 0, q2.size
+      uow = Roundhouse::RoundRobinFetch::UnitOfWork
+      Roundhouse::RoundRobinFetch.bulk_requeue([uow.new('fuzzy:queue:1000', 'bob'), uow.new('fuzzy:queue:1000', 'bar'), uow.new('fuzzy:queue:2000', 'widget')], {:queues => []})
+      assert_equal 2, q1.size
+      assert_equal 1, q2.size
+
+      # Changed bulk requeues not to change status
+      # Not sure if this is a good idea yet
+      #assert_equal :active, q1.status
+      #assert_equal :active, q2.status
+    end
+
+    describe 'fetching' do
+      before do
+        Roundhouse::Fetcher.reset
+      end
+
+      it 'instantiates' do
+        begin
+          Roundhouse.options[:fetch] = NullFetch
+          mgr = Minitest::Mock.new
+          fetch = Roundhouse::Fetcher.new(mgr, {})
+          fetch.fetch
+          Roundhouse::Fetcher.done!
+        ensure
+          Roundhouse.options[:fetch] = Roundhouse::RoundRobinFetch
+        end
+      end
+
+      class NullFetch
+        def initialize(opts)
+        end
+        def retrieve_work
+        end
+        def self.bulk_requeue(*args)
+        end
+      end
+
+      it 'handles redis network errors' do
+        begin
+          Roundhouse.logger.level = Logger::FATAL
+          Roundhouse.options[:fetch] = ErrorFetch
+          mgr = Minitest::Mock.new
+          fetch = Roundhouse::Fetcher.new(mgr, {})
+          def fetch.pause
+          end
+          refute fetch.down
+          fetch.fetch
+          Roundhouse::Fetcher.done!
+          assert fetch.down
+        ensure
+          Roundhouse.options[:fetch] = Roundhouse::RoundRobinFetch
+          Roundhouse.logger.level = Logger::ERROR
+        end
+      end
+
+      class ErrorFetch
+        def initialize(opts)
+        end
+        def retrieve_work
+          raise IOError, "ker-BOOM"
+        end
+        def self.bulk_requeue(*args)
+        end
+      end
+    end
+
+  end
+end

data/test/test_logging.rb

@@ -0,0 +1,34 @@
+require_relative 'helper'
+require 'roundhouse/logging'
+
+class TestFetcher < Roundhouse::Test
+  describe Roundhouse::Logging do
+    describe "#with_context" do
+      def context
+        Roundhouse::Logging.logger.formatter.context
+      end
+
+      it "has no context by default" do
+        context.must_equal nil
+      end
+
+      it "can add a context" do
+        Roundhouse::Logging.with_context "xx" do
+          context.must_equal " xx"
+        end
+        context.must_equal nil
+      end
+
+      it "can use multiple contexts" do
+        Roundhouse::Logging.with_context "xx" do
+          context.must_equal " xx"
+          Roundhouse::Logging.with_context "yy" do
+            context.must_equal " xx yy"
+          end
+          context.must_equal " xx"
+        end
+        context.must_equal nil
+      end
+    end
+  end
+end

data/test/test_manager.rb

@@ -0,0 +1,169 @@
+require_relative 'helper'
+require 'roundhouse/manager'
+
+class TestManager < Roundhouse::Test
+
+  describe 'manager' do
+    before do
+      Roundhouse.redis = REDIS
+      Roundhouse.redis {|c| c.flushdb }
+    end
+
+    def new_manager(opts)
+      condvar = Minitest::Mock.new
+      condvar.expect(:signal, nil, [])
+      Roundhouse::Manager.new(condvar, opts)
+    end
+
+    it 'creates N processor instances' do
+      mgr = new_manager(options)
+      assert_equal options[:concurrency], mgr.ready.size
+      assert_equal [], mgr.busy
+    end
+
+    it 'assigns work to a processor' do
+      uow = Object.new
+      processor = Minitest::Mock.new
+      processor.expect(:async, processor, [])
+      processor.expect(:process, nil, [uow])
+
+      mgr = new_manager(options)
+      mgr.ready << processor
+      mgr.assign(uow)
+      assert_equal 1, mgr.busy.size
+
+      processor.verify
+    end
+
+    it 'requeues work if stopping' do
+      uow = Minitest::Mock.new
+      uow.expect(:requeue, nil, [])
+
+      mgr = new_manager(options)
+      mgr.fetcher = Roundhouse::RoundRobinFetch.new({:queues => []})
+      mgr.stop
+      mgr.assign(uow)
+      uow.verify
+    end
+
+    it 'shuts down the system' do
+      mgr = new_manager(options)
+      mgr.fetcher = Roundhouse::RoundRobinFetch.new({:queues => []})
+      mgr.stop
+
+      assert mgr.busy.empty?
+      assert mgr.ready.empty?
+    end
+
+    it 'returns finished processors to the ready pool' do
+      fetcher = MiniTest::Mock.new
+      fetcher.expect :async, fetcher, []
+      fetcher.expect :fetch, nil, []
+      mgr = new_manager(options)
+      mgr.fetcher = fetcher
+      init_size = mgr.ready.size
+      processor = mgr.ready.pop
+      mgr.busy << processor
+      mgr.processor_done(processor)
+
+      assert_equal 0, mgr.busy.size
+      assert_equal init_size, mgr.ready.size
+      fetcher.verify
+    end
+
+    it 'throws away dead processors' do
+      fetcher = MiniTest::Mock.new
+      fetcher.expect :async, fetcher, []
+      fetcher.expect :fetch, nil, []
+      mgr = new_manager(options)
+      mgr.fetcher = fetcher
+      init_size = mgr.ready.size
+      processor = mgr.ready.pop
+      mgr.busy << processor
+      mgr.processor_died(processor, 'ignored')
+
+      assert_equal 0, mgr.busy.size
+      assert_equal init_size, mgr.ready.size
+      refute mgr.ready.include?(processor)
+      fetcher.verify
+    end
+
+    it 'does not support invalid concurrency' do
+      assert_raises(ArgumentError) { new_manager(concurrency: 0) }
+      assert_raises(ArgumentError) { new_manager(concurrency: -1) }
+    end
+
+    describe 'heartbeat' do
+      before do
+        uow = Object.new
+
+        @processor = Minitest::Mock.new
+        @processor.expect(:async, @processor, [])
+        @processor.expect(:process, nil, [uow])
+
+        @mgr = new_manager(options)
+        @mgr.ready << @processor
+        @mgr.assign(uow)
+
+        @processor.verify
+        @proctitle = $0
+      end
+
+      after do
+        $0 = @proctitle
+      end
+
+      describe 'when manager is active' do
+        before do
+          Roundhouse::Manager::PROCTITLES << proc { "xyz" }
+          @mgr.heartbeat('identity', heartbeat_data, Roundhouse.dump_json(heartbeat_data))
+          Roundhouse::Manager::PROCTITLES.pop
+        end
+
+        it 'sets useful info to proctitle' do
+          assert_equal "roundhouse #{Roundhouse::VERSION} myapp [1 of 3 busy] xyz", $0
+        end
+
+        it 'stores process info in redis' do
+          info = Roundhouse.redis { |c| c.hmget('identity', 'busy') }
+          assert_equal ["1"], info
+          expires = Roundhouse.redis { |c| c.pttl('identity') }
+          assert_in_delta 60000, expires, 500
+        end
+      end
+
+      describe 'when manager is stopped' do
+        before do
+          @processor.expect(:alive?, [])
+          @processor.expect(:terminate, [])
+
+          @mgr.stop
+          @mgr.processor_done(@processor)
+          @mgr.heartbeat('identity', heartbeat_data, Roundhouse.dump_json(heartbeat_data))
+
+          @processor.verify
+        end
+
+        it 'indicates stopping status in proctitle' do
+          assert_equal "roundhouse #{Roundhouse::VERSION} myapp [0 of 3 busy] stopping", $0
+        end
+
+        it 'stores process info in redis' do
+          info = Roundhouse.redis { |c| c.hmget('identity', 'busy') }
+          assert_equal ["0"], info
+          expires = Roundhouse.redis { |c| c.pttl('identity') }
+          assert_in_delta 60000, expires, 50
+        end
+      end
+    end
+
+    def options
+      { :concurrency => 3, :queues => ['default'] }
+    end
+
+    def heartbeat_data
+      { 'concurrency' => 3, 'tag' => 'myapp' }
+    end
+  end
+
+end

data/test/test_middleware.rb

@@ -0,0 +1,160 @@
+require_relative 'helper'
+require 'roundhouse/middleware/chain'
+require 'roundhouse/processor'
+require 'roundhouse/fetch'
+
+class TestMiddleware < Roundhouse::Test
+  describe 'middleware chain' do
+    before do
+      $errors = []
+      Roundhouse.redis = REDIS
+    end
+
+    class CustomMiddleware
+      def initialize(name, recorder)
+        @name = name
+        @recorder = recorder
+      end
+
+      def call(*args)
+        @recorder << [@name, 'before']
+        yield
+        @recorder << [@name, 'after']
+      end
+    end
+
+    it 'supports custom middleware' do
+      chain = Roundhouse::Middleware::Chain.new
+      chain.add CustomMiddleware, 1, []
+
+      assert_equal CustomMiddleware, chain.entries.last.klass
+    end
+
+    class CustomWorker
+      $recorder = []
+      include Roundhouse::Worker
+      def perform(recorder)
+        $recorder << ['work_performed']
+      end
+    end
+
+    class NonYieldingMiddleware
+      def call(*args)
+      end
+    end
+
+    class AnotherCustomMiddleware
+      def initialize(name, recorder)
+        @name = name
+        @recorder = recorder
+      end
+
+      def call(*args)
+        @recorder << [@name, 'before']
+        yield
+        @recorder << [@name, 'after']
+      end
+    end
+
+    class YetAnotherCustomMiddleware
+      def initialize(name, recorder)
+        @name = name
+        @recorder = recorder
+      end
+
+      def call(*args)
+        @recorder << [@name, 'before']
+        yield
+        @recorder << [@name, 'after']
+      end
+    end
+
+    it 'executes middleware in the proper order' do
+      msg = Roundhouse.dump_json({ 'class' => CustomWorker.to_s, 'args' => [$recorder] })
+
+      Roundhouse.server_middleware do |chain|
+        # should only add once, second should replace the first
+        2.times { |i| chain.add CustomMiddleware, i.to_s, $recorder }
+        chain.insert_before CustomMiddleware, AnotherCustomMiddleware, '2', $recorder
+        chain.insert_after AnotherCustomMiddleware, YetAnotherCustomMiddleware, '3', $recorder
+      end
+
+      boss = Minitest::Mock.new
+      processor = Roundhouse::Processor.new(boss)
+      actor = Minitest::Mock.new
+      actor.expect(:processor_done, nil, [processor])
+      actor.expect(:real_thread, nil, [nil, Thread])
+      boss.expect(:async, actor, [])
+      boss.expect(:async, actor, [])
+      processor.process(Roundhouse::RoundRobinFetch::UnitOfWork.new('queue:100', msg))
+      assert_equal %w(2 before 3 before 1 before work_performed 1 after 3 after 2 after), $recorder.flatten
+    end
+
+    it 'correctly replaces middleware when using middleware with options in the initializer' do
+      chain = Roundhouse::Middleware::Chain.new
+      chain.add Roundhouse::Middleware::Server::RetryJobs
+      chain.add Roundhouse::Middleware::Server::RetryJobs, {:max_retries => 5}
+      assert_equal 1, chain.count
+    end
+
+    it 'correctly prepends middleware' do
+      chain = Roundhouse::Middleware::Chain.new
+      chain_entries = chain.entries
+      chain.add CustomMiddleware
+      chain.prepend YetAnotherCustomMiddleware
+      assert_equal YetAnotherCustomMiddleware, chain_entries.first.klass
+      assert_equal CustomMiddleware, chain_entries.last.klass
+    end
+
+    it 'allows middleware to abruptly stop processing rest of chain' do
+      recorder = []
+      chain = Roundhouse::Middleware::Chain.new
+      chain.add NonYieldingMiddleware
+      chain.add CustomMiddleware, 1, recorder
+
+      final_action = nil
+      chain.invoke { final_action = true }
+      assert_equal nil, final_action
+      assert_equal [], recorder
+    end
+  end
+
+  describe 'i18n' do
+    before do
+      require 'i18n'
+      I18n.enforce_available_locales = false
+      require 'roundhouse/middleware/i18n'
+    end
+
+    it 'saves and restores locale' do
+      I18n.locale = 'fr'
+      msg = {}
+      mw = Roundhouse::Middleware::I18n::Client.new
+      mw.call(nil, msg, nil, nil) { }
+      assert_equal :fr, msg['locale']
+
+      msg['locale'] = 'jp'
+      I18n.locale = I18n.default_locale
+      assert_equal :en, I18n.locale
+      mw = Roundhouse::Middleware::I18n::Server.new
+      mw.call(nil, msg, nil) do
+        assert_equal :jp, I18n.locale
+      end
+      assert_equal :en, I18n.locale
+    end
+
+    it 'supports I18n.enforce_available_locales = true' do
+      I18n.enforce_available_locales = true
+      I18n.available_locales = [:en, :jp]
+
+      msg = { 'locale' => 'jp' }
+      mw = Roundhouse::Middleware::I18n::Server.new
+      mw.call(nil, msg, nil) do
+        assert_equal :jp, I18n.locale
+      end
+
+      I18n.enforce_available_locales = false
+      I18n.available_locales = nil
+    end
+  end
+end