WIP

Author: ioquatix

async-container-demo/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "async-container", path: "../"
+gem "debug"

async-container-demo/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: ..
+  specs:
+    async-container (0.18.3)
+      async (~> 2.10)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    async (2.21.1)
+      console (~> 1.29)
+      fiber-annotation
+      io-event (~> 1.6, >= 1.6.5)
+    console (1.29.0)
+      fiber-annotation
+      fiber-local (~> 1.1)
+      json
+    date (3.4.1)
+    debug (1.9.2)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    fiber-annotation (0.2.0)
+    fiber-local (1.1.0)
+      fiber-storage
+    fiber-storage (1.0.0)
+    io-console (0.8.0)
+    io-event (1.7.4)
+    irb (1.14.1)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.9.0)
+    psych (5.2.1)
+      date
+      stringio
+    rdoc (6.8.1)
+      psych (>= 4.0.0)
+    reline (0.5.12)
+      io-console (~> 0.5)
+    stringio (3.1.2)
+
+PLATFORMS
+  arm64-darwin-22
+  ruby
+
+DEPENDENCIES
+  async-container!
+  debug
+
+BUNDLED WITH
+   2.5.22

async-container-demo/jobs

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "console"
+
+Console.logger.debug!
+
+class Jobs
+	LOG_FILE = File.join(Dir.pwd, "jobs.log")
+
+	def self.start = self.new.start
+
+	def start
+		Console.debug(self, "Starting jobs...")
+
+		loop do
+			Console.info(self, "Jobs running...")
+
+			sleep 1
+		end
+		rescue Interrupt
+			Console.debug(self, "Exiting jobs...")
+			exit
+	end
+end
+
+Jobs.start

async-container-demo/start

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "async/container"
+require "console"
+require "debug"
+
+# container = Async::Container.new
+
+# container.spawn(name: "Web") do |task|
+#   task.exec("bundle", "exec", "web")
+# end
+
+# container.spawn(name: "Jobs") do |task|
+#   task.exec("bundle", "exec", "jobs")
+# end
+
+Console.logger.debug!
+
+class WebController < Async::Container::Controller
+	def setup(container)
+		container.spawn(name: "Web") do |instance|
+			instance.exec("bundle", "exec", "web")
+		end
+
+		# container.spawn(name: "Jobs") do |instance|
+		#   instance.exec("bundle", "exec", "jobs")
+		# end
+	end
+end
+
+class App
+	def self.start = self.new.start
+
+	def start
+		Console.debug(self, "Starting container...")
+
+		web_controller = WebController.new
+		web_controller.run
+	end
+end
+
+pid = Process.pid
+pgid = Process.getpgid(pid)
+
+Thread.new do
+	sleep 5
+	Console.debug(self, "Sending HUP signal to restart container...")
+	Process.kill("HUP", -pgid)
+		
+	# sleep 5
+	# Console.debug(self, "Sending INT signal to stop container...")
+	# Process.kill("INT", Process.pid)
+end
+
+App.start

async-container-demo/web

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "console"
+
+Console.logger.debug!
+
+class Web
+	LOG_FILE = File.join(Dir.pwd, "web.log")
+
+	def self.start = self.new.start
+
+	def start
+		Console.debug(self, "Starting web...")
+
+		loop do
+			Console.info(self, "Web running...")
+
+			sleep 1
+		end
+		rescue Interrupt
+			Console.debug(self, "Exiting web...")
+			exit
+	end
+end
+
+Web.start

lib/async/container/controller.rb

@@ -186,17 +186,17 @@ 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
-					# $stderr.puts "Received INT signal, terminating...", caller
+					$stderr.puts "Received INT signal, terminating...", caller
 					::Thread.current.raise(Interrupt)
 				end
 
 				terminate_action = Signal.trap(:TERM) do
-					# $stderr.puts "Received TERM signal, terminating...", caller
+					$stderr.puts "Received TERM signal, terminating...", caller
 					::Thread.current.raise(Terminate)
 				end
 
 				hangup_action = Signal.trap(:HUP) do
-					# $stderr.puts "Received HUP signal, restarting...", caller
+					$stderr.puts "Received HUP signal, restarting...", caller
 					::Thread.current.raise(Hangup)
 				end
 
@@ -208,6 +208,7 @@ def run
 					rescue SignalException => exception
 						if handler = @signals[exception.signo]
 							begin
+								Console.debug(self, "Invoking signal handler for #{exception.signo}...", handler: handler)
 								handler.call
 							rescue SetupError => error
 								Console.error(self) {error}

lib/async/container/generic.rb

@@ -107,13 +107,20 @@ def wait_until_ready
 					Console.debug(self) do |buffer|
 						buffer.puts "Waiting for ready:"
 						@state.each do |child, state|
-							buffer.puts "\t#{child.class}: #{state.inspect}"
+							buffer.puts "\t#{child.inspect}: #{state}"
 						end
 					end
 
 					self.sleep
 
 					if self.status?(:ready)
+						Console.logger.debug(self) do |buffer|
+							buffer.puts "All ready:"
+							@state.each do |child, state|
+								buffer.puts "\t#{child.inspect}: #{state}"
+							end
+						end
+						
 						return true
 					end
 				end

lib/async/container/group.rb

@@ -137,7 +137,8 @@ def wait_for(channel)
 			protected
 
 			def wait_for_children(duration = nil)
-				Console.debug(self, "Waiting for children...", duration: duration)
+				Console.debug(self, "Waiting for children...", duration: duration, running: @running)
+				
 				if !@running.empty?
 					# Maybe consider using a proper event loop here:
 					readable, _, _ = ::IO.select(@running.keys, nil, nil, duration)

lib/async/container/process.rb

@@ -122,10 +122,12 @@ def name= value
 
 			# A human readable representation of the process.
 			# @returns [String]
-			def to_s
-				"\#<#{self.class} #{@name}>"
+			def inspect
+				"\#<#{self.class} name=#{@name.inspect} status=#{@status.inspect} pid=#{@pid.inspect}>"
 			end
 
+			alias to_s inspect
+			
 			# Invoke {#terminate!} and then {#wait} for the child process to exit.
 			def close
 				self.terminate!
@@ -151,6 +153,8 @@ def terminate!
 			# Wait for the child process to exit.
 			# @returns [::Process::Status] The process exit status.
 			def wait
+				$stderr.puts "Waiting for #{@pid}...", caller
+				
 				if @pid && @status.nil?
 					_, @status = ::Process.wait2(@pid, ::Process::WNOHANG)