higgs 0.1.0 → 0.1.1

data/test/test_utils_bman.rb

@@ -11,7 +11,7 @@ module Higgs::Test
     include Higgs
 
     # for ident(1)
-    CVS_ID = '$Id: test_utils_bman.rb 567 2007-09-29 06:44:00Z toki $'
+    CVS_ID = '$Id: test_utils_bman.rb 621 2007-10-08 13:10:08Z toki $'
 
     STORAGE_ITEMS = (ENV['STORAGE_ITEMS'] || '100').to_i
     WARM_START_ITEMS = (ENV['WARM_START_ITEMS'] || '1000').to_i
@@ -25,6 +25,7 @@ module Higgs::Test
       @from = File.join(@from_dir, @from_name)
       @to_dir = 'bman_to'
       @to_name = 'bar'
+      @to = File.join(@to_dir, @to_name)
       FileUtils.rm_rf(@from_dir) #  for debug
       FileUtils.mkdir_p(@from_dir)
       FileUtils.rm_rf(@to_dir)  # for debug
@@ -42,11 +43,12 @@ module Higgs::Test
                                        :to_dir => @to_dir,
                                        :to_name => @to_name,
                                        :jlog_rotate_service_uri => @jlog_rotate_service_uri,
-                                       :verbose => $DEBUG ? 2 : 0)
+                                       :verbose => $DEBUG ? 2 : 0,
+                                       :out => $DEBUG ? STDERR : '')
     end
 
     def teardown
-      @from_st.shutdown
+      @from_st.shutdown unless @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
@@ -54,52 +56,52 @@ module Higgs::Test
 
     def test_backup_index
       @bman.backup_index
-      assert((File.exist? File.join(@to_dir, @to_name + '.idx')))
+      assert((File.exist? "#{@to}.idx"))
     end
 
     def test_backup_data
       @bman.backup_data
-      assert(FileUtils.cmp(@from + '.tar', File.join(@to_dir, @to_name + '.tar')))
+      assert(FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
     end
 
     def test_rotate_jlog_0
-      assert_equal(0, Storage.rotate_entries(@from + '.jlog').length)
+      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)
+      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)
+      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)
+      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)
+      assert_equal(0, Storage.rotate_entries("#{@to}.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)
+      assert_equal(1, Storage.rotate_entries("#{@to}.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)
+      assert_equal(2, Storage.rotate_entries("#{@to}.jlog").length)
     end
 
     def test_backup_jlog_10
@@ -107,7 +109,7 @@ module Higgs::Test
         @bman.rotate_jlog
       end
       @bman.backup_jlog
-      assert_equal(10, Storage.rotate_entries(File.join(@to_dir, @to_name + '.jlog')).length)
+      assert_equal(10, Storage.rotate_entries("#{@to}.jlog").length)
     end
 
     def test_clean_jlog
@@ -116,12 +118,16 @@ module Higgs::Test
       @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)
+      assert_equal(3, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(3, Storage.rotate_entries("#{@to}.jlog").length)
+
+      @bman.clean_jlog_from
+      assert_equal(0, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(3, Storage.rotate_entries("#{@to}.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)
+      @bman.clean_jlog_to
+      assert_equal(0, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(0, Storage.rotate_entries("#{@to}.jlog").length)
     end
 
     def test_clean_jlog_delete_backup
@@ -131,12 +137,16 @@ module Higgs::Test
       @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)
+      assert_equal(4, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(3, Storage.rotate_entries("#{@to}.jlog").length)
+
+      @bman.clean_jlog_from
+      assert_equal(1, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(3, Storage.rotate_entries("#{@to}.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)
+      @bman.clean_jlog_to
+      assert_equal(1, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(0, Storage.rotate_entries("#{@to}.jlog").length)
     end
 
     def test_clean_jlog_no_backup_no_delete
@@ -144,12 +154,16 @@ module Higgs::Test
       @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)
+      assert_equal(3, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(0, Storage.rotate_entries("#{@to}.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)
+      @bman.clean_jlog_from
+      assert_equal(3, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(0, Storage.rotate_entries("#{@to}.jlog").length)
+
+      @bman.clean_jlog_to
+      assert_equal(3, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(0, Storage.rotate_entries("#{@to}.jlog").length)
     end
 
     def update_storage(options)
@@ -159,7 +173,7 @@ module Higgs::Test
         options[:end_of_warm_up].start if (count == WARM_START_ITEMS)
 
         write_list = []
-        ope = [ :write, :system_properties, :custom_properties, :delete ][rand(3)]
+        ope = [ :write, :system_properties, :custom_properties, :delete ][rand(4)]
         key = rand(STORAGE_ITEMS)
         case (ope)
         when :write
@@ -200,13 +214,14 @@ module Higgs::Test
       @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)
+      @bman.clean_jlog_from
+      @bman.clean_jlog_to
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@to}.idx").to_h)
+      assert_equal(0, Storage.rotate_entries("#{@from}.jlog").length)
+      assert_equal(0, Storage.rotate_entries("#{@to}.jlog").length)
     end
 
     def test_online_backup
@@ -221,9 +236,212 @@ module Higgs::Test
       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)
+      assert((File.file? "#{@to}.tar"))
+      assert((File.file? "#{@to}.idx"))
+      assert_equal(0, Storage.rotate_entries("#{@to}.jlog").length)
+    end
+
+    def test_online_backup_with_latest_journal_log
+      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
+
+      @bman.backup_jlog
+      FileUtils.cp("#{@from}.jlog", "#{@to}.jlog", :preserve => true)
+      @bman.recover
+      @from_st.shutdown
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@to}.idx").to_h)
+      assert(! FileUtils.cmp("#{@from}.jlog", "#{@to}.jlog"))
+
+      st = Storage.new(@to)
+      st.shutdown
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@to}.idx").to_h)
+      assert(FileUtils.cmp("#{@from}.jlog", "#{@to}.jlog"))
+    end
+
+    def test_online_backup_with_incompleted_journal_log
+      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
+
+      @bman.backup_jlog
+      FileUtils.cp("#{@from}.jlog", "#{@to}.jlog", :preserve => true)
+      File.truncate("#{@to}.jlog", File.stat("#{@to}.jlog").size + 1) # like incompleted
+      @bman.recover
+      @from_st.shutdown
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@to}.idx").to_h)
+      assert(! FileUtils.cmp("#{@from}.jlog", "#{@to}.jlog"))
+
+      st = Storage.new(@to)
+      st.shutdown
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@to}.idx").to_h)
+      assert(FileUtils.cmp("#{@from}.jlog", "#{@to}.jlog"))
+    end
+
+    def test_restore_files
+      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
+
+      @from_st.shutdown
+
+      assert(! FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
+      assert(Index.new.load("#{@from}.idx").to_h !=
+             Index.new.load("#{@to}.idx").to_h)
+
+      @bman.restore_files
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@to}.tar"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@to}.idx").to_h)
+    end
+
+    def test_restore_recover_and_verify
+      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
+
+      @from_st.shutdown
+      FileUtils.cp("#{@from}.tar", "#{@from}.tar.orig", :preserve => true)
+      FileUtils.cp("#{@from}.idx", "#{@from}.idx.orig", :preserve => true)
+
+      @bman.restore_files
+      @bman.restore_recover
+      @bman.restore_verify
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@from}.tar.orig"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@from}.idx.orig").to_h)
+    end
+
+    def test_restore
+      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
+
+      @from_st.shutdown
+      FileUtils.cp("#{@from}.tar", "#{@from}.tar.orig", :preserve => true)
+      FileUtils.cp("#{@from}.idx", "#{@from}.idx.orig", :preserve => true)
+
+      @bman.restore
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@from}.tar.orig"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@from}.idx.orig").to_h)
+    end
+
+    def test_incremental_backup_with_recovery_and_restore
+      options = {
+        :end_of_warm_up => Latch.new,
+        :spin_lock => true
+      }
+      t = Thread.new{ update_storage(options) }
+
+      options[:end_of_warm_up].wait
+
+      # first step: full backup
+      @bman.online_backup
+
+      @bman.rotate_jlog
+
+      # incremental backup with recovery
+      @bman.backup_jlog
+      @bman.recover
+      @bman.verify
+      @bman.clean_jlog_from
+      @bman.clean_jlog_to
+
+      options[:spin_lock] = false
+      t.join
+
+      @from_st.shutdown
+      FileUtils.cp("#{@from}.tar", "#{@from}.tar.orig", :preserve => true)
+      FileUtils.cp("#{@from}.idx", "#{@from}.idx.orig", :preserve => true)
+
+      @bman.restore
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@from}.tar.orig"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@from}.idx.orig").to_h)
+    end
+
+    def test_incremental_backup_without_recovery_and_restore
+      options = {
+        :end_of_warm_up => Latch.new,
+        :spin_lock => true
+      }
+      t = Thread.new{ update_storage(options) }
+
+      options[:end_of_warm_up].wait
+
+      # first step: full backup
+      @bman.online_backup
+
+      @bman.rotate_jlog
+
+      # incremental backup without recovery
+      @bman.backup_jlog
+      @bman.clean_jlog_from
+
+      options[:spin_lock] = false
+      t.join
+
+      @from_st.shutdown
+      FileUtils.cp("#{@from}.tar", "#{@from}.tar.orig", :preserve => true)
+      FileUtils.cp("#{@from}.idx", "#{@from}.idx.orig", :preserve => true)
+
+      @bman.restore
+
+      assert(FileUtils.cmp("#{@from}.tar", "#{@from}.tar.orig"))
+      assert(Index.new.load("#{@from}.idx").to_h ==
+             Index.new.load("#{@from}.idx.orig").to_h)
     end
   end
 end

metadata

@@ -3,8 +3,8 @@ 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
+  version: 0.1.1
+date: 2007-10-08 00:00:00 +09:00
 summary: pure ruby transactional storage compatible with unix TAR format
 require_paths: 
 - lib
@@ -71,6 +71,7 @@ files:
 - test/test_storage_init_opts.rb
 - test/test_tman.rb
 - test/test_block.rb
+- test/test_dbm.rb
 - test/test_storage_conf.rb
 - test/test_tar.rb
 - test/run.rb