async-container-supervisor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ecde9321579fc86b6e3af0434fe518fefa5c63e161a68e8b982fa74028b5db43
+  data.tar.gz: 754cf3efc6d28f4f4e8e97da1ddfbad020a23578bbc710a81d4a7cc302d89912
+SHA512:
+  metadata.gz: c0105355ee822e38cf60d3adf43192ab070766efbf5b54ef87283ac4cf7e0a7ed211f4154045ce91e2f9566cfe4478e1a51799fc04a40e1504c1749dd0420802
+  data.tar.gz: 21ffe53df327d2d8ba1b669316473bf571bbdae79dac7f1c50bb88c5198c72be9025b6620218ccac7e1a9bba0a19bb457182873d3b5a56399f8c09977d4707e5

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "io/stream"
+require_relative "connection"
+
+module Async
+	module Container
+		module Supervisor
+			class Client
+				def self.run(...)
+					self.new(...).run
+				end
+				
+				def initialize(instance, endpoint = Supervisor.endpoint)
+					@instance = instance
+					@endpoint = endpoint
+				end
+				
+				def dispatch(call)
+					method_name = "do_#{call.message[:do]}"
+					self.public_send(method_name, call)
+				end
+				
+				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
+					
+					return @connection unless block_given?
+					
+					begin
+						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
+				
+				def run
+					Async do |task|
+						loop do
+							connect do |connection|
+								connection.run(self)
+							end
+						rescue => error
+							Console.error(self, "Unexpected error while running client!", exception: error)
+							
+							# Retry after a small delay:
+							sleep(rand)
+						end
+					ensure
+						task.stop
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "json"
+
+module Async
+	module Container
+		module Supervisor
+			class Connection
+				class Call
+					def initialize(connection, id, message)
+						@connection = connection
+						@id = id
+						@message = message
+						
+						@queue = ::Thread::Queue.new
+					end
+					
+					# @attribute [Connection] The connection that initiated the call.
+					attr :connection
+					
+					# @attribute [Hash] The message that initiated the call.
+					attr :message
+					
+					def [] key
+						@message[key]
+					end
+					
+					def push(**response)
+						@queue.push(response)
+					end
+					
+					def pop(...)
+						@queue.pop(...)
+					end
+					
+					def each(&block)
+						while response = self.pop
+							yield response
+						end
+					end
+					
+					def finish(**response)
+						self.push(id: @id, finished: true, **response)
+						@queue.close
+					end
+					
+					def closed?
+						@queue.closed?
+					end
+					
+					def self.dispatch(connection, target, id, message)
+						Async do
+							call = self.new(connection, id, message)
+							connection.calls[id] = call
+							
+							target.dispatch(call)
+							
+							while response = call.pop
+								connection.write(id: id, **response)
+							end
+						ensure
+							# If the queue is closed, we don't need to send a finished message.
+							unless call.closed?
+								connection.write(id: id, finished: true)
+							end
+							
+							connection.calls.delete(id)
+						end
+					end
+					
+					def self.call(connection, **message, &block)
+						id = connection.next_id
+						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
+						end
+					end
+				end
+				
+				def initialize(stream, id, **state)
+					@stream = stream
+					@state = state
+					
+					@calls = {}
+					
+					@id = id
+				end
+				
+				# @attribute [Hash(Integer, Call)] Calls in progress.
+				attr :calls
+				
+				# @attribute [Hash(Symbol, Object)] State associated with this connection, for example the process ID, etc.
+				attr_accessor :state
+				
+				def next_id
+					@id += 2
+				end
+				
+				def write(**message)
+					@stream.write(JSON.dump(message) << "\n")
+					@stream.flush
+				end
+				
+				def call(timeout: nil, **message)
+					id = next_id
+					calls[id] = ::Thread::Queue.new
+					
+					write(id: id, **message)
+					
+					return calls[id].pop(timeout: timeout)
+				ensure
+					calls.delete(id)
+				end
+				
+				def read
+					if line = @stream&.gets
+						JSON.parse(line, symbolize_names: true)
+					end
+				end
+				
+				def each
+					while message = self.read
+						yield message
+					end
+				end
+				
+				def call(...)
+					Call.call(self, ...)
+				end
+				
+				def run(target)
+					self.each do |message|
+						if id = message[:id]
+							if call = @calls[id]
+								# Response to a call:
+								call.push(**message)
+							else
+								# Incoming call:
+								Call.dispatch(self, target, id, message)
+							end
+						else
+							Console.error(self, "Unknown message:", message)
+						end
+					end
+				end
+				
+				def close
+					if stream = @stream
+						@stream = nil
+						stream.close
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "io/endpoint/unix_endpoint"
+
+module Async
+	module Container
+		module Supervisor
+			def self.endpoint(path = "supervisor.ipc")
+				::IO::Endpoint.unix(path)
+			end
+		end
+	end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, 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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "memory/leak/cluster"
+require "set"
+
+module Async
+	module Container
+		module Supervisor
+			class MemoryMonitor
+				def initialize(interval: 10, limit: nil)
+					@interval = interval
+					@cluster = Memory::Leak::Cluster.new(limit: limit)
+					@processes = Hash.new{|hash, key| hash[key] = Set.new.compare_by_identity}
+				end
+				
+				def register(connection)
+					if process_id = connection.state[:process_id]
+						connections = @processes[process_id]
+						
+						if connections.empty?
+							Console.info(self, "Registering process:", process_id: process_id)
+							@cluster.add(process_id)
+						end
+						
+						connections.add(connection)
+					end
+				end
+				
+				def remove(connection)
+					if process_id = connection.state[:process_id]
+						connections = @processes[process_id]
+						
+						connections.delete(connection)
+						
+						if connections.empty?
+							Console.info(self, "Removing process:", process_id: process_id)
+							@cluster.remove(process_id)
+						end
+					end
+				end
+				
+				def run
+					Async do
+						while true
+							@cluster.check! do |process_id, monitor|
+								Console.error(self, "Memory leak detected in process:", process_id: process_id, monitor: monitor)
+								connections = @processes[process_id]
+								
+								connections.each do |connection|
+									path = "/tmp/memory_dump_#{process_id}.json"
+									
+									response = connection.call(do: :memory_dump, path: path, timeout: 30)
+									Console.info(self, "Memory dump saved to:", path, response: response)
+								end
+								
+								# Kill the process:
+								Console.info(self, "Killing process:", process_id: process_id)
+								Process.kill(:INT, process_id)
+							end
+							
+							sleep(@interval)
+						end
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,78 @@
+# 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
+			class Server
+				def initialize(endpoint = Supervisor.endpoint, monitors: [])
+					@endpoint = endpoint
+					@monitors = monitors
+				end
+				
+				attr :monitors
+				
+				def dispatch(call)
+					method_name = "do_#{call.message[:do]}"
+					self.public_send(method_name, call)
+				end
+				
+				def do_register(call)
+					call.connection.state.merge!(call.message[:state])
+					
+					@monitors.each do |monitor|
+						begin
+							monitor.register(call.connection)
+						rescue => error
+							Console.error(self, "Error while registering process!", monitor: monitor, exception: error)
+						end
+					end
+				ensure
+					call.finish
+				end
+				
+				def remove(connection)
+					@monitors.each do |monitor|
+						begin
+							monitor.remove(connection)
+						rescue => error
+							Console.error(self, "Error while removing process!", monitor: monitor, exception: error)
+						end
+					end
+				end
+				
+				def run
+					Async do |task|
+						@monitors.each do |monitor|
+							begin
+								monitor.run
+							rescue => error
+								Console.error(self, "Error while starting monitor!", monitor: monitor, exception: error)
+							end
+						end
+						
+						@endpoint.accept do |peer|
+							stream = IO::Stream(peer)
+							connection = Connection.new(stream, 1, remote_address: peer.remote_address)
+							connection.run(self)
+						ensure
+							connection.close
+							remove(connection)
+						end
+						
+						task.children&.each(&:wait)
+					ensure
+						task.stop
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "async"
+require "async/service/generic"
+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

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Async
+	module Container
+		module Supervisor
+			VERSION = "0.1.0"
+		end
+	end
+end

data/lib/async/container/supervisor.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "supervisor/version"
+
+require_relative "supervisor/server"
+require_relative "supervisor/client"
+
+require_relative "supervisor/memory_monitor"
+
+require_relative "supervisor/environment"
+require_relative "supervisor/service"

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2025, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,43 @@
+# Async::Container::Supervisor
+
+Provides a supervisor service for
+
+[![Development Status](https://github.com/socketry/async-container-supervisor/workflows/Test/badge.svg)](https://github.com/socketry/async-container-supervisor/actions?workflow=Test)
+
+## Features
+
+  - Supports multi-process, multi-thread and hybrid containers.
+  - Automatic scalability based on physical hardware.
+  - Direct integration with [systemd](https://www.freedesktop.org/software/systemd/man/sd_notify.html) using `$NOTIFY_SOCKET`.
+  - Internal process readiness protocol for handling state changes.
+  - Automatic restart of failed processes.
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/async-container-supervisor/) for more details.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/async-container-supervisor/releases/index) for all releases.
+
+### v0.1.0
+
+  - Initial implementation.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,5 @@
+# Releases
+
+## v0.1.0
+
+  - Initial implementation.

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: async-container-supervisor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 2025-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: async-service
+  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: io-endpoint
+  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: 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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/async/container/supervisor.rb
+- lib/async/container/supervisor/client.rb
+- lib/async/container/supervisor/connection.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
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/async-container-supervisor
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/async-container-supervisor/
+  source_code_uri: https://github.com/socketry/async-container-supervisor.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A supervisor for managing multiple container processes.
+test_files: []