async-container 0.15.0 → 0.16.0

data/examples/test.rb

@@ -0,0 +1,50 @@
+
+require_relative 'group'
+require_relative 'thread'
+require_relative 'process'
+
+group = Async::Container::Group.new
+
+thread_monitor = Fiber.new do
+	while true
+		thread = Async::Container::Thread.fork do |instance|
+			if rand < 0.2
+				raise "Random Failure!"
+			end
+			
+			instance.send(ready: true, status: "Started Thread")
+			
+			sleep(1)
+		end
+		
+		status = group.wait_for(thread) do |message|
+			puts "Thread message: #{message}"
+		end
+		
+		puts "Thread status: #{status}"
+	end
+end.resume
+
+process_monitor = Fiber.new do
+	while true
+		# process = Async::Container::Process.fork do |instance|
+		# 	if rand < 0.2
+		# 		raise "Random Failure!"
+		# 	end
+		# 
+		# 	instance.send(ready: true, status: "Started Process")
+		# 
+		# 	sleep(1)
+		# end
+		
+		process = Async::Container::Process.spawn('bash -c "sleep 1; echo foobar; sleep 1; exit -1"')
+		
+		status = group.wait_for(process) do |message|
+			puts "Process message: #{message}"
+		end
+		
+		puts "Process status: #{status}"
+	end
+end.resume
+
+group.wait

data/examples/udppipe.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'async/io'
+require 'async/io/endpoint'
+require 'async/io/unix_endpoint'
+
+@endpoint = Async::IO::Endpoint.unix("/tmp/notify-test.sock", Socket::SOCK_DGRAM)
+# address = Async::IO::Address.udp("127.0.0.1", 6778)
+# @endpoint = Async::IO::AddressEndpoint.new(address)
+
+def server
+	@endpoint.bind do |server|
+		puts "Receiving..."
+		packet, address = server.recvfrom(512)
+		
+		puts "Received: #{packet} from #{address}"
+	end
+end
+
+def client(data = "Hello World!")
+	@endpoint.connect do |peer|
+		puts "Sending: #{data}"
+		peer.send(data)
+		puts "Sent!"
+	end
+end
+
+Async do |task|
+	server_task = task.async do
+		server
+	end
+	
+	client
+end

data/lib/async/container/best.rb

@@ -26,7 +26,7 @@ module Async
 	# Containers execute one or more "instances" which typically contain a reactor. A container spawns "instances" using threads and/or processes. Because these are resources that must be cleaned up some how (either by `join` or `waitpid`), their creation is deferred until the user invokes `Container#wait`. When executed this way, the container guarantees that all "instances" will be complete once `Container#wait` returns. Containers are constructs for achieving parallelism, and are not designed to be used directly for concurrency. Typically, you'd create one or more container, add some tasks to it, and then wait for it to complete.
 	module Container
 		def self.fork?
-			Process.respond_to?(:fork) and Process.respond_to?(:setpgid)
+			::Process.respond_to?(:fork) && ::Process.respond_to?(:setpgid)
 		end
 		
 		def self.best_container_class

data/lib/async/container/channel.rb

@@ -0,0 +1,57 @@
+# Copyright, 2020, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require 'json'
+
+module Async
+	module Container
+		class Channel
+			def initialize
+				@in, @out = ::IO.pipe
+			end
+			
+			attr :in
+			attr :out
+			
+			def close_read
+				@in.close
+			end
+			
+			def close_write
+				@out.close
+			end
+			
+			def close
+				close_read
+				close_write
+			end
+			
+			def receive
+				if data = @in.gets
+					begin
+						return JSON.parse(data, symbolize_names: true)
+					rescue
+						return {line: data}
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/container/controller.rb

@@ -22,10 +22,11 @@ require_relative 'error'
 require_relative 'best'
 
 require_relative 'statistics'
+require_relative 'notify'
 
 module Async
 	module Container
-		class ContainerFailed < Error
+		class ContainerError < Error
 			def initialize(container)
 				super("Could not create container!")
 				@container = container
@@ -37,12 +38,37 @@ module Async
 		# Manages the life-cycle of a container.
 		class Controller
 			SIGHUP = Signal.list["HUP"]
-			DEFAULT_TIMEOUT = 2
+			SIGINT = Signal.list["INT"]
+			SIGTERM = Signal.list["TERM"]
+			SIGUSR1 = Signal.list["USR1"]
+			SIGUSR2 = Signal.list["USR2"]
 			
-			def initialize(startup_duration: DEFAULT_TIMEOUT)
+			def initialize(notify: Notify.open!)
 				@container = nil
 				
-				@startup_duration = startup_duration
+				if @notify = notify
+					@notify.status!("Initializing...")
+				end
+				
+				@signals = {}
+				
+				trap(SIGHUP, &self.method(:restart))
+			end
+			
+			def state_string
+				if running?
+					"running"
+				else
+					"stopped"
+				end
+			end
+			
+			def to_s
+				"#{self.class} #{state_string}"
+			end
+			
+			def trap(signal, &block)
+				@signals[signal] = block
 			end
 			
 			attr :container
@@ -51,11 +77,21 @@ module Async
 				Container.new
 			end
 			
+			def running?
+				!!@container
+			end
+			
+			def wait
+				@container&.wait
+			end
+			
 			def setup(container)
+				# Don't do this, otherwise calling super is risky for sub-classes:
+				# raise NotImplementedError, "Container setup is must be implemented in derived class!"
 			end
 			
 			def start
