fsdb 0.5 → 0.6.0

data/junk/insert-dir.rb

@@ -0,0 +1,48 @@
+  def insert(path, object)
+    abs_path = absolute(path)
+    file_id = make_file_id(abs_path)
+    object_exclusive file_id do |cache_entry|
+      open_write_lock(path) do |f|
+        dump(object, f)
+        cache_entry.update(f.mtime, inc_version_of(f, cache_entry), object)
+        object
+      end
+    end
+  rescue DirIsImmutableError
+    begin
+      ary = object.to_a
+        # when default to_a becomes obsolete, this will be reported as
+        # an error, which is ok--it will be caught and reported below.
+      raise unless ary.all?{|x|x.size == 2}
+    rescue StandardError
+      raise DirIsImmutableError,
+        "Cannot insert given object at dir #{path} in #{inspect}"
+    end
+    ary.each do |k,v|
+      insert(File.join(path, k), v)
+    end
+
+
+  def test_insert_dir
+    @db['insert_dir/'] = {
+      'path1' => 1,
+      'path2' => 2
+    }
+    assert_equal(1, @db['insert_dir/path1'])
+    assert_equal(2, @db['insert_dir/path2'])
+  end
+  
+
+__END__
+
+- FSDB::Database#insert now allows
+
+    db['dir/'] = {
+      'path1' => obj1,
+      'path2' => obj2
+    }
+
+  as a shorthand for
+
+    db['dir/path1'] = obj1
+    db['dir/path2'] = obj2

data/junk/lock-test-bug.rb

@@ -0,0 +1,150 @@
+#!/usr/bin/env ruby
+
+require 'thread'
+require 'sync'
+
+@path   = '/tmp/foo'
+
+@cache_mutex = Mutex.new
+
+def make_entry
+  @cache_mutex.synchronize do
+    @cache  = Mutex.new
+    @sync   = Synchronizer.new
+    @object = nil
+  end
+end
+
+# This is just for housekeeping, so that stale entries don't result
+# in unused, but uncollectable, CacheEntry objects.
+def clear_entry
+  @cache_mutex.synchronize do
+    @cache  = nil
+    @sync   = nil
+    @object = nil
+  end
+end
+
+def object(f)
+  @cache.synchronize do
+    @object ||= f.read
+  end
+end
+
+def sync_object_shared
+  @sync.synchronize(Synchronizer::SH) {yield}
+end
+
+def sync_object_exclusive
+  @sync.synchronize(Synchronizer::EX) {yield}
+end
+
+def browse
+  make_entry
+  sync_object_shared do
+    open_read_lock(@path) do |f|
+      yield object(f)
+    end
+  end
+end
+
+def change
+  make_entry
+  sync_object_exclusive do
+    open_write_lock(@path) do |f|
+      object = object(f)
+      yield object
+      f.write(object)
+    end
+  end
+end
+
+def open_read_lock(path)
+  File.open(path, "r") do |f|
+    begin
+      f.flock(File::LOCK_SH)
+      yield f
+    ensure
+      f.flock(File::LOCK_UN)
+    end
+  end
+end
+
+def open_write_lock(path)
+  File.open(path, "r+") do |f|
+    f.rewind
+    begin
+      f.flock(File::LOCK_EX) ## need to use fcntl for Linux NFS
+      yield f
+    ensure
+      f.flush ## is this necessary? [ruby-talk:16721]
+      f.flock(File::LOCK_UN)
+    end
+  end
+end
+
+def do_test
+  $stdout.sync = true
+  Thread.abort_on_exception = true
+
+  srand(3765)
+
+  thread_count  =   2
+  rep_count     = 100
+  max_sleep     =   0.01
+
+  File.open(@path, "w") do |f|
+    f.write("0")
+  end
+
+  threads = (0..thread_count).map do |thread_index|
+    Thread.new(thread_index) do |ti|
+      Thread.current[:number] = ti
+      rep_count.times do |iter|
+        Thread.current[:iter] = iter
+
+        case rand(3)
+
+        when 0
+          browse do |tester|
+            old_tester = tester
+            sleep(rand*max_sleep)
+            unless old_tester == tester
+              fail "browse: #{old_tester} != #{tester}"
+            end
+          end
+
+        when 1
+          change do |tester|
+            tester.replace (tester.to_i + 1).to_s
+            old_tester = tester
+            sleep(rand*max_sleep)
+            unless old_tester == tester
+              fail "browse: #{old_tester} != #{tester}"
+            end
+          end
+
+        else
+          sleep(rand*max_sleep)
+          if rand(20) == 0
+            clear_entry
+          end
+
+        end
+
+      end
+    end
+  end
+
+  sleep(rep_count * max_sleep * 2)
+  if threads.any? {|t|t.alive?}
+    $stderr.puts "Deadlock!"
+    exit!
+  end
+
+  threads.each do |thread|
+    thread.join
+  end
+end
+
+do_test

data/junk/lock-test-too-simple.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+require 'thread'
+require 'sync'
+#require 'ftools'
+
+@path         = '/tmp/foo'
+
+@cache_mutex  = Mutex.new
+@sync         = Synchronizer.new
+@object       = nil
+
+def object(f)
+  @cache_mutex.synchronize do
+    @object ||= f.read
+  end
+end
+
+def clear_cache
+  @object = nil
+end
+
+def sync_object_shared
+  @sync.synchronize(Synchronizer::SH) {yield}
+end
+def sync_object_exclusive
+  @sync.synchronize(Synchronizer::EX) {yield}
+end
+
+def browse
+  sync_object_shared do
+    open_read_lock(@path) do |f|
+      yield object(f)
+    end
+  end
+end
+
+def change
+  sync_object_exclusive do
+    open_write_lock(@path) do |f|
+      object = object(f)
+      yield object
+      f.write(object)
+    end
+  end
+end
+
+def open_read_lock(path)
+  File.open(path, "r") do |f|
+    begin
+      f.flock(File::LOCK_SH)
+      yield f
+    ensure
+      f.flock(File::LOCK_UN)
+    end
+  end
+end
+
+def open_write_lock(path)
+  File.open(path, "r+") do |f|
+    f.rewind
+    begin
+      f.flock(File::LOCK_EX) ## need to use fcntl for Linux NFS
+      yield f
+    ensure
+      f.flush ## is this necessary? [ruby-talk:16721]
+      f.flock(File::LOCK_UN)
+    end
+  end
+end
+
+def do_test
+  $stdout.sync = true
+  Thread.abort_on_exception = true
+
+  srand(3765)
+
+  thread_count  =   2
+  rep_count     = 100
+  max_sleep     =   0.01
+
+  File.open(@path, "w") do |f|
+    f.write "0"
+  end
+
+  threads = (0..thread_count).map do |thread_index|
+    Thread.new(thread_index) do |ti|
+      Thread.current[:number] = ti
+      rep_count.times do |iter|
+        Thread.current[:iter] = iter
+
+        case rand(3)
+
+        when 0
+          browse do |tester|
+            old_tester = tester
+            sleep(rand*max_sleep)
+            unless old_tester == tester
+              fail "browse: #{old_tester} != #{tester}"
+            end
+          end
+
+        when 1
+          change do |tester|
+            tester.replace (tester.to_i + 1).to_s
+            old_tester = tester
+            sleep(rand*max_sleep)
+            unless old_tester == tester
+              fail "browse: #{old_tester} != #{tester}"
+            end
+          end
+
+        else
+          sleep(rand*max_sleep)
+          if rand(20) == 0
+            clear_cache
+          end
+
+        end
+
+      end
+    end
+  end
+
+  sleep(rep_count * max_sleep * 2)
+  if threads.any? {|t|t.alive?}
+    $stderr.puts "Deadlock!"
+    exit!
+  end
+
+  threads.each do |thread|
+    thread.join
+  end
+end
+
+do_test

data/junk/lock-test.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+
+require 'thread'
+require 'sync'
+
+@path   = '/tmp/foo'
+
+@cache_mutex = Mutex.new
+
+def make_entry
+  @cache_mutex.synchronize do
+    unless @mutex
+      @mutex  ||= Mutex.new
+      @sync   ||= Synchronizer.new
+      @object = nil
+    end
+  end
+end
+
+# This is just for housekeeping, so that stale entries don't result
+# in unused, but uncollectable, CacheEntry objects.
+def clear_entry
+  @cache_mutex.synchronize do
+    @mutex  = nil
+    @sync   = nil
+    @object = nil
+  end
+end
+
+def object(f)
+  @mutex.synchronize do
+    @object ||= f.read
+  end
+end
+
+def sync_object_shared
+  @sync.synchronize(Synchronizer::SH) {yield}
+end
+
+def sync_object_exclusive
+  @sync.synchronize(Synchronizer::EX) {yield}
+end
+
+def browse
+  make_entry
+  sync_object_shared do
+    open_read_lock(@path) do |f|
+      yield object(f)
+    end
+  end
+end
+
+def change
+  make_entry
+  sync_object_exclusive do
+    open_write_lock(@path) do |f|
+      object = object(f)
+      yield object
+      f.write(object)
+    end
+  end
+end
+
+def open_read_lock(path)
+  File.open(path, "r") do |f|
+    begin
+      f.flock(File::LOCK_SH)
+      yield f
+    ensure
+      f.flock(File::LOCK_UN)
+    end
+  end
+end
+
+def open_write_lock(path)
+  File.open(path, "r+") do |f|
+    begin
+      f.flock(File::LOCK_EX) ## need to use fcntl for Linux NFS
+      yield f
+    ensure
+      f.flush ## is this necessary? [ruby-talk:16721]
+      f.flock(File::LOCK_UN)
+    end
+  end
+end
+
+def do_test
+  $stdout.sync = true
+  Thread.abort_on_exception = true
+
+  srand(3765)
+
+  thread_count  =   2
+  rep_count     = 100
+  max_sleep     =   0.01
+
+  File.open(@path, "w") do |f|
+    f.write("0")
+  end
+
+  threads = (0..thread_count).map do |thread_index|
+    Thread.new(thread_index) do |ti|
+      Thread.current[:number] = ti
+      rep_count.times do |iter|
+        Thread.current[:iter] = iter
+
+        case rand(3)
+
+        when 0
+          browse do |tester|
+            old_tester = tester
+            sleep(rand*max_sleep)
+            unless old_tester == tester
+              fail "browse: #{old_tester} != #{tester}"
+            end
+          end
+
+        when 1
+          change do |tester|
+            tester.replace (tester.to_i + 1).to_s
+            old_tester = tester
+            sleep(rand*max_sleep)
+            unless old_tester == tester
+              fail "browse: #{old_tester} != #{tester}"
+            end
+          end
+
+        else
+          sleep(rand*max_sleep)
+          if rand(20) == 0
+            clear_entry
+          end
+
+        end
+
+      end
+    end
+  end
+
+  sleep(rep_count * max_sleep * 2)
+  if threads.any? {|t|t.alive?}
+    $stderr.puts "Deadlock!"
+    exit!
+  end
+
+  threads.each do |thread|
+    thread.join
+  end
+end
+
+do_test