async-container-supervisor 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecde9321579fc86b6e3af0434fe518fefa5c63e161a68e8b982fa74028b5db43
-  data.tar.gz: 754cf3efc6d28f4f4e8e97da1ddfbad020a23578bbc710a81d4a7cc302d89912
+  metadata.gz: b5936025301bd2c10f66b6e1348207c6f59e94e41c9a5ac4705fe3cd70d6ed90
+  data.tar.gz: 19aea49ee76c918c3192acb05a6fb2ac87cdb73cb75c95965b716bcf9f571c56
 SHA512:
-  metadata.gz: c0105355ee822e38cf60d3adf43192ab070766efbf5b54ef87283ac4cf7e0a7ed211f4154045ce91e2f9566cfe4478e1a51799fc04a40e1504c1749dd0420802
-  data.tar.gz: 21ffe53df327d2d8ba1b669316473bf571bbdae79dac7f1c50bb88c5198c72be9025b6620218ccac7e1a9bba0a19bb457182873d3b5a56399f8c09977d4707e5
+  metadata.gz: 8cf7aa51fb4dd4947d43b37db76eb990ad06be54d5e9c1fa67016881cc80ef7d703aec514ca4be6243b33763dca221f2a8fe5f957c2fc0566d35cc893f0f3b10
+  data.tar.gz: 39d5d9b0ef7913af202d0ff7fc62b31afcbe3355075b21093deb6554fcc82a4a63a6ba68b0d5a67e91c4e367a873e616d124830fe87a535289bcfad5be003565

data/lib/async/container/supervisor/client.rb

@@ -3,120 +3,63 @@
 # 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
+			# A client provides a mechanism to connect to a supervisor server in order to execute operations.
 			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

data/lib/async/container/supervisor/connection.rb

@@ -18,6 +18,14 @@ module Async
 						@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 @@ module Async
 						@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 @@ module Async
 						@queue.close
 					end
 					
+					def fail(**response)
+						self.finish(failed: true, **response)
+					end
+					
 					def closed?
 						@queue.closed?
 					end
@@ -76,23 +93,45 @@ module Async
 						call = self.new(connection, id, message)
 						
 						connection.calls[id] = call
-						connection.write(id: id, **message)
-						
-						if block_given?
-							call.each(&block)
-						else
-							return call.pop
+						begin
+							connection.write(id: id, **message)
+							
+							if block_given?
+								call.each(&block)
+							else
+								intermediate = nil
+								
+								while response = call.pop
+									if response.delete(:finished)
+										if intermediate
+											if response.any?
+												intermediate << response
+											end
+											
+											return intermediate
+										else
+											return response
+										end
+									else
+										# Buffer intermediate responses:
+										intermediate ||= []
+										intermediate << response
+									end
+								end
+							end
+						ensure
+							connection.calls.delete(id)
 						end
 					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.
@@ -139,7 +178,7 @@ module Async
 				
 				def run(target)
 					self.each do |message|
-						if id = message[:id]
+						if id = message.delete(:id)
 							if call = @calls[id]
 								# Response to a call:
 								call.push(**message)
@@ -153,11 +192,30 @@ module Async
 					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

data/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

data/lib/async/container/supervisor/environment.rb

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

data/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,10 @@ module Async
 					end
 				end
 				
+				def status(call)
+					call.push(memory_monitor: @cluster)
+				end
+				
 				def run
 					Async do
 						while true
@@ -54,6 +58,7 @@ module Async
 									
 									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:

data/lib/async/container/supervisor/server.rb

@@ -5,24 +5,25 @@
 
 require_relative "connection"
 require_relative "endpoint"
+require_relative "dispatchable"
 
 require "io/stream"
 
 module Async
 	module Container
 		module Supervisor
+			# The server represents the main supervisor process which is responsible for managing the lifecycle of other processes.
+			#
+			# There are various tasks that can be executed by the server, such as restarting the process group, and querying the status of the processes. The server is also responsible for managing the lifecycle of the monitors, which can be used to monitor the status of the connected workers.
 			class Server
-				def initialize(endpoint = Supervisor.endpoint, monitors: [])
-					@endpoint = endpoint
+				def initialize(monitors: [], endpoint: Supervisor.endpoint)
 					@monitors = monitors
+					@endpoint = endpoint
 				end
 				
 				attr :monitors
 				
-				def dispatch(call)
-					method_name = "do_#{call.message[:do]}"
-					self.public_send(method_name, call)
-				end
+				include Dispatchable
 				
 				def do_register(call)
 					call.connection.state.merge!(call.message[:state])
@@ -38,6 +39,26 @@ module Async
 					call.finish
 				end
 				
+				# Restart the current process group, usually including the supervisor and any other processes.
+				#
+				# @parameter signal [Symbol] The signal to send to the process group.
+				def do_restart(call)
+					signal = call[:signal] || :INT
+					
+					# We are going to terminate the progress group, including *this* process, so finish the current RPC before that:
+					call.finish
+					
+					::Process.kill(signal, ::Process.ppid)
+				end
+				
+				def do_status(call)
+					@monitors.each do |monitor|
+						monitor.status(call)
+					end
+					
+					call.finish
+				end
+				
 				def remove(connection)
 					@monitors.each do |monitor|
 						begin
@@ -48,8 +69,8 @@ module Async
 					end
 				end
 				
-				def run
-					Async do |task|
+				def run(parent: Task.current)
+					parent.async do |task|
 						@monitors.each do |monitor|
 							begin
 								monitor.run
@@ -59,8 +80,7 @@ module Async
 						end
 						
 						@endpoint.accept do |peer|
-							stream = IO::Stream(peer)
-							connection = Connection.new(stream, 1, remote_address: peer.remote_address)
+							connection = Connection.new(peer, 1)
 							connection.run(self)
 						ensure
 							connection.close

data/lib/async/container/supervisor/version.rb

@@ -6,7 +6,7 @@
 module Async
 	module Container
 		module Supervisor
-			VERSION = "0.1.0"
+			VERSION = "0.3.0"
 		end
 	end
 end

data/lib/async/container/supervisor/worker.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "client"
+require_relative "dispatchable"
+
+module Async
+	module Container
+		module Supervisor
+			# A worker represents a long running process that can be controlled by the supervisor.
+			#
+			# There are various tasks that can be executed by the worker, such as dumping memory, threads, and garbage collection profiles.
+			class Worker < Client
+				def self.run(...)
+					self.new(...).run
+				end
+				
+				def initialize(state, endpoint: Supervisor.endpoint)
+					@state = state
+					@endpoint = endpoint
+				end
+				
+				include Dispatchable
+				
+				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
+				
+				protected def connected!(connection)
+					super
+					
+					# Register the worker with the supervisor:
+					connection.call(do: :register, state: @state)
+				end
+			end
+		end
+	end
+end

data/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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-container-supervisor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -36,7 +36,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2025-02-26 00:00:00.000000000 Z
+date: 2025-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-container
@@ -80,20 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: io-stream
-  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: memory-leak
   requirement: !ruby/object:Gem::Requirement
@@ -115,12 +101,14 @@ files:
 - lib/async/container/supervisor.rb
 - lib/async/container/supervisor/client.rb
 - lib/async/container/supervisor/connection.rb
+- lib/async/container/supervisor/dispatchable.rb
 - lib/async/container/supervisor/endpoint.rb
 - lib/async/container/supervisor/environment.rb
 - lib/async/container/supervisor/memory_monitor.rb
 - lib/async/container/supervisor/server.rb
 - lib/async/container/supervisor/service.rb
 - lib/async/container/supervisor/version.rb
+- lib/async/container/supervisor/worker.rb
 - license.md
 - readme.md
 - releases.md