-				self.restart
+				self.restart unless @container
 			end
 			
 			def stop(graceful = true)
@@ -63,47 +99,94 @@ module Async
 				@container = nil
 			end
 			
-			def restart(duration = @startup_duration)
-				hup_action = Signal.trap(:HUP, :IGNORE)
+			def restart
+				if @container
+					@notify&.restarting!
+					
+					Async.logger.debug(self) {"Restarting container..."}
+				else
+					Async.logger.debug(self) {"Starting container..."}
+				end
+				
 				container = self.create_container
 				
 				begin
 					self.setup(container)
 				rescue
-					raise ContainerFailed, container
+					@notify&.error!($!.to_s)
+					
+					raise ContainerError, container
 				end
 				
+				# Wait for all child processes to enter the ready state.
 				Async.logger.debug(self, "Waiting for startup...")
-				container.sleep(duration)
+				container.wait_until_ready
 				Async.logger.debug(self, "Finished startup.")
 				
 				if container.failed?
+					@notify&.error!($!.to_s)
+					
 					container.stop
 					
-					raise ContainerFailed, container
+					raise ContainerError, container
 				end
 				
-				@container&.stop
+				# Make this swap as atomic as possible:
+				old_container = @container
 				@container = container
-			ensure
-				Signal.trap(:HUP, hup_action)
+				
+				old_container&.stop
+				@notify&.ready!
+			rescue
+				# If we are leaving this function with an exception, try to kill the container:
+				container&.stop(false)
+			end
+			
+			def reload
+				@notify&.reloading!
+				
+				Async.logger.info(self) {"Reloading container: #{@container}..."}
+				
+				begin
+					self.setup(@container)
+				rescue
+					raise ContainerError, container
+				end
+				
+				# Wait for all child processes to enter the ready state.
+				Async.logger.debug(self, "Waiting for startup...")
+				@container.wait_until_ready
+				Async.logger.debug(self, "Finished startup.")
+				
+				if @container.failed?
+					@notify.error!("Container failed!")
+					
+					raise ContainerError, @container
+				else
+					@notify&.ready!
+				end
 			end
 			
 			def run
-				Async.logger.debug(self) {"Starting container..."}
+				# I thought this was the default... but it doesn't always raise an exception unless you do this explicitly.
+				interrupt_action = Signal.trap(:INT) do
+					raise Interrupt
+				end
+				
+				terminate_action = Signal.trap(:TERM) do
+					raise Terminate
+				end
 				
 				self.start
 				
-				while true
+				while @container&.running?
 					begin
 						@container.wait
 					rescue SignalException => exception
-						if exception.signo == SIGHUP
-							Async.logger.info(self) {"Reloading container..."}
-							
+						if handler = @signals[exception.signo]
 							begin
-								self.restart
-							rescue ContainerFailed => failure
+								handler.call
+							rescue ContainerError => failure
 								Async.logger.error(self) {failure}
 							end
 						else
@@ -111,8 +194,16 @@ module Async
 						end
 					end
 				end
+			rescue Interrupt
+				self.stop(true)
+			rescue Terminate
+				self.stop(false)
+			else
+				self.stop(true)
 			ensure
-				self.stop
+				# Restore the interrupt handler:
+				Signal.trap(:INT, interrupt_action)
+				Signal.trap(:TERM, terminate_action)
 			end
 		end
 	end

data/lib/async/container/error.rb

@@ -22,5 +22,15 @@ module Async
 	module Container
 		class Error < StandardError
 		end
+		
+		Interrupt = ::Interrupt
+		
+		class Terminate < SignalException
+			SIGTERM = Signal.list['TERM']
+
+			def initialize
+				super(SIGTERM)
+			end
+		end
 	end
 end

data/lib/async/container/forked.rb

@@ -18,81 +18,19 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'async/reactor'
-
-require_relative 'group'
 require_relative 'generic'
-require_relative 'statistics'
+require_relative 'process'
 
 module Async
 	# Manages a reactor within one or more threads.
 	module Container
 		class Forked < Generic
-			UNNAMED = "Unnamed"
-			
-			class Instance
-				def name= value
-					::Process.setproctitle(value)
-				end
-				
-				def exec(*arguments)
-					::Process.exec(*arguments)
-				end
-			end
-			
-			def self.run(*args, &block)
-				self.new.run(*args, &block)
-			end
-			
 			def self.multiprocess?
 				true
 			end
 			
-			def initialize
-				super
-				
-				@group = Group.new
-			end
-			
-			def spawn(name: nil, restart: false)
-				Fiber.new do
-					while true
-						@statistics.spawn!
-						exit_status = @group.fork do
-							::Process.setproctitle(name) if name
-							
-							yield Instance.new
-						end
-						
-						if exit_status.success?
-							Async.logger.info(self) {"#{name || UNNAMED} #{exit_status}"}
-						else
-							@statistics.failure!
-							Async.logger.error(self) {exit_status}
-						end
-						
-						if restart
-							@statistics.restart!
-						else
-							break
-						end
-					end
-				end.resume
-				
-				return self
-			end
-			
-			def sleep(duration)
-				@group.sleep(duration)
-			end
-			
-			def wait
-				@group.wait
-			end
-			
-			# Gracefully shut down all children processes.
-			def stop(graceful = true)
-				@group.stop(graceful)
+			def start(name, &block)
+				Process.fork(name: name, &block)
 			end
 		end
 	end