higgs 0.1.4 → 0.1.5

data/test/test_storage.rb

@@ -11,7 +11,7 @@ module Higgs::Test
     include Higgs
 
     # for ident(1)
-    CVS_ID = '$Id: test_storage.rb 676 2007-11-08 16:09:51Z toki $'
+    CVS_ID = '$Id: test_storage.rb 742 2008-01-13 15:55:53Z toki $'
 
     def setup
       srand(0)                  # preset for rand
@@ -37,7 +37,7 @@ module Higgs::Test
     include StorageTestCase
 
     # for ident(1)
-    CVS_ID = '$Id: test_storage.rb 676 2007-11-08 16:09:51Z toki $'
+    CVS_ID = '$Id: test_storage.rb 742 2008-01-13 15:55:53Z toki $'
 
     def new_storage
       Storage.new(@name, :logger => @logger)
@@ -80,7 +80,6 @@ module Higgs::Test
       assert_equal(Digest::MD5.hexdigest("Hello world.\n"), properties['system_properties']['hash_value'])
       assert_equal(false, properties['system_properties']['string_only'])
       assert_equal({}, properties['custom_properties'])
-      assert_equal(false, @st.string_only('foo'))
 
       # update properties
       @st.write_and_commit([ [ :system_properties, 'foo', { 'string_only' => true } ] ])
@@ -91,7 +90,6 @@ module Higgs::Test
       assert_equal(Digest::MD5.hexdigest("Hello world.\n"), properties['system_properties']['hash_value'])
       assert_equal(true, properties['system_properties']['string_only'])
       assert_equal({ :comment => 'test' }, properties['custom_properties'])
-      assert_equal(true, @st.string_only('foo'))
 
       # update
       @st.write_and_commit([ [ :write, 'foo', "Good bye.\n" ] ])
@@ -101,7 +99,6 @@ module Higgs::Test
       assert_equal(Digest::MD5.hexdigest("Good bye.\n"), properties['system_properties']['hash_value'])
       assert_equal(true, properties['system_properties']['string_only'])
       assert_equal({ :comment => 'test' }, properties['custom_properties'])
-      assert_equal(true, @st.string_only('foo'))
 
       # delete
       @st.write_and_commit([ [ :delete, 'foo' ] ])
@@ -229,10 +226,6 @@ module Higgs::Test
       assert_equal(mod_time2, @st.fetch_properties(:foo)['system_properties']['modified_time'])
     end
 
-    def test_string_only_IndexError_not_exist_properties
-      assert_raise(IndexError) { @st.string_only('foo') }
-    end
-
     def test_change_number_and_unique_data_id
       assert_equal(nil, @st.data_change_number(:foo))
       assert_equal(nil, @st.properties_change_number(:foo))
@@ -476,7 +469,7 @@ module Higgs::Test
     include StorageTestCase
 
     # for ident(1)
