Working simple example.

Author: ioquatix

async-container-supervisor.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
 	spec.required_ruby_version = ">= 3.1"
 
 	spec.add_dependency "async-container"
+	spec.add_dependency "async-service"
 	spec.add_dependency "io-stream"
 	spec.add_dependency "memory-leak", "~> 0.2"
 end

example/simple/simple.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env async-service
+
+require "async/container/supervisor"
+
+class SleepService < Async::Service::Generic
+	def setup(container)
+		super
+		
+		container.run(count: 1, restart: true, health_check_timeout: 2) do |instance|
+			Async do
+				client = Async::Container::Supervisor::Client.new(instance, @evaluator.supervisor_endpoint)
+				client.run
+				
+				instance.ready!
+				
+				chunks = []
+				while true
+					Console.info(self, "Allocating memory...")
+					# Allocate 10MB of memory every second:
+					chunks << " " * 1024 * 1024
+					sleep 0.1
+					instance.ready!
+				end
+			ensure
+				Console.info(self, "Exiting...")
+			end
+		end
+	end	
+end
+
+service "sleep" do
+	service_class SleepService
+	
+	supervisor_endpoint {Async::Container::Supervisor.endpoint}
+end
+
+service "supervisor" do
+	include Async::Container::Supervisor::Environment
+	
+	monitors do
+		[Async::Container::Supervisor::Monitor::MemoryMonitor.new(interval: 1, limit: 1024 * 1024 * 100)]
+	end
+end

lib/async/container/supervisor.rb

@@ -7,3 +7,7 @@
 
 require_relative "supervisor/server"
 require_relative "supervisor/client"
+require_relative "supervisor/monitor"
+
+require_relative "supervisor/environment"
+require_relative "supervisor/service"

lib/async/container/supervisor/client.rb

@@ -44,16 +44,31 @@ def close
 					end
 				end
 
+				def do_memory_dump(wrapper, message)
+					Console.info(self, "Memory dump:", message)
+					path = message[:path]
+					
+					File.open(path, "w") do |file|
+						ObjectSpace.dump_all(output: file)
+					end
+				end
+				
 				def run
-					loop do
-						connect do |wrapper|
-							wrapper.run(self)
+					Async do |task|
+						loop do
+							Console.info(self, "Connecting to supervisor...")
+							connect do |wrapper|
+								Console.info(self, "Connected to supervisor.")
+								wrapper.run(self)
+							end
+						rescue => error
+							Console.error(self, "Unexpected error while running client!", exception: error)
+							
+							# Retry after a small delay:
+							sleep(rand)
 						end
-					rescue => error
-						Console.error(self, "Unexpected error while running client!", exception: error)
-						
-						# Retry after a small delay:
-						sleep(rand)
+					ensure
+						task.stop
 					end
 				end
 			end

lib/async/container/supervisor/environment.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2019-2024, by Samuel Williams.
+
+require "async/service/environment"
+
+module Async
+	module Container
+		module Supervisor
+			module Environment
+				# The service class to use for the supervisor.
+				# @returns [Class]
+				def service_class
+					Supervisor::Service
+				end
+				
+				# The name of the supervisor
+				# @returns [String]
+				def name
+					"supervisor"
+				end
+				
+				# The IPC path to use for communication with the supervisor.
+				# @returns [String]
+				def ipc_path
+					::File.expand_path("supervisor.ipc", root)
+				end
+				
+				# The endpoint the supervisor will bind to.
+				# @returns [::IO::Endpoint::Generic]
+				def endpoint
+					::IO::Endpoint.unix(ipc_path)
+				end
+				
+				# Options to use when creating the container.
+				def container_options
+					{restart: true, count: 1, health_check_timeout: 30}
+				end
+				
+				def monitors
+					[]
+				end
+				
+				def make_server(endpoint)
+					Server.new(endpoint, monitors: self.monitors)
+				end
+			end
+		end
+	end
+end

lib/async/container/supervisor/monitor.rb

@@ -0,0 +1,2 @@
+require_relative "monitor/periodic_monitor"
+require_relative "monitor/memory_monitor"

lib/async/container/supervisor/monitor/memory_monitor.rb

@@ -4,46 +4,62 @@
 # Copyright, 2025, by Samuel Williams.
 
 require_relative "periodic_monitor"
-require "memory/leaks/cluster"
+require "memory/leak/cluster"
 
 module Async
 	module Container
 		module Supervisor
 			module Monitor
-				class MemoryMonitor < PeriodicMonitor
-					def initialize(cluster, **options)
-						super(**options)
-						@cluster = cluster
-						@processes = Hash.new
+				class MemoryMonitor
+					def initialize(interval: 10, limit: nil)
+						@interval = interval
+						@cluster = Memory::Leak::Cluster.new(limit: limit)
+						@processes = Hash.new(0)
 					end
 
-					def register(wrapper, message)
-						if process_id = message[:process_id]
+					def register(wrapper, registration)
+						return unless instance = registration[:instance]
+						
+						Console.info(self, "Registering process:", instance)
+						if process_id = instance[:process_id]
 							if @processes.key?(process_id)
+								Console.info(self, "Incrementing process:", process_id: process_id)
 								@processes[process_id] += 1
 							else
+								Console.info(self, "Registering process:", process_id: process_id)
 								@cluster.add(process_id)
 								@processes[process_id] = 1
 							end
 						end
 					end
 
-					def remove()
-						# if 
-						@cluster.remove(worker.process_id)
-					end
-					
-					def call
-						@cluster.check! do |pid, monitor|
-							kill(pid)
+					def remove(wrapper, registration)
+						return unless instance = registration[:instance]
+						
+						if process_id = instance[:process_id]
+							if @processes.key?(process_id)
+								@processes[process_id] -= 1
+								
+								if @processes[process_id] == 0
+									Console.info(self, "Deregistering process:", process_id: process_id)
+									@cluster.remove(process_id)
+									@processes.delete(process_id)
+								end
+							end
 						end
 					end
 
 					def run
-						while true
-							self.call
-							
-							sleep(@interval)
+						Async do
+							while true
+								Console.info(self, "Checking for memory leaks...", processes: @processes)
+								@cluster.check! do |process_id, monitor|
+									Console.error(self, "Memory leak detected in process:", process_id: process_id, monitor: monitor)
+									::Process.kill(:INT, process_id)
+								end
+								
+								sleep(@interval)
+							end
 						end
 					end
 				end

lib/async/container/supervisor/monitor/periodic_monitor.rb

@@ -8,19 +8,24 @@ module Container
 		module Supervisor
 			module Monitor
 				class PeriodicMonitor
-					def initialize(interval: 1)
+					def initialize(interval: 1, &block)
 						@interval = interval
+						@block = block
 					end
 
-					def call
-						raise NotImplementedError
+					def register(wrapper, state)
+					end
+					
+					def remove(wrapper, state)
 					end
 
 					def run
-						while true
-							self.call
-							
-							sleep(@interval)
+						Async do
+							while true
+								@block.call
+								
+								sleep(@interval)
+							end
 						end
 					end
 				end

lib/async/container/supervisor/server.rb

@@ -26,6 +26,7 @@ def initialize(endpoint = Supervisor.endpoint, monitors: [])
 				attr :registered
 
 				def do_register(wrapper, state)
+					Console.info(self, "Registering process:", state)
 					@registered[wrapper] = state
 
 					@monitors.each do |monitor|
@@ -42,13 +43,25 @@ def remove(wrapper)
 				end
 
 				def run
-					@endpoint.accept do |peer|
-						stream = IO::Stream(peer)
-						wrapper = Wrapper.new(stream)
-						wrapper.run(self)
+					Async do |task|
+						Console.info(self, "Starting monitors...")
+						@monitors.each(&:run)
+						
+						Console.info(self, "Accepting connections...")
+						@endpoint.accept do |peer|
+							Console.info(self, "Accepted connection from peer:", peer: peer)
+							stream = IO::Stream(peer)
+							wrapper = Wrapper.new(stream)
+							wrapper.run(self)
+						ensure
+							wrapper.close
+							remove(wrapper)
+						end
+						
+						task.children&.each(&:wait)
 					ensure
-						wrapper.close
-						remove(wrapper)
+						Console.info(self, "Stopping...")
+						task.stop
 					end
 				end
 			end

lib/async/container/supervisor/service.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "async"
+require "io/endpoint/bound_endpoint"
+
+module Async
+	module Container
+		module Supervisor
+			class Service < Async::Service::Generic
+				# Initialize the supervisor using the given environment.
+				# @parameter environment [Build::Environment]
+				def initialize(...)
+					super
+					
+					@bound_endpoint = nil
+				end
+				
+				# The endpoint which the supervisor will bind to.
+				# Typically a unix pipe in the same directory as the host.
+				def endpoint
+					@evaluator.endpoint
+				end
+				
+				# Bind the supervisor to the specified endpoint.
+				def start
+					@bound_endpoint = self.endpoint.bound
+					
+					super
+				end
+				
+				def name
+					@evaluator.name
+				end
+				
+				def setup(container)
+					container_options = @evaluator.container_options
+					health_check_timeout = container_options[:health_check_timeout]
+					
+					container.run(name: self.name, **container_options) do |instance|
+						evaluator = @environment.evaluator
+						
+						Async do
+							server = evaluator.make_server(@bound_endpoint)
+							server.run
+							
+							instance.ready!
+							
+							if health_check_timeout
+								Async(transient: true) do
+									while true
+										sleep(health_check_timeout / 2)
+										instance.ready!
+									end
+								end
+							end
+						end
+					end
+					
+					super
+				end
+				
+				# Release the bound endpoint.
+				def stop
+					@bound_endpoint&.close
+					@bound_endpoint = nil
+					
+					super
+				end
+			end
+		end
+	end
+end