higgs 0.1.0

data/test/test_tman_init_opts.rb

@@ -0,0 +1,56 @@
+#!/usr/local/bin/ruby
+
+require 'higgs/tman'
+require 'test/unit'
+require 'yaml'
+
+module Higgs::Test
+  class TransactionManagerInitOptionsTest < Test::Unit::TestCase
+    # for ident(1)
+    CVS_ID = '$Id: test_tman_init_opts.rb 559 2007-09-25 15:20:20Z toki $'
+
+    include Higgs::TransactionManager::InitOptions
+
+    def test_default
+      init_options({})
+      assert_equal(false, @read_only)
+      assert_equal(false, self.read_only)
+      assert_equal(:foo, @decode.call(:foo))
+      assert_equal(:bar, @encode.call(:bar))
+      assert_instance_of(Higgs::GiantLockManager, @lock_manager) # auto: require 'higgs/lock'
+      assert_instance_of(Higgs::LRUCache, @master_cache) # auto: require 'higgs/cache'
+    end
+
+    def test_read_only_true
+      init_options(:read_only => true)
+      assert_equal(true, @read_only)
+      assert_equal(true, self.read_only)
+    end
+
+    def test_read_only_false
+      init_options(:read_only => false)
+      assert_equal(false, @read_only)
+      assert_equal(false, self.read_only)
+    end
+
+    def test_decode
+      init_options(:decode => proc{|r| YAML.load(r) })
+      assert_equal([ 1, 2, 3], @decode.call([ 1, 2, 3 ].to_yaml))
+    end
+
+    def test_encode
+      init_options(:encode => proc{|w| w.to_yaml })
+      assert_equal([ 1, 2, 3 ].to_yaml, @encode.call([ 1, 2, 3 ]))
+    end
+
+    def test_lock_manager
+      init_options(:lock_manager => :dummy_lock_manager)
+      assert_equal(:dummy_lock_manager, @lock_manager)
+    end
+
+    def test_master_cache
+      init_options(:master_cache => :dummy_master_cache)
+      assert_equal(:dummy_master_cache, @master_cache)
+    end
+  end
+end

data/test/test_utils_bman.rb

@@ -0,0 +1,234 @@
+#!/usr/local/bin/ruby
+
+require 'fileutils'
+require 'higgs/thread'
+require 'higgs/utils/bman'
+require 'logger'
+require 'test/unit'
+
+module Higgs::Test
+  class UtilsBackupManagerTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_utils_bman.rb 567 2007-09-29 06:44:00Z toki $'
+
+    STORAGE_ITEMS = (ENV['STORAGE_ITEMS'] || '100').to_i
+    WARM_START_ITEMS = (ENV['WARM_START_ITEMS'] || '1000').to_i
+    MAX_ITEM_BYTES = (ENV['MAX_ITEM_BYTES'] || '16384').to_i
+    ITEM_CHARS = ('A'..'Z').to_a + ('a'..'z').to_a
+
+    def setup
+      srand(0)
+      @from_dir = 'bman_from'
+      @from_name = 'foo'
+      @from = File.join(@from_dir, @from_name)
+      @to_dir = 'bman_to'
+      @to_name = 'bar'
+      FileUtils.rm_rf(@from_dir) #  for debug
+      FileUtils.mkdir_p(@from_dir)
+      FileUtils.rm_rf(@to_dir)  # for debug
+      FileUtils.mkdir_p(@to_dir)
+      @jlog_rotate_service_uri = 'druby://localhost:17320'
+      @from_st = Storage.new(@from,
+                             :jlog_rotate_max => 0,
+                             :jlog_rotate_service_uri => @jlog_rotate_service_uri,
+                             :logger => proc{|path|
+                               logger = Logger.new(path, 1)
+                               logger.level = Logger::DEBUG
+                               logger
+                             })
+      @bman = Utils::BackupManager.new(:from => @from,
+                                       :to_dir => @to_dir,
+                                       :to_name => @to_name,
+                                       :jlog_rotate_service_uri => @jlog_rotate_service_uri,
+                                       :verbose => $DEBUG ? 2 : 0)
+    end
+
+    def teardown
+      @from_st.shutdown
+      DRb.stop_service          # Why cannot each service be stopped?
+      FileUtils.rm_rf(@from_dir) unless $DEBUG
+      FileUtils.rm_rf(@to_dir) unless $DEBUG
+    end
+
+    def test_backup_index
+      @bman.backup_index
+      assert((File.exist? File.join(@to_dir, @to_name + '.idx')))
+    end
+
+    def test_backup_data
+      @bman.backup_data
+      assert(FileUtils.cmp(@from + '.tar', File.join(@to_dir, @to_name + '.tar')))
+    end
+
+    def test_rotate_jlog_0
+      assert_equal(0, Storage.rotate_entries(@from + '.jlog').length)
+    end
+
+    def test_rotate_jlog_1
+      @bman.rotate_jlog
+      assert_equal(1, Storage.rotate_entries(@from + '.jlog').length)
+    end
+
+    def test_rotate_jlog_2
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+      assert_equal(2, Storage.rotate_entries(@from + '.jlog').length)
+    end
+
+    def test_rotate_jlog_10
+      10.times do
+        @bman.rotate_jlog
+      end
+      assert_equal(10, Storage.rotate_entries(@from + '.jlog').length)
+    end
+
+    def test_backup_jlog_0
+      @bman.backup_jlog
+      assert_equal(0, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def test_backup_jlog_1
+      @bman.rotate_jlog
+      @bman.backup_jlog
+      assert_equal(1, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def test_backup_jlog_2
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+      @bman.backup_jlog
+      assert_equal(2, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def test_backup_jlog_10
+      10.times do
+        @bman.rotate_jlog
+      end
+      @bman.backup_jlog
+      assert_equal(10, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def test_clean_jlog
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+      @bman.backup_jlog
+
+      assert_equal(3, Storage.rotate_entries(@from + '.jlog').length)
+      assert_equal(3, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+
+      @bman.clean_jlog
+      assert_equal(0, Storage.rotate_entries(@from + '.jlog').length)
+      assert_equal(0, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def test_clean_jlog_delete_backup
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+      @bman.backup_jlog
+      @bman.rotate_jlog
+
+      assert_equal(4, Storage.rotate_entries(@from + '.jlog').length)
+      assert_equal(3, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+
+      @bman.clean_jlog
+      assert_equal(1, Storage.rotate_entries(@from + '.jlog').length)
+      assert_equal(0, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def test_clean_jlog_no_backup_no_delete
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+      @bman.rotate_jlog
+
+      assert_equal(3, Storage.rotate_entries(@from + '.jlog').length)
+      assert_equal(0, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+
+      @bman.clean_jlog
+      assert_equal(3, Storage.rotate_entries(@from + '.jlog').length)
+      assert_equal(0, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def update_storage(options)
+      count = 0
+      while (options[:spin_lock])
+        count += 1
+        options[:end_of_warm_up].start if (count == WARM_START_ITEMS)
+
+        write_list = []
+        ope = [ :write, :system_properties, :custom_properties, :delete ][rand(3)]
+        key = rand(STORAGE_ITEMS)
+        case (ope)
+        when :write
+          value = rand(256).chr * rand(MAX_ITEM_BYTES)
+          write_list << [ ope, key, value ]
+        when :system_properties
+          next unless (@from_st.key? key)
+          write_list << [ ope, key, { 'string_only' => [ true, false ][rand(2)] } ]
+        when :custom_properties
+          next unless (@from_st.key? key)
+          value = ITEM_CHARS[rand(ITEM_CHARS.size)] * rand(MAX_ITEM_BYTES)
+          write_list << [ ope, key, { 'foo' => value } ]
+        when :delete
+          next unless (@from_st.key? key)
+          write_list << [ ope, key ]
+        else
+          raise "unknown operation: #{ope}"
+        end
+        @from_st.write_and_commit(write_list)
+      end
+    end
+    private :update_storage
+
+    def test_recover_and_verify_and_clean_jlog
+      options = {
+        :end_of_warm_up => Latch.new,
+        :spin_lock => true
+      }
+      t = Thread.new{ update_storage(options) }
+
+      options[:end_of_warm_up].wait
+      @bman.backup_index
+      @bman.backup_data
+      options[:spin_lock] = false
+      t.join
+
+      @bman.rotate_jlog
+      @bman.backup_jlog
+      @bman.recover
+      @bman.verify
+      @bman.clean_jlog
+
+      assert(FileUtils.cmp(@from + '.tar', File.join(@to_dir, @to_name + '.tar')))
+      assert_equal(Index.new.load(@from + '.idx').to_h,
+                   Index.new.load(File.join(@to_dir, @to_name + '.idx')).to_h)
+      assert_equal(0, Storage.rotate_entries(@from + '.jlog').length)
+      assert_equal(0, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+
+    def test_online_backup
+      options = {
+        :end_of_warm_up => Latch.new,
+        :spin_lock => true
+      }
+      t = Thread.new{ update_storage(options) }
+
+      options[:end_of_warm_up].wait
+      @bman.online_backup
+      options[:spin_lock] = false
+      t.join
+
+      assert((File.file? File.join(@to_dir, @to_name + '.tar')))
+      assert((File.file? File.join(@to_dir, @to_name + '.idx')))
+      assert_equal(0, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: higgs
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-09-29 00:00:00 +09:00
+summary: pure ruby transactional storage compatible with unix TAR format
+require_paths: 
+- lib
+email: toki@freedom.ne.jp
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- TOKI Yoshinori
+files: 
+- misc/dbm_bench/Rakefile
+- test/Rakefile
+- Rakefile
+- misc/dbm_bench/.strc
+- lib/cgi/session/higgs.rb
+- lib/higgs/jlog.rb
+- lib/higgs/utils/bman.rb
+- lib/higgs/exceptions.rb
+- lib/higgs/cache.rb
+- lib/higgs/lock.rb
+- lib/higgs/thread.rb
+- lib/higgs/block.rb
+- lib/higgs/dbm.rb
+- lib/higgs/tman.rb
+- lib/higgs/storage.rb
+- lib/higgs/tar.rb
+- lib/higgs/index.rb
+- lib/higgs/flock.rb
+- lib/higgs/store.rb
+- lib/higgs/version.rb
+- lib/higgs/utils.rb
+- lib/higgs.rb
+- misc/cache_bench/cache_bench.rb
+- misc/thread_bench/lock_bench.rb
+- misc/dbm_bench/dbm_seq_read.rb
+- misc/dbm_bench/dbm_rnd_read.rb
+- misc/dbm_bench/dbm_multi_thread.rb
+- misc/dbm_bench/dbm_seq_write.rb
+- misc/dbm_bench/st_verify.rb
+- misc/dbm_bench/dbm_rnd_delete.rb
+- misc/dbm_bench/dbm_rnd_update.rb
+- misc/io_bench/write_bench.rb
+- misc/io_bench/cksum_bench.rb
+- misc/io_bench/jlog_bench.rb
+- test/test_cgi_session.rb
+- test/test_utils_bman.rb
+- test/test_lock.rb
+- test/test_thread.rb
+- test/test_cache.rb
+- test/test_storage_init_opts.rb
+- test/test_tman.rb
+- test/test_block.rb
+- test/test_storage_conf.rb
+- test/test_tar.rb
+- test/run.rb
+- test/test_storage.rb
+- test/test_index.rb
+- test/test_tman_init_opts.rb
+- test/test_flock.rb
+- test/test_store.rb
+- test/test_jlog.rb
+- test/test_online_backup.rb
+- mkrdoc.rb
+- sample/count.rb
+- sample/dbmtest.rb
+- rdoc.yml
+- bin/higgs_backup
+- bin/higgs_dump_index
+- bin/higgs_dump_jlog
+- bin/higgs_verify
+- ChangeLog
+- LICENSE
+- README
+test_files: 
+- test/run.rb
+rdoc_options: 
+- -SNa
+- -i
+- .
+- -m
+- Higgs
+extra_rdoc_files: []
+
+executables: 
+- higgs_backup
+- higgs_dump_index
+- higgs_dump_jlog
+- higgs_verify
+extensions: []
+
+requirements: []
+
+dependencies: []
+