higgs 0.1.0

data/lib/higgs/jlog.rb

@@ -0,0 +1,159 @@
+# = journal log writer
+#
+# Author:: $Author: toki $
+# Date:: $Date: 2007-09-26 00:20:20 +0900 (Wed, 26 Sep 2007) $
+# Revision:: $Revision: 559 $
+#
+# == license
+#   :include:LICENSE
+#
+
+require 'higgs/block'
+
+module Higgs
+  # = journal log writer
+  class JournalLogger
+    # for ident(1)
+    CVS_ID = '$Id: jlog.rb 559 2007-09-25 15:20:20Z toki $'
+
+    include Block
+
+    MAGIC_SYMBOL = 'HIGGS_JLOG'
+    EOF_MARK = :END_OF_JLOG
+    BIN_EOF_MARK = Marshal.dump(EOF_MARK)
+
+    # see Higgs::Block#block_write for <tt>hash_type</tt>
+    def initialize(out, sync=false, hash_type=:MD5)
+      @out = out
+      @sync = sync
+      @hash_type = hash_type
+    end
+
+    def sync?
+      @sync
+    end
+
+    def size
+      @out.stat.size
+    end
+
+    def write(log, hash_type=nil)
+      bin_log = Marshal.dump(log)
+      start_pos = @out.tell
+      commit_completed = false
+      begin
+        block_write(@out, MAGIC_SYMBOL, bin_log, hash_type || @hash_type)
+        if (@sync) then
+          @out.fsync
+        else
+          @out.flush
+        end
+        commit_completed = true
+      ensure
+        @out.truncate(start_pos) unless commit_completed
+      end
+
+      self
+    end
+
+    def write_EOF
+      JournalLogger.eof_mark(@out)
+      self
+    end
+
+    def close(eof=true)
+      write_EOF if eof
+      @out.fsync
+      @out.close
+      @out = nil
+      nil
+    end
+
+    class << self
+      def has_eof_mark?(path)
+        unless (File.exist? path) then
+          return true
+        end
+
+        File.open(path, 'r') {|f|
+          f.binmode
+          fsiz = f.stat.size
+          if (fsiz < Block::BLOCK_SIZE * 2) then
+            return false
+          end
+          f.seek(fsiz - Block::BLOCK_SIZE * 2)
+
+          begin
+            bin_log = Block.block_read(f, MAGIC_SYMBOL) or return
+            log = Marshal.load(bin_log)
+            if (log == EOF_MARK) then
+              return true
+            end
+          rescue Block::BrokenError
+            return false
+          end
+        }
+
+        false
+      end
+
+      def need_for_recovery?(path)
+        ! (has_eof_mark? path)
+      end
+
+      def open(path, *args)
+        begin
+          f = File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0660)
+        rescue Errno::EEXIST
+          if (need_for_recovery? path) then
+            raise "need for recovery: #{path}"
+          end
+          f = File.open(path, File::WRONLY, 0660)
+          fsiz = f.stat.size
+          f.truncate(fsiz - Block::BLOCK_SIZE * 2)
+        end
+        f.binmode
+        f.seek(0, IO::SEEK_END)
+        new(f, *args)
+      end
+
+      def eof_mark(out)
+        Block.block_write(out, MAGIC_SYMBOL, BIN_EOF_MARK)
+        nil
+      end
+
+      def scan_log(io)
+        safe_pos = io.tell
+        begin
+          while (bin_log = Block.block_read(io, MAGIC_SYMBOL))
+            log = Marshal.load(bin_log)
+            if (log == EOF_MARK) then
+              break
+            end
+            yield(log)
+            safe_pos = io.tell
+          end
+        rescue Block::BrokenError
+          io.seek(safe_pos)
+          raise
+        end
+        self
+      end
+
+      def each_log(path)
+        File.open(path, 'r') {|f|
+          f.binmode
+          scan_log(f) {|log|
+            yield(log)
+          }
+        }
+        nil
+      end
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/lib/higgs/lock.rb

@@ -0,0 +1,189 @@
+# = multi-thread lock manager
+#
+# Author:: $Author: toki $
+# Date:: $Date: 2007-09-26 00:20:20 +0900 (Wed, 26 Sep 2007) $
+# Revision:: $Revision: 559 $
+#
+# == license
+#   :include:LICENSE
+#
+
+require 'forwardable'
+require 'higgs/cache'
+require 'higgs/exceptions'
+require 'singleton'
+require 'thread'
+
+module Higgs
+  # = multi-thread lock manager
+  class LockManager
+    # for ident(1)
+    CVS_ID = '$Id: lock.rb 559 2007-09-25 15:20:20Z toki $'
+
+    include Exceptions
+
+    class Error < HiggsError
+    end
+
+    class TryLockTimeoutError < Error
+    end
+
+    SPIN_LOCK_COUNT = 100
+    TRY_LOCK_LIMIT = 10
+    TRY_LOCK_INTERVAL = 0.1
+
+    RAND_GEN = proc{|seed|
+      n = seed
+      cycle = 0xFFFF
+      proc{
+        n = (n * 37549 + 12345) % cycle
+        n.to_f / cycle
+      }
+    }
+
+    def initialize(options={})
+      @spin_lock_count = options[:spin_lock_count] || SPIN_LOCK_COUNT
+      @try_lock_limit = options[:try_lock_limit] || TRY_LOCK_LIMIT
+      @try_lock_interval = options[:try_lock_interval] || TRY_LOCK_INTERVAL
+      @rand_gen = options[:random_number_generator] || RAND_GEN
+    end
+
+    attr_reader :spin_lock_count
+    attr_reader :try_lock_limit
+    attr_reader :try_lock_interval
+
+    def new_rand(seed)
+      @rand_gen.call(seed)
+    end
+
+    def self.try_lock(lock, attrs)
+      t0 = Time.now
+      c = attrs.spin_lock_count
+      while (c > 0)
+        if (lock.try_lock) then
+          return
+        end
+        c -= 1
+      end
+
+      if (attrs.try_lock_limit > 0) then
+        rand = attrs.new_rand(::Thread.current.object_id ^ t0.to_i)
+        while (Time.now - t0 < attrs.try_lock_limit)
+          if (lock.try_lock) then
+            return
+          end
+          sleep(attrs.try_lock_interval * rand.call)
+        end
+        raise TryLockTimeoutError, 'expired'
+      else
+        # brave man who doesn't fear deadlock.
+        lock.lock
+      end
+    end
+  end
+
+  class GiantLockManager < LockManager
+    # for ident(1)
+    CVS_ID = '$Id: lock.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def initialize(*args)
+      super
+      @rw_lock = ReadWriteLock.new
+    end
+
+    class NoWorkLockHandler
+      include Singleton
+
+      def lock(key)
+        self
+      end
+
+      def unlock(key)
+        self
+      end
+    end
+
+    def transaction(read_only=false)
+      if (read_only) then
+        lock = @rw_lock.read_lock
+      else
+        lock = @rw_lock.write_lock
+      end
+      r = nil
+      lock.synchronize{
+        r = yield(NoWorkLockHandler.instance)
+      }
+      r
+    end
+  end
+
+  class FineGrainLockManager < LockManager
+    # for ident(1)
+    CVS_ID = '$Id: lock.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def initialize(*args)
+      super
+      @cache = SharedWorkCache.new{|key| ReadWriteLock.new }
+    end
+
+    class LockHandler
+      def initialize(attrs, cache)
+        @attrs = attrs
+        @cache = cache
+        @lock_map = {}
+      end
+
+      def lock_list
+        @lock_map.values
+      end
+
+      def unlock(key)
+        if (lock = @lock_map.delete(key)) then
+          lock.unlock
+        else
+          raise "not locked key: #{key}"
+        end
+        self
+      end
+    end
+
+    class ReadOnlyLockHandler < LockHandler
+      def lock(key)
+        r_lock = @cache[key].read_lock
+        LockManager.try_lock(r_lock, @attrs)
+        @lock_map[key] = r_lock
+        self
+      end
+    end
+
+    class ReadWriteLockHandler < LockHandler
+      def lock(key)
+        w_lock = @cache[key].write_lock
+        LockManager.try_lock(w_lock, @attrs)
+        @lock_map[key] = w_lock
+        self
+      end
+    end
+
+    def transaction(read_only=false)
+      if (read_only) then
+        lock_handler = ReadOnlyLockHandler.new(self, @cache)
+      else
+        lock_handler = ReadWriteLockHandler.new(self, @cache)
+      end
+      begin
+        r = yield(lock_handler)
+      ensure
+        for lock in lock_handler.lock_list
+          lock.unlock
+        end
+      end
+      r
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: