async-container 0.15.0 → 0.16.0

data/lib/async/container/generic.rb

@@ -18,10 +18,14 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'async/reactor'
+require 'async'
 
 require 'etc'
 
+require_relative 'group'
+require_relative 'keyed'
+require_relative 'statistics'
+
 module Async
 	module Container
 		# @return [Integer] the number of hardware processors which can run threads/processes simultaneously.
@@ -32,8 +36,30 @@ module Async
 		end
 		
 		class Generic
-			def initialize
+			def self.run(*arguments, **options, &block)
+				self.new.run(*arguments, **options, &block)
+			end
+			
+			UNNAMED = "Unnamed"
+			
+			def initialize(**options)
+				@group = Group.new
+				@running = true
+				
+				@state = {}
+				
 				@statistics = Statistics.new
+				@keyed = {}
+			end
+			
+			attr :state
+			
+			def to_s
+				"#{self.class} with #{@statistics.spawns} spawns and #{@statistics.failures} failures."
+			end
+			
+			def [] key
+				@keyed[key]&.value
 			end
 			
 			attr :statistics
@@ -42,23 +68,168 @@ module Async
 				@statistics.failed?
 			end
 			
+			# Whether there are running tasks.
+			def running?
+				@group.running?
+			end
+			
+			# Sleep until some state change occurs.
+			# @param duration [Integer] the maximum amount of time to sleep for.
+			def sleep(duration = nil)
+				@group.sleep(duration)
+			end
+			
+			# Wait until all spawned tasks are completed.
+			def wait
+				@group.wait
+			end
+			
+			def status?(flag)
+				# This also returns true if all processes have exited/failed:
+				@state.all?{|_, state| state[flag]}
+			end
+			
+			def wait_until_ready
+				while true
+					Async.logger.debug(self) do |buffer|
+						buffer.puts "Waiting for ready:"
+						@state.each do |child, state|
+							buffer.puts "\t#{child.class}: #{state.inspect}"
+						end
+					end
+					
+					self.sleep
+					
+					if self.status?(:ready)
+						return true
+					end
+				end
+			end
+			
+			def stop(timeout = true)
+				@running = false
+				@group.stop(timeout)
+				
+				if @group.running?
+					Async.logger.warn(self) {"Group is still running after stopping it!"}
+				end
+			ensure
+				@running = true
+			end
+			
+			def spawn(name: nil, restart: false, key: nil, &block)
+				name ||= UNNAMED
+				
+				if mark?(key)
+					Async.logger.debug(self) {"Reusing existing child for #{key}: #{name}"}
+					return false
+				end
+				
+				@statistics.spawn!
+				
+				Fiber.new do
+					while @running
+						child = self.start(name, &block)
+						
+						state = insert(key, child)
+						
+						begin
+							status = @group.wait_for(child) do |message|
+								state.update(message)
+							end
+						ensure
+							delete(key, child)
+						end
+						
+						if status.success?
+							Async.logger.info(self) {"#{child} #{status}"}
+						else
+							@statistics.failure!
+							Async.logger.error(self) {status}
+						end
+						
+						if restart
+							@statistics.restart!
+						else
+							break
+						end
+					end
+				# ensure
+				# 	Async.logger.error(self) {$!} if $!
+				end.resume
+				
+				return true
+			end
+			
 			def async(**options, &block)
 				spawn(**options) do |instance|
-					begin
-						Async::Reactor.run(instance, &block)
-					rescue Interrupt
-						# Graceful exit.
-					end
+					Async::Reactor.run(instance, &block)
 				end
 			end
 			
 			def run(count: Container.processor_count, **options, &block)
 				count.times do
-					async(**options, &block)
+					spawn(**options, &block)
 				end
 				
 				return self
 			end
+			
+			def reload
+				@keyed.each_value(&:clear!)
+				
+				yield
+				
+				dirty = false
+				
+				@keyed.delete_if do |key, value|
+					value.stop? && (dirty = true)
+				end
+				
+				return dirty
+			end
+			
+			def mark?(key)
+				if key
+					if value = @keyed[key]
+						value.mark!
+						
+						return true
+					end
+				end
+				
+				return false
+			end
+			
+			def key?(key)
+				if key
+					@keyed.key?(key)
+				end
+			end
+			
+			protected
+			
+			# Register the child (value) as running.
+			def insert(key, child)
+				if key
+					@keyed[key] = Keyed.new(key, child)
+				end
+				
+				state = {}
+				
+				@state[child] = state
+				
+				return state
+			end
+			
+			# Clear the child (value) as running.
+			def delete(key, child)
+				if key
+					@keyed.delete(key)
+				end
+				
+				@state.delete(child)
+			end
 		end
 	end
 end

data/lib/async/container/group.rb

@@ -18,83 +18,143 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'fiber'
+
+require 'async/clock'
+
+require_relative 'error'
+
 module Async
 	module Container
+		# Manages a group of running processes.
 		class Group
 			def initialize
-				@pgid = nil
 				@running = {}
 				
+				# This queue allows us to wait for processes to complete, without spawning new processes as a result.
 				@queue = nil
 			end
 			
-			def spawn(*arguments)
-				self.yield
-				
-				if pid = ::Process.spawn(*arguments)
-					wait_for(pid)
-				end
-			end
+			# @attribute [Hash<IO, Fiber>] the running tasks, indexed by IO.
+			attr :running
 			
-			def fork(&block)
-				self.yield
-				
-				if pid = ::Process.fork(&block)
-					wait_for(pid)
-				end
+			def running?
+				@running.any?
 			end
 			
 			def any?
 				@running.any?
 			end
 			
+			def empty?
+				@running.empty?
+			end
+			
+			# This method sleeps for at most the specified duration.
 			def sleep(duration)
 				self.resume
 				self.suspend
 				
-				Kernel::sleep(duration)
-				
-				while self.wait_one(::Process::WNOHANG)
-				end
+				self.wait_for_children(duration)
 			end
 			
 			def wait
 				self.resume
 				
-				while self.any?
-					self.wait_one
+				while self.running?
+					self.wait_for_children
 				end
 			end
 			
-			def kill(signal = :INT)
-				::Process.kill(signal, -@pgid) if @pgid
+			def interrupt
+				@running.each_value do |fiber|
+					fiber.resume(Interrupt)
+				end
 			end
 			
-			def stop(graceful = false)
-				if graceful
-					self.kill(:INT)
-					interrupt_all
+			def terminate
+				@running.each_value do |fiber|
+					fiber.resume(Terminate)
 				end
-			ensure
-				self.close
 			end
 			
-			def close
-				begin
-					self.kill(:TERM)
-				rescue Errno::EPERM
-					# Sometimes, `kill` code can give EPERM, if any signal couldn't be delivered to a child. This might occur if an exception is thrown in the user code (e.g. within the fiber), and there are other zombie processes which haven't been reaped yet. These should be dealt with below, so it shouldn't be an issue to ignore this condition.
+			def stop(timeout = 1)
+				# Handle legacy `graceful = true` argument:
+				if timeout
+					start_time = Async::Clock.now
+					
+					# Use a default timeout if not specified:
+					timeout = 1 if timeout == true
+					
+					self.interrupt
+					
+					while self.any?
+						duration = Async::Clock.now - start_time
+						remaining = timeout - duration
+						
+						if remaining >= 0
+							self.wait_for_children(duration)
+						else
+							self.wait_for_children(0)
+							break
+						end
+					end
+				end
+				
+				# Timeout can also be `graceful = false`:
+				if timeout
+					self.interrupt
+					self.sleep(timeout)
 				end
 				
-				# Clean up zombie processes - if user presses Ctrl-C or for some reason something else blows up, exception would propagate back to caller:
-				interrupt_all
+				self.wait_for_children(duration)
+				
+				# Terminate all children:
+				self.terminate
+				
+				# Wait for all children to exit:
+				self.wait
+			end
+			
+			def wait_for(channel)
+				io = channel.in
+				
+				@running[io] = Fiber.current
+				
+				while @running.key?(io)
+					result = Fiber.yield
+					
+					if result == Interrupt
+						channel.interrupt!
+					elsif result == Terminate
+						channel.terminate!
+					elsif message = channel.receive
+						yield message
+					else
+						return channel.wait
+					end
+				end
+			ensure
+				@running.delete(io)
 			end
 			
 			protected
 			
+			def wait_for_children(duration = nil)
+				if !@running.empty?
+					readable, _, _ = ::IO.select(@running.keys, nil, nil, duration)
+					
+					readable&.each do |io|
+						@running[io].resume
+					end
+				end
+			end
+			
 			def yield
 				if @queue
-					@queue << Fiber.current
+					fiber = Fiber.current
+					
+					@queue << fiber
 					Fiber.yield
 				end
 			end
@@ -105,65 +165,10 @@ module Async
 			
 			def resume
 				if @queue
-					@queue.each(&:resume)
+					queue = @queue
 					@queue = nil
-				end
-			end
-			
-			def interrupt_all
-				while self.any?
-					self.wait_one do |fiber, status|
-						begin
-							# This causes the waiting fiber to `raise Interrupt`:
-							fiber.resume(nil)
-						rescue Interrupt
-							# Graceful exit.
-						end
-					end
-				end
-			end
-			
-			# Wait for one process, should only be called when a child process has finished, otherwise would block.
-			def wait_one(flags = 0)
-				return unless @pgid
-				
-				# Wait for processes in this group:
-				pid, status = ::Process.wait2(-@pgid, flags)
-				
-				return if flags & ::Process::WNOHANG and pid == nil
-				
-				fiber = @running.delete(pid)
-				
-				if @running.empty?
-					@pgid = nil
-				end
-				
-				if block_given?
-					yield fiber, status
-				else
-					fiber.resume(status)
-				end
-			end
-			
-			def wait_for(pid)
-				if @pgid
-					# Set this process as part of the existing process group:
-					::Process.setpgid(pid, @pgid)
-				else
-					# Establishes the child process as a process group leader:
-					::Process.setpgid(pid, 0)
 					
-					# Save the process group id:
-					@pgid = pid
-				end
-				
-				@running[pid] = Fiber.current
-				
-				# Return process status:
-				if result = Fiber.yield
-					return result
-				else
-					raise Interrupt
+					queue.each(&:resume)
 				end
 			end
 		end