ractor-wrapper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba8fea27b45cfb0ee50c95d09c19c43e3aa185db4871e1e5f892551de35c33eb
+  data.tar.gz: ae2558e2e07b3bc74c2409c10f91a997b391709c8d1ee10157327684f4528bc5
+SHA512:
+  metadata.gz: 0e76769526ea1db2f95819275b87252a29c188aaad1a1caf5d610d84b9e1cbe18344f4266c96e2274a2ff972c6faf910393be811dfa3496c0a715aeda415f7d4
+  data.tar.gz: ac39e5fc611ad01bedfaf2f4c065108d9d487dfd040a21ed26845d1d92968cd137aed98c96cb5a7e45ec3485e6da03d5338685521799edf221f0f836557495e5

data/.yardopts

@@ -0,0 +1,10 @@
+--no-private
+--title=Ractor::Wrapper
+--markup=markdown
+--markup-provider redcarpet
+--main=README.md
+./lib/ractor/wrapper.rb
+-
+README.md
+LICENSE.md
+CHANGELOG.md

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Release History
+
+### v0.1.0 / 2021-03-02
+
+* Initial release. HIGHLY EXPERIMENTAL.

data/LICENSE.md

@@ -0,0 +1,21 @@
+# License
+
+Copyright 2021 Daniel Azuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+# Ractor::Wrapper
+
+`Ractor::Wrapper` is an experimental class that wraps a non-shareable object,
+allowing multiple Ractors to access it concurrently. This can make it possible
+for multiple ractors to share an object such as a database connection.
+
+## Quick start
+
+Install ractor-wrapper as a gem, or include it in your bundle.
+
+    gem install ractor-wrapper
+
+Require it in your code:
+
+    require "ractor/wrapper"
+
+You can then create wrappers for objects. See the example below.
+
+Ractor::Wrapper requires Ruby 3.0.0 or later.
+
+WARNING: This is a highly experimental library, and not currently intended for
+production use. (As of Ruby 3.0.0, the same can be said of Ractors in general.)
+
+## About Ractor::Wrapper
+
+Ractors for the most part cannot access objects concurrently with other
+Ractors unless the object is _shareable_ (that is, deeply immutable along
+with a few other restrictions.) If multiple Ractors need to access a shared
+resource that is stateful or otherwise not Ractor-shareable, that resource
+must itself be a Ractor.
+
+`Ractor::Wrapper` makes it possible for such a shared resource to be
+implemented as an ordinary object and accessed using ordinary method calls. It
+does this by "wrapping" the object in a Ractor, and mapping method calls to
+message passing. This may make it easier to implement such a resource with
+a simple class rather than a full-blown Ractor with message passing, and it
+may also useful for adapting existing legacy object-based implementations.
+
+Given a shared resource object, `Ractor::Wrapper` starts a new Ractor and
+"runs" the object within that Ractor. It provides you with a stub object
+on which you can invoke methods. The wrapper responds to these method calls
+by sending messages to the internal Ractor, which invokes the shared object
+and then sends back the result. If the underlying object is thread-safe,
+you can configure the wrapper to run multiple threads that can run methods
+concurrently. Or, if not, the wrapper can serialize requests to the object.
+
+### Example usage
+
+The following example shows how to share a single `Faraday::Conection`
+object among multiple Ractors. Because `Faraday::Connection` is not itself
+thread-safe, this example serializes all calls to it.
+
+    require "faraday"
+    require "ractor/wrapper"
+
+    # Create a Faraday connection and a wrapper for it.
+    connection = Faraday.new "http://example.com"
+    wrapper = Ractor::Wrapper.new(connection)
+
+    # At this point, the connection ojbect cannot be accessed directly
+    # because it has been "moved" to the wrapper's internal Ractor.
+    #     connection.get("/whoops")  # <= raises an error
+
+    # However, any number of Ractors can now access it through the wrapper.
+    # By default, access to the object is serialized; methods will not be
+    # invoked concurrently. (To allow concurrent access, set up threads when
+    # creating the wrapper.)
+    r1 = Ractor.new(wrapper) do |w|
+      10.times do
+        w.stub.get("/hello")
+      end
+      :ok
+    end
+    r2 = Ractor.new(wrapper) do |w|
+      10.times do
+        w.stub.get("/ruby")
+      end
+      :ok
+    end
+
+    # Wait for the two above Ractors to finish.
+    r1.take
+    r2.take
+
+    # After you stop the wrapper, you can retrieve the underlying
+    # connection object and access it directly again.
+    wrapper.async_stop
+    connection = wrapper.recover_object
+    connection.get("/finally")
+
+### Features
+
+*   Provides a method interface to an object running in a different Ractor.
+*   Supports arbitrary method arguments and return values.
+*   Supports exceptions thrown by the method.
+*   Can serialize method calls for non-concurrency-safe objects, or run
+    methods concurrently in multiple worker threads for thread-safe objects.
+*   Can gracefully shut down the wrapper and retrieve the original object.
+
+### Caveats
+
+Ractor::Wrapper is subject to some limitations (and bugs) of Ractors, as of
+Ruby 3.0.0.
+
+*   You cannot pass blocks to wrapped methods.
+*   Certain types cannot be used as method arguments or return values
+    because Ractor does not allow them to be moved between Ractors. These
+    include threads, procs, backtraces, and a few others.
+*   You can call wrapper methods from multiple Ractors concurrently, but
+    you cannot call them from multiple Threads within a single Ractor.
+    (This is due to https://bugs.ruby-lang.org/issues/17624)
+*   If you close the incoming port on a Ractor, it will no longer be able
+    to call out via a wrapper. If you close its incoming port while a call
+    is currently pending, that call may hang. (This is due to
+    https://bugs.ruby-lang.org/issues/17617)
+
+## Contributing
+
+Development is done in GitHub at https://github.com/dazuma/ractor-wrapper.
+
+*   To file issues: https://github.com/dazuma/ractor-wrapper/issues.
+*   For questions and discussion, please do not file an issue. Instead, use the
+    discussions feature: https://github.com/dazuma/ractor-wrapper/discussions.
+*   Pull requests are welcome, but the library is highly experimental at this
+    stage, and I recommend discussing features or design changes first before
+    implementing.
+
+The library uses [toys](https://dazuma.github.io/toys) for testing and CI. To
+run the test suite, `gem install toys` and then run `toys ci`. You can also run
+unit tests, rubocop, and builds independently.    
+
+## License
+
+Copyright 2021 Daniel Azuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/lib/ractor-wrapper.rb

@@ -0,0 +1 @@
+require "ractor/wrapper"

data/lib/ractor/wrapper.rb

@@ -0,0 +1,443 @@
+##
+# See ruby-doc.org for info on Ractors.
+#
+class Ractor
+  ##
+  # An experimental class that wraps a non-shareable object, allowing multiple
+  # Ractors to access it concurrently.
+  #
+  # ## What is Ractor::Wrapper?
+  #
+  # Ractors for the most part cannot access objects concurrently with other
+  # Ractors unless the object is _shareable_ (that is, deeply immutable along
+  # with a few other restrictions.) If multiple Ractors need to access a shared
+  # resource that is stateful or otherwise not Ractor-shareable, that resource
+  # must itself be implemented and accessed as a Ractor.
+  #
+  # `Ractor::Wrapper` makes it possible for such a shared resource to be
+  # implemented as an object and accessed using ordinary method calls. It does
+  # this by "wrapping" the object in a Ractor, and mapping method calls to
+  # message passing. This may make it easier to implement such a resource with
+  # a simple class rather than a full-blown Ractor with message passing, and it
+  # may also useful for adapting existing legacy object-based implementations.
+  #
+  # Given a shared resource object, `Ractor::Wrapper` starts a new Ractor and
+  # "runs" the object within that Ractor. It provides you with a stub object
+  # on which you can invoke methods. The wrapper responds to these method calls
+  # by sending messages to the internal Ractor, which invokes the shared object
+  # and then sends back the result. If the underlying object is thread-safe,
+  # you can configure the wrapper to run multiple threads that can run methods
+  # concurrently. Or, if not, the wrapper can serialize requests to the object.
+  #
+  # ## Example usage
+  #
+  # The following example shows how to share a single `Faraday::Conection`
+  # object among multiple Ractors. Because `Faraday::Connection` is not itself
+  # thread-safe, this example serializes all calls to it.
+  #
+  #     require "faraday"
+  #
+  #     # Create a Faraday connection and a wrapper for it.
+  #     connection = Faraday.new "http://example.com"
+  #     wrapper = Ractor::Wrapper.new(connection)
+  #
+  #     # At this point, the connection ojbect cannot be accessed directly
+  #     # because it has been "moved" to the wrapper's internal Ractor.
+  #     #     connection.get("/whoops")  # <= raises an error
+  #
+  #     # However, any number of Ractors can now access it through the wrapper.
+  #     # By default, access to the object is serialized; methods will not be
+  #     # invoked concurrently.
+  #     r1 = Ractor.new(wrapper) do |w|
+  #       10.times do
+  #         w.stub.get("/hello")
+  #       end
+  #       :ok
+  #     end
+  #     r2 = Ractor.new(wrapper) do |w|
+  #       10.times do
+  #         w.stub.get("/ruby")
+  #       end
+  #       :ok
+  #     end
+  #
+  #     # Wait for the two above Ractors to finish.
+  #     r1.take
+  #     r2.take
+  #
+  #     # After you stop the wrapper, you can retrieve the underlying
+  #     # connection object and access it directly again.
+  #     wrapper.async_stop
+  #     connection = wrapper.recover_object
+  #     connection.get("/finally")
+  #
+  # ## Features
+  #
+  # *   Provides a method interface to an object running in a different Ractor.
+  # *   Supports arbitrary method arguments and return values.
+  # *   Supports exceptions thrown by the method.
+  # *   Can serialize method calls for non-concurrency-safe objects, or run
+  #     methods concurrently in multiple worker threads for thread-safe objects.
+  # *   Can gracefully shut down the wrapper and retrieve the original object.
+  #
+  # ## Caveats
+  #
+  # Ractor::Wrapper is subject to some limitations (and bugs) of Ractors, as of
+  # Ruby 3.0.0.
+  #
+  # *   You cannot pass blocks to wrapped methods.
+  # *   Certain types cannot be used as method arguments or return values
+  #     because Ractor does not allow them to be moved between Ractors. These
+  #     include threads, procs, backtraces, and a few others.
+  # *   You can call wrapper methods from multiple Ractors concurrently, but
+  #     you cannot call them from multiple Threads within a single Ractor.
+  #     (This is due to https://bugs.ruby-lang.org/issues/17624)
+  # *   If you close the incoming port on a Ractor, it will no longer be able
+  #     to call out via a wrapper. If you close its incoming port while a call
+  #     is currently pending, that call may hang. (This is due to
+  #     https://bugs.ruby-lang.org/issues/17617)
+  #
+  class Wrapper
+    ##
+    # Create a wrapper around the given object.
+    #
+    # If you pass an optional block, the wrapper itself will be yielded to it
+    # at which time you can set additional configuration options. (The
+    # configuration is frozen once the object is constructed.)
+    #
+    # @param object [Object] The non-shareable object to wrap.
+    # @param threads [Integer,nil] The number of worker threads to run.
+    #     Defaults to `nil`, which causes the worker to serialize calls.
+    #
+    def initialize(object, threads: nil, logging: false, name: nil)
+      self.threads = threads
+      self.logging = logging
+      self.name = name
+      yield self if block_given?
+
+      maybe_log("Starting server")
+      @ractor = ::Ractor.new(name: name) { Server.new.run }
+      opts = {name: @name, threads: @threads, logging: @logging}
+      @ractor.send([object, opts], move: true)
+
+      maybe_log("Server ready")
+      @stub = Stub.new(self)
+      freeze
+    end
+
+    ##
+    # Set the number of threads to run in the wrapper. If the underlying object
+    # is thread-safe, this allows concurrent calls to it. If the underlying
+    # object is not thread-safe, you should leave this set to `nil`, which will
+    # cause calls to be serialized. Setting the thread count to 1 is
+    # effectively the same as no threading.
+    #
+    # This method can be called only during an initialization block.
+    #
+    # @param value [Integer,nil]
+    #
+    def threads=(value)
+      if value
+        value = value.to_i
+        value = 1 if value < 1
+        @threads = value
+      else
+        @threads = nil
+      end
+    end
+
+    ##
+    # Enable or disable internal debug logging.
+    #
+    # This method can be called only during an initialization block.
+    #
+    # @param value [Boolean]
+    #
+    def logging=(value)
+      @logging = value ? true : false
+    end
+
+    ##
+    # Set the name of this wrapper, shown in logging.
+    #
+    # This method can be called only during an initialization block.
+    #
+    # @param value [String, nil]
+    #
+    def name=(value)
+      @name = value ? value.to_s.freeze : nil
+    end
+
+    ##
+    # Return the wrapper stub. This is an object that responds to the same
+    # methods as the wrapped object, providing an easy way to call a wrapper.
+    #
+    # @return [Ractor::Wrapper::Stub]
+    #
+    attr_reader :stub
+
+    ##
+    # Return the number of threads used by the wrapper, or `nil` for no
+    # no threading.
+    #
+    # @return [Integer, nil]
+    #
+    attr_reader :threads
+
+    ##
+    # Return whether logging is enabled for this wrapper
+    #
+    # @return [Boolean]
+    #
+    attr_reader :logging
+
+    ##
+    # Return the name of this wrapper.
+    #
+    # @return [String, nil]
+    #
+    attr_reader :name
+
+    ##
+    # A lower-level interface for calling the wrapper.
+    #
+    # @param method_name [Symbol] The name of the method to call
+    # @param args [arguments] The positional arguments
+    # @param kwargs [keywords] The keyword arguments
+    # @return [Object] The return value
+    #
+    def call(method_name, *args, **kwargs)
+      request = Message.new(:call, data: [method_name, args, kwargs])
+      transaction = request.transaction
+      maybe_log("Sending method #{method_name} (transaction=#{transaction})")
+      @ractor.send(request, move: true)
+      reply = ::Ractor.receive_if { |msg| msg.is_a?(Message) && msg.transaction == transaction }
+      case reply.type
+      when :result
+        maybe_log("Received result for method #{method_name} (transaction=#{transaction})")
+        reply.data
+      when :error
+        maybe_log("Received exception for method #{method_name} (transaction=#{transaction})")
+        raise reply.data
+      end
+    end
+
+    ##
+    # Request that the wrapper stop. All currently running calls will complete
+    # before the wrapper actually terminates. However, any new calls will fail.
+    #
+    # This metnod is idempotent and can be called multiple times (even from
+    # different ractors).
+    #
+    # @return [self]
+    #
+    def async_stop
+      maybe_log("Stopping #{name}")
+      @ractor.send(Message.new(:stop))
+      self
+    rescue ::Ractor::ClosedError
+      # Ignore to allow stops to be idempotent.
+      self
+    end
+
+    ##
+    # Return the original object that was wrapped. The object is returned after
+    # the wrapper finishes stopping. Only one ractor may call this method; any
+    # additional calls will fail.
+    #
+    # @return [Object] The original wrapped object
+    #
+    def recovered_object
+      @ractor.take
+    end
+
+    private
+
+    def maybe_log(str)
+      return unless logging
+      time = ::Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%L")
+      $stderr.puts("[#{time} Ractor::Wrapper/#{name}]: #{str}")
+      $stderr.flush
+    end
+
+    ##
+    # A stub that forwards calls to a wrapper.
+    #
+    class Stub
+      ##
+      # Create a stub given a wrapper.
+      #
+      # @param wrapper [Ractor::Wrapper]
+      #
+      def initialize(wrapper)
+        @wrapper = wrapper
+        freeze
+      end
+
+      ##
+      # Forward calls to {Ractor::Wrapper#call}.
+      #
+      def method_missing(name, *args, **kwargs)
+        @wrapper.call(name, *args, **kwargs)
+      end
+
+      # @private
+      def respond_to_missing?(name, include_all)
+        @wrapper.respond_to?(name, include_all)
+      end
+    end
+
+    # @private
+    class Message
+      def initialize(type, data: nil, transaction: nil)
+        @sender = ::Ractor.current
+        @type = type
+        @data = data
+        @transaction = transaction || new_transaction
+        freeze
+      end
+
+      attr_reader :type
+      attr_reader :sender
+      attr_reader :transaction
+      attr_reader :data
+
+      private
+
+      def new_transaction
+        ::Random.rand(7958661109946400884391936).to_s(36).freeze
+      end
+    end
+
+    # @private
+    class Server
+      def run
+        @object, opts = ::Ractor.receive
+        @logging = opts[:logging]
+        @name = opts[:name]
+        maybe_log("Server started")
+
+        queue = start_threads(opts[:threads])
+        running_phase(queue)
+        stopping_phase if queue
+        cleanup_phase
+
+        @object
+      rescue ::StandardError => e
+        maybe_log("Unexpected error: #{e.inspect}")
+        @object
+      end
+
+      private
+
+      def start_threads(thread_count)
+        return nil unless thread_count
+        queue = ::Queue.new
+        maybe_log("Spawning #{thread_count} threads")
+        threads = (1..thread_count).map do |worker_num|
+          ::Thread.new { worker_thread(worker_num, queue) }
+        end
+        ::Thread.new { monitor_thread(threads) }
+        queue
+      end
+
+      def worker_thread(worker_num, queue)
+        maybe_worker_log(worker_num, "Starting")
+        loop do
+          maybe_worker_log(worker_num, "Waiting for job")
+          request = queue.deq
+          if request.nil?
+            break
+          end
+          handle_method(worker_num, request)
+        end
+        maybe_worker_log(worker_num, "Stopping")
+      end
+
+      def monitor_thread(workers)
+        workers.each(&:join)
+        maybe_log("All workers finished")
+        ::Ractor.current.send(Message.new(:threads_stopped))
+      end
+
+      def running_phase(queue)
+        loop do
+          maybe_log("Waiting for message")
+          request = ::Ractor.receive_if { |msg| msg.is_a?(Message) }
+          case request.type
+          when :call
+            if queue
+              queue.enq(request)
+              maybe_log("Queued method #{request.data.first} (transaction=#{request.transaction})")
+            else
+              handle_method(0, request)
+            end
+          when :stop
+            maybe_log("Received stop")
+            queue&.close
+            break
+          end
+        end
+      end
+
+      def stopping_phase
+        loop do
+          maybe_log("Waiting for message")
+          message = ::Ractor.receive_if { |msg| msg.is_a?(Message) }
+          case message.type
+          when :call
+            refuse_method(message)
+          when :threads_stopped
+            break
+          end
+        end
+      end
+
+      def cleanup_phase
+        ::Ractor.current.close_incoming
+        loop do
+          maybe_log("Checking queue for cleanup")
+          message = ::Ractor.receive
+          refuse_method(message) if message.is_a?(Message) && message.type == :call
+        end
+      rescue ::Ractor::ClosedError
+        maybe_log("Queue is empty")
+      end
+
+      def handle_method(worker_num, request)
+        method_name, args, kwargs = request.data
+        transaction = request.transaction
+        sender = request.sender
+        maybe_worker_log(worker_num, "Running method #{method_name} (transaction=#{transaction})")
+        begin
+          result = @object.send(method_name, *args, **kwargs)
+          maybe_worker_log(worker_num, "Sending result (transaction=#{transaction})")
+          sender.send(Message.new(:result, data: result, transaction: transaction), move: true)
+        rescue ::Exception => e # rubocop:disable Lint/RescueException
+          maybe_worker_log(worker_num, "Sending exception (transaction=#{transaction})")
+          sender.send(Message.new(:error, data: e, transaction: transaction))
+        end
+      end
+
+      def refuse_method(request)
+        maybe_log("Refusing method call (transaction=#{message.transaction})")
+        error = ::Ractor::ClosedError.new
+        request.sender.send(Message.new(:error, data: error, transaction: message.transaction))
+      end
+
+      def maybe_log(str)
+        return unless @logging
+        time = ::Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%L")
+        $stderr.puts("[#{time} Ractor::Wrapper/#{@name} Server]: #{str}")
+        $stderr.flush
+      end
+
+      def maybe_worker_log(worker_num, str)
+        return unless @logging
+        time = ::Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%L")
+        $stderr.puts("[#{time} Ractor::Wrapper/#{@name} Worker/#{worker_num}]: #{str}")
+        $stderr.flush
+      end
+    end
+  end
+end

data/lib/ractor/wrapper/version.rb

@@ -0,0 +1,10 @@
+class Ractor
+  class Wrapper
+    ##
+    # The version of the ractor-wrapper gem
+    #
+    # @return [String]
+    #
+    VERSION = "0.1.0".freeze
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: ractor-wrapper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Azuma
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-03-02 00:00:00.000000000 Z
+dependencies: []
+description: An experimental class that wraps a non-shareable object, allowing multiple
+  Ractors to access it concurrently.
+email:
+- dazuma@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- lib/ractor-wrapper.rb
+- lib/ractor/wrapper.rb
+- lib/ractor/wrapper/version.rb
+homepage: https://github.com/dazuma/ractor-wrapper
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: A Ractor wrapper for a non-shareable object.
+test_files: []