higgs 0.1.2 → 0.1.3

data/lib/higgs/storage.rb

@@ -1,13 +1,14 @@
 # = transactional storage core
 #
 # Author:: $Author: toki $
-# Date:: $Date: 2007-10-10 00:49:33 +0900 (Wed, 10 Oct 2007) $
-# Revision:: $Revision: 626 $
+# Date:: $Date: 2007-11-11 11:07:25 +0900 (Sun, 11 Nov 2007) $
+# Revision:: $Revision: 681 $
 #
 # == license
 #   :include:LICENSE
 #
 
+require 'digest'
 require 'forwardable'
 require 'higgs/block'
 require 'higgs/cache'
@@ -23,7 +24,7 @@ module Higgs
   # = transactional storage core
   class Storage
     # for ident(1)
-    CVS_ID = '$Id: storage.rb 626 2007-10-09 15:49:33Z toki $'
+    CVS_ID = '$Id: storage.rb 681 2007-11-11 02:07:25Z toki $'
 
     extend Forwardable
     include Exceptions
@@ -44,26 +45,17 @@ module Higgs
     PROPERTIES_CKSUM_BITS = 16
 
     DATA_HASH = {}
-    [ [ :SUM16,  proc{|s| s.sum(16).to_s              },  nil            ],
-      [ :MD5,    proc{|s| Digest::MD5.hexdigest(s)    }, 'digest/md5'    ],
-      [ :RMD160, proc{|s| Digest::RMD160.hexdigest(s) }, 'digest/rmd160' ],
-      [ :SHA1,   proc{|s| Digest::SHA1.hexdigest(s)   }, 'digest/sha1'   ],
-      [ :SHA256, proc{|s| Digest::SHA256.hexdigest(s) }, 'digest/sha2'   ],
-      [ :SHA384, proc{|s| Digest::SHA384.hexdigest(s) }, 'digest/sha2'   ],
-      [ :SHA512, proc{|s| Digest::SHA512.hexdigest(s) }, 'digest/sha2'   ]
-    ].each do |hash_symbol, hash_proc, hash_lib|
-      if (hash_lib) then
-        begin
-          require(hash_lib)
-        rescue LoadError
-          next
-        end
-      end
-      DATA_HASH[hash_symbol] = hash_proc
-    end
-
     DATA_HASH_BIN = {}
-    DATA_HASH.each do |hash_symbol, hash_proc|
+
+    [ [ :SUM16,  proc{|s| s.sum(16).to_s              } ],
+      [ :MD5,    proc{|s| Digest::MD5.hexdigest(s)    } ],
+      [ :RMD160, proc{|s| Digest::RMD160.hexdigest(s) } ],
+      [ :SHA1,   proc{|s| Digest::SHA1.hexdigest(s)   } ],
+      [ :SHA256, proc{|s| Digest::SHA256.hexdigest(s) } ],
+      [ :SHA384, proc{|s| Digest::SHA384.hexdigest(s) } ],
+      [ :SHA512, proc{|s| Digest::SHA512.hexdigest(s) } ]
+    ].each do |hash_symbol, hash_proc|
+      DATA_HASH[hash_symbol] = hash_proc
       DATA_HASH_BIN[hash_symbol.to_s] = hash_proc
     end
 
@@ -72,6 +64,10 @@ module Higgs
       # these options are defined.
       # [<tt>:number_of_read_io</tt>] number of read I/O handle of pool. default is <tt>2</tt>.
       # [<tt>:read_only</tt>] if <tt>true</tt> then storage is read-only. default is <tt>false</tt>.
+      #                       <tt>:standby</tt> is standby mode. in standby mode, storage is read-only
+      #                       and Higgs::Storage#apply_journal_log is callable.
+      #                       if Higgs::Storage#switch_to_write is called in standby mode then
+      #                       state of storage changes from standby mode to read-write mode.
       # [<tt>:properties_cache</tt>] read-cache for properties. default is a new instance of Higgs::LRUCache.
       # [<tt>:data_hash_type</tt>] hash type (<tt>:SUM16</tt>, <tt>:MD5</tt>, <tt>:RMD160</tt>,
       #                            <tt>:SHA1</tt>, <tt>:SHA256</tt>, <tt>:SHA384</tt> or <tt>:SHA512</tt>)
@@ -84,9 +80,6 @@ module Higgs
       #                             if <tt>:jlog_rotate_max</tt> is <tt>0</tt>, old journal log is
       #                             not deleted. if online-backup is used, <tt>:jlog_rotate_max</tt>
       #                             should be <tt>0</tt>. default is <tt>1</tt>.
-      # [<tt>:jlog_rotate_service_uri</tt>] URI for DRb remote call to switch journal log to a new file.
-      #                                     if online-backup is used, <tt>:jlog_rotate_service_uri</tt>
-      #                                     should be defined. default is not defined.
       # [<tt>:logger</tt>] procedure to create a logger. default is a procedure to create a new
       #                    instance of Logger with logging level <tt>Logger::WARN</tt>.
       def init_options(options)
@@ -122,7 +115,6 @@ module Higgs
 
         @jlog_rotate_size = options[:jlog_rotate_size] || 1024 * 256
         @jlog_rotate_max = options[:jlog_rotate_max] || 1
-        @jlog_rotate_service_uri = options[:jlog_rotate_service_uri]
 
         if (options.key? :logger) then
           @Logger = options[:logger]
@@ -144,43 +136,9 @@ module Higgs
       attr_reader :jlog_hash_type
       attr_reader :jlog_rotate_size
       attr_reader :jlog_rotate_max
-      attr_reader :jlog_rotate_service_uri
     end
     include InitOptions
 
-    # export Higgs::Storage methods from <tt>@storage</tt> instance variable.
-    #
-    # these methods are delegated.
-    # * Higgs::Storage#name
-    # * Higgs::Storage#read_only
-    # * Higgs::Storage#number_of_read_io
-    # * Higgs::Storage#data_hash_type
-    # * Higgs::Storage#jlog_sync
-    # * Higgs::Storage#jlog_hash_type
-    # * Higgs::Storage#jlog_rotate_size
-    # * Higgs::Storage#jlog_rotate_max
-    # * Higgs::Storage#jlog_rotate_service_uri
-    # * Higgs::Storage#shutdown
-    # * Higgs::Storage#shutdown?
-    # * Higgs::Storage#rotate_journal_log
-    #
-    module Export
-      extend Forwardable
-
-      def_delegator :@storage, :name
-      def_delegator :@storage, :read_only
-      def_delegator :@storage, :number_of_read_io
-      def_delegator :@storage, :data_hash_type
-      def_delegator :@storage, :jlog_sync
-      def_delegator :@storage, :jlog_hash_type
-      def_delegator :@storage, :jlog_rotate_size
-      def_delegator :@storage, :jlog_rotate_max
-      def_delegator :@storage, :jlog_rotate_service_uri
-      def_delegator :@storage, :shutdown
-      def_delegator :@storage, :shutdown?
-      def_delegator :@storage, :rotate_journal_log
-    end
-
     def self.load_conf(path)
       conf = YAML.load(IO.read(path))
       options = {}
@@ -217,7 +175,7 @@ module Higgs
     # storage is composed of the following 5 files.
     # <tt>name.log</tt>:: event log. default logging level is <tt>WARN</tt>.
     # <tt>name.tar</tt>:: data file compatible with unix TAR format.
-    # <tt>name.idx</tt>:: index snapshot. genuine index is Hash in the memory.
+    # <tt>name.idx</tt>:: index snapshot. genuine index is Hash in memory.
     #                     see Higgs::Index for detail.
     # <tt>name.jlog</tt>:: transaction journal log. see Higgs::JournalLogger for detail.
     # <tt>name.lock</tt>:: lock file for File#flock. see Higgs::FileLock for detail.
@@ -238,9 +196,10 @@ module Higgs
       init_options(options)
 
       init_completed = false
+      read_only = @read_only && @read_only != :standby
       begin
-        @flock = FileLock.new(@lock_name, @read_only)
-        if (@read_only) then
+        @flock = FileLock.new(@lock_name, read_only)
+        if (read_only) then
           @flock.read_lock
         else
           @flock.write_lock
@@ -248,7 +207,7 @@ module Higgs
 
         @logger = @Logger.call(@log_name)
         @logger.info("storage open start...")
-        if (@read_only) then
+        if (read_only) then
           @logger.info("get file lock for read")
         else
           @logger.info("get file lock for write")
@@ -265,7 +224,7 @@ module Higgs
           value = read_record_body(key, :p) and decode_properties(key, value)
         }
 
-        unless (@read_only) then
+        unless (read_only) then
           begin
             w_io = File.open(@tar_name, File::WRONLY | File::CREAT | File::EXCL, 0660)
             @logger.info("create and open I/O handle for write: #{@tar_name}")
@@ -289,25 +248,25 @@ module Higgs
         if (File.exist? @idx_name) then
           @logger.info("load index: #{@idx_name}")
           @index.load(@idx_name)
+          unless (@index.storage_id) then # for migration to new index format of version 0.2 from old version
+            @index.storage_id = create_storage_id
+            @logger.info("save storage id: #{@index.storage_id}")
+            @index.save(@idx_name)
+          end
+        else
+          @index.storage_id = create_storage_id
+          @logger.info("save storage id: #{@index.storage_id}")
+          @index.save(@idx_name)
         end
         if (JournalLogger.need_for_recovery? @jlog_name) then
           recover
         end
-        unless (@read_only) then
+        unless (read_only) then
           @logger.info("journal log sync mode: #{@jlog_sync}")
           @logger.info("open journal log for write: #{@jlog_name}")
           @jlog = JournalLogger.open(@jlog_name, @jlog_sync, @jlog_hash_type)
         end
 
-        if (@jlog_rotate_service_uri) then
-          @logger.info("start journal log rotation service: #{@jlog_rotate_service_uri}")
-          require 'drb'
-          @jlog_rotate_service = DRb::DRbServer.new(@jlog_rotate_service_uri,
-                                                    method(:rotate_journal_log))
-        else
-          @jlog_rotate_service = nil
-        end
-
         init_completed = true
       ensure
         if (init_completed) then
@@ -331,7 +290,7 @@ module Higgs
             end
           end
 
-          unless (@read_only) then
+          unless (read_only) then
             if (@jlog) then
               begin
                 @jlog.close(false)
@@ -351,7 +310,7 @@ module Higgs
             }
           end
 
-          unless (@read_only) then
+          unless (read_only) then
             if (@w_tar) then
               begin
                 @w_tar.close(false)
@@ -381,27 +340,61 @@ module Higgs
       end
     end
 
+    def create_storage_id
+      hash = Digest::MD5.new
+      now = Time.now
+      hash.update(now.to_s)
+      hash.update(String(now.usec))
+      hash.update(String(rand(0)))
+      hash.update(String($$))
+      hash.update(CVS_ID)
+      hash.update(@name)
+      hash.update('toki')
+      hash.hexdigest
+    end
+    private :create_storage_id
+
     def check_panic
+      if (@shutdown) then
+        raise ShutdownException, 'storage shutdown'
+      end
+      if (@panic) then
+        raise PanicError, 'broken storage'
+      end
+    end
+    private :check_panic
+
+    def check_read
       @state_lock.synchronize{
-        if (@shutdown) then
-          raise ShutdownException, 'storage shutdown'
+        check_panic
+      }
+    end
+    private :check_read
+
+    def check_standby
+      @state_lock.synchronize{
+        check_panic
+        if (@read_only && @read_only != :standby) then
+          raise NotWritableError, 'failed to write to read only storage'
         end
-        if (@panic) then
-          raise PanicError, 'broken storage'
+      }
+    end
+    private :check_standby
+
+    def check_read_write
+      @state_lock.synchronize{
+        check_panic
+        if (@read_only) then
+          raise NotWritableError, 'failed to write to read only storage'
         end
       }
     end
-    private :check_panic
+    private :check_read_write
 
     def recover
       @logger.warn('incompleted storage and recover from journal log...')
 
-      check_panic
-      if (@read_only) then
-        @logger.warn('read only storage is not recoverable.')
-        raise NotWritableError, 'need for recovery'
-      end
-
+      check_standby
       recover_completed = false
       begin
         safe_pos = 0
@@ -421,6 +414,9 @@ module Higgs
         }
         @logger.info("last safe point of journal log: #{safe_pos}")
 
+        @logger.info("flush storage.")
+        @w_tar.flush
+
         File.open(@jlog_name, File::WRONLY, 0660) {|f|
           f.binmode
           @logger.info("shrink journal log to erase last broken segment.")
@@ -430,10 +426,6 @@ module Higgs
           JournalLogger.eof_mark(f)
         }
 
-        @logger.info("write EOA to storage: #{@index.eoa}")
-        @w_tar.seek(@index.eoa)
-        @w_tar.write_EOA
-
         recover_completed = true
       ensure
         unless (recover_completed) then
@@ -452,6 +444,8 @@ module Higgs
     def shutdown
       @commit_lock.synchronize{
         @state_lock.synchronize{
+          read_only = @read_only && @read_only != :standby
+
           if (@shutdown) then
             raise ShutdownException, 'storage shutdown'
           end
@@ -463,7 +457,7 @@ module Higgs
             @jlog_rotate_service.stop_service
           end
 
-          unless (@read_only) then
+          unless (read_only) then
             if (@panic) then
               @logger.warn("abort journal log: #{@jlog_name}")
               @jlog.close(false)
@@ -473,7 +467,7 @@ module Higgs
             end
           end
 
-          if (! @panic && ! @read_only) then
+          if (! @panic && ! read_only) then
             @logger.info("save index: #{@idx_name}")
             @index.save(@idx_name)
           end
@@ -482,7 +476,7 @@ module Higgs
             @logger.info("close I/O handle for read: #{@tar_name}")
             r_tar.close
           }
-          unless (@read_only) then
+          unless (read_only) then
             @logger.info("sync write data: #{@tar_name}")
             @w_tar.fsync
             @logger.info("close I/O handle for write: #{@tar_name}")
@@ -503,7 +497,13 @@ module Higgs
       @state_lock.synchronize{ @shutdown }
     end
 
-    def self.rotate_entries(name)
+    def alive?
+      @state_lock.synchronize{
+        ! @shutdown && ! @panic
+      }
+    end
+
+    def self.rotated_entries(name)
       rotate_list = Dir["#{name}.*"].map{|nm|
         n = Integer(nm[(name.length + 1)..-1])
         [ nm, n ]
@@ -516,7 +516,7 @@ module Higgs
     end
 
     def internal_rotate_journal_log(save_index)
-      @logger.info("start journal log rotation...")
+      @logger.info("start journal log rotation.")
 
       commit_log = []
       while (File.exist? "#{@jlog_name}.#{@index.change_number}")
@@ -526,7 +526,7 @@ module Higgs
       end
       unless (commit_log.empty?) then
         @logger.debug("write journal log: #{@index.change_number}") if @logger.debug?
-        @jlog.write([ @index.change_number, commit_log ])
+        @jlog.write([ @index.change_number, commit_log, @index.storage_id ])
       end
       rot_jlog_name = "#{@jlog_name}.#{@index.change_number}"
 
@@ -548,7 +548,7 @@ module Higgs
       @logger.info("rename journal log: #{@jlog_name} -> #{rot_jlog_name}")
       File.rename(@jlog_name, rot_jlog_name)
       if (@jlog_rotate_max > 0) then
-        rotate_list = Storage.rotate_entries(@jlog_name)
+        rotate_list = Storage.rotated_entries(@jlog_name)
         while (rotate_list.length > @jlog_rotate_max)
           unlink_jlog_name = rotate_list.shift
           @logger.info("unlink old journal log: #{unlink_jlog_name}")
@@ -564,11 +564,7 @@ module Higgs
 
     def rotate_journal_log(save_index=true)
       @commit_lock.synchronize{
-        check_panic
-        if (@read_only) then
-          raise NotWritableError, 'failed to write to read only storage'
-        end
-
+        check_read_write
         rotate_completed = false
         begin
           internal_rotate_journal_log(save_index)
@@ -589,16 +585,16 @@ module Higgs
       @commit_lock.synchronize{
         @logger.debug("start raw_write_and_commit.") if @logger.debug?
 
-        check_panic
-        if (@read_only) then
-          raise NotWritableError, 'failed to write to read only storage'
-        end
-
+        check_read_write
         commit_log = []
         commit_completed = false
         eoa = @index.eoa
 
         begin
+          @index.succ!
+          @logger.debug("index succ: #{@index.change_number}") if @logger.debug?
+          commit_log << { :ope => :succ, :cnum => @index.change_number }
+
           for ope, key, type, name, value in write_list
             case (ope)
             when :write
@@ -636,11 +632,12 @@ module Higgs
                     @index.free_store(j[:pos], j[:siz])
                     j[:pos] = pos
                     j[:siz] = blocked_size
+                    j[:cnum] = @index.change_number
                   else
-                    i[type] = { :pos => pos, :siz => blocked_size }
+                    i[type] = { :pos => pos, :siz => blocked_size, :cnum => @index.change_number }
                   end
                 else
-                  @index[key] = { type => { :pos => pos, :siz => blocked_size } }
+                  @index[key] = { type => { :pos => pos, :siz => blocked_size, :cnum => @index.change_number } }
                 end
                 next
               end
@@ -659,6 +656,7 @@ module Higgs
                       :nam => name,
                       :val => value
                     }
+                    j[:cnum] = @index.change_number
                     if (j[:siz] > blocked_size) then
                       commit_log << {
                         :ope => :free_store,
@@ -697,11 +695,12 @@ module Higgs
                   @index.free_store(j[:pos], j[:siz])
                   j[:pos] = eoa
                   j[:siz] = blocked_size
+                  j[:cnum] = @index.change_number
                 else
-                  i[type] = { :pos => eoa, :siz => blocked_size }
+                  i[type] = { :pos => eoa, :siz => blocked_size, :cnum => @index.change_number }
                 end
               else
-                @index[key] = { type => { :pos => eoa, :siz => blocked_size } }
+                @index[key] = { type => { :pos => eoa, :siz => blocked_size, :cnum => @index.change_number } }
               end
               eoa += blocked_size
               commit_log << {
@@ -730,12 +729,8 @@ module Higgs
             end
           end
 
-          @index.succ!
-          @logger.debug("index succ: #{@index.change_number}") if @logger.debug?
-          commit_log << { :ope => :succ, :cnum => @index.change_number }
-
           @logger.debug("write journal log: #{@index.change_number}") if @logger.debug?
-          @jlog.write([ @index.change_number, commit_log ])
+          @jlog.write([ @index.change_number, commit_log, @index.storage_id ])
 
           for cmd in commit_log
             case (cmd[:ope])
@@ -784,7 +779,14 @@ module Higgs
     end
 
     def self.apply_journal(w_tar, index, log)
-      change_number, commit_log = log
+      change_number, commit_log, storage_id = log
+
+      if (storage_id) then # check for backward compatibility
+        if (storage_id != index.storage_id) then
+          raise PanicError, "unexpected storage id: expected <#{index.storage_id}> but was <#{storage_id}>"
+        end
+      end
+
       if (change_number - 1 < index.change_number) then
         # skip old jounal log
       elsif (change_number - 1 > index.change_number) then
@@ -793,6 +795,7 @@ module Higgs
         for cmd in commit_log
           case (cmd[:ope])
           when :write
+            yield(cmd[:key]) if block_given?
             name = "#{cmd[:key]}.#{cmd[:typ]}"[0, Tar::Block::MAX_LEN]
             w_tar.seek(cmd[:pos])
             w_tar.add(cmd[:nam], cmd[:val], :mtime => cmd[:mod])
@@ -801,13 +804,15 @@ module Higgs
               if (j = i[cmd[:typ]]) then
                 j[:pos] = cmd[:pos]
                 j[:siz] = blocked_size
+                j[:cnum] = index.change_number
               else
-                i[cmd[:typ]] = { :pos => cmd[:pos], :siz => blocked_size }
+                i[cmd[:typ]] = { :pos => cmd[:pos], :siz => blocked_size, :cnum => index.change_number }
               end
             else
-              index[cmd[:key]] = { cmd[:typ] => { :pos => cmd[:pos], :siz => blocked_size } }
+              index[cmd[:key]] = { cmd[:typ] => { :pos => cmd[:pos], :siz => blocked_size, :cnum => index.change_number } }
             end
           when :delete
+            yield(cmd[:key]) if block_given?
             index.delete(cmd[:key])
           when :free_fetch
             index.free_fetch_at(cmd[:pos], cmd[:siz])
@@ -818,6 +823,8 @@ module Higgs
             w_tar.write_header(:name => name, :size => cmd[:siz] - Tar::Block::BLKSIZ, :mtime => cmd[:mod])
           when :eoa
             index.eoa = cmd[:pos]
+            w_tar.seek(cmd[:pos])
+            w_tar.write_EOA
           when :succ
             index.succ!
             if (index.change_number != cmd[:cnum]) then
@@ -828,6 +835,7 @@ module Higgs
           end
         end
       end
+
       nil
     end
 
@@ -851,7 +859,7 @@ module Higgs
           index.load(idx_name) if (File.exist? idx_name)
 
           out << "recovery target: #{name}\n" if (out && verbose_level >= 1)
-          jlog_list = rotate_entries(jlog_name)
+          jlog_list = rotated_entries(jlog_name)
           jlog_list << jlog_name if (File.exist? jlog_name)
           for curr_name in jlog_list
             begin
@@ -864,8 +872,6 @@ module Higgs
               out << "warning: incompleted journal log and stopped at #{curr_name}\n" if out
             end
           end
-          w_tar.seek(index.eoa)
-          w_tar.write_EOA
 
           index.save(idx_name)
           w_tar.fsync
@@ -876,11 +882,72 @@ module Higgs
       nil
     end
 
+    def apply_journal_log(path)
+      @commit_lock.synchronize{
+        @logger.info("start to apply journal log.")
+
+        check_standby
+        apply_completed = false
+        begin
+          JournalLogger.each_log(path) do |log|
+            change_number, commit_log, storage_id = log
+
+            if (storage_id) then # check for backward compatibility
+              if (storage_id != @index.storage_id) then
+                raise PanicError, "unexpected storage id: expected <#{@index.storage_id}> but was <#{storage_id}>"
+              end
+            end
+
+            if (change_number - 1 < @index.change_number) then
+              @logger.debug("skip journal log: #{change_number}") if @logger.debug?
+            elsif (change_number - 1 > @index.change_number) then
+              raise PanicError, "lost journal log (cnum: #{@index.change_number + 1})"
+            else # if (change_number - 1 == @index.change_number) then
+              @logger.debug("write journal log: #{change_number}") if @logger.debug?
+              @jlog.write(log)
+
+              @logger.debug("apply journal log: #{change_number}") if @logger.debug?
+              Storage.apply_journal(@w_tar, @index, log) {|key|
+                @properties_cache.delete(key)
+                yield(key) if block_given?
+              }
+
+              if (@jlog_rotate_size > 0 && @jlog.size >= @jlog_rotate_size) then
+                internal_rotate_journal_log(true)
+              end
+            end
+          end
+
+          @logger.debug("flush storage.")
+          @w_tar.flush
+
+          apply_completed = true
+        ensure
+          unless (apply_completed) then
+            @state_lock.synchronize{ @panic = true }
+            @logger.error("panic: failed to apply journal log.")
+            @logger.error($!) if $!
+          end
+        end
+
+        @logger.info("completed to apply journal log.")
+      }
+
+      nil
+    end
+
+    def switch_to_write
+      @state_lock.synchronize{
+        if (@read_only != :standby) then
+          raise "not standby mode: #{@read_only}"
+        end
+        @read_only = false
+      }
+      nil
+    end
+
     def write_and_commit(write_list, commit_time=Time.now)
-      check_panic
-      if (@read_only) then
-        raise NotWritableError, 'failed to write to read only storage'
-      end
+      check_read_write
 
       raw_write_list = []
       deleted_entries = {}
@@ -1013,12 +1080,12 @@ module Higgs
     private :internal_fetch_properties
 
     def fetch_properties(key)
-      check_panic
+      check_read
       internal_fetch_properties(key)
     end
 
     def fetch(key)
-      check_panic
+      check_read
       value = read_record_body(key, :d) or return
       unless (properties = internal_fetch_properties(key)) then
         @state_lock.synchronize{ @panic = true }
@@ -1047,13 +1114,27 @@ module Higgs
 
     def_delegator :@index, :identity
 
+    def data_change_number(key)
+      i = @index[key] and i[:d][:cnum] || -1
+    end
+
+    def properties_change_number(key)
+      i = @index[key] and i[:p][:cnum] || -1
+    end
+
+    def unique_data_id(key)
+      id = identity(key) or return
+      cnum = data_change_number(key) or return
+      "#{id}\t#{cnum}"
+    end
+
     def key?(key)
-      check_panic
+      check_read
       @index.key? key
     end
 
     def each_key
-      check_panic
+      check_read
       @index.each_key do |key|
         yield(key)
       end
@@ -1070,7 +1151,7 @@ module Higgs
     ]
 
     def verify(out=nil, verbose_level=1)
-      check_panic
+      check_read
 
       keys = @index.keys
       keys.sort!{|a, b|
@@ -1096,6 +1177,55 @@ module Higgs
 
       nil
     end
+
+    class ClientSideLocalhostCheckHandler
+      def initialize(path, messg)
+        @path = File.expand_path(path)
+        @messg = messg
+      end
+
+      def call
+        unless (File.exist? @path) then
+          raise 'client should exist in localhost.'
+        end
+
+        File.open(@path, 'r') {|f|
+          f.binmode
+          if (f.read != @messg) then
+            raise 'client should exist in localhost.'
+          end
+        }
+        nil
+      end
+    end
+
+    # check that client exists in localhost.
+    def localhost_check
+      base_dir = File.dirname(@name)
+      tmp_fname = File.join(base_dir, ".localhost_check.#{$$}")
+      messg = (0...8).map{ rand(64) }.pack("C*").tr("\x00-\x3f", "A-Za-z0-9./")
+
+      begin
+        f = File.open(tmp_fname, File::WRONLY | File::CREAT | File::EXCL, 0644)
+      rescue Errno::EEXIST
+        tmp_fname.succ!
+        retry
+      end
+
+      begin
+        begin
+          f.binmode
+          f.write(messg)
+        ensure
+          f.close
+        end
+        yield(ClientSideLocalhostCheckHandler.new(tmp_fname, messg))
+      ensure
+        File.unlink(tmp_fname) if (File.exist? tmp_fname)
+      end
+
+      nil
+    end
   end
 end