rims 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 397075dab0a3fa9bdf66a3a3be278b2d1eb3f67f6e2b12e73dcd27bf37190e66
-  data.tar.gz: 8e0734fcdda1d88e9720cefea0c8a2464f4fd4ddb5cfd68c67bc56635c9ef6f3
+  metadata.gz: e462eb67ba5bb6cdfa73906f100e9e11474e42e64616df8fc119a7dcaa879374
+  data.tar.gz: 9f860520538eb8bd52aeac784dd668d6778a9c51f343ff368548225d955c6dca
 SHA512:
-  metadata.gz: 5b9fa09f69d35c243e8be71387fe29c4ab3b2237e2a530737e5108dba9371579c2fda3d9fa6bfa7bbebb0ffef3121e6e84863fa111c31b93d1ef8aeeb979c870
-  data.tar.gz: 8cb95a095d7f15f0fe6c7a7ac3bb6d4ec845e6950923c50dc69a93428c082576faaf0a48d83273a923d923dafc6a85eced6affb2c5039408f9b83add0cddd6e9
+  metadata.gz: b5d7aff45f4ce0d921e10136f2e161abd5f6ddf8307fc2f96909db0399cb3230f11ec073a6f401bc3f4d9a28432334a9845ae8da5e31bba30064cee2e78e33de
+  data.tar.gz: b9f72aa820f34528f47383d4e3c74245747edf60b0c370a24f75b3f5189c740c0887366cab1b66f7ae8237819d3407d7a31d8cc0786c487d9778a801fdb66a8a

data/ChangeLog

@@ -1,3 +1,21 @@
+2019-04-25  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* test/test_protocol_decoder.rb: integrated individual IMAP
+	command test and IMAP command stream test.
+
+2019-04-16  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/protocol/connection.rb, lib/rims/protocol/decoder.rb,
+	lib/rims/service.rb: autologout for too long ideling or graceful
+	shutdown.
+
+2019-04-13  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/rims/protocol/decoder.rb
+	(RIMS::Protocol::UserMailboxDecoder#idle): fix a bug of idle
+	command that uninitialized variable had been logged as debug
+	message.
+
 2019-04-10  TOKI Yoshinori  <toki@freedom.ne.jp>
 
 	* RIMS version 0.2.3 is released.

data/lib/rims/cmd.rb

@@ -408,11 +408,29 @@ module RIMS
                  Integer
                 ) do |size|
         build.chain{|c|
-          c.load(server: {
+          c.load(connection: {
                    send_buffer_limit_size: size
                  })
         }
       end
+      options.on('--read-polling-interval=SECONDS',
+                 Float
+                ) do |seconds|
+        build.chain{|c|
+          c.load(connection: {
+                   read_polling_interval_seconds: seconds
+                 })
+        }
+      end
+      options.on('--command-wait-timeout=SECONDS',
+                 Float
+                ) do |seconds|
+        build.chain{|c|
+          c.load(connection: {
+                   command_wait_timeout_seconds: seconds
+                 })
+        }
+      end
       options.on('--read-lock-timeout=SECONDS',
                  Float
                 ) do |seconds|

data/lib/rims/protocol.rb

@@ -62,6 +62,8 @@ module RIMS
     autoload :AuthenticationReader, 'rims/protocol/parser'
     autoload :SearchParser, 'rims/protocol/parser'
     autoload :FetchParser, 'rims/protocol/parser'
+    autoload :ConnectionLimits, 'rims/protocol/connection'
+    autoload :ConnectionTimer, 'rims/protocol/connection'
     autoload :Decoder, 'rims/protocol/decoder'
 
     def body(symbol: nil, option: nil, section: nil, section_list: nil, partial_origin: nil, partial_size: nil)

data/lib/rims/protocol/connection.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+require 'riser'
+
+module RIMS
+  module Protocol
+    class ConnectionLimits
+      def initialize(read_polling_interval_seconds, command_wait_timeout_seconds)
+        @mutex = Thread::Mutex.new
+        @read_polling_interval_seconds = read_polling_interval_seconds
+        self.command_wait_timeout_seconds = command_wait_timeout_seconds
+      end
+
+      attr_reader :read_polling_interval_seconds
+
+      def command_wait_timeout_seconds
+        @mutex.synchronize{ @command_wait_timeout_seconds }
+      end
+
+      def command_wait_timeout_seconds=(value)
+        @mutex.synchronize{ @command_wait_timeout_seconds = value }
+      end
+
+      def to_h
+        Hash[
+          [ :read_polling_interval_seconds,
+            :command_wait_timeout_seconds
+          ].map{|n| [ n, __send__(n) ] }
+        ]
+      end
+    end
+
+    class ConnectionTimer
+      def initialize(limits, read_io)
+        @limits = limits
+        @read_poll = Riser::ReadPoll.new(read_io)
+        @command_wait_timeout = false
+      end
+
+      def command_wait
+        if (@limits.command_wait_timeout_seconds == 0) then
+          if (@read_poll.call(0) != nil) then
+            return self
+          else
+            @command_wait_timeout = true
+            return
+          end
+        end
+
+        @read_poll.reset_timer
+        until (@read_poll.call(@limits.read_polling_interval_seconds) != nil)
+          if (@read_poll.interval_seconds >= @limits.command_wait_timeout_seconds) then
+            @command_wait_timeout = true
+            return
+          end
+        end
+
+        self
+      end
+
+      def command_wait_timeout?
+        @command_wait_timeout
+      end
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/lib/rims/protocol/decoder.rb

@@ -7,11 +7,21 @@ require 'time'
 module RIMS
   module Protocol
     class Decoder
+      # to use `StringIO' as mock in unit test
+      using Riser::CompatibleStringIO
+
       def self.new_decoder(*args, **opts)
         InitialDecoder.new(*args, **opts)
       end
 
-      def self.repl(decoder, input, output, logger)
+      IMAP_CMDs = {}
+      UID_CMDs = {}
+
+      def self.imap_command_normalize(name)
+        name.upcase
+      end
+
+      def self.repl(decoder, limits, input, output, logger)
         response_write = proc{|res|
           begin
             last_line = nil
@@ -31,8 +41,12 @@ module RIMS
 
         decoder.ok_greeting{|res| response_write.call(res) }
 
-        request_reader = Protocol::RequestReader.new(input, output, logger)
-        loop do
+        conn_timer = ConnectionTimer.new(limits, input.to_io)
+        request_reader = RequestReader.new(input, output, logger)
+
+        until (conn_timer.command_wait_timeout?)
+          conn_timer.command_wait or break
+
           begin
             atom_list = request_reader.read_command
           rescue
@@ -47,9 +61,10 @@ module RIMS
           break unless atom_list
 
           tag, command, *opt_args = atom_list
+          normalized_command = imap_command_normalize(command)
           logger.info("client command: #{tag} #{command}")
           if (logger.debug?) then
-            case (command.upcase)
+            case (normalized_command)
             when 'LOGIN'
               log_opt_args = opt_args.dup
               log_opt_args[-1] = '********'
@@ -60,76 +75,29 @@ module RIMS
           end
 
           begin
-            case (command.upcase)
-            when 'CAPABILITY'
-              decoder.capability(tag, *opt_args) {|res| response_write.call(res) }
-            when 'NOOP'
-              decoder.noop(tag, *opt_args) {|res| response_write.call(res) }
-            when 'LOGOUT'
-              decoder.logout(tag, *opt_args) {|res| response_write.call(res) }
-            when 'AUTHENTICATE'
-              decoder.authenticate(tag, input, output, *opt_args) {|res| response_write.call(res) }
-            when 'LOGIN'
-              decoder.login(tag, *opt_args) {|res| response_write.call(res) }
-            when 'SELECT'
-              decoder.select(tag, *opt_args) {|res| response_write.call(res) }
-            when 'EXAMINE'
-              decoder.examine(tag, *opt_args) {|res| response_write.call(res) }
-            when 'CREATE'
-              decoder.create(tag, *opt_args) {|res| response_write.call(res) }
-            when 'DELETE'
-              decoder.delete(tag, *opt_args) {|res| response_write.call(res) }
-            when 'RENAME'
-              decoder.rename(tag, *opt_args) {|res| response_write.call(res) }
-            when 'SUBSCRIBE'
-              decoder.subscribe(tag, *opt_args) {|res| response_write.call(res) }
-            when 'UNSUBSCRIBE'
-              decoder.unsubscribe(tag, *opt_args) {|res| response_write.call(res) }
-            when 'LIST'
-              decoder.list(tag, *opt_args) {|res| response_write.call(res) }
-            when 'LSUB'
-              decoder.lsub(tag, *opt_args) {|res| response_write.call(res) }
-            when 'STATUS'
-              decoder.status(tag, *opt_args) {|res| response_write.call(res) }
-            when 'APPEND'
-              decoder.append(tag, *opt_args) {|res| response_write.call(res) }
-            when 'CHECK'
-              decoder.check(tag, *opt_args) {|res| response_write.call(res) }
-            when 'CLOSE'
-              decoder.close(tag, *opt_args) {|res| response_write.call(res) }
-            when 'EXPUNGE'
-              decoder.expunge(tag, *opt_args) {|res| response_write.call(res) }
-            when 'SEARCH'
-              decoder.search(tag, *opt_args) {|res| response_write.call(res) }
-            when 'FETCH'
-              decoder.fetch(tag, *opt_args) {|res| response_write.call(res) }
-            when 'STORE'
-              decoder.store(tag, *opt_args) {|res| response_write.call(res) }
-            when 'COPY'
-              decoder.copy(tag, *opt_args) {|res| response_write.call(res) }
-            when 'IDLE'
-              decoder.idle(tag, input, output, *opt_args) {|res| response_write.call(res) }
-            when 'UID'
-              unless (opt_args.empty?) then
-                uid_command, *uid_args = opt_args
-                logger.info("uid command: #{uid_command}")
-                logger.debug("uid parameter: #{uid_args}") if logger.debug?
-                case (uid_command.upcase)
-                when 'SEARCH'
-                  decoder.search(tag, *uid_args, uid: true) {|res| response_write.call(res) }
-                when 'FETCH'
-                  decoder.fetch(tag, *uid_args, uid: true) {|res| response_write.call(res) }
-                when 'STORE'
-                  decoder.store(tag, *uid_args, uid: true) {|res| response_write.call(res) }
-                when 'COPY'
-                  decoder.copy(tag, *uid_args, uid: true) {|res| response_write.call(res) }
+            if (name = IMAP_CMDs[normalized_command]) then
+              case (name)
+              when :uid
+                unless (opt_args.empty?) then
+                  uid_command, *uid_args = opt_args
+                  logger.info("uid command: #{uid_command}")
+                  logger.debug("uid parameter: #{uid_args}") if logger.debug?
+                  if (uid_name = UID_CMDs[imap_command_normalize(uid_command)]) then
+                    decoder.__send__(uid_name, tag, *uid_args, uid: true) {|res| response_write.call(res) }
+                  else
+                    logger.error("unknown uid command: #{uid_command}")
+                    response_write.call([ "#{tag} BAD unknown uid command\r\n" ])
+                  end
                 else
-                  logger.error("unknown uid command: #{uid_command}")
-                  response_write.call([ "#{tag} BAD unknown uid command\r\n" ])
+                  logger.error('empty uid parameter.')
+                  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) }
+              when :idle
+                decoder.idle(tag, input, output, conn_timer, *opt_args) {|res| response_write.call(res) }
               else
-                logger.error('empty uid parameter.')
-                response_write.call([ "#{tag} BAD empty uid parameter\r\n" ])
+                decoder.__send__(name, tag, *opt_args) {|res| response_write.call(res) }
               end
             else
               logger.error("unknown command: #{command}")
@@ -143,13 +111,21 @@ module RIMS
             response_write.call([ "#{tag} BAD unexpected error\r\n" ])
           end
 
-          if (command.upcase == 'LOGOUT') then
+          if (normalized_command == 'LOGOUT') then
             break
           end
 
           decoder = decoder.next_decoder
         end
 
+        if (conn_timer.command_wait_timeout?) then
+          if (limits.command_wait_timeout_seconds > 0) then
+            response_write.call([ "* BYE server autologout: idle for too long\r\n" ])
+          else
+            response_write.call([ "* BYE server autologout: shutdown\r\n" ])
+          end
+        end
+
         nil
       ensure
         decoder.cleanup
@@ -207,16 +183,55 @@ module RIMS
       private :guard_error
 
       class << self
+        def to_imap_command(name)
+          imap_command_normalize(name.to_s)
+        end
+        private :to_imap_command
+
+        def kw_params(method)
+          params = method.parameters
+          params.find_all{|arg_type, arg_name|
+            case (arg_type)
+            when :key, :keyreq
+              true
+            else
+              false
+            end
+          }.map{|arg_type, arg_name|
+            arg_name
+          }
+        end
+        private :kw_params
+
         def imap_command(name)
+          name = name.to_sym
+
+          cmd = to_imap_command(name)
+          IMAP_CMDs[cmd] = name
+
+          method = instance_method(name)
+          if (kw_params(method).find(:uid)) then
+            IMAP_CMDs['UID'] = :uid
+            UID_CMDs[cmd] = name
+          end
+
           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)
           }
-          name.to_sym
+
+          name
         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))
@@ -452,7 +467,7 @@ module RIMS
       end
       imap_command :copy
 
-      def idle(tag, client_input_stream, server_output_stream)
+      def idle(tag, client_input_stream, server_output_stream, connection_timer)
         yield(not_authenticated_response(tag))
       end
       imap_command :idle
@@ -595,6 +610,7 @@ module RIMS
 
       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|
@@ -605,6 +621,7 @@ module RIMS
         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|
@@ -971,7 +988,7 @@ module RIMS
       def search(tag, *cond_args, uid: false)
         should_be_alive_folder
         @folder.reload if @folder.updated?
-        parser = Protocol::SearchParser.new(get_mail_store, @folder)
+        parser = SearchParser.new(get_mail_store, @folder)
 
         if (! cond_args.empty? && cond_args[0].upcase == 'CHARSET') then
           cond_args.shift
@@ -1037,7 +1054,7 @@ module RIMS
           end
         end
 
-        parser = Protocol::FetchParser.new(get_mail_store, @folder)
+        parser = FetchParser.new(get_mail_store, @folder)
         fetch = parser.parse(data_item_group)
 
         yield response_stream(tag) {|res|
@@ -1195,7 +1212,7 @@ module RIMS
       end
       imap_command_selected :copy, exclusive: true
 
-      def idle(tag, client_input_stream, server_output_stream)
+      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
@@ -1203,17 +1220,17 @@ module RIMS
         server_response_thread = Thread.new{
           @logger.info('idle server response thread start... ')
           @folder.server_response_idle_wait{|server_response_list|
-            @logger.debug("idle server response: #{server_response}") if @logger.debug?
             for server_response in server_response_list
+              @logger.debug("idle server response: #{server_response}") if @logger.debug?
               server_output_stream.write(server_response)
             end
             server_output_stream.flush
           }
-          server_output_stream.flush
           @logger.info('idle server response thread terminated.')
         }
 
         begin
+          connection_timer.command_wait or return
           line = client_input_stream.gets
         ensure
           @folder.server_response_idle_interrupt
@@ -1472,7 +1489,7 @@ module RIMS
       end
       imap_command :copy
 
-      def idle(tag, client_input_stream, server_output_stream)
+      def idle(tag, client_input_stream, server_output_stream, connection_timer)
         yield(not_allowed_command_response(tag))
       end
       imap_command :idle