rims 0.2.8 → 0.2.9

data/lib/rims/protocol/parser.rb

@@ -232,7 +232,7 @@ module RIMS
         @mail_store = mail_store
         @folder = folder
         @charset_aliases = charset_aliases
-        @charset_convert_options = charset_convert_options
+        @charset_convert_options = charset_convert_options || {}
         @charset = nil
         @mail_cache = Hash.new{|hash, uid|
           if (msg_txt = @mail_store.msg_text(@folder.mbox_id, uid)) then
@@ -269,7 +269,7 @@ module RIMS
         if (string.encoding == @charset) then
           string
         else
-          string.encode(@charset, @charset_convert_options)
+          string.encode(@charset, **@charset_convert_options)
         end
       end
       private :encode_charset

data/lib/rims/service.rb

@@ -118,6 +118,7 @@ module RIMS
       #   daemon:
       #     daemonize: true
       #     debug: false
+      #     umask: 0037
       #     status_file: rims.pid
       #     server_polling_interval_seconds: 3
       #     server_privileged_user: nobody
@@ -418,6 +419,10 @@ module RIMS
         end
       end
 
+      def daemon_umask
+        @config.dig('daemon', 'umask') || 0037
+      end
+
       def status_file
         file_path = @config.dig('daemon', 'status_file') || 'rims.pid'
         file_path = Pathname(file_path)
@@ -799,16 +804,16 @@ module RIMS
     using Logger::JointPlus
 
     def setup(server, daemon: false)
-      file_logger_params = @config.make_file_logger_params
-      logger = Logger.new(*file_logger_params)
+      *file_logger_params, file_logger_opts = @config.make_file_logger_params
+      logger = Logger.new(*file_logger_params, **file_logger_opts)
 
-      stdout_logger_params = @config.make_stdout_logger_params
+      *stdout_logger_params, stdout_logger_opts = @config.make_stdout_logger_params
       unless (daemon && @config.daemonize?) then
-        logger += Logger.new(*stdout_logger_params)
+        logger += Logger.new(*stdout_logger_params, **stdout_logger_opts)
       end
 
-      protocol_logger_params = @config.make_protocol_logger_params
-      protocol_logger = Logger.new(*protocol_logger_params)
+      *protocol_logger_params, protocol_logger_opts = @config.make_protocol_logger_params
+      protocol_logger = Logger.new(*protocol_logger_params, **protocol_logger_opts)
 
       logger.info('preload libraries.')
       Riser.preload
@@ -892,17 +897,17 @@ module RIMS
         file_logger_params[1..-2].each_with_index do |value, i|
           logger.info("file logging parameter: shift_args[#{i}]=#{value}")
         end
-        for name, value in file_logger_params[-1]
+        for name, value in file_logger_opts
           logger.info("file logging parameter: #{name}=#{value}")
         end
-        for name, value in stdout_logger_params[-1]
+        for name, value in stdout_logger_opts
           logger.info("stdout logging parameter: #{name}=#{value}")
         end
         logger.info("protocol logging parameter: path=#{protocol_logger_params[0]}")
         protocol_logger_params[1..-2].each_with_index do |value, i|
           logger.info("protocol logging parameter: shift_args[#{i}]=#{value}")
         end
-        for name, value in protocol_logger_params[-1]
+        for name, value in protocol_logger_opts
           logger.info("protocol logging parameter: #{name}=#{value}")
         end
         logger.info("listen address: #{server_socket.local_address.inspect_sockaddr}")

data/lib/rims/version.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 module RIMS
-  VERSION = '0.2.8'
+  VERSION = '0.2.9'
   MAILBOX_DATA_STRUCTURE_VERSION = 'mailbox.2'
 end
 

data/load_test/Rakefile

@@ -78,6 +78,8 @@ task :imap_append do
   end
 end
 
+CLOBBER.include('imap_append')
+
 desc 'run server'
 task :run_server do
   run_server_conf('imap_server', USER_CONF, *%w[ -v debug -l debug --imap-host=localhost --imap-port=14300 ]) do
@@ -85,7 +87,7 @@ task :run_server do
   end
 end
 
-CLOBBER.include('imap_append')
+CLOBBER.include('imap_server')
 
 # Local Variables:
 # mode: Ruby

data/rims.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.0.0'
 
   spec.add_runtime_dependency 'rims-rfc822', '>= 0.2.2'
-  spec.add_runtime_dependency 'riser', '>= 0.1.11'
+  spec.add_runtime_dependency 'riser', '>= 0.1.12'
   spec.add_runtime_dependency 'logger-joint'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

data/test/cmd/test_command.rb

@@ -119,6 +119,7 @@ module RIMS::Test
       '--no-daemonize'                   => [ %W[ -f #{BASE_DIR}/config.yml --no-daemonize ] ],
       '--daemon-debug'                   => [ %W[ -f #{BASE_DIR}/config.yml --daemon-debug ] ],
       '--no-daemon-debug'                => [ %W[ -f #{BASE_DIR}/config.yml --no-daemon-debug ] ],
+      '--daemon-umask'                   => [ %W[ -f #{BASE_DIR}/config.yml --daemon-umask=0022 ] ],
       '--status-file'                    => [ %W[ -f #{BASE_DIR}/config.yml --status-file=status.yml ] ],
       '--privilege-user'                 => [ %W[ -f #{BASE_DIR}/config.yml --privilege-user=#{Process::UID.eid} ] ],
       '--privilege-group'                => [ %W[ -f #{BASE_DIR}/config.yml --privilege-group=#{Process::GID.eid} ] ],

data/test/test_channel.rb

@@ -55,7 +55,8 @@ module RIMS::Test
       pub1.publish('msg1')
       pub2.publish('msg2')
 
-      error = assert_raise(RuntimeError) { pub3.publish('msg3') }
+      error = assert_raise(RIMS::ServerResponseChannelPublishError) { pub3.publish('msg3') }
+      pp error, error.optional_data if $DEBUG
       assert_match(/detached/, error.message)
 
       assert_equal(%w[ msg2 ], sub1.enum_for(:fetch).to_a)

data/test/test_error.rb

@@ -5,6 +5,18 @@ require 'test/unit'
 
 module RIMS::Test
   class TestError < Test::Unit::TestCase
+    def test_optional_data
+      error = RIMS::Error.new('test', foo: 1, bar: '2')
+      assert_equal('test', error.message)
+      assert_equal({ foo: 1, bar: '2' }, error.optional_data)
+    end
+
+    def test_no_optional_data
+      error = RIMS::Error.new('test')
+      assert_equal('test', error.message)
+      assert_predicate(error.optional_data, :empty?)
+    end
+
     def test_trace_error_chain
       exception = assert_raise(RuntimeError) {
         begin
@@ -32,6 +44,26 @@ module RIMS::Test
                      'error level 0'
                    ], errors.map(&:message))
     end
+
+    def test_optional_data_block
+      count = 0
+      error = RIMS::Error.new('test', foo: 1, bar: '2')
+      RIMS::Error.optional_data(error) do |e, data|
+        count += 1
+        assert_equal(error, e)
+        assert_equal({ foo: 1, bar: '2' }, data)
+      end
+      assert_equal(1, count)
+    end
+
+    data('not a RIMS::Error' => StandardError.new('test'),
+         'no optional data'  => RIMS::Error.new('test'))
+    def test_no_optional_data_block(data)
+      error = data
+      RIMS::Error.optional_data(error) do |e, data|
+        flunk
+      end
+    end
   end
 end
 

data/test/test_lock.rb

@@ -51,7 +51,7 @@ module RIMS::Test
       assert_equal('write-lock wait timeout', error.message)
     end
 
-    def calculate_threa_work_seconds
+    def calculate_thread_work_seconds
       t0 = Time.now
       1000.times{|i| i.succ }
       t1 = Time.now
@@ -60,10 +60,10 @@ module RIMS::Test
 
       wait_seconds
     end
-    private :calculate_threa_work_seconds
+    private :calculate_thread_work_seconds
 
     def test_read_write_lock_multithread
-      lock_wait_seconds = calculate_threa_work_seconds
+      lock_wait_seconds = calculate_thread_work_seconds
 
       count = 0
       read_thread_num = 10
@@ -116,7 +116,7 @@ module RIMS::Test
     def test_write_lock_timeout_detach
       logger = Logger.new(STDOUT)
       logger.level = ($DEBUG) ? Logger::DEBUG : Logger::FATAL
-      wait_seconds = calculate_threa_work_seconds
+      wait_seconds = calculate_thread_work_seconds
 
       t_list = []
       assert_nil(RIMS::ReadWriteLock.write_lock_timeout_detach(wait_seconds, wait_seconds * 2, logger: logger ) {|timeout_seconds|

data/test/test_protocol_decoder.rb

@@ -127,6 +127,7 @@ module RIMS::Test
         cmd_name, cmd_args, cmd_client_output = parse_imap_command(tag, imap_command_message)
         normalized_cmd_name = RIMS::Protocol::Decoder.imap_command_normalize(cmd_name)
         cmd_id = RIMS::Protocol::Decoder::IMAP_CMDs[normalized_cmd_name] or flunk("not a imap command: #{cmd_name}")
+        cmd_kw_args = {}
 
         input = nil
         output = nil
@@ -146,32 +147,29 @@ module RIMS::Test
           cmd_args = inout_args + cmd_args
         end
         unless (uid.nil?) then
-          cmd_args += [ { uid: uid } ]
+          cmd_kw_args[:uid] = uid
         end
 
         block_call = 0
         ret_val = nil
 
+        response_message = cmd_client_output.b
         pp [ :debug_imap_command, imap_command_message, cmd_id, cmd_args ] if $DEBUG
-        @decoder.__send__(cmd_id, tag, *cmd_args) {|responses|
+        @decoder.__send__(cmd_id, tag, *cmd_args, **cmd_kw_args) {|response|
           block_call += 1
-          response_message = cmd_client_output.b
-          if (output) then
+          if (block_call == 1 && output) then
             response_message << output.string
           end
-          for response in responses
-            if (response != :flush) then
-              response_message << response
-            end
+          if (response != :flush) then
+            response_message << response
           end
-          response_lines = StringIO.new(response_message, 'r').each_line
-          ret_val = yield(response_lines)
-          assert_raise(StopIteration) { response_lines.next }
         }
+        response_lines = StringIO.new(response_message, 'r').each_line
+        ret_val = yield(response_lines)
+        assert_raise(StopIteration) { response_lines.next }
         if (client_input_text) then
           pp input.string, output.string if $DEBUG
         end
-        assert_equal(1, block_call, 'IMAP command block should be called only once.')
 
         @decoder = @decoder.next_decoder
 
@@ -1966,7 +1964,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5215,7 +5213,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5242,7 +5240,7 @@ module RIMS::Test
         }
 
         assert_imap_command('EXAMINE INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-ONLY] EXAMINE completed")
         }
 
@@ -5303,7 +5301,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5349,7 +5347,7 @@ module RIMS::Test
         }
 
         assert_imap_command('EXAMINE INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-ONLY] EXAMINE completed")
         }
 
@@ -5730,7 +5728,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5754,7 +5752,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5778,7 +5776,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5806,7 +5804,7 @@ module RIMS::Test
         }
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -5839,10 +5837,8 @@ module RIMS::Test
         }
 
         another_decoder = make_decoder
-        another_writer = proc{|res|
-          for line in res
-            p line if $DEBUG
-          end
+        another_writer = proc{|response|
+          p response if $DEBUG
         }
 
         another_decoder.login('tag', 'foo', 'open_sesame', &another_writer)
@@ -6117,10 +6113,8 @@ module RIMS::Test
         }
 
         another_decoder = make_decoder
-        another_writer = proc{|res|
-          for line in res
-            p line if $DEBUG
-          end
+        another_writer = proc{|response|
+          p response if $DEBUG
         }
 
         another_decoder.login('tag', 'foo', 'open_sesame', &another_writer)
@@ -6212,7 +6206,7 @@ module RIMS::Test
         end
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -6293,7 +6287,7 @@ module RIMS::Test
         end
 
         assert_imap_command('SELECT INBOX') {|assert|
-          assert.skip_while{|line| line =~ /^\* /}
+          assert.skip_while{|line| line =~ /^\* / }
           assert.equal("#{tag} OK [READ-WRITE] SELECT completed")
         }
 
@@ -6341,7 +6335,7 @@ module RIMS::Test
 
     def test_charset_convert_options_stream
       use_imap_stream_decode_engine
-      test_charset_aliases
+      test_charset_convert_options
     end
   end
 
@@ -6365,6 +6359,93 @@ module RIMS::Test
       assert_equal(%w[ foo INBOX ], RIMS::Protocol::Decoder.decode_delivery_target_mailbox(encoded_mbox_name))
     end
   end
+
+  class ProtocolDecoderBulkResponseTest < Test::Unit::TestCase
+    def setup
+      limit_count = 10
+      limit_size = 100
+      @res = RIMS::Protocol::Decoder::BulkResponse.new(limit_count, limit_size)
+    end
+
+    data('empty' => [ 0, 0,  [] ],
+         '1'     => [ 1, 3,  %w[ foo ] ],
+         '2'     => [ 2, 6,  %w[ foo bar ] ],
+         '3'     => [ 3, 11, %w[ foo bar baaaz ] ])
+    def test_add(data)
+      expected_count, expected_size, response_list = data
+
+      assert_equal(0, @res.count)
+      assert_equal(0, @res.size)
+
+      for response in response_list
+        @res << response
+      end
+
+      assert_equal(expected_count, @res.count)
+      assert_equal(expected_size, @res.size)
+    end
+
+    def test_emtpy?
+      assert_true(@res.empty?)
+    end
+
+    def test_not_empty?
+      @res << 'foo'
+      assert_false(@res.empty?)
+    end
+
+    data('count: boundary'      => %w[ 1 2 3 4 5 6 7 8 9 0 ],
+         'count: over'          => %w[ 1 2 3 4 5 6 7 8 9 0 a ],
+         'size: boundary'       => [ 'x' * 50, 'y' * 50 ],
+         'size: over'           => [ 'x' * 50, 'y' * 50, 'z' ],
+         'count,size: boundary' => %w[ 1 2 3 4 5 6 7 8 9 0 ].map{|s| s * 10 },
+         'count,size: over'     => %w[ 1 2 3 4 5 6 7 8 9 0 ].map{|s| s * 10 } + %w[ a ])
+    def test_full?(data)
+      response_list = data
+      for response in response_list
+        @res << response
+      end
+      assert_true(@res.full?)
+    end
+
+    data('empty'           => [],
+         'under'           => %w[ foo bar baz ],
+         'count: boundary' => %w[ 1 2 3 4 5 6 7 8 9 ],
+         'size: boundary'  => [ 'x' * 50, 'y' * 49 ])
+    def test_not_full?(data)
+      response_list = data
+      for response in response_list
+        @res << response
+      end
+      assert_false(@res.full?)
+    end
+
+    def test_flush
+      @res << 'foo'
+      @res << 'bar'
+      r1 = @res.flush
+      assert_equal('foo' + 'bar', r1.join(''), 'responses may be joined.')
+      assert_true(@res.empty?)
+      assert_false(@res.full?)
+
+      @res << 'baz'
+      r2 = @res.flush
+      assert_equal('baz', r2.join(''), 'responses may be joined.')
+      assert_true(@res.empty?)
+      assert_false(@res.full?)
+
+      assert_not_equal(r1, r2)
+    end
+
+    def test_flush_joined
+      for c in ('a'..).first(10)
+        @res << c
+      end
+      assert_equal([ ('a'..).first(10).join('') ], @res.flush)
+      assert_true(@res.empty?)
+      assert_false(@res.full?)
+    end
+  end
 end
 
 # Local Variables: