semian 0.0.8 → 0.1.0

data/test/test_circuit_breaker.rb

@@ -0,0 +1,114 @@
+require 'minitest/autorun'
+require 'semian'
+require 'timecop'
+
+class TestCircuitBreaker < MiniTest::Unit::TestCase
+  SomeError = Class.new(StandardError)
+
+  def setup
+    Semian.destroy(:testing) rescue nil
+    Semian.register(:testing, tickets: 1, exceptions: [SomeError], error_threshold: 2, error_timeout: 5, success_threshold: 1)
+    @resource = Semian[:testing]
+  end
+
+  def test_with_fallback_value_returns_the_value
+    result = @resource.with_fallback(42) do
+      raise SomeError
+    end
+    assert_equal 42, result
+  end
+
+  def test_with_fallback_block_call_the_block
+    result = @resource.with_fallback(-> { 42 }) do
+      raise SomeError
+    end
+    assert_equal 42, result
+  end
+
+  def test_unknown_exceptions_are_not_rescued
+    assert_raises RuntimeError do
+      @resource.with_fallback(42) do
+        raise RuntimeError
+      end
+    end
+  end
+
+  def test_all_semian_exceptions_are_rescued
+    result = @resource.with_fallback(42) do
+      raise Semian::BaseError
+    end
+    assert_equal 42, result
+  end
+
+  def test_acquire_yield_when_the_circuit_is_closed
+    block_called = false
+    @resource.acquire { block_called = true }
+    assert_equal true, block_called
+  end
+
+  def test_acquire_raises_circuit_open_error_when_the_circuit_is_open
+    open_circuit!
+    assert_raises Semian::OpenCircuitError do
+      @resource.acquire { 1 + 1 }
+    end
+  end
+
+  def test_after_error_threshold_the_circuit_is_open
+    open_circuit!
+    assert_circuit_opened
+  end
+
+  def test_after_error_timeout_is_elapsed_requests_are_attempted_again
+    half_open_cicuit!
+    assert_circuit_closed
+  end
+
+  def test_until_success_threshold_is_reached_a_single_error_will_reopen_the_circuit
+    half_open_cicuit!
+    trigger_error!
+    assert_circuit_opened
+  end
+
+  def test_once_success_threshold_is_reached_only_error_threshold_will_open_the_circuit_again
+    half_open_cicuit!
+    assert_circuit_closed
+    trigger_error!
+    assert_circuit_closed
+    trigger_error!
+    assert_circuit_opened
+  end
+
+  def test_reset_allow_to_close_the_circuit_and_forget_errors
+    open_circuit!
+    @resource.reset
+    assert_circuit_closed
+  end
+
+  private
+
+  def open_circuit!
+    2.times { trigger_error! }
+  end
+
+  def half_open_cicuit!
+    Timecop.travel(Time.now - 10) do
+      open_circuit!
+    end
+  end
+
+  def trigger_error!
+    @resource.with_fallback(42) { raise SomeError }
+  end
+
+  def assert_circuit_closed
+    block_called = false
+    @resource.with_fallback(42) { block_called = true }
+    assert block_called, 'Expected the circuit to be closed, but it was open'
+  end
+
+  def assert_circuit_opened
+    block_called = false
+    @resource.with_fallback(42) { block_called = true }
+    refute block_called, 'Expected the circuit to be open, but it was closed'
+  end
+end

data/test/test_instrumentation.rb

@@ -0,0 +1,62 @@
+require 'minitest/autorun'
+require 'semian'
+
+class TestInstrumentation < MiniTest::Unit::TestCase
+  def setup
+    Semian.destroy(:testing) if Semian[:testing]
+    Semian.register(:testing, tickets: 1, error_threshold: 1, error_timeout: 5, success_threshold: 1)
+  end
+
+  def test_occupied_instrumentation
+    assert_notify(:success, :occupied) do
+      Semian[:testing].acquire do
+        assert_raises Semian::TimeoutError do
+          Semian[:testing].acquire {}
+        end
+      end
+    end
+  end
+
+  def test_circuit_open_instrumentation
+    assert_notify(:success, :occupied) do
+      Semian[:testing].acquire do
+        assert_raises Semian::TimeoutError do
+          Semian[:testing].acquire {}
+        end
+      end
+    end
+
+    assert_notify(:circuit_open) do
+      assert_raises Semian::OpenCircuitError do
+        Semian[:testing].acquire {}
+      end
+    end
+  end
+
+  def test_success_instrumentation
+    assert_notify(:success) do
+      Semian[:testing].acquire {}
+    end
+  end
+
+  def test_success_instrumentation_when_unknown_exceptions_occur
+    assert_notify(:success) do
+      assert_raises RuntimeError do
+        Semian[:testing].acquire { raise "Some error" }
+      end
+    end
+  end
+
+  private
+
+  def assert_notify(*expected_events)
+    events = []
+    subscription = Semian.subscribe do |event, resource|
+      events << event
+    end
+    yield
+    assert_equal expected_events, events, "The timeline of events was not as expected"
+  ensure
+    Semian.unsubscribe(subscription)
+  end
+end

data/test/test_mysql2.rb

@@ -0,0 +1,186 @@
+require 'minitest/autorun'
+require 'semian/mysql2'
+require 'toxiproxy'
+require 'timecop'
+
+class TestMysql2 < MiniTest::Unit::TestCase
+  ERROR_TIMEOUT = 5
+  ERROR_THRESHOLD = 1
+  SEMIAN_OPTIONS = {
+    name: :testing,
+    tickets: 1,
+    timeout: 0,
+    error_threshold: ERROR_THRESHOLD,
+    success_threshold: 2,
+    error_timeout: ERROR_TIMEOUT,
+  }
+
+  attr_writer :threads
+  def setup
+    @proxy = Toxiproxy[:semian_test_mysql]
+    Semian.destroy(:mysql_testing)
+  end
+
+  def teardown
+    threads.each { |t| t.kill }
+    self.threads = []
+  end
+
+  def test_semian_identifier
+    assert_equal :mysql_foo, FakeMysql.new(semian: {name: 'foo'}).semian_identifier
+    assert_equal :'mysql_localhost:3306', FakeMysql.new.semian_identifier
+    assert_equal :'mysql_127.0.0.1:3306', FakeMysql.new(host: '127.0.0.1').semian_identifier
+    assert_equal :'mysql_example.com:42', FakeMysql.new(host: 'example.com', port: 42).semian_identifier
+  end
+
+  def test_connect_instrumentation
+    notified = false
+    subscriber = Semian.subscribe do |event, resource, scope|
+      notified = true
+      assert_equal :success, event
+      assert_equal Semian[:mysql_testing], resource
+      assert_equal :connect, scope
+    end
+
+    connect_to_mysql!
+
+    assert notified, 'No notification have been emitted'
+  ensure
+    Semian.unsubscribe(subscriber)
+  end
+
+  def test_resource_acquisition_for_connect
+    client = connect_to_mysql!
+
+    Semian[:mysql_testing].acquire do
+      assert_raises Mysql2::ResourceOccupiedError do
+        connect_to_mysql!
+      end
+    end
+  end
+
+  def test_resource_timeout_on_connect
+    @proxy.downstream(:latency, latency: 500).apply do
+      background { connect_to_mysql! }
+
+      assert_raises Mysql2::ResourceOccupiedError do
+        connect_to_mysql!
+      end
+    end
+  end
+
+  def test_circuit_breaker_on_connect
+    @proxy.downstream(:latency, latency: 500).apply do
+      background { connect_to_mysql! }
+
+      ERROR_THRESHOLD.times do
+        assert_raises Mysql2::ResourceOccupiedError do
+          connect_to_mysql!
+        end
+      end
+    end
+
+    yield_to_background
+
+    assert_raises Mysql2::CircuitOpenError do
+      connect_to_mysql!
+    end
+
+    Timecop.travel(ERROR_TIMEOUT + 1) do
+      connect_to_mysql!
+    end
+  end
+
+  def test_query_instrumentation
+    client = connect_to_mysql!
+
+    notified = false
+    subscriber = Semian.subscribe do |event, resource, scope|
+      notified = true
+      assert_equal :success, event
+      assert_equal Semian[:mysql_testing], resource
+      assert_equal :query, scope
+    end
+
+    client.query('SELECT 1 + 1;')
+
+    assert notified, 'No notification have been emitted'
+  ensure
+    Semian.unsubscribe(subscriber)
+  end
+
+  def test_resource_acquisition_for_query
+    client = connect_to_mysql!
+
+    Semian[:mysql_testing].acquire do
+      assert_raises Mysql2::ResourceOccupiedError do
+        client.query('SELECT 1 + 1;')
+      end
+    end
+  end
+
+  def test_resource_timeout_on_query
+    client = connect_to_mysql!
+    client2 = connect_to_mysql!
+
+    @proxy.downstream(:latency, latency: 500).apply do
+      background { client2.query('SELECT 1 + 1;') }
+
+      assert_raises Mysql2::ResourceOccupiedError do
+        client.query('SELECT 1 + 1;')
+      end
+    end
+  end
+
+  def test_circuit_breaker_on_query
+    client = connect_to_mysql!
+    client2 = connect_to_mysql!
+
+    @proxy.downstream(:latency, latency: 1000).apply do
+      background { client2.query('SELECT 1 + 1;') }
+
+      ERROR_THRESHOLD.times do
+        assert_raises Mysql2::ResourceOccupiedError do
+          client.query('SELECT 1 + 1;')
+        end
+      end
+    end
+
+    yield_to_background
+
+    assert_raises Mysql2::CircuitOpenError do
+      client.query('SELECT 1 + 1;')
+    end
+
+    Timecop.travel(ERROR_TIMEOUT + 1) do
+      assert_equal 2, client.query('SELECT 1 + 1 as sum;').to_a.first['sum']
+    end
+  end
+
+  private
+
+  def background(&block)
+    thread = Thread.new(&block)
+    threads << thread
+    thread.join(0.1)
+    thread
+  end
+
+  def threads
+    @threads ||= []
+  end
+
+  def yield_to_background
+    threads.each(&:join)
+  end
+
+  def connect_to_mysql!(semian_options = {})
+    Mysql2::Client.new(host: '127.0.0.1', port: '13306', semian: SEMIAN_OPTIONS.merge(semian_options))
+  end
+
+  class FakeMysql < Mysql2::Client
+    private
+    def connect(*)
+    end
+  end
+end

data/test/{test_semian.rb → test_resource.rb}

@@ -1,25 +1,29 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'semian'
 require 'tempfile'
 require 'fileutils'
 
-class TestSemian < Test::Unit::TestCase
+class TestResource < MiniTest::Unit::TestCase
   def setup
-    Semian[:testing].destroy rescue Semian::BaseError
+    Semian.destroy(:testing) rescue nil
   end
 
-  def test_register_invalid_args
+  def teardown
+    destroy_resources
+  end
+
+  def test_initialize_invalid_args
     assert_raises TypeError do
-      Semian.register 123
+      create_resource 123, tickets: 2
     end
     assert_raises ArgumentError do
-      Semian.register :testing, tickets: -1
+      create_resource :testing, tickets: -1
     end
     assert_raises ArgumentError do
-      Semian.register :testing, tickets: 1_000_000
+      create_resource :testing, tickets: 1_000_000
     end
     assert_raises TypeError do
-      Semian.register :testing, permissions: "test"
+      create_resource :testing, tickets: 2, permissions: 'test'
     end
   end
 
@@ -28,30 +32,30 @@ class TestSemian < Test::Unit::TestCase
   end
 
   def test_register
-    Semian.register :testing, tickets: 2
+    create_resource :testing, tickets: 2
   end
 
   def test_register_with_no_tickets_raises
     assert_raises Semian::SyscallError do
-      Semian.register :testing
+      create_resource :testing, tickets: 0
     end
   end
 
   def test_acquire
     acquired = false
-    Semian.register :testing, tickets: 1
-    Semian[:testing].acquire { acquired = true }
+    resource = create_resource :testing, tickets: 1
+    resource.acquire { acquired = true }
     assert acquired
   end
 
   def test_acquire_return_val
-    Semian.register :testing, tickets: 1
-    val = Semian[:testing].acquire { 1234 }
+    resource = create_resource :testing, tickets: 1
+    val = resource.acquire { 1234 }
     assert_equal 1234, val
   end
 
   def test_acquire_timeout
-    Semian.register :testing, tickets: 1, timeout: 0.05
+    resource = create_resource :testing, tickets: 1, timeout: 0.05
 
     acquired = false
     m = Monitor.new
@@ -61,12 +65,12 @@ class TestSemian < Test::Unit::TestCase
       m.synchronize do
         cond.wait_until { acquired }
         assert_raises Semian::TimeoutError do
-          Semian[:testing].acquire { refute true }
+          resource.acquire { refute true }
         end
       end
     end
 
-    Semian[:testing].acquire do
+    resource.acquire do
       acquired = true
       m.synchronize { cond.signal }
       sleep 0.2
@@ -78,7 +82,7 @@ class TestSemian < Test::Unit::TestCase
   end
 
   def test_acquire_timeout_override
-    Semian.register :testing, tickets: 1, timeout: 0.01
+    resource = create_resource :testing, tickets: 1, timeout: 0.01
 
     acquired = false
     thread_acquired = false
@@ -88,11 +92,11 @@ class TestSemian < Test::Unit::TestCase
     t = Thread.start do
       m.synchronize do
         cond.wait_until { acquired }
-        Semian[:testing].acquire(timeout: 1) { thread_acquired = true }
+        resource.acquire(timeout: 1) { thread_acquired = true }
       end
     end
 
-    Semian[:testing].acquire do
+    resource.acquire do
       acquired = true
       m.synchronize { cond.signal }
       sleep 0.2
@@ -105,14 +109,13 @@ class TestSemian < Test::Unit::TestCase
   end
 
   def test_acquire_with_fork
-    Semian.register :testing, tickets: 2, timeout: 0.5
+    resource = create_resource :testing, tickets: 2, timeout: 0.5
 
-    Semian[:testing].acquire do
+    resource.acquire do
       pid = fork do
-        Semian.register :testing, timeout: 0.5
-        Semian[:testing].acquire do
+        resource.acquire do
           assert_raises Semian::TimeoutError do
-            Semian[:testing].acquire {  }
+            resource.acquire {  }
           end
         end
       end
@@ -123,7 +126,7 @@ class TestSemian < Test::Unit::TestCase
 
   def test_acquire_releases_on_kill
     begin
-      Semian.register :testing, tickets: 1, timeout: 0.1
+      resource = create_resource :testing, tickets: 1, timeout: 0.1
       acquired = false
 
       # Ghetto process synchronization
@@ -132,7 +135,7 @@ class TestSemian < Test::Unit::TestCase
       file.close!
 
       pid = fork do
-        Semian[:testing].acquire do
+        resource.acquire do
           FileUtils.touch(path)
           sleep 1000
         end
@@ -140,11 +143,11 @@ class TestSemian < Test::Unit::TestCase
 
       sleep 0.1 until File.exists?(path)
       assert_raises Semian::TimeoutError do
-        Semian[:testing].acquire {}
+        resource.acquire {}
       end
 
       Process.kill("KILL", pid)
-      Semian[:testing].acquire { acquired = true }
+      resource.acquire { acquired = true }
       assert acquired
 
       Process.wait
@@ -154,50 +157,51 @@ class TestSemian < Test::Unit::TestCase
   end
 
   def test_count
-    Semian.register :testing, tickets: 2
+    resource = create_resource :testing, tickets: 2
     acquired = false
 
-    Semian[:testing].acquire do
+    resource.acquire do
       acquired = true
-      assert_equal 1, Semian[:testing].count
+      assert_equal 1, resource.count
+      assert_equal 2, resource.tickets
     end
 
     assert acquired
   end
 
   def test_sem_undo
-    Semian.register :testing, tickets: 1
+    resource = create_resource :testing, tickets: 1
 
     # Ensure we don't hit ERANGE errors caused by lack of SEM_UNDO on semop* calls
     # by doing an acquire > SEMVMX (32767) times:
     #
     # See: http://lxr.free-electrons.com/source/ipc/sem.c?v=3.8#L419
     (1 << 16).times do # do an acquire 64k times
-      Semian[:testing].acquire do
+      resource.acquire do
         1
       end
     end
   end
 
   def test_destroy
-    Semian.register :testing, tickets: 1
-    Semian[:testing].destroy
+    resource = create_resource :testing, tickets: 1
+    resource.destroy
     assert_raises Semian::SyscallError do
-      Semian[:testing].acquire { }
+      resource.acquire { }
     end
   end
 
   def test_permissions
-    Semian.register :testing, permissions: 0600, tickets: 1
-    semid = Semian[:testing].semid
+    resource = create_resource :testing, permissions: 0600, tickets: 1
+    semid = resource.semid
     `ipcs -s `.lines.each do |line|
       if /\s#{semid}\s/.match(line)
         assert_equal '600', line.split[3]
       end
     end
 
-    Semian.register :testing, permissions: 0660, tickets: 1
-    semid = Semian[:testing].semid
+    resource = create_resource :testing, permissions: 0660, tickets: 1
+    semid = resource.semid
     `ipcs -s `.lines.each do |line|
       if /\s#{semid}\s/.match(line)
         assert_equal '660', line.split[3]
@@ -206,7 +210,7 @@ class TestSemian < Test::Unit::TestCase
   end
 
   def test_resize_tickets_increase
-    Semian.register :testing, tickets: 1
+    resource = create_resource :testing, tickets: 1
 
     acquired = false
     m = Monitor.new
@@ -216,14 +220,14 @@ class TestSemian < Test::Unit::TestCase
       m.synchronize do
         cond.wait_until { acquired }
 
-        Semian.register :testing, tickets: 5
-        assert_equal 4, Semian[:testing].count
+        resource = create_resource :testing, tickets: 5
+        assert_equal 4, resource.count
       end
     end
 
-    assert_equal 1, Semian[:testing].count
+    assert_equal 1, resource.count
 
-    Semian[:testing].acquire do
+    resource.acquire do
       acquired = true
       m.synchronize { cond.signal }
       sleep 0.2
@@ -231,11 +235,11 @@ class TestSemian < Test::Unit::TestCase
 
     t.join
 
-    assert_equal 5, Semian[:testing].count
+    assert_equal 5, resource.count
   end
 
   def test_resize_tickets_decrease
-    Semian.register :testing, tickets: 5
+    resource = create_resource :testing, tickets: 5
 
     acquired = false
     m = Monitor.new
@@ -245,14 +249,14 @@ class TestSemian < Test::Unit::TestCase
       m.synchronize do
         cond.wait_until { acquired }
 
-        Semian.register :testing, tickets: 1
-        assert_equal 0, Semian[:testing].count
+        resource = create_resource :testing, tickets: 1
+        assert_equal 0, resource.count
       end
     end
 
-    assert_equal 5, Semian[:testing].count
+    assert_equal 5, resource.count
 
-    Semian[:testing].acquire do
+    resource.acquire do
       acquired = true
       m.synchronize { cond.signal }
       sleep 0.2
@@ -260,7 +264,7 @@ class TestSemian < Test::Unit::TestCase
 
     t.join
 
-    assert_equal 1, Semian[:testing].count
+    assert_equal 1, resource.count
   end
 
   def test_multiple_register_with_fork
@@ -275,7 +279,7 @@ class TestSemian < Test::Unit::TestCase
           acquired = false
 
           f.flock(File::LOCK_SH)
-          Semian.register(:testing, tickets: 5).acquire do |resource|
+          create_resource(:testing, tickets: 5).acquire do |resource|
             assert resource.count < 5
             acquired = true
           end
@@ -290,10 +294,24 @@ class TestSemian < Test::Unit::TestCase
         children.delete(Process.wait)
       end
 
-      assert_equal 5, Semian.register(:testing).count
+      assert_equal 5, create_resource(:testing, tickets: 0).count
     ensure
       f.close!
     end
   end
 
+  def create_resource(*args)
+    @resources ||= []
+    resource = Semian::Resource.new(*args)
+    @resources << resource
+    resource
+  end
+
+  def destroy_resources
+    return unless @resources
+    @resources.each do |resource|
+      resource.destroy rescue nil
+    end
+    @resources = []
+  end
 end

data/test/test_unsupported.rb

@@ -1,10 +1,14 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'semian'
 
-class TestSemian < Test::Unit::TestCase
+class TestSemian < MiniTest::Unit::TestCase
+  def setup
+    Semian.destroy(:testing) rescue nil
+  end
+
   def test_unsupported_acquire_yields
     acquired = false
-    Semian.register :testing, tickets: 1
+    Semian.register :testing, tickets: 1, error_threshold: 1, error_timeout: 2, success_threshold: 1
     Semian[:testing].acquire { acquired = true }
     assert acquired
   end