-    CVS_ID = '$Id: test_storage.rb 676 2007-11-08 16:09:51Z toki $'
+    CVS_ID = '$Id: test_storage.rb 742 2008-01-13 15:55:53Z toki $'
 
     def new_storage
       Storage.new(@name,
@@ -798,7 +791,7 @@ module Higgs::Test
     include Higgs
 
     # for ident(1)
-    CVS_ID = '$Id: test_storage.rb 676 2007-11-08 16:09:51Z toki $'
+    CVS_ID = '$Id: test_storage.rb 742 2008-01-13 15:55:53Z toki $'
 
     def setup
       @test_dir = 'st_test'

data/test/test_tman.rb

@@ -8,12 +8,14 @@ require 'higgs/tman'
 require 'logger'
 require 'test/unit'
 
+Thread.abort_on_exception = true if $DEBUG
+
 module Higgs::Test
   class TransactionManagerTest < Test::Unit::TestCase
     include Higgs
 
     # for ident(1)
-    CVS_ID = '$Id: test_tman.rb 685 2007-11-12 14:58:12Z toki $'
+    CVS_ID = '$Id: test_tman.rb 745 2008-01-20 13:28:02Z toki $'
 
     def setup
       @test_dir = 'st_test'
@@ -50,32 +52,6 @@ module Higgs::Test
       assert_equal(1, count)
     end
 
-    def test_transaction_RuntimeError_nested_transaction_forbidden
-      @tman.transaction(true) {|tx|
-        assert_raise(RuntimeError) {
-          @tman.transaction(true) {|tx2|
-            flunk('not to reach.')
-          }
-        }
-      }
-    end
-
-    def test_in_transaction?
-      assert_equal(false, TransactionManager.in_transaction?)
-      @tman.transaction{|tx|
-        assert_equal(true, TransactionManager.in_transaction?)
-      }
-      assert_equal(false, TransactionManager.in_transaction?)
-    end
-
-    def test_current_transaction
-      assert_equal(nil, TransactionManager.current_transaction)
-      @tman.transaction{|tx|
-        assert_equal(tx, TransactionManager.current_transaction)
-      }
-      assert_equal(nil, TransactionManager.current_transaction)
-    end
-
     def test_fetch_and_store
       @tman.transaction{|tx|
         assert_equal(nil, tx[:foo])
@@ -1059,8 +1035,8 @@ module Higgs::Test
       }
     end
 
-    def test_fine_grain_lock_manager
-      @tman = TransactionManager.new(@st, :lock_manager => FineGrainLockManager.new)
+    def test_optimistic_lock_manager
+      @tman = TransactionManager.new(@st, :lock_manager => OptimisticLockManager.new)
       @tman.transaction{|tx|
         tx[:foo] = '0'
         tx[:bar] = '0'
@@ -1073,20 +1049,28 @@ module Higgs::Test
       a = Thread.new{
         barrier.wait
         count.times do
-          @tman.transaction{|tx|
-            tx[:foo] = tx[:foo].succ
-            tx[:bar] = tx[:bar].succ
-          }
+          begin
+            @tman.transaction{|tx|
+              tx[:foo] = tx[:foo].succ
+              tx[:bar] = tx[:bar].succ
+            }
+          rescue LockManager::CollisionError
+            retry
+          end
         end
       }
 
       b = Thread.new{
         barrier.wait
         count.times do
-          @tman.transaction{|tx|
-            tx[:bar] = tx[:bar].succ
-            tx[:baz] = tx[:baz].succ
-          }
+          begin
+            @tman.transaction{|tx|
+              tx[:bar] = tx[:bar].succ
+              tx[:baz] = tx[:baz].succ
+            }
+          rescue LockManager::CollisionError
+            retry
+          end
         end
       }
 
@@ -1104,7 +1088,7 @@ module Higgs::Test
 
   class TransactionManagerTest_with_SecondaryCache < TransactionManagerTest
     # for ident(1)
-    CVS_ID = '$Id: test_tman.rb 685 2007-11-12 14:58:12Z toki $'
+    CVS_ID = '$Id: test_tman.rb 745 2008-01-20 13:28:02Z toki $'
 
     def setup
       super

data/test/test_tman_mvcc.rb

@@ -0,0 +1,265 @@
+#!/usr/local/bin/ruby
+
+require 'fileutils'
+require 'higgs/storage'
+require 'higgs/thread'
+require 'higgs/tman'
+require 'logger'
+require 'test/unit'
+require 'timeout'
+
+Thread.abort_on_exception = true if $DEBUG
+
+module Higgs::Test
+  class TransactionManagerMVCCTest < Test::Unit::TestCase
+    include Higgs
+    include Timeout
+
+    # for ident(1)
+    CVS_ID = '$Id$'
+
+    def create_lock_manager
+      GiantLockManager.new
+    end
+
+    def setup
+      @test_dir = 'st_test'
+      FileUtils.rm_rf(@test_dir) # for debug
+      FileUtils.mkdir_p(@test_dir)
+      @name = File.join(@test_dir, 'foo')
+      @logger = proc{|path|
+        logger = Logger.new(path, 1)
+        logger.level = Logger::DEBUG
+        logger
+      }
+      @st = Storage.new(@name, :logger => @logger)
+      @tman = TransactionManager.new(@st, :lock_manager => create_lock_manager)
+    end
+
+    def teardown
+      @st.shutdown unless @st.shutdown?
+      FileUtils.rm_rf(@test_dir) unless $DEBUG
+    end
+
+    MVCC_WARMUP_COUNT = 10
+    WRITE_TIMEOUT = 10
+
+    class RunFlag
+      def initialize(running)
+        #@lock = Mutex.new
+        @running = running
+      end
+
+      def running=(running)
+        #@lock.synchronize{
+          @running = running
+        #}
+      end
+
+      def running?
+        #@lock.synchronize{
+          @running
+        #}
+      end
+    end
+
+    class Count
+      def initialize
+        @value = 0
+        @lock = Mutex.new
+      end
+
+      def succ!
+        @lock.synchronize{ @value += 1 }
+      end
+
+      def value
+        @lock.synchronize{ @value }
+      end
+    end
+
+    def test_mvcc
+      do_read = RunFlag.new(true)
+
+      init_read_latch = Latch.new
+      init_read_count = Count.new
+      init_read_thread = Thread.new{
+        @tman.transaction(true) {|tx|
+          while (do_read.running?)
+            assert_equal([], tx.keys)
+            assert_nil(tx[:foo])
+            init_read_count.succ!
+            init_read_latch.start if (init_read_count.value == MVCC_WARMUP_COUNT)
+          end
+        }
+      }
+      init_read_latch.wait
+
+      # insert
+      p [ self.class, :test_mvcc, :insert ] if $DEBUG
+      timeout(WRITE_TIMEOUT) {
+        @tman.transaction{|tx|
+          tx[:foo] = 'Hello world.'
+        }
+      }
+
+      insert_read_latch = Latch.new
+      insert_read_count = Count.new
+      insert_read_thread = Thread.new{
+        @tman.transaction(true) {|tx|
+          while (do_read.running?)
+            assert_equal([ :foo ], tx.keys)
+            assert_equal('Hello world.', tx[:foo])
+            insert_read_count.succ!
+            insert_read_latch.start if (insert_read_count.value == MVCC_WARMUP_COUNT)
+          end
+        }
+      }
+      insert_read_latch.wait
+
+      # update
+      p [ self.class, :test_mvcc, :update ] if $DEBUG
+      timeout(WRITE_TIMEOUT) {
+        @tman.transaction{|tx|
+          tx[:foo] = 'I like ruby.'
+        }
+      }
+
+      update_read_latch = Latch.new
+      update_read_count = Count.new
+      update_read_thread = Thread.new{
+        @tman.transaction(true) {|tx|
+          while (do_read.running?)
+            assert_equal([ :foo ], tx.keys)
+            assert_equal('I like ruby.', tx[:foo])
+            update_read_count.succ!
+            update_read_latch.start if (update_read_count.value == MVCC_WARMUP_COUNT)
+          end
+        }
+      }
+      update_read_latch.wait
+
+      # delete
+      p [ self.class, :test_mvcc, :delete ] if $DEBUG
+      timeout(WRITE_TIMEOUT) {
+        @tman.transaction{|tx|
+          tx.delete(:foo)
+        }
+      }
+
+      delete_read_latch = Latch.new
+      delete_read_count = Count.new
+      delete_read_thread = Thread.new{
+        @tman.transaction(true) {|tx|
+          count = 0
+          while (do_read.running?)
+            assert_equal([], tx.keys)
+            assert_nil(tx[:foo])
+            delete_read_count.succ!
+            delete_read_latch.start if (delete_read_count.value == MVCC_WARMUP_COUNT)
+          end
+        }
+      }
+      delete_read_latch.wait
+
+      # insert
+      p [ self.class, :test_mvcc, :insert2 ] if $DEBUG
+      timeout(WRITE_TIMEOUT) {
+        @tman.transaction{|tx|
+          tx[:foo] = 'Hello world.'
+        }
+      }
+
+      [ init_read_count,
+        insert_read_count,
+        update_read_count,
+        delete_read_count
+      ].each do |count|
+        c = count.value
+        until (count.value > c)
+          # nothing to do.
+        end
+      end
+
+      do_read.running = false
+      [ init_read_thread,
+        update_read_thread,
+        update_read_thread,
+        delete_read_thread
+      ].each do |thread|
+        thread.join
+      end
+
+      @tman.transaction(true) {|tx|
+        assert_equal([ :foo ], tx.keys)
+        assert_equal('Hello world.', tx[:foo])
+      }
+    end
+
+    WORK_COUNT = 100
+    READ_THREAD_COUNT = 10
+    WRITE_THREAD_COUNT = 2
+
+    def test_read_write_multithread_mvcc
+      do_read = RunFlag.new(true)
+      read_th_grp = ThreadGroup.new
+      write_th_grp = ThreadGroup.new
+      barrier = Barrier.new((READ_THREAD_COUNT + WRITE_THREAD_COUNT) + 1)
+
+      READ_THREAD_COUNT.times{|i|
+        read_th_grp.add Thread.new{
+          barrier.wait
+          while (do_read.running?)
+            @tman.transaction(true) {|tx|
+              if (tx.key? :foo) then
+                assert_equal(tx.change_number.to_s, tx[:foo], "thread: #{i}")
+              end
+            }
+          end
+        }
+      }
+
+      WRITE_THREAD_COUNT.times{|i|
+        write_th_grp.add Thread.new{
+          barrier.wait
+          WORK_COUNT.times do |j|
+            begin
+              @tman.transaction{|tx|
+                value = tx[:foo] || '0'
+                assert_equal(tx.change_number.to_s, value, "thread-count: #{i}-#{j}")
+                tx[:foo] = value.succ
+              }
+            rescue LockManager::CollisionError
+              retry
+            end
+          end
+        }
+      }
+
+      barrier.wait
+      for t in write_th_grp.list
+        t.join
+      end
+
+      do_read.running = false
+      for t in read_th_grp.list
+        t.join
+      end
+
+      @tman.transaction(true) {|tx|
+        assert_equal((WRITE_THREAD_COUNT * WORK_COUNT).to_s, tx[:foo])
+      }
+    end
+  end
+
+  class TransactionManagerMVCCTest_with_OptimisticLockManager < TransactionManagerMVCCTest
+    def create_lock_manager
+      OptimisticLockManager.new
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_utils_bman.rb

@@ -8,12 +8,14 @@ require 'higgs/utils/bman'
 require 'logger'
 require 'test/unit'
 
+Thread.abort_on_exception = true if $DEBUG
+
 module Higgs::Test
   class UtilsBackupManagerTest < Test::Unit::TestCase
     include Higgs
 
     # for ident(1)
-    CVS_ID = '$Id: test_utils_bman.rb 688 2007-11-21 14:35:49Z toki $'
+    CVS_ID = '$Id: test_utils_bman.rb 742 2008-01-13 15:55:53Z toki $'
 
     STORAGE_ITEMS = (ENV['STORAGE_ITEMS'] || '100').to_i
     WARM_START_ITEMS = (ENV['WARM_START_ITEMS'] || '1000').to_i