rims 0.2.1

data/lib/rims/daemon.rb

@@ -0,0 +1,338 @@
+# -*- coding: utf-8 -*-
+
+require 'logger'
+require 'yaml'
+
+module RIMS
+  class Daemon
+    class ExclusiveStatusFile
+      def initialize(filename)
+        @filename = filename
+        @file = nil
+        @is_locked = false
+      end
+
+      def open
+        if (block_given?) then
+          open
+          begin
+            r = yield
+          ensure
+            close
+          end
+          return r
+        end
+
+        begin
+          @file = File.open(@filename, File::WRONLY | File::CREAT, 0640)
+        rescue SystemCallError
+          @fiile = File.open(@filename, File::WRONLY)
+        end
+
+        self
+      end
+
+      def close
+        @file.close
+        self
+      end
+
+      def locked?
+        @is_locked
+      end
+
+      def should_be_locked
+        unless (locked?) then
+          raise "not locked: #{@filename}"
+        end
+        self
+      end
+
+      def should_not_be_locked
+        if (locked?) then
+          raise "already locked: #{@filename}"
+        end
+        self
+      end
+
+      def lock
+        should_not_be_locked
+        unless (@file.flock(File::LOCK_EX | File::LOCK_NB)) then
+          raise "locked by another process: #{@filename}"
+        end
+        @is_locked = true
+        self
+      end
+
+      def unlock
+        should_be_locked
+        @file.flock(File::LOCK_UN)
+        @is_locked = false
+        self
+      end
+
+      def synchronize
+        lock
+        begin
+          yield
+        ensure
+          unlock
+        end
+      end
+
+      def write(text)
+        should_be_locked
+
+        @file.truncate(0)
+        @file.syswrite(text)
+
+        self
+      end
+    end
+
+    class ReadableStatusFile
+      def initialize(filename)
+        @filename = filename
+        @file = nil
+      end
+
+      def open
+        if (block_given?) then
+          open
+          begin
+            r = yield
+          ensure
+            close
+          end
+          return r
+        end
+
+        @file = File.open(@filename, File::RDONLY)
+
+        self
+      end
+
+      def close
+        @file.close
+        self
+      end
+
+      def locked?
+        if (@file.flock(File::LOCK_EX | File::LOCK_NB)) then
+          @file.flock(File::LOCK_UN)
+          false
+        else
+          true
+        end
+      end
+
+      def should_be_locked
+        unless (locked?) then
+          raise "not locked: #{@filename}"
+        end
+        self
+      end
+
+      def read
+        should_be_locked
+        @file.seek(0)
+        @file.read
+      end
+    end
+
+    def self.new_status_file(filename, exclusive: false)
+      if (exclusive) then
+        ExclusiveStatusFile.new(filename)
+      else
+        ReadableStatusFile.new(filename)
+      end
+    end
+
+    def self.make_stat_file_path(base_dir)
+      File.join(base_dir, 'status')
+    end
+
+    RELOAD_SIGNAL_LIST = %w[ HUP ]
+    RESTART_SIGNAL_LIST = %w[ USR1 ]
+    STOP_SIGNAL_LIST = %w[ TERM INT ]
+
+    RELOAD_SIGNAL = RELOAD_SIGNAL_LIST[0]
+    RESTART_SIGNAL = RESTART_SIGNAL_LIST[0]
+    STOP_SIGNAL = STOP_SIGNAL_LIST[0]
+
+    SERVER_RESTART_INTERVAL_SECONDS = 5
+
+    class ChildProcess
+      # return self if child process has been existed.
+      # return nil if no child process.
+      def self.cleanup_terminated_process(logger)
+        begin
+          while (pid = Process.waitpid(-1))
+            if ($?.exitstatus != 0) then
+              logger.warn("aborted child process: #{pid} (#{$?.exitstatus})")
+            end
+            yield(pid) if block_given?
+          end
+        rescue Errno::ECHILD
+          return
+        end
+
+        self
+      end
+
+      def initialize(logger=Logger.new(STDOUT))
+        @logger = logger
+        @pid = run{ yield }
+      end
+
+      attr_reader :pid
+
+      def run
+        begin
+          pipe_in, pipe_out = IO.pipe
+          pid = Process.fork{
+            @logger.close
+            pipe_in.close
+
+            status_code = catch(:rims_daemon_child_process_stop) {
+              for sig_name in RELOAD_SIGNAL_LIST + RESTART_SIGNAL_LIST
+                Signal.trap(sig_name, :DEFAULT)
+              end
+              for sig_name in STOP_SIGNAL_LIST
+                Signal.trap(sig_name) { throw(:rims_daemon_child_process_stop, 0) }
+              end
+
+              pipe_out.puts("child process (pid: #{$$}) is ready to go.")
+              pipe_out.close
+
+              yield
+            }
+            exit!(status_code)
+          }
+        rescue
+          @logger.error("failed to fork new child process: #{$!}")
+          return
+        end
+
+        begin
+          pipe_out.close
+          s = pipe_in.gets
+          @logger.info("[child process message] #{s}") if $DEBUG
+          pipe_in.close
+        rescue
+          @logger.error("failed to start new child process: #{$!}")
+          begin
+            Process.kill(STOP_SIGNAL, pid)
+          rescue SystemCallError
+            @logger.warn("failed to kill abnormal child process: #{$!}")
+          end
+          return
+        end
+
+        pid
+      end
+      private :run
+
+      def forked?
+        @pid != nil
+      end
+
+      def terminate
+        begin
+          Process.kill(STOP_SIGNAL, @pid)
+        rescue SystemCallError
+          @logger.warn("failed to terminate child process: #{@pid}")
+        end
+
+        nil
+      end
+    end
+
+    def initialize(stat_file_path, logger=Logger.new(STDOUT), server_options: [])
+      @stat_file = self.class.new_status_file(stat_file_path, exclusive: true)
+      @logger = logger
+      @server_options = server_options
+      @server_running = true
+      @server_process = nil
+    end
+
+    def new_server_process
+      ChildProcess.new(@logger) { Cmd.run_cmd(%w[ server ] + @server_options) }
+    end
+    private :new_server_process
+
+    def run
+      @stat_file.open{
+        @stat_file.synchronize{
+          @stat_file.write({ 'pid' => $$ }.to_yaml)
+          begin
+            @logger.info('start daemon.')
+            loop do
+              break unless @server_running
+
+              unless (@server_process && @server_process.forked?) then
+                start_time = Time.now
+                @server_process = new_server_process
+                @logger.info("run server process: #{@server_process.pid}")
+              end
+
+              break unless @server_running
+
+              ChildProcess.cleanup_terminated_process(@logger) do |pid|
+                if (@server_process.pid == pid) then
+                  @server_process = nil
+                end
+              end
+
+              break unless @server_running
+
+              elapsed_seconds = Time.now - start_time
+              the_rest_in_interval_seconds = SERVER_RESTART_INTERVAL_SECONDS - elapsed_seconds
+              sleep(the_rest_in_interval_seconds) if (the_rest_in_interval_seconds > 0)
+            end
+          ensure
+            if (@server_process && @server_process.forked?) then
+              @server_process.terminate
+              ChildProcess.cleanup_terminated_process(@logger)
+            end
+            @logger.info('stop daemon.')
+          end
+        }
+      }
+
+      self
+    end
+
+    # signal trap hook.
+    # this method is not true reload.
+    def reload_server
+      restart_server
+    end
+
+    # signal trap hook.
+    def restart_server
+      @stat_file.should_be_locked
+      if (@server_process && @server_process.forked?) then
+        @server_process.terminate
+      end
+
+      self
+    end
+
+    # signal trap hook.
+    def stop_server
+      @stat_file.should_be_locked
+      @server_running = false
+      if (@server_process && @server_process.forked?) then
+        @server_process.terminate
+      end
+
+      self
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/lib/rims/db.rb

