rims 0.2.1 → 0.2.2

data/lib/rims/pool.rb

@@ -14,8 +14,8 @@ module RIMS
       end
 
       # optional block is called when a mail store is closed.
-      def return_pool(**name_args, &block) # yields:
-        @object_pool.put(self, **name_args, &block)
+      def return_pool(&block) # yields:
+        @object_pool.put(self, &block)
         nil
       end
     end
@@ -35,27 +35,25 @@ module RIMS
     end
 
     def initialize(&object_factory)      # yields: object_pool, object_key, object_lock
+      @mutex = Thread::Mutex.new
       @object_factory = object_factory
-      @pool_map = {}
-      @pool_lock = Mutex.new
-      @object_lock_map = Hash.new{|hash, key| hash[key] = ReadWriteLock.new }
+      @pool = {}
     end
 
     def empty?
-      @pool_map.empty?
+      @mutex.synchronize{ @pool.empty? }
     end
 
     # optional block is called when a new object is added to an object pool.
-    def get(object_key, timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS) # yields:
-      object_lock = @pool_lock.synchronize{ @object_lock_map[object_key] }
-      object_lock.write_synchronize(timeout_seconds) {
-        if (@pool_lock.synchronize{ @pool_map.key? object_key }) then
-          ref_count = @pool_lock.synchronize{ @pool_map[object_key] }
+    def get(object_key)         # yields:
+      @mutex.synchronize{
+        if (@pool.key? object_key) then
+          ref_count = @pool[object_key]
         else
           yield if block_given?
-          object_holder = @object_factory.call(self, object_key, object_lock)
+          object_holder = @object_factory.call(self, object_key)
           ref_count = ReferenceCount.new(0, object_holder)
-          @pool_lock.synchronize{ @pool_map[object_key] = ref_count }
+          @pool[object_key] = ref_count
         end
         ref_count.count >= 0 or raise 'internal error'
         ref_count.count += 1
@@ -64,15 +62,14 @@ module RIMS
     end
 
     # optional block is called when an object is deleted from an object pool.
-    def put(object_holder, timeout_seconds: ReadWriteLock::DEFAULT_TIMEOUT_SECONDS) # yields:
-      object_lock = @pool_lock.synchronize{ @object_lock_map[object_holder.object_key] }
-      object_lock.write_synchronize(timeout_seconds) {
-        ref_count = @pool_lock.synchronize{ @pool_map[object_holder.object_key] } or raise 'internal error'
+    def put(object_holder) # yields:
+      @mutex.synchronize{
+        ref_count = @pool[object_holder.object_key] or raise 'internal error'
         ref_count.object_holder.equal? object_holder or raise 'internal error'
         ref_count.count > 0 or raise 'internal error'
         ref_count.count -= 1
         if (ref_count.count == 0) then
-          @pool_lock.synchronize{ @pool_map.delete(object_holder.object_key) }
+          @pool.delete(object_holder.object_key)
           ref_count.object_destroy
           yield if block_given?
         end

data/lib/rims/protocol/decoder.rb

@@ -156,7 +156,7 @@ module RIMS
             @logger.error($!)
             res << "#{tag} BAD client command syntax error\r\n"
           rescue
-            raise if ($!.name =~ /AssertionFailedError/)
+            raise if ($!.class.name =~ /AssertionFailedError/)
             @logger.error('internal server error.')
             @logger.error($!)
             res << "#{tag} BAD internal server error\r\n"
@@ -206,7 +206,7 @@ module RIMS
           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, timeout_seconds: write_lock_timeout_seconds) {
+          mail_store_holder = mail_store_pool.get(unique_user_id) {
             logger.info("open mail store: #{unique_user_id} [ #{username} ]")
           }
 
@@ -510,7 +510,7 @@ module RIMS
           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(timeout_seconds: timeout_seconds) {
+            tmp_mail_store_holder.return_pool{
               @logger.info("close mail store: #{tmp_mail_store_holder.unique_user_id}")
             }
           }
@@ -1272,7 +1272,7 @@ module RIMS
           @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(timeout_seconds: timeout_seconds) {
+            mail_store_holder.return_pool{
               @logger.info("close cached mail store to deliver message: #{mail_store_holder.unique_user_id}")
             }
           }

data/lib/rims/protocol/parser.rb

@@ -631,9 +631,9 @@ module RIMS
         unless (search_key.empty?) then
           search_key = search_key.dup
           factory = fetch_next_node(search_key)
-          cond = factory.call(parse_cached(search_key))
+          _cond = factory.call(parse_cached(search_key))
         else
-          cond = end_of_cond
+          _cond = end_of_cond
         end
       end
       private :parse_cached

data/lib/rims/test.rb

@@ -235,6 +235,38 @@ EOF
         end
       end
 
+      def db_closed_error
+        RuntimeError
+      end
+
+      def db_closed_fetch_error
+        db_closed_error
+      end
+
+      def db_closed_store_error
+        db_closed_error
+      end
+
+      def db_closed_delete_error
+        db_closed_error
+      end
+
+      def db_closed_key_error
+        db_closed_error
+      end
+
+      def db_closed_each_key_error
+        db_closed_error
+      end
+
+      def db_closed_each_value_error
+        db_closed_error
+      end
+
+      def db_closed_each_pair_error
+        db_closed_error
+      end
+
       def setup
         @base_dir = 'kvs_test_dir'
         FileUtils.mkdir_p(@base_dir)
@@ -336,13 +368,13 @@ EOF
         assert_equal(true, db_closed?)
 
         # closed exception
-        assert_raise(RuntimeError) { @kvs['foo'] }
-        assert_raise(RuntimeError) { @kvs['foo'] = 'apple' }
-        assert_raise(RuntimeError) { @kvs.delete('foo') }
-        assert_raise(RuntimeError) { @kvs.key? 'foo' }
-        assert_raise(RuntimeError) { @kvs.each_key.to_a }
-        assert_raise(RuntimeError) { @kvs.each_value.to_a }
-        assert_raise(RuntimeError) { @kvs.each_pair.to_a }
+        assert_raise(db_closed_fetch_error) { @kvs['foo'] }
+        assert_raise(db_closed_store_error) { @kvs['foo'] = 'apple' }
+        assert_raise(db_closed_delete_error) { @kvs.delete('foo') }
+        assert_raise(db_closed_key_error) { @kvs.key? 'foo' }
+        assert_raise(db_closed_each_key_error) { @kvs.each_key.to_a }
+        assert_raise(db_closed_each_value_error) { @kvs.each_value.to_a }
+        assert_raise(db_closed_each_pair_error) { @kvs.each_pair.to_a }
       end
     end
 

data/lib/rims/version.rb

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

data/test/test_channel.rb

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+
+require 'rims'
+require 'test/unit'
+
+module RIMS::Test
+  class ServerResponseChannelTest < Test::Unit::TestCase
+    def setup
+      @channel = RIMS::ServerResponseChannel.new
+    end
+
+    def test_pub_sub_fetch_message
+      pub1, sub1 = @channel.make_pub_sub_pair(0)
+      pub2, sub2 = @channel.make_pub_sub_pair(0)
+      pub3, sub3 = @channel.make_pub_sub_pair(0)
+
+      pub1.publish('msg1')
+      assert_equal(false, sub1.message?)
+      assert_equal(true, sub2.message?)
+      assert_equal(true, sub3.message?)
+
+      pub2.publish('msg2')
+      assert_equal(true, sub1.message?)
+      assert_equal(true, sub2.message?)
+      assert_equal(true, sub3.message?)
+
+      pub3.publish('msg3')
+      assert_equal(true, sub1.message?)
+      assert_equal(true, sub2.message?)
+      assert_equal(true, sub3.message?)
+
+      assert_equal(%w[ msg2 msg3 ], sub1.enum_for(:fetch).to_a)
+      assert_equal(%w[ msg1 msg3 ], sub2.enum_for(:fetch).to_a)
+      assert_equal(%w[ msg1 msg2 ], sub3.enum_for(:fetch).to_a)
+
+      assert_equal(false, sub1.message?)
+      assert_equal(false, sub2.message?)
+      assert_equal(false, sub3.message?)
+    end
+
+    def test_pub_sub_fetch_no_message
+      _, sub = @channel.make_pub_sub_pair(0)
+      assert_equal(false, sub.message?)
+      assert_equal([], sub.enum_for(:fetch).to_a)
+    end
+
+    def test_pub_sub_detach
+      pub1, sub1 = @channel.make_pub_sub_pair(0)
+      pub2, sub2 = @channel.make_pub_sub_pair(0)
+      pub3, sub3 = @channel.make_pub_sub_pair(0)
+
+      pub3.detach
+      sub3.detach
+
+      pub1.publish('msg1')
+      pub2.publish('msg2')
+
+      error = assert_raise(RuntimeError) { pub3.publish('msg3') }
+      assert_match(/detached/, error.message)
+
+      assert_equal(%w[ msg2 ], sub1.enum_for(:fetch).to_a)
+      assert_equal(%w[ msg1 ], sub2.enum_for(:fetch).to_a)
+      assert_equal([], sub3.enum_for(:fetch).to_a)
+    end
+
+    def test_pub_sub_different_mailboxes
+      mbox0_pub1, mbox0_sub1 = @channel.make_pub_sub_pair(0)
+      mbox0_pub2, mbox0_sub2 = @channel.make_pub_sub_pair(0)
+      mbox1_pub1, mbox1_sub1 = @channel.make_pub_sub_pair(1)
+      mbox1_pub2, mbox1_sub2 = @channel.make_pub_sub_pair(1)
+
+      mbox0_pub1.publish('mbox0:msg1')
+      mbox0_pub2.publish('mbox0:msg2')
+
+      assert_equal(%w[ mbox0:msg2 ], mbox0_sub1.enum_for(:fetch).to_a)
+      assert_equal(%w[ mbox0:msg1 ], mbox0_sub2.enum_for(:fetch).to_a)
+      assert_equal([], mbox1_sub1.enum_for(:fetch).to_a)
+      assert_equal([], mbox1_sub2.enum_for(:fetch).to_a)
+
+      mbox1_pub1.publish('mbox1:msg1')
+      mbox1_pub2.publish('mbox1:msg2')
+
+      assert_equal([], mbox0_sub1.enum_for(:fetch).to_a)
+      assert_equal([], mbox0_sub2.enum_for(:fetch).to_a)
+      assert_equal(%w[ mbox1:msg2 ], mbox1_sub1.enum_for(:fetch).to_a)
+      assert_equal(%w[ mbox1:msg1 ], mbox1_sub2.enum_for(:fetch).to_a)
+    end
+
+    def test_pub_sub_idle
+      pub, _ = @channel.make_pub_sub_pair(0)
+      _, sub = @channel.make_pub_sub_pair(0)
+
+      pub.publish('msg1')
+      sub.idle_interrupt
+      assert_equal([ %w[ msg1 ] ], sub.enum_for(:idle_wait).to_a)
+
+      pub.publish('msg2')
+      pub.publish('msg3')
+      sub.idle_interrupt
+      assert_equal([ %w[ msg2 msg3 ] ], sub.enum_for(:idle_wait).to_a)
+    end
+
+    def test_pub_sub_idle_chunks
+      pub, _ = @channel.make_pub_sub_pair(0)
+      _, sub = @channel.make_pub_sub_pair(0)
+
+      t = Thread.new{ sub.enum_for(:idle_wait).to_a }
+
+      pub.publish('msg1')
+      t.wakeup
+      sleep(0.1)
+
+      pub.publish('msg2')
+      pub.publish('msg3')
+      sub.idle_interrupt
+
+      assert_equal([ %w[ msg1 ], %w[ msg2 msg3 ] ], t.value)
+    end
+
+    def test_pub_sub_idle_no_message
+      _, sub = @channel.make_pub_sub_pair(0)
+      sub.idle_interrupt
+      assert_equal([], sub.enum_for(:idle_wait).to_a)
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_cksum_kvs.rb

@@ -107,10 +107,12 @@ module RIMS::Test
 
       s = @db['foo']
       @db['foo'] = s.chop
-      assert_raise(RuntimeError) { @kvs['foo'] }
+      error = assert_raise(RuntimeError) { @kvs['foo'] }
+      assert_match(/checksum error/, error.message)
 
       @db['foo'] = 'Hello world.'
-      assert_raise(RuntimeError) { @kvs['foo'] }
+      error = assert_raise(RuntimeError) { @kvs['foo'] }
+      assert_match(/checksum format error/, error.message)
     end
   end
 end

data/test/test_config.rb

@@ -108,7 +108,7 @@ module RIMS::Test
         begin
           assert_config(load_libraries: %w[ prime ]) {|conf|
             conf.setup_load_libraries
-            assert($LOADED_FEATURES.any?{|name| name =~ /prime/})          
+            assert($LOADED_FEATURES.any?{|name| name =~ /prime/})
           }
         rescue
           exit!(1)

data/test/test_db.rb

@@ -448,7 +448,8 @@ module RIMS::Test
       assert_equal(false, (@db.msg_exist? 1))
       assert_equal(true, (@db.msg_exist? 2))
 
-      assert_raise(RuntimeError) { @db.del_msg(1) }
+      error = assert_raise(RuntimeError) { @db.del_msg(1) }
+      assert_match(/not found a message text/, error.message)
     end
   end
 
@@ -531,8 +532,10 @@ module RIMS::Test
         assert_equal(deleted, @db.msg_flag_deleted(uid))
       end
 
-      assert_raise(RuntimeError) { @db.expunge_msg(1) }
-      assert_raise(RuntimeError) { @db.expunge_msg(2) }
+      error = assert_raise(RuntimeError) { @db.expunge_msg(1) }
+      assert_match(/not found a message uid/, error.message)
+      error = assert_raise(RuntimeError) { @db.expunge_msg(2) }
+      assert_match(/not deleted flag/, error.message)
     end
   end
 
@@ -572,12 +575,13 @@ module RIMS::Test
       @cksum_kvs['baz'] = 'orange'
 
       count = 0
-      assert_raise(RuntimeError) {
+      error = assert_raise(RuntimeError) {
         @db.test_read_all{|read_error|
           assert_kind_of(RuntimeError, read_error)
           count += 1
         }
       }
+      assert_match(/checksum format error/, error.message)
       assert_equal(1, count)
 
       @cksum_kvs['foo'] = 'apple'; @kvs['foo'] = 'apple'
@@ -585,12 +589,13 @@ module RIMS::Test
       @cksum_kvs['baz'] = 'orange'; @kvs['baz'] = 'orange'
 
       count = 0
-      assert_raise(RuntimeError) {
+      error = assert_raise(RuntimeError) {
         @db.test_read_all{|read_error|
           assert_kind_of(RuntimeError, read_error)
           count += 1
         }
       }
+      assert_match(/checksum format error/, error.message)
       assert_equal(2, count)
     end
   end

data/test/test_db_recovery.rb

@@ -73,7 +73,8 @@ module RIMS::Test
 
       @kvs['meta'].delete('msg_id2date-1')
       assert_instance_of(Time, @meta_db.msg_date(0))
-      assert_raise(RuntimeError) { @meta_db.msg_date(1) }
+      error = assert_raise(RuntimeError) { @meta_db.msg_date(1) }
+      assert_match(/not found a message date/, error.message)
       assert_instance_of(Time, @meta_db.msg_date(2))
 
       @meta_db.recovery_phase1_msg_scan(@msg_db, logger: @logger)
@@ -635,7 +636,8 @@ module RIMS::Test
 
       # recovery phase 2
       assert_equal({}, @meta_db.msg_mbox_uid_mapping(3))
-      assert_raise(RuntimeError) { @meta_db.msg_date(3) }
+      error = assert_raise(RuntimeError) { @meta_db.msg_date(3) }
+      assert_match(/not found a message date/, error.message)
 
       # recovery phase 3
       assert_equal(5, @meta_db.uidvalidity)
@@ -672,7 +674,8 @@ module RIMS::Test
       # recovery phase 1,8
       @msg_db.add_msg(3, 'apple')
       assert_equal({}, @meta_db.msg_mbox_uid_mapping(3))
-      assert_raise(RuntimeError) { @meta_db.msg_date(3) }
+      error = assert_raise(RuntimeError) { @meta_db.msg_date(3) }
+      assert_match(/not found a message date/, error.message)
 
       # recovery phase 2,5,8
       mbox_uid_map = Marshal.load(@kvs['meta']['msg_id2mbox-0'])

data/test/test_lock.rb

@@ -34,19 +34,21 @@ module RIMS::Test
     end
 
     def test_read_lock_timeout
-      assert_raise(RIMS::ReadLockTimeoutError) {
+      error = assert_raise(RIMS::ReadLockTimeoutError) {
         @lock.write_synchronize{
           @lock.read_synchronize(0) {}
         }
       }
+      assert_equal('read-lock wait timeout', error.message)
     end
 
     def test_write_lock_timeout
-      assert_raise(RIMS::WriteLockTimeoutError) {
+      error = assert_raise(RIMS::WriteLockTimeoutError) {
         @lock.write_synchronize{
           @lock.write_synchronize(0) {}
         }
       }
+      assert_equal('write-lock wait timeout', error.message)
     end
 
     def calculate_threa_work_seconds