Improved separation between client and worker.

Author: ioquatix

async-container-supervisor.gemspec

@@ -27,6 +27,5 @@ Gem::Specification.new do |spec|
 	spec.add_dependency "async-container", "~> 0.22"
 	spec.add_dependency "async-service"
 	spec.add_dependency "io-endpoint"
-	spec.add_dependency "io-stream"
 	spec.add_dependency "memory-leak", "~> 0.3"
 end

bake/async/container/supervisor.rb

@@ -0,0 +1,30 @@
+
+def initialize(...)
+	super
+	
+	require "async/container/supervisor"
+end
+
+def restart
+	client do |connection|
+		connection.call(do: :restart)
+	end
+end
+
+def status
+	client do |connection|
+		connection.call(do: :status)
+	end
+end
+
+private
+
+def endpoint
+	Async::Container::Supervisor.endpoint
+end
+
+def client(&block)
+	Sync do
+		Async::Container::Supervisor::Client.new(endpoint: self.endpoint).connect(&block)
+	end
+end

example/simple/simple.rb

@@ -12,8 +12,7 @@ def setup(container)
 
 		container.run(name: self.class.name, count: 4, restart: true, health_check_timeout: 2) do |instance|
 			Async do
-				client = Async::Container::Supervisor::Client.new(instance, @evaluator.supervisor_endpoint)
-				client.run
+				Async::Container::Supervisor::Worker.new(instance, endpoint: @evaluator.supervisor_endpoint).run
 
 				start_time = Time.now
 
@@ -45,6 +44,6 @@ def setup(container)
 	include Async::Container::Supervisor::Environment
 
 	monitors do
-		[Async::Container::Supervisor::MemoryMonitor.new(interval: 1, limit: 1024 * 1024 * 100)]
+		[Async::Container::Supervisor::MemoryMonitor.new(interval: 1, limit: 1024 * 1024 * 400)]
 	end
 end

fixtures/async/container/supervisor/a_server.rb

@@ -46,7 +46,7 @@ def around(&block)
 
 				let(:registration_monitor) {RegistrationMonitor.new}
 				let(:monitors) {[registration_monitor]}
-				let(:server) {Async::Container::Supervisor::Server.new(@bound_endpoint, monitors: monitors)}
+				let(:server) {Async::Container::Supervisor::Server.new(endpoint: @bound_endpoint, monitors: monitors)}
 
 				before do
 					@bound_endpoint = endpoint.bound

lib/async/container/supervisor.rb

@@ -6,6 +6,7 @@
 require_relative "supervisor/version"
 
 require_relative "supervisor/server"
+require_relative "supervisor/worker"
 require_relative "supervisor/client"
 
 require_relative "supervisor/memory_monitor"

lib/async/container/supervisor/client.rb

@@ -3,120 +3,62 @@
 # Released under the MIT License.
 # Copyright, 2025, by Samuel Williams.
 
-require "io/stream"
 require_relative "connection"
+require_relative "dispatchable"
 
 module Async
 	module Container
 		module Supervisor
 			class Client
-				def self.run(...)
-					self.new(...).run
+				def initialize(endpoint: Supervisor.endpoint)
+					@endpoint = endpoint
 				end
 
-				def initialize(instance, endpoint = Supervisor.endpoint)
-					@instance = instance
-					@endpoint = endpoint
+				include Dispatchable
+				
+				protected def connect!
+					peer = @endpoint.connect
+					return Connection.new(peer, 0)
 				end
 
-				def dispatch(call)
-					method_name = "do_#{call.message[:do]}"
-					self.public_send(method_name, call)
+				# Called when a connection is established.
+				protected def connected!(connection)
+					# Do nothing by default.
 				end
 
+				# Connect to the server.
 				def connect
-					unless @connection
-						peer = @endpoint.connect
-						stream = IO::Stream(peer)
-						@connection = Connection.new(stream, 0, instance: @instance)
-						
-						# Register the instance with the server:
-						Async do
-							@connection.call(do: :register, state: @instance)
-						end
-					end
+					connection = connect!
+					connection.run_in_background(self)
 
-					return @connection unless block_given?
+					connected!(connection)
+					
+					return connection unless block_given?
 
 					begin
-						yield @connection
+						yield connection
 					ensure
-						@connection.close
-					end
-				end
-				
-				def close
-					if connection = @connection
-						@connection = nil
 						connection.close
 					end
 				end
 
-				private def dump(call)
-					if path = call[:path]
-						File.open(path, "w") do |file|
-							yield file
-						end
-						
-						call.finish(path: path)
-					else
-						buffer = StringIO.new
-						yield buffer
-						
-						call.finish(data: buffer.string)
-					end
-				end
-				
-				def do_scheduler_dump(call)
-					dump(call) do |file|
-						Fiber.scheduler.print_hierarchy(file)
-					end
-				end
-				
-				def do_memory_dump(call)
-					require "objspace"
-					
-					dump(call) do |file|
-						ObjectSpace.dump_all(output: file)
-					end
-				end
-				
-				def do_thread_dump(call)
-					dump(call) do |file|
-						Thread.list.each do |thread|
-							file.puts(thread.inspect)
-							file.puts(thread.backtrace)
-						end
-					end
-				end
-				
-				def do_garbage_profile_start(call)
-					GC::Profiler.enable
-					call.finish(started: true)
-				end
-				
-				def do_garbage_profile_stop(call)
-					GC::Profiler.disable
-					
-					dump(connection, message) do |file|
-						file.puts GC::Profiler.result
-					end
-				end
-				
+				# Run the client in a loop, reconnecting if necessary.
 				def run
-					Async do |task|
+					Async do
 						loop do
-							connect do |connection|
-								connection.run(self)
+							connection = connect!
+							
+							Async do
+								connected!(connection)
 							end
-						rescue => error
-							Console.error(self, "Unexpected error while running client!", exception: error)
 
-							# Retry after a small delay:
+							connection.run(self)
+						rescue => error
+							Console.error(self, "Connection failed:", exception: error)
 							sleep(rand)
+						ensure
+							connection.close
 						end
-					ensure
-						task.stop
 					end
 				end
 			end

lib/async/container/supervisor/connection.rb

@@ -18,6 +18,14 @@ def initialize(connection, id, message)
 						@queue = ::Thread::Queue.new
 					end
 
+					def as_json(...)
+						@message
+					end
+					
+					def to_json(...)
+						as_json.to_json(...)
+					end
+					
 					# @attribute [Connection] The connection that initiated the call.
 					attr :connection
 
@@ -36,6 +44,11 @@ def pop(...)
 						@queue.pop(...)
 					end
 
+					# The call was never completed and the connection itself was closed.
+					def close
+						@queue.close
+					end
+					
 					def each(&block)
 						while response = self.pop
 							yield response
@@ -47,6 +60,10 @@ def finish(**response)
 						@queue.close
 					end
 
+					def fail(**response)
+						self.finish(failed: true, **response)
+					end
+					
 					def closed?
 						@queue.closed?
 					end
@@ -86,13 +103,13 @@ def self.call(connection, **message, &block)
 					end
 				end
 
-				def initialize(stream, id, **state)
+				def initialize(stream, id = 0, **state)
 					@stream = stream
+					@id = id
 					@state = state
 
+					@reader = nil
 					@calls = {}
-					
-					@id = id
 				end
 
 				# @attribute [Hash(Integer, Call)] Calls in progress.
@@ -153,11 +170,30 @@ def run(target)
 					end
 				end
 
+				def run_in_background(target, parent: Task.current)
+					@reader ||= parent.async do
+						self.run(target)
+					end
+				end
+				
 				def close
+					if @reader
+						@reader.stop
+						@reader = nil
+					end
+					
 					if stream = @stream
 						@stream = nil
 						stream.close
 					end
+					
+					if @calls
+						@calls.each do |id, call|
+							call.close
+						end
+						
+						@calls.clear
+					end
 				end
 			end
 		end

lib/async/container/supervisor/dispatchable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "connection"
+require_relative "endpoint"
+
+require "io/stream"
+
+module Async
+	module Container
+		module Supervisor
+			module Dispatchable
+				def dispatch(call)
+					method_name = "do_#{call.message[:do]}"
+					self.public_send(method_name, call)
+				rescue => error
+					Console.error(self, "Error while dispatching call.", exception: error, call: call)
+					
+					call.fail(error: {
+						class: error.class,
+						message: error.message,
+						backtrace: error.backtrace,
+					})
+				end
+			end
+		end
+	end
+end

lib/async/container/supervisor/environment.rb

@@ -43,7 +43,7 @@ def monitors
 				end
 
 				def make_server(endpoint)
-					Server.new(endpoint, monitors: self.monitors)
+					Server.new(endpoint: endpoint, monitors: self.monitors)
 				end
 			end
 		end

lib/async/container/supervisor/memory_monitor.rb

@@ -10,7 +10,7 @@ module Async
 	module Container
 		module Supervisor
 			class MemoryMonitor
-				def initialize(interval: 10, limit: nil)
+				def initialize(interval: 10, limit: nil, &block)
 					@interval = interval
 					@cluster = Memory::Leak::Cluster.new(limit: limit)
 					@processes = Hash.new{|hash, key| hash[key] = Set.new.compare_by_identity}
@@ -42,6 +42,12 @@ def remove(connection)
 					end
 				end
 
+				def status(call)
+					@processes.each do
+						call.push(memory_monitor: @cluster)
+					end
+				end
+				
 				def run
 					Async do
 						while true
@@ -54,6 +60,7 @@ def run
 
 									response = connection.call(do: :memory_dump, path: path, timeout: 30)
 									Console.info(self, "Memory dump saved to:", path, response: response)
+									@block.call(response) if @block
 								end
 
 								# Kill the process: