Refactor Factory::Pool

Author: byroot

ChangeLog

@@ -1,3 +1,4 @@
+* Implement `Factory::Pool#unpacker` and `Factory::Pool#packer` to allow for more precise serialization.
 * Require Ruby 2.5+.
 
 2023-03-03 1.6.1:

doclib/msgpack/factory.rb

@@ -124,8 +124,6 @@ class Pool
       # @param data [String]
       # @return [Object] deserialized object
       #
-      # See Unpacker#initialize for supported options.
-      #
       def load(data)
       end
 
@@ -140,6 +138,28 @@ def load(data)
       #
       def dump(object)
       end
+
+      #
+      # Yields an Unpacker from the pool, and check it back in.
+      #
+      # The unpacker should no longer be held after the block has returned.
+      #
+      # @yieldparam unpacker [MessagePack::Unpacker]
+      # @returns [Object] the block return value
+      #
+      def unpacker(&block)
+      end
+
+      #
+      # Yields a Packer from the pool, and check it back in.
+      #
+      # The packer should no longer be held after the block has returned.
+      #
+      # @yieldparam packer [MessagePack::Packer]
+      # @returns [Object] the block return value
+      #
+      def packer(&block)
+      end
     end
   end
 end

ext/msgpack/unpacker_class.c

@@ -450,7 +450,7 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Unpacker, "read_array_header", Unpacker_read_array_header, 0);
     rb_define_method(cMessagePack_Unpacker, "read_map_header", Unpacker_read_map_header, 0);
     rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed_reference, 1);
-    rb_define_method(cMessagePack_Unpacker, "feed_reference", Unpacker_feed_reference, 1);
+    rb_define_alias(cMessagePack_Unpacker, "feed_reference", "feed");
     rb_define_method(cMessagePack_Unpacker, "each", Unpacker_each, 0);
     rb_define_method(cMessagePack_Unpacker, "feed_each", Unpacker_feed_each, 1);
     rb_define_method(cMessagePack_Unpacker, "reset", Unpacker_reset, 0);

lib/msgpack/factory.rb

@@ -95,21 +95,22 @@ def initialize(size, &block)
             @members = []
           end
 
-          def checkout
-            @members.pop || @new_member.call
-          end
-
-          def checkin(member)
-            # If the pool is already full, we simply drop the extra member.
-            # This is because contrary to a connection pool, creating an extra instance
-            # is extremely unlikely to cause some kind of resource exhaustion.
-            #
-            # We could cycle the members (keep the newer one) but first It's more work and second
-            # the older member might have been created pre-fork, so it might be at least partially
-            # in shared memory.
-            if member && @members.size < @size
-              member.reset
-              @members << member
+          def with
+            member = @members.pop || @new_member.call
+            begin
+              yield member
+            ensure
+              # If the pool is already full, we simply drop the extra member.
+              # This is because contrary to a connection pool, creating an extra instance
+              # is extremely unlikely to cause some kind of resource exhaustion.
+              #
+              # We could cycle the members (keep the newer one) but first It's more work and second
+              # the older member might have been created pre-fork, so it might be at least partially
+              # in shared memory.
+              if member && @members.size < @size
+                member.reset
+                @members << member
+              end
             end
           end
         end
@@ -122,15 +123,16 @@ def initialize(size, &block)
             @mutex = Mutex.new
           end
 
-          def checkout
-            @mutex.synchronize { @members.pop } || @new_member.call
-          end
-
-          def checkin(member)
-            member.reset
-            @mutex.synchronize do
-              if member && @members.size < @size
-                @members << member
+          def with
+            member = @mutex.synchronize { @members.pop } || @new_member.call
+            begin
+              yield member
+            ensure
+              member.reset
+              @mutex.synchronize do
+                if member && @members.size < @size
+                  @members << member
+                end
               end
             end
           end
@@ -145,41 +147,25 @@ def initialize(factory, size, options = nil)
       end
 
       def load(data)
-        unpacker = @unpackers.checkout
-        begin
-          unpacker.feed_reference(data)
+        @unpackers.with do |unpacker|
+          unpacker.feed(data)
           unpacker.full_unpack
-        ensure
-          @unpackers.checkin(unpacker)
         end
       end
 
       def dump(object)
-        packer = @packers.checkout
-        begin
+        @packers.with do |packer|
           packer.write(object)
           packer.full_pack
-        ensure
-          @packers.checkin(packer)
         end
       end
 
-      def unpacker
-        unpacker = @unpackers.checkout
-        begin
-          yield unpacker
-        ensure
-          @unpackers.checkin(unpacker)
-        end
+      def unpacker(&block)
+        @unpackers.with(&block)
       end
 
-      def packer
-        packer = @packers.checkout
-        begin
-          yield packer
-        ensure
-          @packers.checkin(packer)
-        end
+      def packer(&block)
+        @packers.with(&block)
       end
     end
   end