fsdb 0.6.0 → 0.6.1

data/junk/insert-dir.rb

@@ -1,48 +0,0 @@
-  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

@@ -1,150 +0,0 @@
-#!/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

@@ -1,136 +0,0 @@
-#!/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

@@ -1,151 +0,0 @@
-#!/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