@@ -0,0 +1,793 @@
+# -*- coding: utf-8 -*-
+
+require 'logger'
+require 'set'
+
+module RIMS
+  module DB
+    class Core
+      def initialize(kvs)
+        @kvs = kvs
+      end
+
+      def sync
+        @kvs.sync
+        self
+      end
+
+      def close
+        @kvs.close
+        self
+      end
+
+      def destroy
+        @kvs.destroy
+        nil
+      end
+
+      def test_read_all         # :yields: read_error
+        last_error = nil
+        @kvs.each_key do |key|
+          begin
+            @kvs[key]
+          rescue
+            last_error = $!
+            yield($!)
+          end
+        end
+
+        if (last_error) then
+          raise last_error
+        end
+
+        self
+      end
+
+      def get_str(key, default_value: nil)
+        @kvs[key] || default_value
+      end
+      private :get_str
+
+      def put_str(key, str)
+        @kvs[key] = str
+        self
+      end
+      private :put_str
+
+      def get_str_set(key)
+        if (s = @kvs[key]) then
+          s.split(',', -1).to_set
+        else
+          [].to_set
+        end
+      end
+      private :get_str_set
+
+      def put_str_set(key, str_set)
+        @kvs[key] = str_set.to_a.join(',')
+        self
+      end
+      private :put_str_set
+
+      def get_num(key, default_value: 0)
+        if (s = @kvs[key]) then
+          s.to_i
+        else
+          default_value
+        end
+      end
+      private :get_num
+
+      def put_num(key, num)
+        @kvs[key] = num.to_s
+        self
+      end
+      private :put_num
+
+      def num_succ!(key, default_value: 0)
+        n = get_num(key, default_value: default_value)
+        put_num(key, n + 1)
+        n
+      end
+      private :num_succ!
+
+      def num_increment(key)
+        n = get_num(key)
+        put_num(key, n + 1)
+        self
+      end
+      private :num_increment
+
+      def num_decrement(key)
+        n = get_num(key)
+        put_num(key, n - 1)
+        self
+      end
+      private :num_decrement
+
+      def get_num_set(key)
+        if (s = @kvs[key]) then
+          s.split(',', -1).map{|n| n.to_i }.to_set
+        else
+          [].to_set
+        end
+      end
+      private :get_num_set
+
+      def put_num_set(key, num_set)
+        @kvs[key] = num_set.to_a.join(',')
+        self
+      end
+      private :put_num_set
+
+      def get_obj(key, default_value: nil)
+        if (s = @kvs[key]) then
+          Marshal.load(s)
+        else
+          default_value
+        end
+      end
+      private :get_obj
+
+      def put_obj(key, value)
+        @kvs[key] = Marshal.dump(value)
+        self
+      end
+      private :put_obj
+    end
+
+    class Meta < Core
+      def dirty?
+        @kvs.key? 'dirty'
+      end
+
+      def dirty=(dirty_flag)
+        if (dirty_flag) then
+          put_str('dirty', '')
+        else
+          @kvs.delete('dirty')
+        end
+        @kvs.sync
+
+        dirty_flag
+      end
+
+      def cnum
+        get_num('cnum')
+      end
+
+      def cnum_succ!
+        num_succ!('cnum')
+      end
+
+      def msg_id
+        get_num('msg_id')
+      end
+
+      def msg_id_succ!
+        num_succ!('msg_id')
+      end
+
+      def uidvalidity
+        get_num('uidvalidity', default_value: 1)
+      end
+
+      def uidvalidity_succ!
+        num_succ!('uidvalidity', default_value: 1)
+      end
+
+      def add_mbox(name, mbox_id: nil)
+        if (@kvs.key? "mbox_name2id-#{name}") then
+          raise "duplicated mailbox name: #{name}."
+        end
+
+        if (mbox_id) then
+          if (@kvs.key? "mbox_id2name-#{mbox_id}") then
+            raise "duplicated mailbox id: #{mbox_id}"
+          end
+          if (uidvalidity <= mbox_id) then
+            put_num('uidvalidity', mbox_id + 1)
+          end
+        else
+          mbox_id = uidvalidity_succ!
+        end
+
+        mbox_set = get_num_set('mbox_set')
+        if (mbox_set.include? mbox_id) then
+          raise "internal error: duplicated mailbox id: #{mbox_id}"
+        end
+        mbox_set << mbox_id
+        put_num_set('mbox_set', mbox_set)
+
+        put_str("mbox_id2name-#{mbox_id}", name)
+        put_num("mbox_name2id-#{name}", mbox_id)
+
+        mbox_id
+      end
+
+      def del_mbox(mbox_id)
+        mbox_set = get_num_set('mbox_set')
+        if (mbox_set.include? mbox_id) then
+          mbox_set.delete(mbox_id)
+          put_num_set('mbox_set', mbox_set)
+          name = mbox_name(mbox_id)
+          @kvs.delete("mbox_id2name-#{mbox_id}") or raise "not found a mailbox name for id: #{mbox_id}"
+          @kvs.delete("mbox_name2id-#{name}") or raise "not found a mailbox id for name: #{name}"
+          @kvs.delete("mbox_id2uid-#{mbox_id}")
+          @kvs.delete("mbox_id2msgnum-#{mbox_id}")
+          self
+        end
+      end
+
+      def rename_mbox(mbox_id, new_name)
+        old_name = get_str("mbox_id2name-#{mbox_id}") or raise "not found a mailbox name for id: #{mbox_id}"
+        if (new_name == old_name) then
+          return
+        end
+        if (@kvs.key? "mbox_name2id-#{new_name}") then
+          raise "duplicated mailbox name: #{new_name}"
+        end
+        @kvs.delete("mbox_name2id-#{old_name}") or raise "not found a mailbox old name for id: #{mbox_id}"
+        put_str("mbox_id2name-#{mbox_id}", new_name)
+        put_num("mbox_name2id-#{new_name}", mbox_id)
+        self
+      end
+
+      def each_mbox_id
+        return enum_for(:each_mbox_id) unless block_given?
+        mbox_set = get_num_set('mbox_set')
+        for mbox_id in mbox_set
+          yield(mbox_id)
+        end
+        self
+      end
+
+      def mbox_name(mbox_id)
+        get_str("mbox_id2name-#{mbox_id}", default_value: nil)
+      end
+
+      def mbox_id(name)
+        get_num("mbox_name2id-#{name}", default_value: nil)
+      end
+
+      def mbox_uid(mbox_id)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        get_num("mbox_id2uid-#{mbox_id}", default_value: 1)
+      end
+
+      def mbox_uid_succ!(mbox_id)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        num_succ!("mbox_id2uid-#{mbox_id}", default_value: 1)
+      end
+
+      def mbox_msg_num(mbox_id)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        get_num("mbox_id2msgnum-#{mbox_id}")
+      end
+
+      def mbox_msg_num_increment(mbox_id)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        num_increment("mbox_id2msgnum-#{mbox_id}")
+        self
+      end
+
+      def mbox_msg_num_decrement(mbox_id)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        num_decrement("mbox_id2msgnum-#{mbox_id}")
+        self
+      end
+
+      def mbox_flag_num(mbox_id, name)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        get_num("mbox_id2flagnum-#{mbox_id}-#{name}")
+      end
+
+      def mbox_flag_num_increment(mbox_id, name)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        num_increment("mbox_id2flagnum-#{mbox_id}-#{name}")
+        self
+      end
+
+      def mbox_flag_num_decrement(mbox_id, name)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        num_decrement("mbox_id2flagnum-#{mbox_id}-#{name}")
+        self
+      end
+
+      def clear_mbox_flag_num(mbox_id, name)
+        mbox_name(mbox_id) or raise "not found a mailbox for id: #{mbox_id}"
+        if (@kvs.delete("mbox_id2flagnum-#{mbox_id}-#{name}")) then
+          self
+        end
+      end
+
+      def msg_date(msg_id)
+        get_obj("msg_id2date-#{msg_id}") or raise "not found a message date for internal id: #{msg_id}"
+      end
+
+      def set_msg_date(msg_id, date)
+        put_obj("msg_id2date-#{msg_id}", date)
+        self
+      end
+
+      def clear_msg_date(msg_id)
+        if (@kvs.delete("msg_id2date-#{msg_id}")) then
+          self
+        end
+      end
+
+      def msg_flag(msg_id, name)
+        flag_set = get_str_set("msg_id2flag-#{msg_id}")
+        flag_set.include? name
+      end
+
+      def set_msg_flag(msg_id, name, value)
+        flag_set = get_str_set("msg_id2flag-#{msg_id}")
+        if (value) then
+          unless (flag_set.include? name) then
+            mbox_uid_map = msg_mbox_uid_mapping(msg_id)
+            for mbox_id, uid_set in mbox_uid_map
+              uid_set.length.times do
+                mbox_flag_num_increment(mbox_id, name)
+              end
+            end
+          end
+          flag_set.add(name)
+        else
+          if (flag_set.include? name) then
+            mbox_uid_map = msg_mbox_uid_mapping(msg_id)
+            for mbox_id, uid_set in mbox_uid_map
+              uid_set.length.times do
+                mbox_flag_num_decrement(mbox_id, name)
+              end
+            end
+          end
+          flag_set.delete(name)
+        end
+        put_str_set("msg_id2flag-#{msg_id}", flag_set)
+        self
+      end
+
+      def clear_msg_flag(msg_id)
+        if (@kvs.delete("msg_id2flag-#{msg_id}")) then
+          self
+        end
+      end
+
+      def msg_mbox_uid_mapping(msg_id)
+        get_obj("msg_id2mbox-#{msg_id}", default_value: {})
+      end
+
+      def add_msg_mbox_uid(msg_id, mbox_id)
+        uid = mbox_uid_succ!(mbox_id)
+        mbox_uid_map = msg_mbox_uid_mapping(msg_id)
+        if (mbox_uid_map.key? mbox_id) then
+          msg_uid_set = mbox_uid_map[mbox_id]
+        else
+          msg_uid_set = mbox_uid_map[mbox_id] = [].to_set
+        end
+        if (msg_uid_set.include? uid) then
+          raise "duplicated uid(#{uid}) in mailbox id(#{mbox_id} on message id(#{msg_id}))"
+        end
+        mbox_uid_map[mbox_id] << uid
+        put_obj("msg_id2mbox-#{msg_id}", mbox_uid_map)
+
+        mbox_msg_num_increment(mbox_id)
+        flag_set = get_str_set("msg_id2flag-#{msg_id}")
+        for name in flag_set
+          mbox_flag_num_increment(mbox_id, name)
+        end
+
+        uid
+      end
+
+      def del_msg_mbox_uid(msg_id, mbox_id, uid)
+        mbox_uid_map = msg_mbox_uid_mapping(msg_id)
+        if (uid_set = mbox_uid_map[mbox_id]) then
+          if (uid_set.include? uid) then
+            uid_set.delete(uid)
+            mbox_uid_map.delete(mbox_id) if uid_set.empty?
+            put_obj("msg_id2mbox-#{msg_id}", mbox_uid_map)
+
+            mbox_msg_num_decrement(mbox_id)
+            flag_set = get_str_set("msg_id2flag-#{msg_id}")
+            for name in flag_set
+              mbox_flag_num_decrement(mbox_id, name)
+            end
+
+            mbox_uid_map
+          end
+        end
+      end
+
+      def clear_msg_mbox_uid_mapping(msg_id)
+        if (@kvs.delete("msg_id2mbox-#{msg_id}")) then
+          self
+        end
+      end
+
+      def recovery_start
+        @lost_found_msg_set = [].to_set
+        @lost_found_mbox_set = [].to_set
+      end
+
+      def recovery_end
+        @lost_found_msg_set = nil
+        @lost_found_mbox_set = nil
+      end
+
+      attr_reader :lost_found_msg_set
+      attr_reader :lost_found_mbox_set
+
+      def get_recover_entry(key, prefix)
+        if (key.start_with? prefix) then
+          entry_key = key[(prefix.length)..-1]
+          entry_key = yield(entry_key) if block_given?
+          entry_key
+        end
+      end
+      private :get_recover_entry
+
+      def recovery_phase1_msg_scan(msg_db, logger: Logger.new(STDOUT))
+        logger.info('recovery phase 1: start.')
+
+        max_msg_id = -1
+        msg_db.each_msg_id do |msg_id|
+          max_msg_id = msg_id if (max_msg_id < msg_id)
+          unless (@kvs.key? "msg_id2mbox-#{msg_id}") then
+            logger.warn("lost+found message: #{msg_id}")
+            @lost_found_msg_set << msg_id
+          end
+          unless (@kvs.key? "msg_id2date-#{msg_id}") then
+            logger.warn("repair internal date: #{msg_id}")
+            set_msg_date(msg_id, Time.now)
+          end
+        end
+
+        if (msg_id <= max_msg_id) then
+          next_msg_id = max_msg_id + 1
+          logger.warn("repair msg_id: #{next_msg_id}")
+          put_num('msg_id', next_msg_id)
+        end
+
+        logger.info('recovery phase 1: end.')
+
+        self
+      end
+
+      def recovery_phase2_msg_scan(msg_db, logger: Logger.new(STDOUT))
+        logger.info('recovery phase 2: start.')
+
+        lost_msg_set = [].to_set
+        mbox_set = get_num_set('mbox_set')
+
+        @kvs.each_key do |key|
+          if (msg_id = get_recover_entry(key, 'msg_id2mbox-') {|s| s.to_i }) then
+            if (msg_db.msg_exist? msg_id) then
+              msg_mbox_uid_mapping(msg_id).each_key do |mbox_id|
+                unless (mbox_set.include? mbox_id) then
+                  logger.warn("lost+found mailbox: #{mbox_id}")
+                  @lost_found_mbox_set << mbox_id
+                end
+              end
+            else
+              lost_msg_set << msg_id
+            end
+          end
+        end
+
+        for msg_id in lost_msg_set
+          logger.warn("clear lost message: #{msg_id}")
+          clear_msg_date(msg_id)
+          clear_msg_flag(msg_id)
+          clear_msg_mbox_uid_mapping(msg_id)
+        end
+
+        logger.info('recovery phase 2: end.')
+
+        self
+      end
+
+      def make_mbox_repair_name(mbox_id)
+        new_name = "MAILBOX##{mbox_id}"
+        if (mbox_id(new_name)) then
+          new_name << ' (1)'
+          while (mbox_id(new_name))
+            new_name.succ!
+          end
+        end
+
+        new_name
+      end
+      private :make_mbox_repair_name
+
+      def recovery_phase3_mbox_scan(logger: Logger.new(STDOUT))
+        logger.info('recovery phase 3: start.')
+
+        mbox_set = get_num_set('mbox_set')
+
+        max_mbox_id = 0
+        for mbox_id in mbox_set
+          max_mbox_id = mbox_id if (mbox_id > max_mbox_id)
+          if (name = mbox_name(mbox_id)) then
+            mbox_id2 = mbox_id(name)
+            unless (mbox_id2 && (mbox_id2 == mbox_id)) then
+              logger.warn("repair mailbox name -> id: #{name.inspect} -> #{mbox_id}")
+              put_num("mbox_name2id-#{name}", mbox_id)
+            end
+          else
+            new_name = make_mbox_repair_name(mbox_id)
+            logger.warn("repair mailbox id name pair: #{mbox_id}, #{new_name.inspect}")
+            put_str("mbox_id2name-#{mbox_id}", new_name)
+            put_num("mbox_name2id-#{new_name}", mbox_id)
+          end
+        end
+
+        if (uidvalidity <= max_mbox_id) then
+          next_uidvalidity = max_mbox_id + 1
+          logger.warn("repair uidvalidity: #{next_uidvalidity}")
+          put_num('uidvalidity', next_uidvalidity)
+        end
+
+        logger.info('recovery phase 3: end.')
+
+        self
+      end
+
+      def recovery_phase4_mbox_scan(logger: Logger.new(STDOUT))
+        logger.info('recovery phase 4: start.')
+
+        mbox_set = get_num_set('mbox_set')
+
+        del_key_list = []
+        @kvs.each_key do |key|
+          if (mbox_id = get_recover_entry(key, 'mbox_id2name-') {|s| s.to_i }) then
+            unless (mbox_set.include? mbox_id) then
+              del_key_list << key
+            end
+          elsif (name = get_recover_entry(key, 'mbox_name2id-')) then
+            unless ((mbox_id = mbox_id(name)) && (mbox_set.include? mbox_id) && (mbox_name(mbox_id) == name)) then
+              del_key_list << key
+            end
+          end
+        end
+
+        for key in del_key_list
+          logger.warn("unlinked mailbox entry: #{key}")
+          @kvs.delete(key)
+        end
+
+        logger.info('recovery phase 4: end.')
+
+        self
+      end
+
+      LOST_FOUND_MBOX_NAME = 'lost+found'.freeze
+
+      def recovery_phase5_mbox_repair(logger: Logger.new(STDOUT))
+        logger.info('recovery phase 5: start.')
+
+        for mbox_id in @lost_found_mbox_set
+          logger.warn("repair lost mailbox: #{mbox_id}")
+          add_mbox(make_mbox_repair_name(mbox_id), mbox_id: mbox_id)
+          yield(mbox_id)
+        end
+        unless (mbox_id(LOST_FOUND_MBOX_NAME)) then
+          logger.warn('create lost+found mailbox.')
+          mbox_id = add_mbox(LOST_FOUND_MBOX_NAME)
+          yield(mbox_id)
+        end
+
+        logger.info('recovery phase 5: end.')
+
+        self
+      end
+
+      def recovery_phase6_msg_scan(mbox_db, logger: Logger.new(STDOUT))
+        logger.info('recovery phase 6: start.')
+
+        @kvs.each_key do |key|
+          if (msg_id = get_recover_entry(key, 'msg_id2mbox-') {|s| s.to_i }) then
+            is_modified = false
+            mbox_uid_map = msg_mbox_uid_mapping(msg_id)
+            mbox_uid_map.each_pair.to_a.each do |mbox_id, uid_set|
+              uid_set.to_a.each do |uid|
+                if (msg_id2 = mbox_db[mbox_id].msg_id(uid)) then
+                  if (msg_id != msg_id2) then
+                    logger.warn("lost+found message -> mailbox: #{msg_id} -> #{mbox_id},#{uid}")
+                    is_modified = true
+                    uid_set.delete(uid)
+                    mbox_uid_map.delete(mbox_id) if uid_set.empty?
+                    @lost_found_msg_set << msg_id
+                  end
+                else
+                  logger.warn("repair mailbox -> message: #{mbox_id},#{uid} -> #{msg_id}")
+                  mbox_db[mbox_id].add_msg(uid, msg_id)
+                end
+              end
+            end
+
+            if (is_modified) then
+              logger.warn("save repaired message: #{msg_id}")
+              put_obj("msg_id2mbox-#{msg_id}", mbox_uid_map)
+            end
+          end
+        end
+
+        logger.info('recovery phase 6: end.')
+
+        self
+      end
+
+      def recovery_phase7_mbox_msg_scan(mbox_db, flag_name_list, logger: Logger.new(STDOUT))
+        logger.info('recovery phase 7: start.')
+
+        mbox_db.each_key do |mbox_id|
+          logger.info("scan mailbox: #{mbox_id}")
+
+          max_uid = 0
+          msg_num = 0
+          flag_num = Hash.new(0)
+          del_uid_list = []
+
+          mbox_db[mbox_id].each_msg_uid do |uid|
+            msg_id = mbox_db[mbox_id].msg_id(uid)
+            if ((mbox_uid_map = msg_mbox_uid_mapping(msg_id)) && (uid_set = mbox_uid_map[mbox_id]) && (uid_set.include? uid)) then
+              max_uid = uid if (max_uid < uid)
+              msg_num += 1
+              for name in flag_name_list
+                if (name == 'deleted') then
+                  if (mbox_db[mbox_id].msg_flag_deleted(uid)) then
+                    flag_num['deleted'] += 1
+                  end
+                else
+                  if (msg_flag(msg_id, name)) then
+                    flag_num[name] += 1
+                  end
+                end
+              end
+            else
+              del_uid_list << uid
+            end
+          end
+
+          for uid in del_uid_list
+            logger.warn("unlinked message uid: #{mbox_id},#{uid}")
+            mbox_db[mbox_id].set_msg_flag_deleted(uid, true)
+            mbox_db[mbox_id].expunge_msg(uid)
+          end
+
+          if (mbox_uid(mbox_id) <= max_uid) then
+            next_uid = max_uid + 1
+            logger.warn("repair mailbox uid: #{next_uid}")
+            put_num("mbox_id2uid-#{mbox_id}", next_uid)
+          end
+
+          if (mbox_msg_num(mbox_id) != msg_num) then
+            logger.warn("repair mailbox message number: #{msg_num}")
+            put_num("mbox_id2msgnum-#{mbox_id}", msg_num)
+          end
+
+          for name in flag_name_list
+            if (mbox_flag_num(mbox_id, name) != flag_num[name]) then
+              logger.warn("repair mailbox #{name} flag number: #{flag_num[name]}")
+              put_num("mbox_id2flagnum-#{mbox_id}-#{name}", flag_num[name])
+            end
+          end
+        end
+
+        logger.info('recovery phase 7: end.')
+
+        self
+      end
+
+      def recovery_phase8_lost_found(mbox_db, logger: Logger.new(STDOUT))
+        logger.info('recovery phase 8: start.')
+
+        mbox_id = mbox_id(LOST_FOUND_MBOX_NAME) or raise "not found a #{LOST_FOUND_MBOX_NAME} mailbox."
+        for msg_id in @lost_found_msg_set
+          logger.warn("repair lost+found message: #{msg_id}")
+          uid = add_msg_mbox_uid(msg_id, mbox_id)
+          mbox_db[mbox_id].add_msg(uid, msg_id)
+        end
+
+        logger.info('recovery phase 8: end.')
+
+        self
+      end
+    end
+
+    class Message < Core
+      def add_msg(msg_id, text)
+        put_str(msg_id.to_s, text)
+        self
+      end
+
+      def del_msg(msg_id)
+        @kvs.delete(msg_id.to_s) or raise "not found a message text for id: #{msg_id}"
+        self
+      end
+
+      def each_msg_id
+        return enum_for(:each_msg_id) unless block_given?
+        @kvs.each_key do |msg_id|
+          yield(msg_id.to_i)
+        end
+        self
+      end
+
+      def msg_text(msg_id)
+        get_str(msg_id.to_s)
+      end
+
+      def msg_exist?(msg_id)
+	@kvs.key? msg_id.to_s
+      end
+    end
+
+    class Mailbox < Core
+      def put_msg_id(uid, msg_id, deleted: false)
+        s = msg_id.to_s
+        s << ',deleted' if deleted
+        @kvs[uid.to_s] = s
+        self
+      end
+      private :put_msg_id
+
+      def add_msg(uid, msg_id)
+        put_msg_id(uid, msg_id)
+        self
+      end
+
+      def each_msg_uid
+        return enum_for(:each_msg_uid) unless block_given?
+        @kvs.each_key do |uid|
+          yield(uid.to_i)
+        end
+        self
+      end
+
+      def msg_exist?(uid)
+        @kvs.key? uid.to_s
+      end
+
+      def msg_id(uid)
+        if (s = @kvs[uid.to_s]) then
+          s.split(',', 2)[0].to_i
+        end
+      end
+
+      def msg_flag_deleted(uid)
+        if (s = @kvs[uid.to_s]) then
+          s.split(',', 2)[1] == 'deleted'
+        end
+      end
+
+      def set_msg_flag_deleted(uid, value)
+        msg_id = msg_id(uid) or raise "not found a message uid: #{uid}"
+        put_msg_id(uid, msg_id, deleted: value)
+        self
+      end
+
+      def expunge_msg(uid)
+        case (msg_flag_deleted(uid))
+        when true
+          # OK
+        when false
+          raise "not deleted flag at message uid: #{uid}"
+        when nil
+          raise "not found a message uid: #{uid}"
+        else
+          raise 'internal error.'
+        end
+        @kvs.delete(uid.to_s) or raise 'internal error.'
+        self
+      end
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: