rims 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e462eb67ba5bb6cdfa73906f100e9e11474e42e64616df8fc119a7dcaa879374
-  data.tar.gz: 9f860520538eb8bd52aeac784dd668d6778a9c51f343ff368548225d955c6dca
+  metadata.gz: 7acc91008294ca9589a19ecb657d5a04cc9d21c17e6349e059dd371bba0f4dbb
+  data.tar.gz: f750c5ef8ea6064033d1b6e1e0329964db61e56f1e9e1535883a19fcb1738aa3
 SHA512:
-  metadata.gz: b5d7aff45f4ce0d921e10136f2e161abd5f6ddf8307fc2f96909db0399cb3230f11ec073a6f401bc3f4d9a28432334a9845ae8da5e31bba30064cee2e78e33de
-  data.tar.gz: b9f72aa820f34528f47383d4e3c74245747edf60b0c370a24f75b3f5189c740c0887366cab1b66f7ae8237819d3407d7a31d8cc0786c487d9778a801fdb66a8a
+  metadata.gz: 003c20745f575ba8801f6b72956b42b3329f45fc84f70fe68146767fae15a657f9a3cb1767f759877e8cf442738873a05182c835d697c702e4fad7a575b560d3
+  data.tar.gz: 449554fe7059796dd4fbbce1c433b7abc2a411ad5ee24acccc0618bb1043e2fb6b9a006dc0e93eb5c32813409a80b2bb677c37e39437e819153c38233cbaa194

data/ChangeLog

@@ -1,5 +1,70 @@
+2019-06-10  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* RIMS version 0.2.5 is released.
+
+2019-06-07  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/protocol/decoder.rb: IMAP CLOSE command may not send
+	untagged EXPUNGE responses.
+
+	see: RFC 3501 / 6.4.2.  CLOSE Command
+	<https://tools.ietf.org/html/rfc3501#section-6.4.2>
+
+	The CLOSE command permanently removes all messages that have the
+	\Deleted flag set from the currently selected mailbox, and returns
+	to the authenticated state from the selected state.  No untagged
+	EXPUNGE responses are sent.
+
+2019-06-05  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* test/cmd/test_command.rb: IMAP server system test.
+
+2019-05-24  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/protocol/parser.rb: fix bodystructure response for
+	FETCH command.  removed extra SP of bodystructure response on a
+	multipart message.
+
+	see: RFC 3501 / 9. Formal Syntax
+
+	    body-type-mpart = 1*body SP media-subtype [SP body-ext-mpart]
+
+	`1*body' indicates that there is no extra separator.
+
+2019-05-22  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/protocol/parser.rb: date comparison search (BEFORE, ON,
+	SENTBEFORE, SENTON, SENTSINCE, SINCE) disregarding timezone. TEXT
+	keyword searches a multipart message.
+
+2019-05-12  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/cmd.rb, lib/rims/service.rb: add multi-process server
+	options to server command.
+
+2019-05-11  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/mail_store.rb, lib/rims/pool.rb: obsoleted mail store
+	holder. obsoleted mail store pool. obsoleted generic object pool.
+
+2019-05-10  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/mail_store.rb, lib/rims/protocol/decoder.rb,
+	lib/rims/service.rb: mail store pool is replaced by dRuby
+	services.
+
+	* lib/rims/protocol/decoder.rb: mail store holder is replaced by
+	decoder engine.
+
+2019-05-08  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/protocol/decoder.rb: decoder engine for dRuby services
+	is defined.
+
 2019-04-25  TOKI Yoshinori  <toki@freedom.ne.jp>
 
+	* RIMS version 0.2.4 is released.
+
 	* test/test_protocol_decoder.rb: integrated individual IMAP
 	command test and IMAP command stream test.
 

data/lib/rims.rb

@@ -18,11 +18,9 @@ module RIMS
   autoload :LockError, 'rims/lock'
   autoload :MailFolder, 'rims/mail_store'
   autoload :MailStore, 'rims/mail_store'
-  autoload :MailStoreHolder, 'rims/mail_store'
   autoload :MailboxDB, 'rims/db'
   autoload :MessageDB, 'rims/db'
   autoload :MessageSetSyntaxError, 'rims/protocol'
-  autoload :ObjectPool, 'rims/pool'
   autoload :Password, 'rims/passwd'
   autoload :Protocol, 'rims/protocol'
   autoload :ProtocolError, 'rims/protocol'

data/lib/rims/cksum_kvs.rb

@@ -10,7 +10,7 @@ module RIMS
 
     def md5_cksum_parse(key, s)
       if (s) then
-        s =~ /\Amd5 (\S+?)\n/ or raise "checksum format error at key: #{key}"
+        s =~ /\A md5 \s (\S+?) \n/x or raise "checksum format error at key: #{key}"
         md5_cksum = $1
         value = $'
         if (Digest::MD5.hexdigest(value) != md5_cksum) then

data/lib/rims/cmd.rb

@@ -25,7 +25,7 @@ module RIMS
     def self.command_function(method_name, description)
       module_function(method_name)
       method_name = method_name.to_s
-      unless (method_name =~ /^cmd_/) then
+      unless (method_name =~ /\A cmd_/x) then
         raise "invalid command function name: #{method_name}"
       end
       cmd_name = $'.gsub(/_/, '-')
@@ -62,7 +62,7 @@ module RIMS
       w = CMDs.keys.map{|k| k.length }.max + 4
       fmt = "    %- #{w}s%s"
       CMDs.each do |cmd_name, cmd_entry|
-        if ((! show_debug_command) && (cmd_name =~ /^debug/)) then
+        if ((! show_debug_command) && (cmd_name =~ /\A debug/x)) then
           next
         end
         puts format(fmt, cmd_name, cmd_entry[:description])
@@ -377,6 +377,40 @@ module RIMS
                  })
         }
       end
+      options.on('--process-num=NUMBER',
+                 Integer
+                ) do |num|
+        build.chain{|c|
+          c.load(server: {
+                   process_num: num
+                 })
+        }
+      end
+      options.on('--process-queue-size=SIZE',
+                 Integer
+                ) do |size|
+        build.chain{|c|
+          c.load(server: {
+                   process_queue_size: size
+                 })
+        }
+      end
+      options.on('--process-queue-polling-timeout=SECONDS',
+                 Float) do |seconds|
+        build.chain{|c|
+          c.load(server: {
+                   process_queue_polling_timeout_seconds: seconds
+                 })
+        }
+      end
+      options.on('--process-send-io-polling-timeout=SECONDS',
+                 Float) do |seconds|
+        build.chain{|c|
+          c.load(server: {
+                   process_send_io_polling_timeout_seconds: seconds
+                 })
+        }
+      end
       options.on('--thread-num=NUMBER',
                  Integer
                 ) do |num|
@@ -431,12 +465,33 @@ module RIMS
                  })
         }
       end
+      options.on('--drb-process-num=NUMBER',
+                 Integer
+                ) do |num|
+        build.chain{|c|
+          c.load(drb_services: {
+                   process_num: num
+                 })
+        }
+      end
+      options.on('--bulk-response-count=COUNT',
+                 Integer) do |count|
+        build.chain{|c|
+          c.load(drb_services: {
+                   engine: {
+                     bulk_response_count: count
+                   }
+                 })
+        }
+      end
       options.on('--read-lock-timeout=SECONDS',
                  Float
                 ) do |seconds|
         build.chain{|c|
-          c.load(lock: {
-                   read_lock_timeout_seconds: seconds
+          c.load(drb_services: {
+                   engine: {
+                     read_lock_timeout_seconds: seconds
+                   }
                  })
         }
       end
@@ -444,8 +499,10 @@ module RIMS
                  Float
                 ) do |seconds|
         build.chain{|c|
-          c.load(lock: {
-                   write_lock_timeout_seconds: seconds
+          c.load(drb_services: {
+                   engine: {
+                     write_lock_timeout_seconds: seconds
+                   }
                  })
         }
       end
@@ -453,8 +510,10 @@ module RIMS
                  Float
                 ) do |seconds|
         build.chain{|c|
-          c.load(lock: {
-                   cleanup_write_lock_timeout_seconds: seconds
+          c.load(drb_services: {
+                   engine: {
+                     cleanup_write_lock_timeout_seconds: seconds
+                   }
                  })
         }
       end

data/lib/rims/lock.rb

@@ -119,9 +119,9 @@ module RIMS
 
     def self.write_lock_timeout_detach(first_timeout_seconds, detached_timeout_seconds, logger: Logger.new(STDOUT)) # yields: timeout_seconds
       begin
-        logger.debug('ready to detach write-lock timeout.')
+        logger.debug('ready to detach write-lock timeout.') if logger.debug?
         yield(first_timeout_seconds)
-        logger.debug('not detached write-lock timeout.')
+        logger.debug('not detached write-lock timeout.') if logger.debug?
         nil
       rescue WriteLockTimeoutError
         logger.warn($!)

data/lib/rims/mail_store.rb

@@ -32,6 +32,20 @@ module RIMS
       @channel = ServerResponseChannel.new
     end
 
+    def self.build(unique_user_id, kvs_meta_open, kvs_text_open)
+      kvs_build = proc{|kvs_open, db_name|
+        kvs_open.call(MAILBOX_DATA_STRUCTURE_VERSION, unique_user_id, db_name)
+      }
+
+      mail_store = MailStore.new(DB::Meta.new(kvs_build.call(kvs_meta_open, 'meta')),
+                                 DB::Message.new(kvs_build.call(kvs_text_open, 'message'))) {|mbox_id|
+        DB::Mailbox.new(kvs_build.call(kvs_meta_open, "mailbox_#{mbox_id}"))
+      }
+      mail_store.add_mbox('INBOX') unless mail_store.mbox_id('INBOX')
+
+      mail_store
+    end
+
     def_delegators :@rw_lock, :read_synchronize, :write_synchronize
 
     def get_mbox_db(mbox_id)
@@ -138,7 +152,7 @@ module RIMS
 
     def add_mbox(name)
       transaction{
-        name = 'INBOX' if (name =~ /\AINBOX\z/i)
+        name = 'INBOX' if (name =~ /\A INBOX \z/xi)
         name = name.b
 
         mbox_id = @meta_db.add_mbox(name)
@@ -179,7 +193,7 @@ module RIMS
         old_name = @meta_db.mbox_name(mbox_id) or raise "not found a mailbox: #{mbox_id}."
         old_name = old_name.dup.force_encoding('utf-8')
 
-        new_name = 'INBOX' if (new_name =~ /\AINBOX\z/i)
+        new_name = 'INBOX' if (new_name =~ /\A INBOX \z/xi)
         @meta_db.rename_mbox(mbox_id, new_name.b)
 
         @meta_db.cnum_succ!
@@ -195,7 +209,7 @@ module RIMS
     end
 
     def mbox_id(mbox_name)
-      mbox_name = 'INBOX' if (mbox_name =~ /\AINBOX\z/i)
+      mbox_name = 'INBOX' if (mbox_name =~ /\A INBOX \z/xi)
       @meta_db.mbox_id(mbox_name.b)
     end
 
@@ -348,20 +362,9 @@ module RIMS
       }
     end
 
-    def select_mbox(mbox_id)
+    def open_folder(mbox_id, read_only: false)
       @meta_db.mbox_name(mbox_id) or raise "not found a mailbox: #{mbox_id}."
-      MailFolder.new(mbox_id, self).attach(@channel)
-    end
-
-    def examine_mbox(mbox_id)
-      @meta_db.mbox_name(mbox_id) or raise "not found a mailbox: #{mbox_id}."
-      MailFolder.new(mbox_id, self, read_only: true).attach(@channel)
-    end
-
-    def self.build_pool(kvs_meta_open, kvs_text_open)
-      RIMS::ObjectPool.new{|object_pool, unique_user_id|
-        RIMS::MailStoreHolder.build(object_pool, unique_user_id, kvs_meta_open, kvs_text_open)
-      }
+      MailFolder.new(mbox_id, self, read_only: read_only).attach(@channel)
     end
   end
 
@@ -381,6 +384,16 @@ module RIMS
       @uid_map = nil
     end
 
+    attr_reader :mbox_id
+
+    def alive?
+      ! @mail_store.mbox_name(@mbox_id).nil?
+    end
+
+    def should_be_alive
+      alive? or raise "deleted folder: #{@mbox_id}"
+    end
+
     def attach(server_response_channel)
       @pub, @sub = server_response_channel.make_pub_sub_pair(@mbox_id)
       self
@@ -415,8 +428,6 @@ module RIMS
       @mail_store.cnum != @cnum
     end
 
-    attr_reader :mbox_id
-
     def [](msg_idx)
       @msg_list[msg_idx]
     end
@@ -501,6 +512,13 @@ module RIMS
           end
         end
       end
+      @cnum = nil
+      @msg_list = nil
+      @uid_map = nil
+      self
+    end
+
+    def detach
       @mail_store = nil
       @pub.detach
       @sub.detach
@@ -523,9 +541,9 @@ module RIMS
 
     def self.parse_msg_seq(msg_seq_desc, last_number)
       case (msg_seq_desc)
-      when /\A(\d+|\*)\z/
+      when /\A (\d+|\*) \z/x
         msg_seq_pair = [ $&, $& ]
-      when /\A(\d+|\*):(\d+|\*)\z/
+      when /\A (\d+|\*):(\d+|\*) \z/x
         msg_seq_pair = [ $1, $2 ]
       else
         raise MessageSetSyntaxError, "invalid message sequence format: #{msg_seq_desc}"
@@ -559,38 +577,6 @@ module RIMS
       msg_set
     end
   end
-
-  class MailStoreHolder < ObjectPool::ObjectHolder
-    extend Forwardable
-
-    def self.build(object_pool, unique_user_id, kvs_meta_open, kvs_text_open)
-      kvs_build = proc{|kvs_open, db_name|
-        kvs_open.call(MAILBOX_DATA_STRUCTURE_VERSION, unique_user_id, db_name)
-      }
-
-      mail_store = MailStore.new(DB::Meta.new(kvs_build.call(kvs_meta_open, 'meta')),
-                                 DB::Message.new(kvs_build.call(kvs_text_open, 'message'))) {|mbox_id|
-        DB::Mailbox.new(kvs_build.call(kvs_meta_open, "mailbox_#{mbox_id}"))
-      }
-      mail_store.add_mbox('INBOX') unless mail_store.mbox_id('INBOX')
-
-      new(object_pool, unique_user_id, mail_store)
-    end
-
-    def initialize(object_pool, unique_user_id, mail_store)
-      super(object_pool, unique_user_id)
-      @mail_store = mail_store
-    end
-
-    alias unique_user_id object_key
-    attr_reader :mail_store
-
-    def_delegators :@mail_store, :read_synchronize, :write_synchronize
-
-    def object_destroy
-      @mail_store.close
-    end
-  end
 end
 
 # Local Variables:

data/lib/rims/protocol/decoder.rb

@@ -22,15 +22,21 @@ module RIMS
       end
 
       def self.repl(decoder, limits, input, output, logger)
+        input_gets = input.method(:gets)
+        output_write = lambda{|res|
+          last_line = nil
+          for data in res
+            logger.debug("response data: #{Protocol.io_data_log(data)}") if logger.debug?
+            output << data
+            last_line = data
+          end
+          output.flush
+
+          last_line
+        }
         response_write = proc{|res|
           begin
-            last_line = nil
-            for data in res
-              logger.debug("response data: #{Protocol.io_data_log(data)}") if logger.debug?
-              output << data
-              last_line = data
-            end
-            output.flush
+            last_line = output_write.call(res)
             logger.info("server response: #{last_line.strip}")
           rescue
             logger.error('response write error.')
@@ -68,6 +74,13 @@ module RIMS
             when 'LOGIN'
               log_opt_args = opt_args.dup
               log_opt_args[-1] = '********'
+            when 'AUTHENTICATE'
+              if (opt_args[1]) then
+                log_opt_args = opt_args.dup
+                log_opt_args[1] = '********'
+              else
+                log_opt_args = opt_args
+              end
             else
               log_opt_args = opt_args
             end
@@ -93,9 +106,9 @@ module RIMS
                   response_write.call([ "#{tag} BAD empty uid parameter\r\n" ])
                 end
               when :authenticate
-                decoder.authenticate(tag, input, output, *opt_args) {|res| response_write.call(res) }
+                decoder.authenticate(tag, input_gets, output_write, *opt_args) {|res| response_write.call(res) }
               when :idle
-                decoder.idle(tag, input, output, conn_timer, *opt_args) {|res| response_write.call(res) }
+                decoder.idle(tag, input_gets, output_write, conn_timer, *opt_args) {|res| response_write.call(res) }
               else
                 decoder.__send__(name, tag, *opt_args) {|res| response_write.call(res) }
               end
@@ -128,14 +141,18 @@ module RIMS
 
         nil
       ensure
-        decoder.cleanup
+        # don't forget to clean up if the next decoder has been generated
+        decoder.next_decoder.cleanup
       end
 
       def initialize(auth, logger)
         @auth = auth
         @logger = logger
+        @next_decoder = self
       end
 
+      attr_reader :next_decoder
+
       def response_stream(tag)
         Enumerator.new{|res|
           begin
@@ -156,12 +173,12 @@ module RIMS
       end
       private :response_stream
 
-      def guard_error(tag, imap_command, *args, **name_args)
+      def guard_error(imap_command, tag, *args, **kw_args, &block)
         begin
-          if (name_args.empty?) then
-            __send__(imap_command, tag, *args) {|res| yield(res) }
+          if (kw_args.empty?) then
+            __send__(imap_command, tag, *args, &block)
           else
-            __send__(imap_command, tag, *args, **name_args) {|res| yield(res) }
+            __send__(imap_command, tag, *args, **kw_args, &block)
           end
         rescue SyntaxError
           @logger.error('client command syntax error.')
@@ -203,63 +220,71 @@ module RIMS
         end
         private :kw_params
 
-        def imap_command(name)
-          name = name.to_sym
-
+        def should_be_imap_command(name)
           cmd = to_imap_command(name)
-          IMAP_CMDs[cmd] = name
+          unless (IMAP_CMDs.key? cmd) then
+            raise ArgumentError, "not an IMAP command: #{name}"
+          end
 
           method = instance_method(name)
-          if (kw_params(method).find(:uid)) then
-            IMAP_CMDs['UID'] = :uid
-            UID_CMDs[cmd] = name
+          if (UID_CMDs.key? cmd) then
+            unless (kw_params(method).include? :uid) then
+              raise ArgumentError, "not defined `uid' keyword parameter: #{name}"
+            end
+          else
+            if (kw_params(method).include? :uid) then
+              raise ArgumentError, "not allowed `uid' keyword parameter: #{name}"
+            end
           end
 
+          nil
+        end
+        private :should_be_imap_command
+
+        def imap_command(name)
+          should_be_imap_command(name)
           orig_name = "_#{name}".to_sym
           alias_method orig_name, name
-          define_method name, lambda{|tag, *args, **name_args, &block|
-            guard_error(tag, orig_name, *args, **name_args, &block)
+          define_method name, lambda{|tag, *args, **kw_args, &block|
+            guard_error(orig_name, tag, *args, **kw_args, &block)
           }
-
-          name
+          name.to_sym
         end
         private :imap_command
 
-        def should_be_imap_command(name)
-          unless (IMAP_CMDs.key? to_imap_command(name)) then
-            raise ArgumentError, "not an IMAP command: #{name}"
-          end
-        end
-        private :should_be_imap_command
-
-        def fetch_mail_store_holder_and_on_demand_recovery(mail_store_pool, username,
-                                                           write_lock_timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS,
-                                                           logger: Logger.new(STDOUT))
+        def make_engine_and_recovery_if_needed(services, username,
+                                               logger: Logger.new(STDOUT))
           unique_user_id = Authentication.unique_user_id(username)
           logger.debug("unique user ID: #{username} -> #{unique_user_id}") if logger.debug?
 
-          mail_store_holder = mail_store_pool.get(unique_user_id) {
-            logger.info("open mail store: #{unique_user_id} [ #{username} ]")
-          }
+          logger.info("open mail store: #{unique_user_id} [ #{username} ]")
+          engine = services[:engine, unique_user_id]
 
-          mail_store_holder.write_synchronize(write_lock_timeout_seconds) {
-            if (mail_store_holder.mail_store.abort_transaction?) then
-              logger.warn("user data recovery start: #{username}")
-              yield("* OK [ALERT] start user data recovery.\r\n")
-              mail_store_holder.mail_store.recovery_data(logger: logger).sync
-              logger.warn("user data recovery end: #{username}")
-              yield("* OK completed user data recovery.\r\n")
-            end
-          }
+          begin
+            engine.recovery_if_needed(username) {|msg| yield(msg) }
+          rescue
+            engine.destroy
+            raise
+          end
 
-          mail_store_holder
+          engine
         end
       end
 
+      def make_logout_response(tag)
+        [ "* BYE server logout\r\n",
+          "#{tag} OK LOGOUT completed\r\n"
+        ]
+      end
+      private :make_logout_response
+
       def ok_greeting
         yield([ "* OK RIMS v#{VERSION} IMAP4rev1 service ready.\r\n" ])
       end
 
+      # common IMAP command
+      IMAP_CMDs['CAPABILITY'] = :capability
+
       def capability(tag)
         capability_list = %w[ IMAP4rev1 UIDPLUS IDLE ]
         capability_list += @auth.capability.map{|auth_capability| "AUTH=#{auth_capability}" }
@@ -269,29 +294,40 @@ module RIMS
         yield(res)
       end
       imap_command :capability
-
-      def next_decoder
-        self
-      end
     end
 
     class InitialDecoder < Decoder
-      def initialize(mail_store_pool, auth, logger,
-                     mail_delivery_user: Service::DEFAULT_CONFIG.mail_delivery_user,
-                     write_lock_timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS,
-                     **next_decoder_optional)
+      class << self
+        def imap_command(name)
+          name = name.to_sym
+
+          cmd = to_imap_command(name)
+          Decoder::IMAP_CMDs[cmd] = name
+
+          method = instance_method(name)
+          if (kw_params(method).include? :uid) then
+            Decoder::IMAP_CMDs['UID'] = :uid
+            Decoder::UID_CMDs[cmd] = name
+          end
+
+          orig_name = "_#{name}".to_sym
+          alias_method orig_name, name
+          define_method name, lambda{|tag, *args, **kw_args, &block|
+            guard_error(orig_name, tag, *args, **kw_args, &block)
+          }
+
+          name
+        end
+        private :imap_command
+      end
+
+      def initialize(services, auth, logger,
+                     mail_delivery_user: Service::DEFAULT_CONFIG.mail_delivery_user)
         super(auth, logger)
-        @next_decoder = self
-        @mail_store_pool = mail_store_pool
-        @folder = nil
-        @auth = auth
+        @services = services
         @mail_delivery_user = mail_delivery_user
-        @write_lock_timeout_seconds = write_lock_timeout_seconds
-        @next_decoder_optional = next_decoder_optional
       end
 
-      attr_reader :next_decoder
-
       def auth?
         false
       end
@@ -304,10 +340,10 @@ module RIMS
         nil
       end
 
-      def not_authenticated_response(tag)
+      def make_not_authenticated_response(tag)
         [ "#{tag} NO not authenticated\r\n" ]
       end
-      private :not_authenticated_response
+      private :make_not_authenticated_response
 
       def noop(tag)
         yield([ "#{tag} OK NOOP completed\r\n" ])
@@ -315,38 +351,26 @@ module RIMS
       imap_command :noop
 
       def logout(tag)
-        cleanup
-        res = []
-        res << "* BYE server logout\r\n"
-        res << "#{tag} OK LOGOUT completed\r\n"
-        yield(res)
+        @next_decoder = LogoutDecoder.new(self)
+        yield(make_logout_response(tag))
       end
       imap_command :logout
 
       def accept_authentication(username)
-        cleanup
-
         case (username)
         when @mail_delivery_user
           @logger.info("mail delivery user: #{username}")
-          MailDeliveryDecoder.new(@mail_store_pool, @auth, @logger,
-                                  write_lock_timeout_seconds: @write_lock_timeout_seconds,
-                                  **@next_decoder_optional)
+          MailDeliveryDecoder.new(self, @services, @auth, @logger)
         else
-          mail_store_holder =
-            self.class.fetch_mail_store_holder_and_on_demand_recovery(@mail_store_pool, username,
-                                                                      write_lock_timeout_seconds: @write_lock_timeout_seconds,
-                                                                      logger: @logger) {|msg| yield(msg) }
-          UserMailboxDecoder.new(self, mail_store_holder, @auth, @logger,
-                                 write_lock_timeout_seconds: @write_lock_timeout_seconds,
-                                 **@next_decoder_optional)
+          engine = self.class.make_engine_and_recovery_if_needed(@services, username, logger: @logger) {|msg| yield(msg) }
+          UserMailboxDecoder.new(self, engine, @auth, @logger)
         end
       end
       private :accept_authentication
 
-      def authenticate(tag, client_response_input_stream, server_challenge_output_stream,
+      def authenticate(tag, client_response_input_gets, server_challenge_output_write,
                        auth_type, inline_client_response_data_base64=nil)
-        auth_reader = AuthenticationReader.new(@auth, client_response_input_stream, server_challenge_output_stream, @logger)
+        auth_reader = AuthenticationReader.new(@auth, client_response_input_gets, server_challenge_output_write, @logger)
         if (username = auth_reader.authenticate_client(auth_type, inline_client_response_data_base64)) then
           if (username != :*) then
             yield response_stream(tag) {|res|
@@ -378,177 +402,119 @@ module RIMS
       imap_command :login
 
       def select(tag, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :select
 
       def examine(tag, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :examine
 
       def create(tag, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :create
 
       def delete(tag, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :delete
 
       def rename(tag, src_name, dst_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :rename
 
       def subscribe(tag, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :subscribe
 
       def unsubscribe(tag, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :unsubscribe
 
       def list(tag, ref_name, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :list
 
       def lsub(tag, ref_name, mbox_name)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :lsub
 
       def status(tag, mbox_name, data_item_group)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :status
 
       def append(tag, mbox_name, *opt_args, msg_text)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :append
 
       def check(tag)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :check
 
       def close(tag)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :close
 
       def expunge(tag)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :expunge
 
       def search(tag, *cond_args, uid: false)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :search
 
       def fetch(tag, msg_set, data_item_group, uid: false)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :fetch
 
       def store(tag, msg_set, data_item_name, data_item_value, uid: false)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :store
 
       def copy(tag, msg_set, mbox_name, uid: false)
-        yield(not_authenticated_response(tag))
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :copy
 
-      def idle(tag, client_input_stream, server_output_stream, connection_timer)
-        yield(not_authenticated_response(tag))
+      def idle(tag, client_input_gets, server_output_write, connection_timer)
+        yield(make_not_authenticated_response(tag))
       end
       imap_command :idle
     end
 
-    class AuthenticatedDecoder < Decoder
-      def authenticate(tag, client_response_input_stream, server_challenge_output_stream,
-                       auth_type, inline_client_response_data_base64=nil, &block)
-        yield([ "#{tag} NO duplicated authentication\r\n" ])
-      end
-      imap_command :authenticate
-
-      def login(tag, username, password, &block)
-        yield([ "#{tag} NO duplicated login\r\n" ])
-      end
-      imap_command :login
-    end
-
-    class UserMailboxDecoder < AuthenticatedDecoder
-      def initialize(parent_decoder, mail_store_holder, auth, logger,
-                     read_lock_timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS,
-                     write_lock_timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS,
-                     cleanup_write_lock_timeout_seconds: 1)
-        super(auth, logger)
+    class LogoutDecoder < Decoder
+      def initialize(parent_decoder)
         @parent_decoder = parent_decoder
-        @mail_store_holder = mail_store_holder
-        @read_lock_timeout_seconds = read_lock_timeout_seconds
-        @write_lock_timeout_seconds = write_lock_timeout_seconds
-        @cleanup_write_lock_timeout_seconds = cleanup_write_lock_timeout_seconds
-        @folder = nil
       end
 
-      def get_mail_store
-        @mail_store_holder.mail_store
+      def next_decoder
+        self
       end
-      private :get_mail_store
 
       def auth?
-        @mail_store_holder != nil
+        false
       end
 
       def selected?
-        @folder != nil
-      end
-
-      def alive_folder?
-        get_mail_store.mbox_name(@folder.mbox_id) != nil
-      end
-      private :alive_folder?
-
-      def close_folder(&block)
-        if (auth? && selected? && alive_folder?) then
-          @folder.reload if @folder.updated?
-          @folder.close(&block)
-          @folder = nil
-        end
-
-        nil
+        false
       end
-      private :close_folder
 
       def cleanup
-        unless (@mail_store_holder.nil?) then
-          begin
-            @mail_store_holder.write_synchronize(@cleanup_write_lock_timeout_seconds) {
-              close_folder
-              @mail_store_holder.mail_store.sync
-            }
-          rescue WriteLockTimeoutError
-            @logger.warn("give up to close folder becaue of write-lock timeout over #{@write_lock_timeout_seconds} seconds")
-            @folder = nil
-          end
-          tmp_mail_store_holder = @mail_store_holder
-          ReadWriteLock.write_lock_timeout_detach(@cleanup_write_lock_timeout_seconds, @write_lock_timeout_seconds, logger: @logger) {|timeout_seconds|
-            tmp_mail_store_holder.return_pool{
-              @logger.info("close mail store: #{tmp_mail_store_holder.unique_user_id}")
-            }
-          }
-          @mail_store_holder = nil
-        end
-
         unless (@parent_decoder.nil?) then
           @parent_decoder.cleanup
           @parent_decoder = nil
@@ -557,471 +523,760 @@ module RIMS
         nil
       end
 
-      def should_be_alive_folder
-        alive_folder? or raise "deleted folder: #{@folder.mbox_id}"
-      end
-      private :should_be_alive_folder
-
-      def guard_authenticated(tag, imap_command, *args, exclusive: false, **name_args)
-        if (auth?) then
-          if (exclusive.nil?) then
-            guard_error(tag, imap_command, *args, **name_args) {|res|
-              yield(res)
-            }
-          else
-            begin
-              if (exclusive) then
-                @mail_store_holder.write_synchronize(@write_lock_timeout_seconds) {
-                  guard_authenticated(tag, imap_command, *args, exclusive: nil, **name_args) {|res|
-                    yield(res)
-                  }
-                }
-              else
-                @mail_store_holder.read_synchronize(@read_lock_timeout_seconds){
-                  guard_authenticated(tag, imap_command, *args, exclusive: nil, **name_args) {|res|
-                    yield(res)
-                  }
-                }
-              end
-            rescue ReadLockTimeoutError
-              @logger.error("write-lock timeout over #{@write_lock_timeout_seconds} seconds")
-              yield([ "#{tag} BAD write-lock timeout over #{@write_lock_timeout_seconds} seconds" ])
-            rescue WriteLockTimeoutError
-              @logger.error("read-lock timeout over #{@read_lock_timeout_seconds} seconds")
-              yield([ "#{tag} BAD read-lock timeout over #{@read_lock_timeout_seconds} seconds" ])
-            end
-          end
-        else
-          yield([ "#{tag} NO not authenticated\r\n" ])
-        end
-      end
-      private :guard_authenticated
-
-      def guard_selected(tag, imap_command, *args, **name_args)
-        if (selected?) then
-          guard_authenticated(tag, imap_command, *args, **name_args) {|res|
-            yield(res)
-          }
-        else
-          yield([ "#{tag} NO not selected\r\n" ])
-        end
-      end
-      private :guard_selected
-
-      class << self
-        def imap_command_authenticated(name, **guard_optional)
-          should_be_imap_command(name)
-          orig_name = "_#{name}".to_sym
-          alias_method orig_name, name
-          define_method name, lambda{|tag, *args, **name_args, &block|
-            guard_authenticated(tag, orig_name, *args, **name_args.merge(guard_optional), &block)
-          }
-          name.to_sym
-        end
-        private :imap_command_authenticated
-
-        def imap_command_selected(name, **guard_optional)
-          should_be_imap_command(name)
-          orig_name = "_#{name}".to_sym
-          alias_method orig_name, name
-          define_method name, lambda{|tag, *args, **name_args, &block|
-            guard_selected(tag, orig_name, *args, **name_args.merge(guard_optional), &block)
-          }
-          name.to_sym
-        end
-        private :imap_command_selected
+      def capability(tag)
+        raise ProtocolError, 'invalid command in logout state.'
       end
+      imap_command :capability
 
       def noop(tag)
-        res = []
-        if (auth? && selected?) then
-          begin
-            @mail_store_holder.read_synchronize(@read_lock_timeout_seconds) {
-              @folder.server_response_fetch{|r| res << r } if @folder.server_response?
-            }
-          rescue ReadLockTimeoutError
-            @logger.warn("give up to get folder status because of read-lock timeout over #{@read_lock_timeout_seconds} seconds")
-          end
-        end
-        res << "#{tag} OK NOOP completed\r\n"
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
       imap_command :noop
 
       def logout(tag)
-        cleanup
-        res = []
-        res << "* BYE server logout\r\n"
-        res << "#{tag} OK LOGOUT completed\r\n"
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
       imap_command :logout
 
-      def folder_open_msgs
-        all_msgs = get_mail_store.mbox_msg_num(@folder.mbox_id)
-        recent_msgs = get_mail_store.mbox_flag_num(@folder.mbox_id, 'recent')
-        unseen_msgs = all_msgs - get_mail_store.mbox_flag_num(@folder.mbox_id, 'seen')
-        yield("* #{all_msgs} EXISTS\r\n")
-        yield("* #{recent_msgs} RECENT\r\n")
-        yield("* OK [UNSEEN #{unseen_msgs}]\r\n")
-        yield("* OK [UIDVALIDITY #{@folder.mbox_id}]\r\n")
-        yield("* FLAGS (\\Answered \\Flagged \\Deleted \\Seen \\Draft)\r\n")
-        nil
+      def authenticate(tag, client_response_input_gets, server_challenge_output_write,
+                       auth_type, inline_client_response_data_base64=nil)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :authenticate
+
+      def login(tag, username, password)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      private :folder_open_msgs
+      imap_command :login
 
       def select(tag, mbox_name)
-        res = []
-        @folder = nil
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        if (id = get_mail_store.mbox_id(mbox_name_utf8)) then
-          @folder = get_mail_store.select_mbox(id)
-          folder_open_msgs do |msg|
-            res << msg
-          end
-          res << "#{tag} OK [READ-WRITE] SELECT completed\r\n"
-        else
-          res << "#{tag} NO not found a mailbox\r\n"
-        end
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :select
+      imap_command :select
 
       def examine(tag, mbox_name)
-        res = []
-        @folder = nil
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        if (id = get_mail_store.mbox_id(mbox_name_utf8)) then
-          @folder = get_mail_store.examine_mbox(id)
-          folder_open_msgs do |msg|
-            res << msg
-          end
-          res << "#{tag} OK [READ-ONLY] EXAMINE completed\r\n"
-        else
-          res << "#{tag} NO not found a mailbox\r\n"
-        end
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :examine
+      imap_command :examine
 
       def create(tag, mbox_name)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        if (get_mail_store.mbox_id(mbox_name_utf8)) then
-          res << "#{tag} NO duplicated mailbox\r\n"
-        else
-          get_mail_store.add_mbox(mbox_name_utf8)
-          res << "#{tag} OK CREATE completed\r\n"
-        end
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :create, exclusive: true
+      imap_command :create
 
       def delete(tag, mbox_name)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        if (id = get_mail_store.mbox_id(mbox_name_utf8)) then
-          if (id != get_mail_store.mbox_id('INBOX')) then
-            get_mail_store.del_mbox(id)
-            res << "#{tag} OK DELETE completed\r\n"
-          else
-            res << "#{tag} NO not delete inbox\r\n"
-          end
-        else
-          res << "#{tag} NO not found a mailbox\r\n"
-        end
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :delete, exclusive: true
+      imap_command :delete
 
       def rename(tag, src_name, dst_name)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        src_name_utf8 = Net::IMAP.decode_utf7(src_name)
-        dst_name_utf8 = Net::IMAP.decode_utf7(dst_name)
-        unless (id = get_mail_store.mbox_id(src_name_utf8)) then
-          return yield(res << "#{tag} NO not found a mailbox\r\n")
-        end
-        if (id == get_mail_store.mbox_id('INBOX')) then
-          return yield(res << "#{tag} NO not rename inbox\r\n")
-        end
-        if (get_mail_store.mbox_id(dst_name_utf8)) then
-          return yield(res << "#{tag} NO duplicated mailbox\r\n")
-        end
-        get_mail_store.rename_mbox(id, dst_name_utf8)
-        return yield(res << "#{tag} OK RENAME completed\r\n")
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :rename, exclusive: true
+      imap_command :rename
 
       def subscribe(tag, mbox_name)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        if (_mbox_id = get_mail_store.mbox_id(mbox_name_utf8)) then
-          res << "#{tag} OK SUBSCRIBE completed\r\n"
-        else
-          res << "#{tag} NO not found a mailbox\r\n"
-        end
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :subscribe
+      imap_command :subscribe
 
       def unsubscribe(tag, mbox_name)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        if (_mbox_id = get_mail_store.mbox_id(mbox_name)) then
-          res << "#{tag} NO not implemented subscribe/unsbscribe command\r\n"
-        else
-          res << "#{tag} NO not found a mailbox\r\n"
-        end
-        yield(res)
-      end
-      imap_command_authenticated :unsubscribe
-
-      def list_mbox(ref_name, mbox_name)
-        ref_name_utf8 = Net::IMAP.decode_utf7(ref_name)
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-
-        mbox_filter = Protocol.compile_wildcard(mbox_name_utf8)
-        mbox_list = get_mail_store.each_mbox_id.map{|id| [ id, get_mail_store.mbox_name(id) ] }
-        mbox_list.keep_if{|id, name| name.start_with? ref_name_utf8 }
-        mbox_list.keep_if{|id, name| name[(ref_name_utf8.length)..-1] =~ mbox_filter }
-
-        for id, name_utf8 in mbox_list
-          name = Net::IMAP.encode_utf7(name_utf8)
-          attrs = '\Noinferiors'
-          if (get_mail_store.mbox_flag_num(id, 'recent') > 0) then
-            attrs << ' \Marked'
-          else
-            attrs << ' \Unmarked'
-          end
-          yield("(#{attrs}) NIL #{Protocol.quote(name)}")
-        end
-
-        nil
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      private :list_mbox
+      imap_command :unsubscribe
 
       def list(tag, ref_name, mbox_name)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        if (mbox_name.empty?) then
-          res << "* LIST (\\Noselect) NIL \"\"\r\n"
-        else
-          list_mbox(ref_name, mbox_name) do |mbox_entry|
-            res << "* LIST #{mbox_entry}\r\n"
-          end
-        end
-        res << "#{tag} OK LIST completed\r\n"
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :list
+      imap_command :list
 
       def lsub(tag, ref_name, mbox_name)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        if (mbox_name.empty?) then
-          res << "* LSUB (\\Noselect) NIL \"\"\r\n"
-        else
-          list_mbox(ref_name, mbox_name) do |mbox_entry|
-            res << "* LSUB #{mbox_entry}\r\n"
-          end
-        end
-        res << "#{tag} OK LSUB completed\r\n"
-        yield(res)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :lsub
+      imap_command :lsub
 
       def status(tag, mbox_name, data_item_group)
-        res = []
-        @folder.server_response_fetch{|r| res << r } if selected?
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        if (id = get_mail_store.mbox_id(mbox_name_utf8)) then
-          unless ((data_item_group.is_a? Array) && (data_item_group[0] == :group)) then
-            raise SyntaxError, 'second arugment is not a group list.'
-          end
-
-          values = []
-          for item in data_item_group[1..-1]
-            case (item.upcase)
-            when 'MESSAGES'
-              values << 'MESSAGES' << get_mail_store.mbox_msg_num(id)
-            when 'RECENT'
-              values << 'RECENT' << get_mail_store.mbox_flag_num(id, 'recent')
-            when 'UIDNEXT'
-              values << 'UIDNEXT' << get_mail_store.uid(id)
-            when 'UIDVALIDITY'
-              values << 'UIDVALIDITY' << id
-            when 'UNSEEN'
-              unseen_flags = get_mail_store.mbox_msg_num(id) - get_mail_store.mbox_flag_num(id, 'seen')
-              values << 'UNSEEN' << unseen_flags
-            else
-              raise SyntaxError, "unknown status data: #{item}"
-            end
-          end
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :status
 
-          res << "* STATUS #{Protocol.quote(mbox_name)} (#{values.join(' ')})\r\n"
-          res << "#{tag} OK STATUS completed\r\n"
-        else
-          res << "#{tag} NO not found a mailbox\r\n"
-        end
-        yield(res)
+      def append(tag, mbox_name, *opt_args, msg_text)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      imap_command_authenticated :status
+      imap_command :append
 
-      def mailbox_size_server_response_multicast_push(mbox_id)
-        all_msgs = get_mail_store.mbox_msg_num(mbox_id)
-        recent_msgs = get_mail_store.mbox_flag_num(mbox_id, 'recent')
+      def check(tag)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :check
 
-        f = get_mail_store.examine_mbox(mbox_id)
-        begin
-          f.server_response_multicast_push("* #{all_msgs} EXISTS\r\n")
-          f.server_response_multicast_push("* #{recent_msgs} RECENT\r\n")
-        ensure
-          f.close
-        end
+      def close(tag)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :close
 
-        nil
+      def expunge(tag)
+        raise ProtocolError, 'invalid command in logout state.'
       end
-      private :mailbox_size_server_response_multicast_push
+      imap_command :expunge
 
-      def append(tag, mbox_name, *opt_args, msg_text)
-        res = []
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        if (mbox_id = get_mail_store.mbox_id(mbox_name_utf8)) then
-          msg_flags = []
-          msg_date = Time.now
-
-          if ((! opt_args.empty?) && (opt_args[0].is_a? Array)) then
-            opt_flags = opt_args.shift
-            if (opt_flags[0] != :group) then
-              raise SyntaxError, 'bad flag list.'
-            end
-            for flag_atom in opt_flags[1..-1]
-              case (flag_atom.upcase)
-              when '\ANSWERED'
-                msg_flags << 'answered'
-              when '\FLAGGED'
-                msg_flags << 'flagged'
-              when '\DELETED'
-                msg_flags << 'deleted'
-              when '\SEEN'
-                msg_flags << 'seen'
-              when '\DRAFT'
-                msg_flags << 'draft'
+      def search(tag, *cond_args, uid: false)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :search
+
+      def fetch(tag, msg_set, data_item_group, uid: false)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :fetch
+
+      def store(tag, msg_set, data_item_name, data_item_value, uid: false)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :store
+
+      def copy(tag, msg_set, mbox_name, uid: false)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :copy
+
+      def idle(tag, client_input_gets, server_output_write, connection_timer)
+        raise ProtocolError, 'invalid command in logout state.'
+      end
+      imap_command :idle
+    end
+
+    class AuthenticatedDecoder < Decoder
+      def authenticate(tag, client_response_input_gets, server_challenge_output_write,
+                       auth_type, inline_client_response_data_base64=nil, &block)
+        yield([ "#{tag} NO duplicated authentication\r\n" ])
+      end
+      imap_command :authenticate
+
+      def login(tag, username, password, &block)
+        yield([ "#{tag} NO duplicated login\r\n" ])
+      end
+      imap_command :login
+    end
+
+    class UserMailboxDecoder < AuthenticatedDecoder
+      class Engine
+        def initialize(unique_user_id, mail_store, logger,
+                       bulk_response_count: 100,
+                       read_lock_timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS,
+                       write_lock_timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS,
+                       cleanup_write_lock_timeout_seconds: 1)
+          @unique_user_id = unique_user_id
+          @mail_store = mail_store
+          @logger = logger
+          @bulk_response_count = bulk_response_count
+          @read_lock_timeout_seconds = read_lock_timeout_seconds
+          @write_lock_timeout_seconds = write_lock_timeout_seconds
+          @cleanup_write_lock_timeout_seconds = cleanup_write_lock_timeout_seconds
+          @folders = {}
+        end
+
+        attr_reader :unique_user_id
+        attr_reader :mail_store # for test only
+
+        def recovery_if_needed(username)
+          @mail_store.write_synchronize(@write_lock_timeout_seconds) {
+            if (@mail_store.abort_transaction?) then
+              @logger.warn("user data recovery start: #{username}")
+              yield("* OK [ALERT] start user data recovery.\r\n")
+              @mail_store.recovery_data(logger: @logger).sync
+              @logger.warn("user data recovery end: #{username}")
+              yield("* OK completed user data recovery.\r\n")
+
+              self
+            end
+          }
+        end
+
+        def open_folder(mbox_id, read_only: false)
+          folder = @mail_store.open_folder(mbox_id, read_only: read_only)
+          token = folder.object_id
+          if (@folders.key? token) then
+            raise "internal error: duplicated folder token: #{token}"
+          end
+          @folders[token] = folder
+
+          token
+        end
+        private :open_folder
+
+        def close_folder(token)
+          folder = @folders.delete(token) or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          folder.reload if folder.updated?
+          begin
+            if (block_given?) then
+              saved_recent_msgs = @mail_store.mbox_flag_num(folder.mbox_id, 'recent')
+              folder.close do |msg_num|
+                yield("* #{msg_num} EXPUNGE\r\n")
+              end
+              last_recent_msgs = @mail_store.mbox_flag_num(folder.mbox_id, 'recent')
+              if (last_recent_msgs != saved_recent_msgs) then
+                yield("* #{last_recent_msgs} RECENT\r\n")
+              end
+            else
+              folder.close
+            end
+          ensure
+            folder.detach
+          end
+          @mail_store.sync
+
+          nil
+        end
+        private :close_folder
+
+        def cleanup(token)
+          if (token) then
+            begin
+              @mail_store.write_synchronize(@cleanup_write_lock_timeout_seconds) {
+                folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+                close_folder(token) do |untagged_response|
+                  folder.server_response_multicast_push(untagged_response)
+                end
+              }
+            rescue WriteLockTimeoutError
+              @logger.warn("give up to close folder becaue of write-lock timeout over #{@write_lock_timeout_seconds} seconds")
+              @folders.delete(token)
+            end
+          end
+
+          nil
+        end
+
+        def destroy
+          tmp_mail_store = @mail_store
+          ReadWriteLock.write_lock_timeout_detach(@cleanup_write_lock_timeout_seconds, @write_lock_timeout_seconds, logger: @logger) {|timeout_seconds|
+            @mail_store.write_synchronize(timeout_seconds) {
+              @logger.info("close mail store: #{@unique_user_id}")
+              tmp_mail_store.close
+            }
+          }
+          @mail_store = nil
+
+          nil
+        end
+
+        def guard_authenticated(imap_command, token, tag, *args, exclusive: false, **kw_args, &block)
+          if (exclusive.nil?) then
+            if (kw_args.empty?) then
+              __send__(imap_command, token, tag, *args, &block)
+            else
+              __send__(imap_command, token, tag, *args, **kw_args, &block)
+            end
+          else
+            begin
+              if (exclusive) then
+                @mail_store.write_synchronize(@write_lock_timeout_seconds) {
+                  guard_authenticated(imap_command, token, tag, *args, exclusive: nil, **kw_args, &block)
+                }
               else
-                raise SyntaxError, "invalid flag: #{flag_atom}"
+                @mail_store.read_synchronize(@read_lock_timeout_seconds){
+                  guard_authenticated(imap_command, token, tag, *args, exclusive: nil, **kw_args, &block)
+                }
               end
+            rescue ReadLockTimeoutError
+              @logger.error("write-lock timeout over #{@write_lock_timeout_seconds} seconds")
+              yield([ "#{tag} BAD write-lock timeout over #{@write_lock_timeout_seconds} seconds" ])
+            rescue WriteLockTimeoutError
+              @logger.error("read-lock timeout over #{@read_lock_timeout_seconds} seconds")
+              yield([ "#{tag} BAD read-lock timeout over #{@read_lock_timeout_seconds} seconds" ])
             end
           end
+        end
+        private :guard_authenticated
+
+        def guard_selected(imap_command, token, tag, *args, **kw_args, &block)
+          if (token) then
+            guard_authenticated(imap_command, token, tag, *args, **kw_args, &block)
+          else
+            yield([ "#{tag} NO not selected\r\n" ])
+          end
+        end
+        private :guard_selected
+
+        class << self
+          def imap_command_authenticated(name, **guard_optional)
+            orig_name = "_#{name}".to_sym
+            alias_method orig_name, name
+            define_method name, lambda{|token, tag, *args, **kw_args, &block|
+              guard_authenticated(orig_name, token, tag, *args, **kw_args, **guard_optional, &block)
+            }
+            name.to_sym
+          end
+          private :imap_command_authenticated
+
+          def imap_command_selected(name, **guard_optional)
+            orig_name = "_#{name}".to_sym
+            alias_method orig_name, name
+            define_method name, lambda{|token, tag, *args, **kw_args, &block|
+              guard_selected(orig_name, token, tag, *args, **kw_args, **guard_optional, &block)
+            }
+            name.to_sym
+          end
+          private :imap_command_selected
+        end
 
-          if ((! opt_args.empty?) && (opt_args[0].is_a? String)) then
+        def noop(token, tag)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
             begin
-              msg_date = Time.parse(opt_args.shift)
-            rescue ArgumentError
-              raise SyntaxError, $!.message
+              @mail_store.read_synchronize(@read_lock_timeout_seconds) {
+                folder.server_response_fetch{|r| res << r } if folder.server_response?
+              }
+            rescue ReadLockTimeoutError
+              @logger.warn("give up to get folder status because of read-lock timeout over #{@read_lock_timeout_seconds} seconds")
             end
           end
+          res << "#{tag} OK NOOP completed\r\n"
+          yield(res)
+        end
+
+        def folder_open_msgs(token)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          all_msgs = @mail_store.mbox_msg_num(folder.mbox_id)
+          recent_msgs = @mail_store.mbox_flag_num(folder.mbox_id, 'recent')
+          unseen_msgs = all_msgs - @mail_store.mbox_flag_num(folder.mbox_id, 'seen')
+          yield("* #{all_msgs} EXISTS\r\n")
+          yield("* #{recent_msgs} RECENT\r\n")
+          yield("* OK [UNSEEN #{unseen_msgs}]\r\n")
+          yield("* OK [UIDVALIDITY #{folder.mbox_id}]\r\n")
+          yield("* FLAGS (\\Answered \\Flagged \\Deleted \\Seen \\Draft)\r\n")
+          nil
+        end
+        private :folder_open_msgs
 
-          unless (opt_args.empty?) then
-            raise SyntaxError, "unknown option: #{opt_args.inspect}"
+        def select(token, tag, mbox_name)
+          if (token) then
+            close_no_response(token)
           end
 
-          uid = get_mail_store.add_msg(mbox_id, msg_text, msg_date)
-          for flag_name in msg_flags
-            get_mail_store.set_msg_flag(mbox_id, uid, flag_name, true)
+          res = []
+          new_token = nil
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+
+          if (id = @mail_store.mbox_id(mbox_name_utf8)) then
+            new_token = open_folder(id)
+            folder_open_msgs(new_token) do |msg|
+              res << msg
+            end
+            res << "#{tag} OK [READ-WRITE] SELECT completed\r\n"
+          else
+            res << "#{tag} NO not found a mailbox\r\n"
           end
-          mailbox_size_server_response_multicast_push(mbox_id)
+          yield(res)
 
-          @folder.server_response_fetch{|r| res << r } if selected?
-          res << "#{tag} OK [APPENDUID #{mbox_id} #{uid}] APPEND completed\r\n"
-        else
-          @folder.server_response_fetch{|r| res << r } if selected?
-          res << "#{tag} NO [TRYCREATE] not found a mailbox\r\n"
+          new_token
         end
-        yield(res)
-      end
-      imap_command_authenticated :append, exclusive: true
+        imap_command_authenticated :select
 
-      def check(tag)
-        res = []
-        @folder.server_response_fetch{|r| res << r }
-        get_mail_store.sync
-        res << "#{tag} OK CHECK completed\r\n"
-        yield(res)
-      end
-      imap_command_selected :check, exclusive: true
+        def examine(token, tag, mbox_name)
+          if (token) then
+            close_no_response(token)
+          end
 
-      def close(tag, &block)
-        yield response_stream(tag) {|res|
-          @folder.server_response_fetch{|r| res << r }
-          close_folder do |msg_num|
-            r = "* #{msg_num} EXPUNGE\r\n"
-            res << r
-            @folder.server_response_multicast_push(r)
+          res = []
+          new_token = nil
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+
+          if (id = @mail_store.mbox_id(mbox_name_utf8)) then
+            new_token = open_folder(id, read_only: true)
+            folder_open_msgs(new_token) do |msg|
+              res << msg
+            end
+            res << "#{tag} OK [READ-ONLY] EXAMINE completed\r\n"
+          else
+            res << "#{tag} NO not found a mailbox\r\n"
           end
-          get_mail_store.sync
-          res << "#{tag} OK CLOSE completed\r\n"
-        }
-      end
-      imap_command_selected :close, exclusive: true
+          yield(res)
 
-      def expunge(tag)
-        return yield([ "#{tag} NO cannot expunge in read-only mode\r\n" ]) if @folder.read_only?
-        should_be_alive_folder
-        @folder.reload if @folder.updated?
+          new_token
+        end
+        imap_command_authenticated :examine
 
-        yield response_stream(tag) {|res|
-          @folder.server_response_fetch{|r| res << r }
-          @folder.expunge_mbox do |msg_num|
-            r = "* #{msg_num} EXPUNGE\r\n"
-            res << r
-            @folder.server_response_multicast_push(r)
+        def create(token, tag, mbox_name)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
           end
-          res << "#{tag} OK EXPUNGE completed\r\n"
-        }
-      end
-      imap_command_selected :expunge, exclusive: true
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+          if (@mail_store.mbox_id(mbox_name_utf8)) then
+            res << "#{tag} NO duplicated mailbox\r\n"
+          else
+            @mail_store.add_mbox(mbox_name_utf8)
+            res << "#{tag} OK CREATE completed\r\n"
+          end
+          yield(res)
+        end
+        imap_command_authenticated :create, exclusive: true
 
-      def search(tag, *cond_args, uid: false)
-        should_be_alive_folder
-        @folder.reload if @folder.updated?
-        parser = SearchParser.new(get_mail_store, @folder)
-
-        if (! cond_args.empty? && cond_args[0].upcase == 'CHARSET') then
-          cond_args.shift
-          charset_string = cond_args.shift or raise SyntaxError, 'need for a charset string of CHARSET'
-          charset_string.is_a? String or raise SyntaxError, "CHARSET charset string expected as <String> but was <#{charset_string.class}>."
-          parser.charset = charset_string
+        def delete(token, tag, mbox_name)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
+          end
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+          if (id = @mail_store.mbox_id(mbox_name_utf8)) then
+            if (id != @mail_store.mbox_id('INBOX')) then
+              @mail_store.del_mbox(id)
+              res << "#{tag} OK DELETE completed\r\n"
+            else
+              res << "#{tag} NO not delete inbox\r\n"
+            end
+          else
+            res << "#{tag} NO not found a mailbox\r\n"
+          end
+          yield(res)
+        end
+        imap_command_authenticated :delete, exclusive: true
+
+        def rename(token, tag, src_name, dst_name)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
+          end
+          src_name_utf8 = Net::IMAP.decode_utf7(src_name)
+          dst_name_utf8 = Net::IMAP.decode_utf7(dst_name)
+          unless (id = @mail_store.mbox_id(src_name_utf8)) then
+            return yield(res << "#{tag} NO not found a mailbox\r\n")
+          end
+          if (id == @mail_store.mbox_id('INBOX')) then
+            return yield(res << "#{tag} NO not rename inbox\r\n")
+          end
+          if (@mail_store.mbox_id(dst_name_utf8)) then
+            return yield(res << "#{tag} NO duplicated mailbox\r\n")
+          end
+          @mail_store.rename_mbox(id, dst_name_utf8)
+          res << "#{tag} OK RENAME completed\r\n"
+          yield(res)
         end
+        imap_command_authenticated :rename, exclusive: true
 
-        if (cond_args.empty?) then
-          raise SyntaxError, 'required search arguments.'
+        def subscribe(token, tag, mbox_name)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
+          end
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+          if (@mail_store.mbox_id(mbox_name_utf8)) then
+            res << "#{tag} OK SUBSCRIBE completed\r\n"
+          else
+            res << "#{tag} NO not found a mailbox\r\n"
+          end
+          yield(res)
         end
+        imap_command_authenticated :subscribe
 
-        if (cond_args[0].upcase == 'UID' && cond_args.length >= 2) then
-          begin
-            msg_set = @folder.parse_msg_set(cond_args[1], uid: true)
-            msg_src = @folder.msg_find_all(msg_set, uid: true)
-            cond_args.shift(2)
-          rescue MessageSetSyntaxError
-            msg_src = @folder.each_msg
+        def unsubscribe(token, tag, mbox_name)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
           end
-        else
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+          if (@mail_store.mbox_id(mbox_name_utf8)) then
+            res << "#{tag} NO not implemented subscribe/unsbscribe command\r\n"
+          else
+            res << "#{tag} NO not found a mailbox\r\n"
+          end
+          yield(res)
+        end
+        imap_command_authenticated :unsubscribe
+
+        def list_mbox(ref_name, mbox_name)
+          ref_name_utf8 = Net::IMAP.decode_utf7(ref_name)
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+
+          mbox_filter = Protocol.compile_wildcard(mbox_name_utf8)
+          mbox_list = @mail_store.each_mbox_id.map{|id| [ id, @mail_store.mbox_name(id) ] }
+          mbox_list.keep_if{|id, name| name.start_with? ref_name_utf8 }
+          mbox_list.keep_if{|id, name| name[(ref_name_utf8.length)..-1] =~ mbox_filter }
+
+          for id, name_utf8 in mbox_list
+            name = Net::IMAP.encode_utf7(name_utf8)
+            attrs = '\Noinferiors'
+            if (@mail_store.mbox_flag_num(id, 'recent') > 0) then
+              attrs << ' \Marked'
+            else
+              attrs << ' \Unmarked'
+            end
+            yield("(#{attrs}) NIL #{Protocol.quote(name)}")
+          end
+
+          nil
+        end
+        private :list_mbox
+
+        def list(token, tag, ref_name, mbox_name)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
+          end
+          if (mbox_name.empty?) then
+            res << "* LIST (\\Noselect) NIL \"\"\r\n"
+          else
+            list_mbox(ref_name, mbox_name) do |mbox_entry|
+              res << "* LIST #{mbox_entry}\r\n"
+            end
+          end
+          res << "#{tag} OK LIST completed\r\n"
+          yield(res)
+        end
+        imap_command_authenticated :list
+
+        def lsub(token, tag, ref_name, mbox_name)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
+          end
+          if (mbox_name.empty?) then
+            res << "* LSUB (\\Noselect) NIL \"\"\r\n"
+          else
+            list_mbox(ref_name, mbox_name) do |mbox_entry|
+              res << "* LSUB #{mbox_entry}\r\n"
+            end
+          end
+          res << "#{tag} OK LSUB completed\r\n"
+          yield(res)
+        end
+        imap_command_authenticated :lsub
+
+        def status(token, tag, mbox_name, data_item_group)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
+          end
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+          if (id = @mail_store.mbox_id(mbox_name_utf8)) then
+            unless ((data_item_group.is_a? Array) && (data_item_group[0] == :group)) then
+              raise SyntaxError, 'second arugment is not a group list.'
+            end
+
+            values = []
+            for item in data_item_group[1..-1]
+              case (item.upcase)
+              when 'MESSAGES'
+                values << 'MESSAGES' << @mail_store.mbox_msg_num(id)
+              when 'RECENT'
+                values << 'RECENT' << @mail_store.mbox_flag_num(id, 'recent')
+              when 'UIDNEXT'
+                values << 'UIDNEXT' << @mail_store.uid(id)
+              when 'UIDVALIDITY'
+                values << 'UIDVALIDITY' << id
+              when 'UNSEEN'
+                unseen_flags = @mail_store.mbox_msg_num(id) - @mail_store.mbox_flag_num(id, 'seen')
+                values << 'UNSEEN' << unseen_flags
+              else
+                raise SyntaxError, "unknown status data: #{item}"
+              end
+            end
+
+            res << "* STATUS #{Protocol.quote(mbox_name)} (#{values.join(' ')})\r\n"
+            res << "#{tag} OK STATUS completed\r\n"
+          else
+            res << "#{tag} NO not found a mailbox\r\n"
+          end
+          yield(res)
+        end
+        imap_command_authenticated :status
+
+        def mailbox_size_server_response_multicast_push(mbox_id)
+          all_msgs = @mail_store.mbox_msg_num(mbox_id)
+          recent_msgs = @mail_store.mbox_flag_num(mbox_id, 'recent')
+
+          f = @mail_store.open_folder(mbox_id, read_only: true)
           begin
-            msg_set = @folder.parse_msg_set(cond_args[0], uid: false)
-            msg_src = @folder.msg_find_all(msg_set, uid: false)
-            cond_args.shift
-          rescue MessageSetSyntaxError
-            msg_src = @folder.each_msg
+            f.server_response_multicast_push("* #{all_msgs} EXISTS\r\n")
+            f.server_response_multicast_push("* #{recent_msgs} RECENT\r\n")
+          ensure
+            f.close
           end
+
+          nil
         end
-        cond = parser.parse(cond_args)
+        private :mailbox_size_server_response_multicast_push
+
+        def append(token, tag, mbox_name, *opt_args, msg_text)
+          res = []
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+          if (mbox_id = @mail_store.mbox_id(mbox_name_utf8)) then
+            msg_flags = []
+            msg_date = Time.now
+
+            if ((! opt_args.empty?) && (opt_args[0].is_a? Array)) then
+              opt_flags = opt_args.shift
+              if (opt_flags[0] != :group) then
+                raise SyntaxError, 'bad flag list.'
+              end
+              for flag_atom in opt_flags[1..-1]
+                case (flag_atom.upcase)
+                when '\ANSWERED'
+                  msg_flags << 'answered'
+                when '\FLAGGED'
+                  msg_flags << 'flagged'
+                when '\DELETED'
+                  msg_flags << 'deleted'
+                when '\SEEN'
+                  msg_flags << 'seen'
+                when '\DRAFT'
+                  msg_flags << 'draft'
+                else
+                  raise SyntaxError, "invalid flag: #{flag_atom}"
+                end
+              end
+            end
+
+            if ((! opt_args.empty?) && (opt_args[0].is_a? String)) then
+              begin
+                msg_date = Time.parse(opt_args.shift)
+              rescue ArgumentError
+                raise SyntaxError, $!.message
+              end
+            end
+
+            unless (opt_args.empty?) then
+              raise SyntaxError, "unknown option: #{opt_args.inspect}"
+            end
+
+            uid = @mail_store.add_msg(mbox_id, msg_text, msg_date)
+            for flag_name in msg_flags
+              @mail_store.set_msg_flag(mbox_id, uid, flag_name, true)
+            end
+
+            mailbox_size_server_response_multicast_push(mbox_id)
+            if (token) then
+              folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+              folder.server_response_fetch{|r| res << r }
+            end
+
+            res << "#{tag} OK [APPENDUID #{mbox_id} #{uid}] APPEND completed\r\n"
+          else
+            if (token) then
+              folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+              folder.server_response_fetch{|r| res << r }
+            end
+            res << "#{tag} NO [TRYCREATE] not found a mailbox\r\n"
+          end
+          yield(res)
+        end
+        imap_command_authenticated :append, exclusive: true
+
+        def check(token, tag)
+          res = []
+          if (token) then
+            folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+            folder.server_response_fetch{|r| res << r }
+          end
+          @mail_store.sync
+          res << "#{tag} OK CHECK completed\r\n"
+          yield(res)
+        end
+        imap_command_selected :check, exclusive: true
+
+        def close_no_response(token)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          close_folder(token) do |untagged_response|
+            # IMAP CLOSE command may not send untagged EXPUNGE
+            # responses, but notifies other connections of them.
+            folder.server_response_multicast_push(untagged_response)
+          end
+
+          nil
+        end
+        private :close_no_response
+
+        def close(token, tag)
+          close_no_response(token)
+          yield([ "#{tag} OK CLOSE completed\r\n" ])
+        end
+        imap_command_selected :close, exclusive: true
+
+        def expunge(token, tag)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          folder.should_be_alive
+          return yield([ "#{tag} NO cannot expunge in read-only mode\r\n" ]) if folder.read_only?
+          folder.reload if folder.updated?
+
+          res = []
+          folder.server_response_fetch{|r|
+            res << r
+            if (res.length >= @bulk_response_count) then
+              yield(res)
+              res = []
+            end
+          }
+
+          folder.expunge_mbox do |msg_num|
+            r = "* #{msg_num} EXPUNGE\r\n"
+            res << r
+            if (res.length >= @bulk_response_count) then
+              yield(res)
+              res = []
+            end
+            folder.server_response_multicast_push(r)
+          end
+
+          res << "#{tag} OK EXPUNGE completed\r\n"
+          yield(res)
+        end
+        imap_command_selected :expunge, exclusive: true
+
+        def search(token, tag, *cond_args, uid: false)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          folder.should_be_alive
+          folder.reload if folder.updated?
+          parser = SearchParser.new(@mail_store, folder)
+
+          if (! cond_args.empty? && cond_args[0].upcase == 'CHARSET') then
+            cond_args.shift
+            charset_string = cond_args.shift or raise SyntaxError, 'need for a charset string of CHARSET'
+            charset_string.is_a? String or raise SyntaxError, "CHARSET charset string expected as <String> but was <#{charset_string.class}>."
+            parser.charset = charset_string
+          end
+
+          if (cond_args.empty?) then
+            raise SyntaxError, 'required search arguments.'
+          end
+
+          if (cond_args[0].upcase == 'UID' && cond_args.length >= 2) then
+            begin
+              msg_set = folder.parse_msg_set(cond_args[1], uid: true)
+              msg_src = folder.msg_find_all(msg_set, uid: true)
+              cond_args.shift(2)
+            rescue MessageSetSyntaxError
+              msg_src = folder.each_msg
+            end
+          else
+            begin
+              msg_set = folder.parse_msg_set(cond_args[0], uid: false)
+              msg_src = folder.msg_find_all(msg_set, uid: false)
+              cond_args.shift
+            rescue MessageSetSyntaxError
+              msg_src = folder.each_msg
+            end
+          end
+          cond = parser.parse(cond_args)
+
+          res = []
+          folder.server_response_fetch{|r|
+            res << r
+            if (res.length >= @bulk_response_count) then
+              yield(res)
+              res = []
+            end
+          }
 
-        yield response_stream(tag) {|res|
-          @folder.server_response_fetch{|r| res << r }
           res << '* SEARCH'
           for msg in msg_src
             if (cond.call(msg)) then
@@ -1030,133 +1285,157 @@ module RIMS
               else
                 res << " #{msg.num}"
               end
+              if (res.length >= @bulk_response_count) then
+                yield(res)
+                res = []
+              end
             end
           end
+
           res << "\r\n"
           res << "#{tag} OK SEARCH completed\r\n"
-        }
-      end
-      imap_command_selected :search
+          yield(res)
+        end
+        imap_command_selected :search
 
-      def fetch(tag, msg_set, data_item_group, uid: false)
-        should_be_alive_folder
-        @folder.reload if @folder.updated?
+        def fetch(token, tag, msg_set, data_item_group, uid: false)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          folder.should_be_alive
+          folder.reload if folder.updated?
 
-        msg_set = @folder.parse_msg_set(msg_set, uid: uid)
-        msg_list = @folder.msg_find_all(msg_set, uid: uid)
+          msg_set = folder.parse_msg_set(msg_set, uid: uid)
+          msg_list = folder.msg_find_all(msg_set, uid: uid)
 
-        unless ((data_item_group.is_a? Array) && data_item_group[0] == :group) then
-          data_item_group = [ :group, data_item_group ]
-        end
-        if (uid) then
-          unless (data_item_group.find{|i| (i.is_a? String) && (i.upcase == 'UID') }) then
-            data_item_group = [ :group, 'UID' ] + data_item_group[1..-1]
+          unless ((data_item_group.is_a? Array) && data_item_group[0] == :group) then
+            data_item_group = [ :group, data_item_group ]
+          end
+          if (uid) then
+            unless (data_item_group.find{|i| (i.is_a? String) && (i.upcase == 'UID') }) then
+              data_item_group = [ :group, 'UID' ] + data_item_group[1..-1]
+            end
           end
-        end
 
-        parser = FetchParser.new(get_mail_store, @folder)
-        fetch = parser.parse(data_item_group)
+          parser = FetchParser.new(@mail_store, folder)
+          fetch = parser.parse(data_item_group)
+
+          res = []
+          folder.server_response_fetch{|r|
+            res << r
+            if (res.length >= @bulk_response_count) then
+              yield(res)
+              res = []
+            end
+          }
 
-        yield response_stream(tag) {|res|
-          @folder.server_response_fetch{|r| res << r }
           for msg in msg_list
             res << ('* '.b << msg.num.to_s.b << ' FETCH '.b << fetch.call(msg) << "\r\n".b)
+            if (res.length >= @bulk_response_count) then
+              yield(res)
+              res = []
+            end
           end
-          res << "#{tag} OK FETCH completed\r\n"
-        }
-      end
-      imap_command_selected :fetch
 
-      def store(tag, msg_set, data_item_name, data_item_value, uid: false)
-        return yield([ "#{tag} NO cannot store in read-only mode\r\n" ]) if @folder.read_only?
-        should_be_alive_folder
-        @folder.reload if @folder.updated?
-
-        msg_set = @folder.parse_msg_set(msg_set, uid: uid)
-        name, option = data_item_name.split(/\./, 2)
-
-        case (name.upcase)
-        when 'FLAGS'
-          action = :flags_replace
-        when '+FLAGS'
-          action = :flags_add
-        when '-FLAGS'
-          action = :flags_del
-        else
-          raise SyntaxError, "unknown store action: #{name}"
+          res << "#{tag} OK FETCH completed\r\n"
+          yield(res)
         end
+        imap_command_selected :fetch
+
+        def store(token, tag, msg_set, data_item_name, data_item_value, uid: false)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          folder.should_be_alive
+          return yield([ "#{tag} NO cannot store in read-only mode\r\n" ]) if folder.read_only?
+          folder.reload if folder.updated?
+
+          msg_set = folder.parse_msg_set(msg_set, uid: uid)
+          name, option = data_item_name.split(/\./, 2)
+
+          case (name.upcase)
+          when 'FLAGS'
+            action = :flags_replace
+          when '+FLAGS'
+            action = :flags_add
+          when '-FLAGS'
+            action = :flags_del
+          else
+            raise SyntaxError, "unknown store action: #{name}"
+          end
 
-        case (option && option.upcase)
-        when 'SILENT'
-          is_silent = true
-        when nil
-          is_silent = false
-        else
-          raise SyntaxError, "unknown store option: #{option.inspect}"
-        end
+          case (option && option.upcase)
+          when 'SILENT'
+            is_silent = true
+          when nil
+            is_silent = false
+          else
+            raise SyntaxError, "unknown store option: #{option.inspect}"
+          end
 
-        if ((data_item_value.is_a? Array) && data_item_value[0] == :group) then
-          flag_list = []
-          for flag_atom in data_item_value[1..-1]
-            case (flag_atom.upcase)
-            when '\ANSWERED'
-              flag_list << 'answered'
-            when '\FLAGGED'
-              flag_list << 'flagged'
-            when '\DELETED'
-              flag_list << 'deleted'
-            when '\SEEN'
-              flag_list << 'seen'
-            when '\DRAFT'
-              flag_list << 'draft'
-            else
-              raise SyntaxError, "invalid flag: #{flag_atom}"
+          if ((data_item_value.is_a? Array) && data_item_value[0] == :group) then
+            flag_list = []
+            for flag_atom in data_item_value[1..-1]
+              case (flag_atom.upcase)
+              when '\ANSWERED'
+                flag_list << 'answered'
+              when '\FLAGGED'
+                flag_list << 'flagged'
+              when '\DELETED'
+                flag_list << 'deleted'
+              when '\SEEN'
+                flag_list << 'seen'
+              when '\DRAFT'
+                flag_list << 'draft'
+              else
+                raise SyntaxError, "invalid flag: #{flag_atom}"
+              end
             end
+            rest_flag_list = (MailStore::MSG_FLAG_NAMES - %w[ recent ]) - flag_list
+          else
+            raise SyntaxError, 'third arugment is not a group list.'
           end
-          rest_flag_list = (MailStore::MSG_FLAG_NAMES - %w[ recent ]) - flag_list
-        else
-          raise SyntaxError, 'third arugment is not a group list.'
-        end
 
-        msg_list = @folder.msg_find_all(msg_set, uid: uid)
+          msg_list = folder.msg_find_all(msg_set, uid: uid)
 
-        for msg in msg_list
-          case (action)
-          when :flags_replace
-            for name in flag_list
-              get_mail_store.set_msg_flag(@folder.mbox_id, msg.uid, name, true)
-            end
-            for name in rest_flag_list
-              get_mail_store.set_msg_flag(@folder.mbox_id, msg.uid, name, false)
-            end
-          when :flags_add
-            for name in flag_list
-              get_mail_store.set_msg_flag(@folder.mbox_id, msg.uid, name, true)
-            end
-          when :flags_del
-            for name in flag_list
-              get_mail_store.set_msg_flag(@folder.mbox_id, msg.uid, name, false)
+          for msg in msg_list
+            case (action)
+            when :flags_replace
+              for name in flag_list
+                @mail_store.set_msg_flag(folder.mbox_id, msg.uid, name, true)
+              end
+              for name in rest_flag_list
+                @mail_store.set_msg_flag(folder.mbox_id, msg.uid, name, false)
+              end
+            when :flags_add
+              for name in flag_list
+                @mail_store.set_msg_flag(folder.mbox_id, msg.uid, name, true)
+              end
+            when :flags_del
+              for name in flag_list
+                @mail_store.set_msg_flag(folder.mbox_id, msg.uid, name, false)
+              end
+            else
+              raise "internal error: unknown action: #{action}"
             end
-          else
-            raise "internal error: unknown action: #{action}"
           end
-        end
 
-        if (is_silent) then
-          silent_res = []
-          @folder.server_response_fetch{|r| silent_res << r }
-          silent_res << "#{tag} OK STORE completed\r\n"
-          yield(silent_res)
-        else
-          yield response_stream(tag) {|res|
-            @folder.server_response_fetch{|r| res << r }
+          res = []
+          folder.server_response_fetch{|r|
+            res << r
+            if (res.length >= @bulk_response_count) then
+              yield(res)
+              res = []
+            end
+          }
+
+          if (is_silent) then
+            res << "#{tag} OK STORE completed\r\n"
+            yield(res)
+          else
             for msg in msg_list
               flag_atom_list = nil
 
-              if (get_mail_store.msg_exist? @folder.mbox_id, msg.uid) then
+              if (@mail_store.msg_exist? folder.mbox_id, msg.uid) then
                 flag_atom_list = []
                 for name in MailStore::MSG_FLAG_NAMES
-                  if (get_mail_store.msg_flag(@folder.mbox_id, msg.uid, name)) then
+                  if (@mail_store.msg_flag(folder.mbox_id, msg.uid, name)) then
                     flag_atom_list << "\\#{name.capitalize}"
                   end
                 end
@@ -1168,96 +1447,302 @@ module RIMS
                 else
                   res << "* #{msg.num} FETCH (FLAGS (#{flag_atom_list.join(' ')}))\r\n"
                 end
+                if (res.length >= @bulk_response_count) then
+                  yield(res)
+                  res = []
+                end
               else
-                @logger.warn("not found a message and skipped: uidvalidity(#{@folder.mbox_id}) uid(#{msg.uid})")
+                @logger.warn("not found a message and skipped: uidvalidity(#{folder.mbox_id}) uid(#{msg.uid})")
               end
             end
+
             res << "#{tag} OK STORE completed\r\n"
+            yield(res)
+          end
+        end
+        imap_command_selected :store, exclusive: true
+
+        def copy(token, tag, msg_set, mbox_name, uid: false)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          folder.should_be_alive
+          folder.reload if folder.updated?
+
+          res = []
+          mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
+          msg_set = folder.parse_msg_set(msg_set, uid: uid)
+
+          if (mbox_id = @mail_store.mbox_id(mbox_name_utf8)) then
+            msg_list = folder.msg_find_all(msg_set, uid: uid)
+
+            src_uids = []
+            dst_uids = []
+            for msg in msg_list
+              src_uids << msg.uid
+              dst_uids << @mail_store.copy_msg(msg.uid, folder.mbox_id, mbox_id)
+            end
+
+            if (msg_list.size > 0) then
+              mailbox_size_server_response_multicast_push(mbox_id)
+              folder.server_response_fetch{|r| res << r }
+              res << "#{tag} OK [COPYUID #{mbox_id} #{src_uids.join(',')} #{dst_uids.join(',')}] COPY completed\r\n"
+            else
+              folder.server_response_fetch{|r| res << r }
+              res << "#{tag} OK COPY completed\r\n"
+            end
+          else
+            folder.server_response_fetch{|r| res << r }
+            res << "#{tag} NO [TRYCREATE] not found a mailbox\r\n"
+          end
+          yield(res)
+        end
+        imap_command_selected :copy, exclusive: true
+
+        def idle(token, tag, client_input_gets, server_output_write, connection_timer)
+          folder = @folders[token] or raise KeyError.new("undefined folder token: #{token}", key: token, receiver: self)
+          folder.should_be_alive
+
+          @logger.info('idle start...')
+          server_output_write.call([ "+ continue\r\n" ])
+
+          server_response_thread = Thread.new{
+            @logger.info('idle server response thread start... ')
+            folder.server_response_idle_wait{|server_response_list|
+              for server_response in server_response_list
+                @logger.debug("idle server response: #{server_response}") if @logger.debug?
+              end
+              server_output_write.call(server_response_list)
+            }
+            @logger.info('idle server response thread terminated.')
           }
+
+          begin
+            connection_timer.command_wait or return
+            line = client_input_gets.call
+          ensure
+            folder.server_response_idle_interrupt
+            server_response_thread.join
+          end
+
+          res = []
+          if (line) then
+            line.chomp!("\n")
+            line.chomp!("\r")
+            if (line.upcase == "DONE") then
+              @logger.info('idle terminated.')
+              res << "#{tag} OK IDLE terminated\r\n"
+            else
+              @logger.warn('unexpected client response and idle terminated.')
+              @logger.debug("unexpected client response data: #{line}") if @logger.debug?
+              res << "#{tag} BAD unexpected client response\r\n"
+            end
+          else
+            @logger.warn('unexpected client connection close and idle terminated.')
+            res << "#{tag} BAD unexpected client connection close\r\n"
+          end
+          yield(res)
         end
+        imap_command_selected :idle, exclusive: nil
       end
-      imap_command_selected :store, exclusive: true
 
-      def copy(tag, msg_set, mbox_name, uid: false)
-        should_be_alive_folder
-        @folder.reload if @folder.updated?
+      def initialize(parent_decoder, engine, auth, logger)
+        super(auth, logger)
+        @parent_decoder = parent_decoder
+        @engine = engine
+        @token = nil
+      end
 
-        res = []
-        mbox_name_utf8 = Net::IMAP.decode_utf7(mbox_name)
-        msg_set = @folder.parse_msg_set(msg_set, uid: uid)
+      def auth?
+        ! @engine.nil?
+      end
 
-        if (mbox_id = get_mail_store.mbox_id(mbox_name_utf8)) then
-          msg_list = @folder.msg_find_all(msg_set, uid: uid)
+      def selected?
+        ! @token.nil?
+      end
 
-          src_uids = []
-          dst_uids = []
-          for msg in msg_list
-            src_uids << msg.uid
-            dst_uids << get_mail_store.copy_msg(msg.uid, @folder.mbox_id, mbox_id)
+      def cleanup
+        unless (@engine.nil?) then
+          begin
+            @engine.cleanup(@token)
+          ensure
+            @token = nil
           end
 
-          if msg_list.size > 0
-            mailbox_size_server_response_multicast_push(mbox_id)
-            @folder.server_response_fetch{|r| res << r }
-            res << "#{tag} OK [COPYUID #{mbox_id} #{src_uids.join(',')} #{dst_uids.join(',')}] COPY completed\r\n"
-          else
-            @folder.server_response_fetch{|r| res << r }
-            res << "#{tag} OK COPY completed\r\n"
+          begin
+            @engine.destroy
+          ensure
+            @engine = nil
           end
-        else
-          @folder.server_response_fetch{|r| res << r }
-          res << "#{tag} NO [TRYCREATE] not found a mailbox\r\n"
         end
-        yield(res)
+
+        unless (@parent_decoder.nil?) then
+          @parent_decoder.cleanup
+          @parent_decoder = nil
+        end
+
+        nil
+      end
+
+      def noop(tag, &block)
+        @engine.noop(@token, tag, &block)
+      end
+      imap_command :noop
+
+      def logout(tag)
+        if (@token) then
+          old_token = @token
+          @token = nil
+          @engine.cleanup(old_token)
+        end
+
+        @next_decoder = LogoutDecoder.new(self)
+        yield(make_logout_response(tag))
+      end
+      imap_command :logout
+
+      def select(tag, mbox_name)
+        ret_val = nil
+        old_token = @token
+        @token = @engine.select(old_token, tag, mbox_name) {|res|
+          ret_val = yield(res)
+        }
+
+        ret_val
+      end
+      imap_command :select
+
+      def examine(tag, mbox_name)
+        ret_val = nil
+        old_token = @token
+        @token = @engine.examine(old_token, tag, mbox_name) {|res|
+          ret_val = yield(res)
+        }
+
+        ret_val
+      end
+      imap_command :examine
+
+      def create(tag, mbox_name, &block)
+        @engine.create(@token, tag, mbox_name, &block)
+      end
+      imap_command :create
+
+      def delete(tag, mbox_name, &block)
+        @engine.delete(@token, tag, mbox_name, &block)
+      end
+      imap_command :delete
+
+      def rename(tag, src_name, dst_name, &block)
+        @engine.rename(@token, tag, src_name, dst_name, &block)
+      end
+      imap_command :rename
+
+      def subscribe(tag, mbox_name, &block)
+        @engine.subscribe(@token, tag, mbox_name, &block)
+      end
+      imap_command :subscribe
+
+      def unsubscribe(tag, mbox_name, &block)
+        @engine.unsubscribe(@token, tag, mbox_name, &block)
+      end
+      imap_command :unsubscribe
+
+      def list(tag, ref_name, mbox_name, &block)
+        @engine.list(@token, tag, ref_name, mbox_name, &block)
+      end
+      imap_command :list
+
+      def lsub(tag, ref_name, mbox_name, &block)
+        @engine.lsub(@token, tag, ref_name, mbox_name, &block)
+      end
+      imap_command :lsub
+
+      def status(tag, mbox_name, data_item_group, &block)
+        @engine.status(@token, tag, mbox_name, data_item_group, &block)
+      end
+      imap_command :status
+
+      def append(tag, mbox_name, *opt_args, msg_text, &block)
+        @engine.append(@token, tag, mbox_name, *opt_args, msg_text, &block)
+      end
+      imap_command :append
+
+      def check(tag, &block)
+        @engine.check(@token, tag, &block)
+      end
+      imap_command :check
+
+      def close(tag, &block)
+        old_token = @token
+        @token = nil
+
+        yield response_stream(tag) {|res|
+          @engine.close(old_token, tag) {|bulk_res|
+            for r in bulk_res
+              res << r
+            end
+          }
+        }
       end
-      imap_command_selected :copy, exclusive: true
+      imap_command :close
 
-      def idle(tag, client_input_stream, server_output_stream, connection_timer)
-        @logger.info('idle start...')
-        server_output_stream.write("+ continue\r\n")
-        server_output_stream.flush
+      def expunge(tag)
+        yield response_stream(tag) {|res|
+          @engine.expunge(@token, tag) {|bulk_res|
+            for r in bulk_res
+              res << r
+            end
+          }
+        }
+      end
+      imap_command :expunge
 
-        server_response_thread = Thread.new{
-          @logger.info('idle server response thread start... ')
-          @folder.server_response_idle_wait{|server_response_list|
-            for server_response in server_response_list
-              @logger.debug("idle server response: #{server_response}") if @logger.debug?
-              server_output_stream.write(server_response)
+      def search(tag, *cond_args, uid: false)
+        yield response_stream(tag) {|res|
+          @engine.search(@token, tag, *cond_args, uid: uid) {|bulk_res|
+            for r in bulk_res
+              res << r
             end
-            server_output_stream.flush
           }
-          @logger.info('idle server response thread terminated.')
         }
+      end
+      imap_command :search
 
-        begin
-          connection_timer.command_wait or return
-          line = client_input_stream.gets
-        ensure
-          @folder.server_response_idle_interrupt
-          server_response_thread.join
-        end
+      def fetch(tag, msg_set, data_item_group, uid: false)
+        yield response_stream(tag) {|res|
+          @engine.fetch(@token, tag, msg_set, data_item_group, uid: uid) {|bulk_res|
+            for r in bulk_res
+              res << r
+            end
+          }
+        }
+      end
+      imap_command :fetch
 
-        res = []
-        if (line) then
-          line.chomp!("\n")
-          line.chomp!("\r")
-          if (line.upcase == "DONE") then
-            @logger.info('idle terminated.')
-            res << "#{tag} OK IDLE terminated\r\n"
-          else
-            @logger.warn('unexpected client response and idle terminated.')
-            @logger.debug("unexpected client response data: #{line}")
-            res << "#{tag} BAD unexpected client response\r\n"
-          end
-        else
-          @logger.warn('unexpected client connection close and idle terminated.')
-          res << "#{tag} BAD unexpected client connection close\r\n"
-        end
-        yield(res)
+      def store(tag, msg_set, data_item_name, data_item_value, uid: false)
+        yield response_stream(tag) {|res|
+          @engine.store(@token, tag, msg_set, data_item_name, data_item_value, uid: uid) {|bulk_res|
+            for r in bulk_res
+              res << r
+            end
+          }
+        }
+      end
+      imap_command :store
+
+      def copy(tag, msg_set, mbox_name, uid: false, &block)
+        @engine.copy(@token, tag, msg_set, mbox_name, uid: uid, &block)
+      end
+      imap_command :copy
+
+      def idle(tag, client_input_gets, server_output_write, connection_timer, &block)
+        @engine.idle(@token, tag, client_input_gets, server_output_write, connection_timer, &block)
       end
-      imap_command_selected :idle, exclusive: nil
+      imap_command :idle
     end
 
+    # alias
+    Decoder::Engine = UserMailboxDecoder::Engine
+
     def Decoder.encode_delivery_target_mailbox(username, mbox_name)
       "b64user-mbox #{Protocol.encode_base64(username)} #{mbox_name}"
     end
@@ -1271,51 +1756,53 @@ module RIMS
     end
 
     class MailDeliveryDecoder < AuthenticatedDecoder
-      def initialize(mail_store_pool, auth, logger,
-                     write_lock_timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS,
-                     cleanup_write_lock_timeout_seconds: 1,
-                     **mailbox_decoder_optional)
+      def initialize(parent_decoder, services, auth, logger)
         super(auth, logger)
-        @mail_store_pool = mail_store_pool
+        @parent_decoder = parent_decoder
+        @services = services
         @auth = auth
-        @write_lock_timeout_seconds = write_lock_timeout_seconds
-        @cleanup_write_lock_timeout_seconds = cleanup_write_lock_timeout_seconds
-        @mailbox_decoder_optional = mailbox_decoder_optional
         @last_user_cache_key_username = nil
-        @last_user_cache_value_mail_store_holder = nil
+        @last_user_cache_value_engine = nil
       end
 
-      def user_mail_store_cached?(username)
+      def engine_cached?(username)
         @last_user_cache_key_username == username
       end
-      private :user_mail_store_cached?
+      private :engine_cached?
 
-      def fetch_user_mail_store_holder(username)
-        unless (user_mail_store_cached? username) then
-          release_user_mail_store_holder
-          @last_user_cache_value_mail_store_holder = yield
-          @last_user_cache_key_username = username
+      def engine_cache(username)
+        unless (engine_cached? username) then
+          raise "not cached: #{username}"
         end
-        @last_user_cache_value_mail_store_holder
+        @last_user_cache_value_engine
       end
-      private :fetch_user_mail_store_holder
+      private :engine_cache
 
-      def release_user_mail_store_holder
-        if (@last_user_cache_value_mail_store_holder) then
-          mail_store_holder = @last_user_cache_value_mail_store_holder
+      def store_engine_cache(username)
+        if (engine_cached? username) then
+          raise "already cached: #{username}"
+        end
+
+        release_engine_cache
+        @last_user_cache_value_engine = yield
+        @last_user_cache_key_username = username # success to store engine cache
+
+        @last_user_cache_value_engine
+      end
+      private :store_engine_cache
+
+      def release_engine_cache
+        if (@last_user_cache_value_engine) then
+          engine = @last_user_cache_value_engine
           @last_user_cache_key_username = nil
-          @last_user_cache_value_mail_store_holder = nil
-          ReadWriteLock.write_lock_timeout_detach(@cleanup_write_lock_timeout_seconds, @write_lock_timeout_seconds, logger: @logger) {|timeout_seconds|
-            mail_store_holder.return_pool{
-              @logger.info("close cached mail store to deliver message: #{mail_store_holder.unique_user_id}")
-            }
-          }
+          @last_user_cache_value_engine = nil
+          engine.destroy
         end
       end
-      private :release_user_mail_store_holder
+      private :release_engine_cache
 
       def auth?
-        @mail_store_pool != nil
+        @services != nil
       end
 
       def selected?
@@ -1323,18 +1810,21 @@ module RIMS
       end
 
       def cleanup
-        release_user_mail_store_holder
-        @mail_store_pool = nil unless @mail_store_pool.nil?
+        release_engine_cache
+        @services = nil unless @services.nil?
         @auth = nil unless @auth.nil?
+
+        unless (@parent_decoder.nil?) then
+          @parent_decoder.cleanup
+          @parent_decoder = nil
+        end
+
         nil
       end
 
       def logout(tag)
-        cleanup
-        res = []
-        res << "* BYE server logout\r\n"
-        res << "#{tag} OK LOGOUT completed\r\n"
-        yield(res)
+        @next_decoder = LogoutDecoder.new(self)
+        yield(make_logout_response(tag))
       end
       imap_command :logout
 
@@ -1354,66 +1844,63 @@ module RIMS
       end
       imap_command :capability
 
-      def not_allowed_command_response(tag)
+      def make_not_allowed_command_response(tag)
         [ "#{tag} NO not allowed command on mail delivery user\r\n" ]
       end
-      private :not_allowed_command_response
+      private :make_not_allowed_command_response
 
       def select(tag, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :select
 
       def examine(tag, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :examine
 
       def create(tag, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :create
 
       def delete(tag, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :delete
 
       def rename(tag, src_name, dst_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :rename
 
       def subscribe(tag, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :subscribe
 
       def unsubscribe(tag, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :unsubscribe
 
       def list(tag, ref_name, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :list
 
       def lsub(tag, ref_name, mbox_name)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :lsub
 
       def status(tag, mbox_name, data_item_group)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :status
 
-      def deliver_to_user(tag, username, mbox_name, opt_args, msg_text, mail_store_holder, res)
-        user_decoder = UserMailboxDecoder.new(self, mail_store_holder, @auth, @logger,
-                                              write_lock_timeout_seconds: @write_lock_timeout_seconds,
-                                              cleanup_write_lock_timeout_seconds: @cleanup_write_lock_timeout_seconds,
-                                              **@mailbox_decoder_optional)
+      def deliver_to_user(tag, username, mbox_name, opt_args, msg_text, engine, res)
+        user_decoder = UserMailboxDecoder.new(self, engine, @auth, @logger)
         user_decoder.append(tag, mbox_name, *opt_args, msg_text) {|append_response|
           if (append_response.last.split(' ', 3)[1] == 'OK') then
             @logger.info("message delivery: successed to deliver #{msg_text.bytesize} octets message.")
@@ -1432,18 +1919,16 @@ module RIMS
         @logger.info("message delivery: user #{username}, mailbox #{mbox_name}")
 
         if (@auth.user? username) then
-          if (user_mail_store_cached? username) then
+          if (engine_cached? username) then
             res = []
-            mail_store_holder = fetch_user_mail_store_holder(username)
-            deliver_to_user(tag, username, mbox_name, opt_args, msg_text, mail_store_holder, res)
+            engine = engine_cache(username)
+            deliver_to_user(tag, username, mbox_name, opt_args, msg_text, engine, res)
           else
             res = Enumerator.new{|stream_res|
-              mail_store_holder = fetch_user_mail_store_holder(username) {
-                self.class.fetch_mail_store_holder_and_on_demand_recovery(@mail_store_pool, username,
-                                                                          write_lock_timeout_seconds: @write_lock_timeout_seconds,
-                                                                          logger: @logger) {|msg| stream_res << msg }
+              engine = store_engine_cache(username) {
+                self.class.make_engine_and_recovery_if_needed(@services, username, logger: @logger) {|msg| stream_res << msg }
               }
-              deliver_to_user(tag, username, mbox_name, opt_args, msg_text, mail_store_holder, stream_res)
+              deliver_to_user(tag, username, mbox_name, opt_args, msg_text, engine, stream_res)
             }
           end
           yield(res)
@@ -1455,42 +1940,42 @@ module RIMS
       imap_command :append
 
       def check(tag)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :check
 
       def close(tag)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :close
 
       def expunge(tag)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :expunge
 
       def search(tag, *cond_args, uid: false)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :search
 
       def fetch(tag, msg_set, data_item_group, uid: false)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :fetch
 
       def store(tag, msg_set, data_item_name, data_item_value, uid: false)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :store
 
       def copy(tag, msg_set, mbox_name, uid: false)
-        yield(not_allowed_command_response(tag))
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :copy
 
-      def idle(tag, client_input_stream, server_output_stream, connection_timer)
-        yield(not_allowed_command_response(tag))
+      def idle(tag, client_input_gets, server_output_write, connection_timer)
+        yield(make_not_allowed_command_response(tag))
       end
       imap_command :idle
     end