ractor-wrapper 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba8fea27b45cfb0ee50c95d09c19c43e3aa185db4871e1e5f892551de35c33eb
-  data.tar.gz: ae2558e2e07b3bc74c2409c10f91a997b391709c8d1ee10157327684f4528bc5
+  metadata.gz: 9fec3af2b1b8b9c105260fe2fca50d69e48de205dd2dd791592317ee41286af3
+  data.tar.gz: e7b4487502427ec05f3dc530925e9efecd8d599e75f4dc2b82c7371592986f59
 SHA512:
-  metadata.gz: 0e76769526ea1db2f95819275b87252a29c188aaad1a1caf5d610d84b9e1cbe18344f4266c96e2274a2ff972c6faf910393be811dfa3496c0a715aeda415f7d4
-  data.tar.gz: ac39e5fc611ad01bedfaf2f4c065108d9d487dfd040a21ed26845d1d92968cd137aed98c96cb5a7e45ec3485e6da03d5338685521799edf221f0f836557495e5
+  metadata.gz: 0ab154c16e2ed53f65a042bf18b85448cb0115e6b1616db5cce96084767ae1f00c23392ba48560177f34c43d757b59e282c05891702af927f40f72fe989b33e1
+  data.tar.gz: 8e16f5694e46c571deac8d66f56bb23467572bad838038d941955f2edaca76537ef741df79b63da0bc28c31708a31ac3ba699e3a2a661b56552dc6b1050625a0

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Release History
 
+### v0.2.0 / 2021-03-08
+
+* BREAKING CHANGE: The wrapper now copies (instead of moves) arguments and return values by default.
+* It is now possible to control, per method, whether arguments and return values are copied or moved.
+* Fixed: The respond_to? method did not work correctly for stubs.
+* Improved: The wrapper server lifecycle is a bit more robust against worker crashes.
+
 ### v0.1.0 / 2021-03-02
 
 * Initial release. HIGHLY EXPERIMENTAL.

data/README.md

@@ -16,18 +16,19 @@ Require it in your code:
 
 You can then create wrappers for objects. See the example below.
 
-Ractor::Wrapper requires Ruby 3.0.0 or later.
+`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.)
+WARNING: This is a highly experimental library, and currently _not_ recommended
+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.
+with a few other restrictions.) If multiple Ractors need to interact with 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 ordinary object and accessed using ordinary method calls. It
@@ -50,49 +51,53 @@ 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")
+```ruby
+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 object 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 be configured to copy or move arguments, return values, and
+    exceptions, per 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.
@@ -127,7 +132,7 @@ Development is done in GitHub at https://github.com/dazuma/ractor-wrapper.
 
 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.    
+unit tests, rubocop, and builds independently.
 
 ## License
 

data/lib/ractor/wrapper.rb

@@ -6,13 +6,17 @@ class Ractor
   # An experimental class that wraps a non-shareable object, allowing multiple
   # Ractors to access it concurrently.
   #
+  # WARNING: This is a highly experimental library, and currently _not_
+  # recommended for production use. (As of Ruby 3.0.0, the same can be said of
+  # Ractors in general.)
+  #
   # ## 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.
+  # with a few other restrictions.) If multiple Ractors need to interact with 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
@@ -41,7 +45,7 @@ class Ractor
   #     connection = Faraday.new "http://example.com"
   #     wrapper = Ractor::Wrapper.new(connection)
   #
-  #     # At this point, the connection ojbect cannot be accessed directly
+  #     # At this point, the connection object cannot be accessed directly
   #     # because it has been "moved" to the wrapper's internal Ractor.
   #     #     connection.get("/whoops")  # <= raises an error
   #
@@ -76,6 +80,8 @@ class Ractor
   # *   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 be configured to copy or move arguments, return values, and
+  #     exceptions, per 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.
@@ -106,19 +112,34 @@ class Ractor
     # 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.
+    # @param threads [Integer] The number of worker threads to run.
+    #     Defaults to 1, which causes the worker to serialize calls.
     #
