async-container 0.15.0 → 0.16.0

data/lib/async/container/process.rb

@@ -0,0 +1,167 @@
+# 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_relative 'channel'
+require_relative 'error'
+
+require_relative 'notify/pipe'
+
+module Async
+	module Container
+		class Process < Channel
+			class Instance < Notify::Pipe
+				def self.for(process)
+					instance = self.new(process.out)
+					
+					# The child process won't be reading from the channel:
+					process.close_read
+					
+					instance.name = process.name
+					
+					return instance
+				end
+				
+				def initialize(io)
+					super
+					
+					@name = nil
+				end
+				
+				def name= value
+					if @name = value
+						::Process.setproctitle(@name)
+					end
+				end
+				
+				def name
+					@name
+				end
+				
+				def exec(*arguments, ready: true, **options)
+					if ready
+						self.ready!(status: "(exec)") if ready
+					else
+						self.before_spawn(arguments, options)
+					end
+					
+					::Process.exec(*arguments, options)
+				end
+			end
+			
+			def self.fork(**options)
+				self.new(**options) do |process|
+					::Process.fork do
+						Signal.trap(:INT) {raise Interrupt}
+						Signal.trap(:TERM) {raise Terminate}
+						
+						begin
+							yield Instance.for(process)
+						rescue Interrupt
+							# Graceful exit.
+						rescue Exception => error
+							Async.logger.error(self) {error}
+							
+							exit!(1)
+						end
+					end
+				end
+			end
+			
+			# def self.spawn(*arguments, name: nil, **options)
+			# 	self.new(name: name) do |process|
+			# 		unless options.key?(:out)
+			# 			options[:out] = process.out
+			# 		end
+			# 
+			# 		::Process.spawn(*arguments, **options)
+			# 	end
+			# end
+			
+			def initialize(name: nil)
+				super()
+				
+				@name = name
+				@status = nil
+				@pid = nil
+				
+				@pid = yield(self)
+				
+				# The parent process won't be writing to the channel:
+				self.close_write
+			end
+			
+			def name= value
+				@name = value
+				
+				# If we are the child process:
+				::Process.setproctitle(@name) if @pid.nil?
+			end
+			
+			attr :name
+			
+			def to_s
+				if @status
+					"\#<#{self.class} #{@name} -> #{@status}>"
+				elsif @pid
+					"\#<#{self.class} #{@name} -> #{@pid}>"
+				else
+					"\#<#{self.class} #{@name}>"
+				end
+			end
+			
+			def close
+				self.terminate!
+				self.wait
+			ensure
+				super
+			end
+			
+			def interrupt!
+				unless @status
+					::Process.kill(:INT, @pid)
+				end
+			end
+			
+			def terminate!
+				unless @status
+					::Process.kill(:TERM, @pid)
+				end
+			end
+			
+			def wait
+				if @pid && @status.nil?
+					_, @status = ::Process.wait2(@pid, ::Process::WNOHANG)
+					
+					if @status.nil?
+						sleep(0.01)
+						_, @status = ::Process.wait2(@pid, ::Process::WNOHANG)
+					end
+					
+					if @status.nil?
+						Async.logger.warn(self) {"Process #{@pid} is blocking, has it exited?"}
+						_, @status = ::Process.wait2(@pid)
+					end
+				end
+				
+				return @status
+			end
+		end
+	end
+end

data/lib/async/container/thread.rb

@@ -0,0 +1,182 @@
+# 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_relative 'channel'
+require_relative 'notify/pipe'
+
+require 'async/logger'
+
+module Async
+	module Container
+		class Thread < Channel
+			class Exit < Exception
+				def initialize(status)
+					@status = status
+				end
+				
+				attr :status
+				
+				def error
+					unless status.success?
+						status
+					end
+				end
+			end
+			
+			class Instance < Notify::Pipe
+				def self.for(thread)
+					instance = self.new(thread.out)
+					
+					return instance
+				end
+				
+				def initialize(io)
+					@name = nil
+					@thread = ::Thread.current
+					
+					super
+				end
+				
+				def name= value
+					@thread.name = value
+				end
+				
+				def name
+					@thread.name
+				end
+				
+				def exec(*arguments, ready: true, **options)
+					if ready
+						self.ready!(status: "(spawn)") if ready
+					else
+						self.before_spawn(arguments, options)
+					end
+					
+					begin
+						# TODO prefer **options... but it doesn't support redirections on < 2.7
+						pid = ::Process.spawn(*arguments, options)
+					ensure
+						_, status = ::Process.wait2(pid)
+						
+						raise Exit, status
+					end
+				end
+			end
+			
+			def self.fork(**options)
+				self.new(**options) do |thread|
+					::Thread.new do
+						yield Instance.for(thread)
+					end
+				end
+			end
+			
+			def initialize(name: nil)
+				super()
+				
+				@status = nil
+				
+				@thread = yield(self)
+				@thread.report_on_exception = false
+				@thread.name = name
+				
+				@waiter = ::Thread.new do
+					begin
+						@thread.join
+					rescue Exit => exit
+						finished(exit.error)
+					rescue Interrupt
+						# Graceful shutdown.
+						finished
+					rescue Exception => error
+						finished(error)
+					else
+						finished
+					end
+				end
+			end
+			
+			def name= value
+				@thread.name = name
+			end
+			
+			def name
+				@thread.name
+			end
+			
+			def to_s
+				if @status
+					"\#<#{self.class} #{@thread.name} -> #{@status}>"
+				else
+					"\#<#{self.class} #{@thread.name}>"
+				end
+			end
+			
+			def close
+				self.terminate!
+				self.wait
+			ensure
+				super
+			end
+			
+			def interrupt!
+				@thread.raise(Interrupt)
+			end
+			
+			def terminate!
+				@thread.raise(Terminate)
+			end
+			
+			def wait
+				if @waiter
+					@waiter.join
+					@waiter = nil
+				end
+				
+				return @status
+			end
+			
+			class Status
+				def initialize(result = nil)
+					@result = result
+				end
+				
+				def success?
+					@result.nil?
+				end
+				
+				def to_s
+					"\#<#{self.class} #{success? ? "success" : "failure"}>"
+				end
+			end
+			
+			protected
+			
+			def finished(error = nil)
+				if error
+					Async.logger.error(self) {error}
+				end
+				
+				@status = Status.new(error)
+				self.close_write
+			end
+		end
+	end
+end

data/lib/async/container/threaded.rb

@@ -18,105 +18,19 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'async/reactor'
-require 'thread'
-
 require_relative 'generic'
-require_relative 'statistics'
+require_relative 'thread'
 
 module Async
+	# Manages a reactor within one or more threads.
 	module Container
-		# Manages a reactor within one or more threads.
 		class Threaded < Generic
-			class Instance
-				def initialize(thread)
-					@thread = thread
-				end
-				
-				def name= value
-					@thread.name = value
-				end
-				
-				def exec(*arguments)
-					pid = ::Process.spawn(*arguments)
-					
-					::Process.waitpid(pid)
-				ensure
-					::Process.kill(:TERM, pid)
-				end
-			end
-			
-			def self.run(*args, &block)
-				self.new.run(*args, &block)
-			end
-			
 			def self.multiprocess?
 				false
 			end
 			
-			def initialize
-				super
-				
-				@threads = []
-				@running = true
-			end
-			
-			def spawn(name: nil, restart: false, &block)
-				@statistics.spawn!
-				
-				thread = ::Thread.new do
-					thread = ::Thread.current
-					
-					thread.name = name if name
-					
-					instance = Instance.new(thread)
-					
-					while @running
-						begin
-							yield instance
-						rescue Exception => exception
-							Async.logger.error(self) {exception}
-							
-							@statistics.failure!
-						end
-						
-						if restart
-							@statistics.restart!
-						else
-							break
-						end
-					end
-				# rescue Interrupt
-				# 	# Graceful exit.
-				end
-				
-				@threads << thread
-				
-				return self
-			end
-			
-			def sleep(duration)
-				Kernel::sleep(duration)
-			end
-			
-			def wait
-				@threads.each(&:join)
-				@threads.clear
-			end
-			
-			# Gracefully shut down all reactors.
-			def stop(graceful = true)
-				@running = false
-				
-				if graceful
-					@threads.each{|thread| thread.raise(Interrupt)}
-				else
-					@threads.each(&:kill)
-				end
-				
-				self.wait
-			ensure
-				@running = true
+			def start(name, &block)
+				Thread.fork(name: name, &block)
 			end
 		end
 	end