[GR-25264] Implement inner context onCancelled callback to raise an exception when stopped

PullRequest: truffleruby/3305

Author: bjfish

spec/truffle/interop/polyglot/inner_context_spec.rb

@@ -50,4 +50,37 @@
       -> { context.eval('does_not_exist', '') }.should raise_error(ArgumentError, 'Unknown language: does_not_exist')
     end
   end
+
+  it "raises a RuntimeError when stopped" do
+    context = Polyglot::InnerContext.new
+    context.eval('ruby', '42') # Eagerly initializes the context to avoid stopping during context initialization
+
+    in_synchronize = false
+    th = Thread.new do
+      Thread.pass until in_synchronize
+      context.stop
+    end
+    -> {
+      in_synchronize = true
+      context.eval('ruby', 'loop { }')
+    }.should raise_error(RuntimeError, 'Polyglot::InnerContext was terminated forcefully')
+    th.join
+  end
+
+  it "calls the given on_cancelled proc when stopped" do
+    custom_error = Class.new(StandardError)
+    context = Polyglot::InnerContext.new(on_cancelled: -> { raise custom_error, 'error message' })
+    context.eval('ruby', '42') # Eagerly initializes the context to avoid stopping during context initialization
+
+    in_synchronize = false
+    th = Thread.new do
+      Thread.pass until in_synchronize
+      context.stop
+    end
+    -> {
+      in_synchronize = true
+      context.eval('ruby', 'loop { }')
+    }.should raise_error(custom_error, 'error message')
+    th.join
+  end
 end

src/main/java/org/truffleruby/interop/PolyglotNodes.java

@@ -21,6 +21,7 @@
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
 import org.truffleruby.core.klass.RubyClass;
+import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.rope.Rope;
 import org.truffleruby.core.rope.RopeNodes;
 import org.truffleruby.core.rope.RopeOperations;
@@ -40,6 +41,7 @@
 import com.oracle.truffle.api.nodes.IndirectCallNode;
 import com.oracle.truffle.api.source.Source;
 import org.truffleruby.language.library.RubyStringLibrary;
+import org.truffleruby.language.yield.CallBlockNode;
 import org.truffleruby.utils.Utils;
 
 @CoreModule("Polyglot")
@@ -169,11 +171,16 @@ private Source getSource(String language, String fileName) {
 
     @Primitive(name = "inner_context_new")
     public abstract static class InnerContextNewNode extends PrimitiveArrayArgumentsNode {
+
+        @TruffleBoundary
         @Specialization
-        protected RubyInnerContext newInnerContext(RubyClass rubyClass) {
+        protected RubyInnerContext newInnerContext(RubyClass rubyClass, RubyProc onCancelledCallback) {
             final TruffleContext innerContext = getContext()
                     .getEnv()
                     .newContextBuilder()
+                    .onCancelled(() -> {
+                        CallBlockNode.getUncached().yield(onCancelledCallback);
+                    })
                     .initializeCreatorContext(false)
                     .build();
 
@@ -182,6 +189,7 @@ protected RubyInnerContext newInnerContext(RubyClass rubyClass) {
                     getLanguage().innerContextShape,
                     innerContext);
         }
+
     }
 
     @Primitive(name = "inner_context_eval")

src/main/ruby/truffleruby/core/truffle/polyglot.rb

@@ -17,8 +17,8 @@ class InnerContext
     # Create a new isolated inner context to eval code in any available public language
     # (those languages can be listed with +Polyglot.languages+).
     # Automatically closes the context when given a block.
-    def self.new
-      inner_context = Primitive.inner_context_new(self)
+    def self.new(on_cancelled: -> { raise RuntimeError, 'Polyglot::InnerContext was terminated forcefully' })
+      inner_context = Primitive.inner_context_new(self, on_cancelled)
       if block_given?
         begin
           yield inner_context