Prefer Thread.current.raise to avoid breaking `Thread.handle_interr…

…upt`. (#30)

examples/minimal.rb

@@ -60,8 +60,8 @@ def initialize(&block)
 		@status = nil
 
 		@pid = Process.fork do
-			Signal.trap(:INT) {raise Interrupt}
-			Signal.trap(:INT) {raise Terminate}
+			Signal.trap(:INT) {::Thread.current.raise(Interrupt)}
+			Signal.trap(:INT) {::Thread.current.raise(Terminate)}
 
 			@channel.in.close
 

lib/async/container/controller.rb

@@ -176,16 +176,17 @@ def reload
 			# Enter the controller run loop, trapping `SIGINT` and `SIGTERM`.
 			def run
 				# I thought this was the default... but it doesn't always raise an exception unless you do this explicitly.
+				# We use `Thread.current.raise(...)` so that exceptions are filtered through `Thread.handle_interrupt` correctly.
 				interrupt_action = Signal.trap(:INT) do
-					raise Interrupt
+					::Thread.current.raise(Interrupt)
 				end
 
 				terminate_action = Signal.trap(:TERM) do
-					raise Terminate
+					::Thread.current.raise(Terminate)
 				end
 
 				hangup_action = Signal.trap(:HUP) do
-					raise Hangup
+					::Thread.current.raise(Hangup)
 				end
 
 				self.start

lib/async/container/generic.rb

@@ -49,6 +49,8 @@ def initialize(**options)
 				@keyed = {}
 			end
 
+			attr :group
+
 			attr :state
 
 			# A human readable representation of the container.

lib/async/container/process.rb

@@ -66,8 +66,9 @@ def exec(*arguments, ready: true, **options)
 			def self.fork(**options)
 				self.new(**options) do |process|
 					::Process.fork do
-						Signal.trap(:INT) {raise Interrupt}
-						Signal.trap(:TERM) {raise Terminate}
+						# We use `Thread.current.raise(...)` so that exceptions are filtered through `Thread.handle_interrupt` correctly.
+						Signal.trap(:INT) {::Thread.current.raise(Interrupt)}
+						Signal.trap(:TERM) {::Thread.current.raise(Terminate)}
 
 						begin
 							yield Instance.for(process)

test/async/container/forked.rb

@@ -39,6 +39,33 @@
 		expect(container.statistics.restarts).to be == 2
 	end
 
+	it "can handle interrupts" do
+		finished = IO.pipe
+		interrupted = IO.pipe
+
+		container.spawn(restart: true) do |instance|
+			Thread.handle_interrupt(Interrupt => :never) do
+				instance.ready!
+
+				finished.first.gets
+			rescue ::Interrupt
+				interrupted.last.puts "incorrectly interrupted"
+			end
+		rescue ::Interrupt
+			interrupted.last.puts "correctly interrupted"
+		end
+
+		container.wait_until_ready
+
+		container.group.interrupt
+		sleep(0.001)
+		finished.last.puts "finished"
+
+		expect(interrupted.first.gets).to be == "correctly interrupted\n"
+
+		container.stop
+	end
+
 	it "should be multiprocess" do
 		expect(subject).to be(:multiprocess?)
 	end