ractor-server 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '029685fbbe91ed839a800417dfe53141a7bbce3fb5058575f4607a7956872ccc'
-  data.tar.gz: 71376351108500ba31e6161ed4229fc836bc90b49d1992c8e0d9cbe4a07a8678
+  metadata.gz: e363bbd188b2a662459734263104b8e18a6fc31984a4ba76d258b8bc49c7ae07
+  data.tar.gz: daf7ade9149e2ee7ff3e39d71def5516566e5329751caef920d2ae0cd0e25fe1
 SHA512:
-  metadata.gz: f728a4a7862ed48732aaf688480e0f5ae64af885a02175b34bbfdec6185a6eb972680ce5d279b24d3d78ef8e9ac26b5a67102f8b1183d227c55b08a55138b138
-  data.tar.gz: 8166754425d64a1747fb3f13b95e2a4a5d1a8c70e1dde578841f161e4aa645dbe1adfafb75a8dcfa63f4fb62b52f9e7dcf7f352597ecec3898818e65674ee1ab
+  metadata.gz: 6395fd4a6db49def30c07f3031f6ffc3fb68b2110c51d14dc2c4d6bf0eea5b5bf16ba424207b39d469a45bcd30e8a4387dd841d81884840e5c53078445444061
+  data.tar.gz: 87ce7921d6973573f6a7b281a5e97234ceab96b50dc75388527e09e1380bb274b3d5a71b5de2409499cea8732188f978f7ad82646cdcd4a5b6bebdfdce89ed4f

data/.github/workflows/main.yml

@@ -35,7 +35,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ ubuntu ]
-        ruby: [ 2.7 ]
+        ruby: [ '3.0' ]
     steps:
       - name: checkout
         uses: actions/checkout@v2

data/.rubocop.yml

@@ -25,3 +25,8 @@ Naming/MethodParameterName:
 
 Metrics/MethodLength:
   Max: 16
+
+Lint/RescueException:
+  Enabled: false
+Security/MarshalLoad:
+  Enabled: false

data/README.md

@@ -15,13 +15,13 @@ class RactorHash < Hash
   include Ractor::Server
 end
 
-H = RactorHash.start
+H = RactorHash.start # => starts Server, returns instance of a Client
 
-Ractor.new { H[:example] = 42 }.take
+Ractor.new { H[:example] = 42 }.take # => 42
 puts Ractor.new { H[:example] }.take # => 42
 ```
 
-Calls with blocks are atomic yet allow reentrant calls:
+Calls are atomic but also allow reentrant calls from blocks:
 
 ```ruby
 ractors = 3.times.map do |i|
@@ -38,6 +38,34 @@ puts H # => {:example => 42, :foo => 0, :bar => 0}
 
 The first ractor to call `fetch_values` will have its block called twice; only the `fetch_values` has completed will the other Ractors have their calls to `fetch_values` run. The block is reentrant as it calls `[]=`; that call will not wait.
 
+Moreover, exceptions are propagated transparently between Client and Server.
+
+```ruby
+H.fetch_values(:z) { raise ArgumentError } # => ArgumentError
+  # (raised by Client, propagated to the Server, then back to the Client)
+
+H.fetch_values(:z) # => KeyError
+  # (raised by Hash#fetch_values) on the Server, propagated to the Client)
+```
+
+Block can also `return`, `break` or `throw` on the client-side and the server will be aware of that
+so that any `ensure` blocks are called and server doesn't hang expecting a return value.
+
+```ruby
+class RactorHash
+  def fetch_values(*)
+    super
+  ensure
+    puts 'here'
+  end
+end
+
+def foo
+  H.fetch_values(:z) { return 42 }
+end
+foo # => 42, prints 'here'
+```
+
 The implementation relies on three layers of functionality.
 
 ### Low-level API: `Request`
@@ -103,6 +131,25 @@ The method `receive_request` will only receive a `Request` that was sent with `s
 
 The method `Request#receive` will only receive a `Request` that is a direct response to the receiver.
 
+#### Exceptions
+
+Instead of responsing with data, it is possible to respond by raising (on the remote side) an error with `send_exception`.
+
+Calling `send_exception` wraps the original exception in a `Ractor::Remote`:
+
+```ruby
+ractor = Ractor.new do
+  request, data = receive_request
+rescue ArgumentError => e
+  puts e # => 'example' (ArgumentError)
+end
+
+ractor.send_exception(ArgumentError.new('example'))
+ractor.take
+```
+
+Calling `send_exception` again on the wrapped `Ractor::Remote` will unwrap it. This way, if an exception travels from the client to the server and back to the client, this voyage will be transparent to the client.
+
 #### Implementation
 
 `send_request` / `receive_request` use `Ractor#send` and `Ractor#receive_if` with the following layout:
@@ -120,7 +167,8 @@ One may specify the expected syncing for a `Request`:
 * `:tell`: receiver may not reply ("do this, I'm assuming it will get done")
 * `:ask`: receiver must reply exactly once with sync type `:conclude`  ("do this, let me know when done, and don't me ask questions")
 * `:conclude`: as with `:tell`, receiver may not reply. Must be in response of `ask` or `converse`
-* `:converse`: receiver may reply has many times as desired (with sync type `:tell`, `:ask`, or `:converse`) and must then reply exactly once with sync type `:conclude`.  ("do this, ask questions if need be, and let me know when done")
+* `:converse`: receiver may reply has many times as desired (with sync type `:tell`, `:ask`, or `:converse`) and must then reply exactly once with sync type `:conclude`.  ("do this, ask questions if need be, and let me know when done"). Exception: if the receiver replies with a `converse`, both `converse` requests may be interrupted with a response of sync `interrupt`; the receiver may no longer reply, not even for the final `:conclude`.
+* `:interrupt`: acts as a kind of "double conclude". Not only should receiver not reply, but outer `conclude`.
 
 The API uses `send_request`/`send` with a `sync:` named argument:
 
@@ -252,7 +300,7 @@ end
 
 It may be necessary to customize the `Client` interface.
 
-For example in the `SharedObject` example above, it may be more efficient if the shared object is always shareable. This can be done by customizing the client:
+For example in the `SharedObject` example above, it may be more efficient if the held object is always shareable. This can be done by customizing the client:
 
 ```ruby
 class SharedObject
@@ -295,7 +343,6 @@ end
 
 ## To do
 
-* Exception rescuing and propagation
 * API to pass block via makeshareable
 * Monitoring
 * Promise-style communication

data/lib/ractor/server/client.rb

@@ -165,18 +165,32 @@ class Ractor
         loop do
           response, result = rq.receive
           case response.sync
-          in :converse
-            block_result = with_requests_nested(response) { yield(result) }
-            Ractor.make_shareable(block_result) if share_inputs?(method)
-            response.conclude block_result
-          in :conclude
-            return result
+          in :converse then handle_yield(method, response) { yield result }
+          in :conclude then return result
           end
         end
       ensure
         debug(:await) { "Finished waiting for #{rq}" }
       end
 
+      private def handle_yield(method, response)
+        begin
+          status, result = with_requests_nested(response) do
+            [:ok, yield]
+          rescue Exception => e
+            [:exception, e]
+          end
+        ensure
+          response.interrupt unless status # throw/return/...
+        end
+        if status == :exception
+          response.send_exception(result)
+        else
+          Ractor.make_shareable(result) if share_inputs?(method)
+          response.conclude result
+        end
+      end
+
       private def with_requests_nested(context)
         store = Thread.current
         prev = store[@nest_request_key]

data/lib/ractor/server/request.rb

@@ -5,6 +5,8 @@ using Ractor::Server::Talk
 
 class Ractor
   module Server
+    WRAP_IN_REMOTE_ERROR = false # unsure what's best
+
     class Request
       include Debugging
       attr_reader :response_to, :initiating_ractor, :sync, :info
@@ -38,7 +40,7 @@ class Ractor
         Request.send(initiating_ractor, *args, **options, response_to: self)
       end
 
-      %i[tell ask converse conclude].each do |sync|
+      %i[tell ask converse conclude interrupt].each do |sync|
         class_eval <<~RUBY, __FILE__, __LINE__ + 1
           def #{sync}(*args, **options)                # def tell(*args, **options)
             send(*args, **options, sync: :#{sync})     #   send(*args, **options, sync: :tell)
@@ -50,9 +52,25 @@ class Ractor
         RUBY
       end
 
+      class WrappedException
+        # Use Marshal to circumvent https://bugs.ruby-lang.org/issues/17577
+        def initialize(exception)
+          @exception = Marshal.dump(exception)
+        end
+
+        def exception
+          Marshal.load(@exception)
+        end
+      end
+      private_constant :WrappedException
+
+      def send_exception(exception)
+        send(WrappedException.new(exception), sync: sync && :conclude)
+      end
+
       def receive
         enforce_sync_when_receiving!
-        Request.receive_if(&self)
+        unwrap(Request.receive_if(&self))
       end
 
       def inspect
@@ -103,7 +121,7 @@ class Ractor
           request
         end
 
-        %i[tell ask converse conclude].each do |sync|
+        %i[tell ask converse conclude interrupt].each do |sync|
           class_eval <<~RUBY, __FILE__, __LINE__ + 1
             def #{sync}(r, *args, **options)             # def tell(r, *args, **options)
               send(r, *args, **options, sync: :#{sync})  #   send(r, *args, **options, sync: :tell)
@@ -112,15 +130,39 @@ class Ractor
         end
       end
 
+      private def unwrap(message)
+        _rq, arg = message
+        raise_exception(arg) if arg.is_a?(WrappedException)
+
+        message
+      end
+
+      private def raise_exception(exc)
+        raise exc unless WRAP_IN_REMOTE_ERROR
+
+        if exc.exception.is_a?(Ractor::RemoteError)
+          debug(:exception) { 'Received RemoteError, raising original cause' }
+          raise exc.exception.cause
+        else
+          debug(:exception) { 'Received exception, raising RemoveError' }
+          begin
+            raise exc.exception
+          rescue Exception
+            raise Ractor::RemoteError # => sets `cause` to exc.exception
+          end
+        end
+      end
+
       # @api private
       def enforce_sync_when_sending!
         # Only dynamic checks are done here; static validity checked in constructor
         case sync
-        when :conclude
+        when :conclude, :interrupt
           registry = Request.pending_send_conclusion
           raise Talk::Error, "Request #{response_to} already answered" unless registry[response_to]
 
           registry[response_to] = false
+          Request.pending_receive_conclusion[response_to.response_to] = false if sync == :interrupt
         when :ask, :converse
           Request.pending_receive_conclusion[self] = true
         end
@@ -130,8 +172,9 @@ class Ractor
       def sync_after_receiving
         # Only dynamic checks are done here; static validity checked in constructor
         case sync
-        when :conclude
+        when :conclude, :interrupt
           Request.pending_receive_conclusion[response_to] = false
+          Request.pending_send_conclusion[response_to.response_to] = false if sync == :interrupt
         when :ask, :converse
           Request.pending_send_conclusion[self] = true
         end
@@ -140,7 +183,7 @@ class Ractor
       # Receiver is request to receive a reply from
       private def enforce_sync_when_receiving!
         case sync
-        when :tell, :conclude
+        when :tell, :conclude, :interrupt
           raise Talk::Error, "Can not receive from a Request for a `#{sync}` sync: #{self}"
         when :ask, :converse
           return :ok if Request.pending_receive_conclusion[self]
@@ -153,7 +196,7 @@ class Ractor
         ractor.name || "##{ractor.to_s.match(/#(\d+) /)[1]}"
       end
 
-      private def enforce_valid_sync!
+      private def enforce_valid_sync! # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         case [response_to&.sync, sync]
         in [nil, nil]
           :ok_unsynchronized
@@ -161,10 +204,15 @@ class Ractor
           :ok_talk
         in [:ask | :converse, :conclude]
           :ok_concluding
-        in [:tell | :conclude => from, _]
+        in [:ask | :converse, :interrupt]
+          raise Talk::Error, 'Can only interrupt a 2-level conversation' unless response_to.response_to&.converse?
+
+          :ok_interrupting
+        in [:tell | :conclude | :interrupt => from, _]
           raise Talk::Error, "Can not respond to a Request with `#{from.inspect}` sync"
         in [:ask, _]
-          raise Talk::Error, "Request with `ask` sync must be responded with a `conclude` sync, got #{sync.inspect}"
+          raise Talk::Error, 'Request with `ask` sync must be responded with a `conclude`' \
+            "or `interrupt` sync, got #{sync.inspect}"
         in [_, nil]
           raise Talk::Error, "Specify sync to respond to a Request with #{sync.inspect}"
         else

data/lib/ractor/server/server.rb

@@ -17,26 +17,35 @@ class Ractor
       :done
     end
 
+    INTERRUPT = Object.new.freeze
+    private_constant :INTERRUPT
+
     private def process(rq, method_name, args, options, block = nil)
-      if rq.converse?
-        public_send(method_name, *args, **options) do |yield_arg|
-          yield_client(rq, yield_arg)
-        end
+      catch(INTERRUPT) do
+        if rq.converse?
+          public_send(method_name, *args, **options) do |yield_arg|
+            yield_client(rq, yield_arg)
+          end
+        else
+          public_send(method_name, *args, **options, &block)
+        end => result
+      rescue Exception => e
+        rq.send_exception(e) unless rq.tell?
       else
-        public_send(method_name, *args, **options, &block)
-      end => result
-
-      rq.conclude(result) unless rq.tell?
+        rq.conclude(result) unless rq.tell?
+      end
     end
 
     private def yield_client(rq, arg)
       yield_request = rq.converse(arg)
       loop do
         rq, *data = yield_request.receive
-        return data.first if rq.conclude?
-
-        # Reentrant request
-        process(rq, *data)
+        case rq.sync
+        when :conclude then return data.first
+        when :interrupt then throw INTERRUPT
+        else # Reentrant request
+          process(rq, *data)
+        end
       end
     end
 

data/lib/ractor/server/talk.rb

@@ -1,27 +1,8 @@
 # frozen_string_literal: true
 # shareable_constant_value: literal
 
-module RefinementExporter
-  refine Module do
-    # See https://bugs.ruby-lang.org/issues/17374#note-8
-    def refine(what, export: false)
-      mod = super(what)
-      return mod unless export
-
-      export = self if export == true
-      export.class_eval do
-        mod.instance_methods(false).each do |method|
-          define_method(method, mod.instance_method(method))
-        end
-        mod.private_instance_methods(false).each do |method|
-          private define_method(method, mod.instance_method(method))
-        end
-      end
-      mod
-    end
-  end
-end
-using RefinementExporter
+require 'refine_export'
+using RefineExport
 
 class Ractor
   module Server

data/lib/ractor/server/version.rb

@@ -3,6 +3,6 @@
 
 class Ractor
   module Server
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end

data/ractor-server.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'refine_export'
   spec.add_dependency 'require_relative_dir', '>= 1.1.0'
 
   # For more information and examples about making a new gem, checkout our

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ractor-server
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Marc-Andre Lafortune
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-01-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: refine_export
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: require_relative_dir
   requirement: !ruby/object:Gem::Requirement