-    def initialize(object, threads: nil, logging: false, name: nil)
+    def initialize(object,
+                   threads: 1,
+                   move: false,
+                   move_arguments: nil,
+                   move_return: nil,
+                   logging: false,
+                   name: nil)
+      @method_settings = {}
       self.threads = threads
       self.logging = logging
       self.name = name
+      configure_method(move: move, move_arguments: move_arguments, move_return: move_return)
       yield self if block_given?
+      @method_settings.freeze
 
       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)
+      opts = {
+        object: object,
+        threads: @threads,
+        method_settings: @method_settings,
+        name: @name,
+        logging: @logging,
+      }
+      @ractor.send(opts, move: true)
 
       maybe_log("Server ready")
       @stub = Stub.new(self)
@@ -128,28 +149,25 @@ class Ractor
     ##
     # 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.
+    # object is not thread-safe, you should leave this set to its default of 1,
+    # which effectively causes calls to be serialized.
     #
     # This method can be called only during an initialization block.
+    # All settings are frozen once the wrapper is active.
     #
-    # @param value [Integer,nil]
+    # @param value [Integer]
     #
     def threads=(value)
-      if value
-        value = value.to_i
-        value = 1 if value < 1
-        @threads = value
-      else
-        @threads = nil
-      end
+      value = value.to_i
+      value = 1 if value < 1
+      @threads = value
     end
 
     ##
     # Enable or disable internal debug logging.
     #
     # This method can be called only during an initialization block.
+    # All settings are frozen once the wrapper is active.
     #
     # @param value [Boolean]
     #
@@ -158,9 +176,11 @@ class Ractor
     end
 
     ##
-    # Set the name of this wrapper, shown in logging.
+    # Set the name of this wrapper. This is shown in logging, and is also used
+    # as the name of the wrapping Ractor.
     #
     # This method can be called only during an initialization block.
+    # All settings are frozen once the wrapper is active.
     #
     # @param value [String, nil]
     #
@@ -168,6 +188,32 @@ class Ractor
       @name = value ? value.to_s.freeze : nil
     end
 
+    ##
+    # Configure the move semantics for the given method (or the default
+    # settings if no method name is given.) That is, determine whether
+    # arguments, return values, and/or exceptions are copied or moved when
+    # communicated with the wrapper. By default, all objects are copied.
+    #
+    # This method can be called only during an initialization block.
+    # All settings are frozen once the wrapper is active.
+    #
+    # @param method_name [Symbol, nil] The name of the method being configured,
+    #     or `nil` to set defaults for all methods not configured explicitly.
+    # @param move [Boolean] Whether to move all communication. This value, if
+    #     given, is used if `move_arguments`, `move_return`, or
+    #     `move_exceptions` are not set.
+    # @param move_arguments [Boolean] Whether to move arguments.
+    # @param move_return [Boolean] Whether to move return values.
+    #
+    def configure_method(method_name = nil,
+                         move: false,
+                         move_arguments: nil,
+                         move_return: nil)
+      method_name = method_name.to_sym unless method_name.nil?
+      @method_settings[method_name] =
+        MethodSettings.new(move: move, move_arguments: move_arguments, move_return: move_return)
+    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.
@@ -177,15 +223,14 @@ class Ractor
     attr_reader :stub
 
     ##
-    # Return the number of threads used by the wrapper, or `nil` for no
-    # no threading.
+    # Return the number of threads used by the wrapper.
     #
-    # @return [Integer, nil]
+    # @return [Integer]
     #
     attr_reader :threads
 
     ##
-    # Return whether logging is enabled for this wrapper
+    # Return whether logging is enabled for this wrapper.
     #
     # @return [Boolean]
     #
@@ -199,7 +244,21 @@ class Ractor
     attr_reader :name
 
     ##
-    # A lower-level interface for calling the wrapper.
+    # Return the method settings for the given method name. This returns the
+    # default method settings if the given method is not configured explicitly
+    # by name.
+    #
+    # @param method_name [Symbol,nil] The method name, or `nil` to return the
+    #     defaults.
+    # @return [MethodSettings]
+    #
+    def method_settings(method_name)
+      method_name = method_name.to_sym
+      @method_settings[method_name] || @method_settings[nil]
+    end
+
+    ##
+    # A lower-level interface for calling methods through the wrapper.
     #
     # @param method_name [Symbol] The name of the method to call
     # @param args [arguments] The positional arguments
@@ -209,8 +268,9 @@ class Ractor
     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)
+      move = method_settings(method_name).move_arguments?
+      maybe_log("Sending method #{method_name} (move=#{move}, transaction=#{transaction})")
+      @ractor.send(request, move: move)
       reply = ::Ractor.receive_if { |msg| msg.is_a?(Message) && msg.transaction == transaction }
       case reply.type
       when :result
@@ -241,9 +301,11 @@ class Ractor
     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.
+    # Retrieves the original object that was wrapped. This should be called
+    # only after a stop request has been issued using {#async_stop}, and may
+    # block until the wrapper has fully stopped.
+    #
+    # Only one ractor may call this method; any additional calls will fail.
     #
     # @return [Object] The original wrapped object
     #
@@ -276,19 +338,75 @@ class Ractor
 
       ##
       # Forward calls to {Ractor::Wrapper#call}.
+      # @private
       #
       def method_missing(name, *args, **kwargs)
         @wrapper.call(name, *args, **kwargs)
       end
 
+      ##
+      # Forward respond_to queries.
       # @private
+      #
       def respond_to_missing?(name, include_all)
-        @wrapper.respond_to?(name, include_all)
+        @wrapper.call(:respond_to?, name, include_all)
       end
     end
 
-    # @private
+    ##
+    # Settings for a method call. Specifies how a method's arguments and
+    # return value are communicated (i.e. copy or move semantics.)
+    #
+    class MethodSettings
+      # @private
+      def initialize(move: false,
+                     move_arguments: nil,
+                     move_return: nil)
+        @move_arguments = interpret_setting(move_arguments, move)
+        @move_return = interpret_setting(move_return, move)
+        freeze
+      end
+
+      ##
+      # @return [Boolean] Whether to move arguments
+      #
+      def move_arguments?
+        @move_arguments
+      end
+
+      ##
+      # @return [Boolean] Whether to move return values
+      #
+      def move_return?
+        @move_return
+      end
+
+      private
+
+      def interpret_setting(setting, default)
+        if setting.nil?
+          default ? true : false
+        else
+          setting ? true : false
+        end
+      end
+    end
+
+    ##
+    # The class of all messages passed between a client Ractor and a wrapper.
+    # This helps the wrapper distinguish these messages from any other messages
+    # that might be received by a client Ractor.
+    #
+    # Any Ractor that calls a wrapper may receive messages of this type when
+    # the call is in progress. If a Ractor interacts with its incoming message
+    # queue concurrently while a wrapped call is in progress, it must ignore
+    # these messages (i.e. by by using `receive_if`) in order not to interfere
+    # with the wrapper. (Similarly, the wrapper will use `receive_if` to
+    # receive only messages of this type, so it does not interfere with your
+    # Ractor's functionality.)
+    #
     class Message
+      # @private
       def initialize(type, data: nil, transaction: nil)
         @sender = ::Ractor.current
         @type = type
@@ -297,9 +415,16 @@ class Ractor
         freeze
       end
 
+      # @private
       attr_reader :type
+
+      # @private
       attr_reader :sender
+
+      # @private
       attr_reader :transaction
+
+      # @private
       attr_reader :data
 
       private
@@ -309,19 +434,34 @@ class Ractor
       end
     end
 
+    ##
+    # This is the backend implementation of a wrapper. A Server runs within a
+    # Ractor, and manages a shared object. It handles communication with
+    # clients, translating those messages into method calls on the object. It
+    # runs worker threads internally to handle actual method calls.
+    #
+    # See the {#run} method for an overview of the Server implementation and
+    # lifecycle.
+    #
     # @private
+    #
     class Server
+      ##
+      # Handle the server lifecycle, running through the following phases:
+      #
+      # *   **init**: Setup and spawning of worker threads.
+      # *   **running**: Normal operation, until a stop request is received.
+      # *   **stopping**: Waiting for worker threads to terminate.
+      # *   **cleanup**: Clearing out of any lingering meessages.
+      #
+      # The server returns the wrapped object, allowing one client Ractor to
+      # take it.
+      #
       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
+        init_phase
+        running_phase
+        stopping_phase
         cleanup_phase
-
         @object
       rescue ::StandardError => e
         maybe_log("Unexpected error: #{e.inspect}")
@@ -330,80 +470,142 @@ class Ractor
 
       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) }
+      ##
+      # In the **init phase**, the Server:
+      #
+      # *   Receives an initial message providing the object to wrap, and
+      #     server configuration such as thread count and communications
+      #     settings.
+      # *   Initializes the job queue and the pending request list.
+      # *   Spawns worker threads.
+      #
+      def init_phase
+        opts = ::Ractor.receive
+        @object = opts[:object]
+        @logging = opts[:logging]
+        @name = opts[:name]
+        @method_settings = opts[:method_settings]
+        @thread_count = opts[:threads]
+        @queue = ::Queue.new
+        @mutex = ::Mutex.new
+        @current_calls = {}
+        maybe_log("Spawning #{@thread_count} threads")
+        (1..@thread_count).map do |worker_num|
+          ::Thread.new { worker_thread(worker_num) }
         end
-        ::Thread.new { monitor_thread(threads) }
-        queue
+        maybe_log("Server initialized")
       end
 
-      def worker_thread(worker_num, queue)
+      ##
+      # A worker thread repeatedly pulls a method call requests off the job
+      # queue, handles it, and sends back a response. It also removes the
+      # request from the pending request list to signal that it has responded.
+      # If no job is available, the thread blocks while waiting. If the queue
+      # is closed, the worker will send an acknowledgement message and then
+      # terminate.
+      #
+      def worker_thread(worker_num)
         maybe_worker_log(worker_num, "Starting")
         loop do
           maybe_worker_log(worker_num, "Waiting for job")
-          request = queue.deq
-          if request.nil?
-            break
-          end
+          request = @queue.deq
+          break if request.nil?
           handle_method(worker_num, request)
+          unregister_call(request.transaction)
         end
+      ensure
         maybe_worker_log(worker_num, "Stopping")
+        ::Ractor.current.send(Message.new(:thread_stopped, data: worker_num), move: true)
       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)
+      ##
+      # In the **running phase**, the Server listens on the Ractor's inbox and
+      # handles messages for normal operation:
+      #
+      # *   If it receives a `call` request, it adds it to the job queue from
+      #     which a worker thread will pick it up. It also adds the request to
+      #     a list of pending requests.
+      # *   If it receives a `stop` request, we proceed to the stopping phase.
+      # *   If it receives a `thread_stopped` message, that indicates one of
+      #     the worker threads has unexpectedly stopped. We don't expect this
+      #     to happen until the stopping phase, so if we do see it here, we
+      #     conclude that something has gone wrong, and we proceed to the
+      #     stopping phase.
+      #
+      def running_phase
         loop do
           maybe_log("Waiting for message")
-          request = ::Ractor.receive_if { |msg| msg.is_a?(Message) }
+          request = ::Ractor.receive
+          next unless request.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
+            @queue.enq(request)
+            register_call(request)
+            maybe_log("Queued method #{request.data.first} (transaction=#{request.transaction})")
+          when :thread_stopped
+            maybe_log("Thread unexpectedly stopped: #{request.data}")
+            @thread_count -= 1
+            break
           when :stop
             maybe_log("Received stop")
-            queue&.close
             break
           end
         end
       end
 
+      ##
+      # In the **stopping phase**, we close the job queue, which signals to all
+      # worker threads that they should finish their current task and then
+      # terminate. We then wait for acknowledgement messages from all workers
+      # before proceeding to the next phase. Any `call` requests received
+      # during stopping are refused (i.e. we send back an error response.) Any
+      # further `stop` requests are ignored.
+      #
       def stopping_phase
-        loop do
-          maybe_log("Waiting for message")
-          message = ::Ractor.receive_if { |msg| msg.is_a?(Message) }
+        @queue.close
+        while @thread_count.positive?
+          maybe_log("Waiting for message while stopping")
+          message = ::Ractor.receive
+          next unless request.is_a?(Message)
           case message.type
           when :call
             refuse_method(message)
-          when :threads_stopped
-            break
+          when :thread_stopped
+            @thread_count -= 1
           end
         end
       end
 
+      ##
+      # In the **cleanup phase**, The Server closes its inbox, and iterates
+      # through one final time to ensure it has responded to all remaining
+      # requests with a refusal. It also makes another pass through the pending
+      # requests; if there are any left, it probably means a worker thread died
+      # without responding to it preoprly, so we send back an error message.
+      #
       def cleanup_phase
         ::Ractor.current.close_incoming
+        maybe_log("Checking message queue for cleanup")
         loop do
-          maybe_log("Checking queue for cleanup")
           message = ::Ractor.receive
           refuse_method(message) if message.is_a?(Message) && message.type == :call
         end
+        maybe_log("Checking current calls for cleanup")
+        @current_calls.each_value do |request|
+          refuse_method(request)
+        end
       rescue ::Ractor::ClosedError
-        maybe_log("Queue is empty")
+        maybe_log("Message queue is empty")
       end
 
+      ##
+      # This is called within a worker thread to handle a method call request.
+      # It calls the method on the wrapped object, and then sends back a
+      # response to the caller. If an exception was raised, it sends back an
+      # error response. It tries very hard always to send a response of some
+      # kind; if an error occurs while constructing or sending a response, it
+      # will catch the exception and try to send a simpler response.
+      #
       def handle_method(worker_num, request)
         method_name, args, kwargs = request.data
         transaction = request.transaction
@@ -412,19 +614,46 @@ class Ractor
         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)
+          sender.send(Message.new(:result, data: result, transaction: transaction),
+                      move: (@method_settings[method_name] || @method_settings[nil]).move_return?)
         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))
+          begin
+            sender.send(Message.new(:error, data: e, transaction: transaction))
+          rescue ::StandardError
+            safe_error = begin
+              ::StandardError.new(e.inspect)
+            rescue ::StandardError
+              ::StandardError.new("Unknown error")
+            end
+            sender.send(Message.new(:error, data: safe_error, transaction: transaction))
+          end
         end
       end
 
+      ##
+      # This is called from the main Ractor thread to report to a caller that
+      # the wrapper cannot handle a requested method call, likely because the
+      # wrapper is shutting down.
+      #
       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 register_call(request)
+        @mutex.synchronize do
+          @current_calls[request.transaction] = request
+        end
+      end
+
+      def unregister_call(transaction)
+        @mutex.synchronize do
+          @current_calls.delete(transaction)
+        end
+      end
+
       def maybe_log(str)
         return unless @logging
         time = ::Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%L")

data/lib/ractor/wrapper/version.rb

@@ -5,6 +5,6 @@ class Ractor
     #
     # @return [String]
     #
-    VERSION = "0.1.0".freeze
+    VERSION = "0.2.0".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ractor-wrapper
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-02 00:00:00.000000000 Z
+date: 2021-03-08 00:00:00.000000000 Z
 dependencies: []
 description: An experimental class that wraps a non-shareable object, allowing multiple
   Ractors to access it concurrently.
@@ -28,7 +28,12 @@ files:
 homepage: https://github.com/dazuma/ractor-wrapper
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/dazuma/ractor-wrapper/issues
+  changelog_uri: https://rubydoc.info/gems/ractor-wrapper/0.2.0/file/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/ractor-wrapper/0.2.0
+  homepage_uri: https://github.com/dazuma/ractor-wrapper
+  source_code_uri: https://github.com/dazuma/ractor-wrapper
 post_install_message:
 rdoc_options: []
 require_paths: