async-container 0.18.3 → 0.20.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-container
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.20.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -9,7 +9,6 @@ authors:
 - Anton Sozontov
 - Juan Antonio Martín Lucas
 - Yuji Yaginuma
-autorequire:
 bindir: bin
 cert_chain:
 - |
@@ -41,7 +40,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-09-04 00:00:00.000000000 Z
+date: 2025-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -49,16 +48,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '2.22'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
-description:
-email:
+        version: '2.22'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -79,20 +76,18 @@ files:
 - lib/async/container/notify/pipe.rb
 - lib/async/container/notify/server.rb
 - lib/async/container/notify/socket.rb
-- lib/async/container/process.rb
 - lib/async/container/statistics.rb
-- lib/async/container/thread.rb
 - lib/async/container/threaded.rb
 - lib/async/container/version.rb
 - license.md
 - readme.md
+- releases.md
 homepage: https://github.com/socketry/async-container
 licenses:
 - MIT
 metadata:
   documentation_uri: https://socketry.github.io/async-container/
   source_code_uri: https://github.com/socketry/async-container.git
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -107,8 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Abstract container-based parallelism using threads and processes where appropriate.
 test_files: []

data/lib/async/container/process.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2020-2024, by Samuel Williams.
-
-require_relative 'channel'
-require_relative 'error'
-
-require_relative 'notify/pipe'
-
-module Async
-	module Container
-		# Represents a running child process from the point of view of the parent container.
-		class Process < Channel
-			# Represents a running child process from the point of view of the child process.
-			class Instance < Notify::Pipe
-				# Wrap an instance around the {Process} instance from within the forked child.
-				# @parameter process [Process] The process intance to wrap.
-				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
-				
-				# Set the process title to the specified value.
-				# @parameter value [String] The name of the process.
-				def name= value
-					if @name = value
-						::Process.setproctitle(@name)
-					end
-				end
-				
-				# The name of the process.
-				# @returns [String]
-				def name
-					@name
-				end
-				
-				# Replace the current child process with a different one. Forwards arguments and options to {::Process.exec}.
-				# This method replaces the child process with the new executable, thus this method never returns.
-				def exec(*arguments, ready: true, **options)
-					if ready
-						self.ready!(status: "(exec)")
-					else
-						self.before_spawn(arguments, options)
-					end
-					
-					::Process.exec(*arguments, **options)
-				end
-			end
-			
-			# Fork a child process appropriate for a container.
-			# @returns [Process]
-			def self.fork(**options)
-				self.new(**options) do |process|
-					::Process.fork do
-						# We use `Thread.current.raise(...)` so that exceptions are filtered through `Thread.handle_interrupt` correctly.
-						Signal.trap(:INT) {::Thread.current.raise(Interrupt)}
-						Signal.trap(:TERM) {::Thread.current.raise(Terminate)}
-						
-						begin
-							yield Instance.for(process)
-						rescue Interrupt
-							# Graceful exit.
-						rescue Exception => error
-							Console.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
-			
-			# Initialize the process.
-			# @parameter name [String] The name to use for the child process.
-			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
-			
-			# Set the name of the process.
-			# Invokes {::Process.setproctitle} if invoked in the child process.
-			def name= value
-				@name = value
-				
-				# If we are the child process:
-				::Process.setproctitle(@name) if @pid.nil?
-			end
-			
-			# The name of the process.
-			# @attribute [String]
-			attr :name
-			
-			# A human readable representation of the process.
-			# @returns [String]
-			def to_s
-				"\#<#{self.class} #{@name}>"
-			end
-			
-			# Invoke {#terminate!} and then {#wait} for the child process to exit.
-			def close
-				self.terminate!
-				self.wait
-			ensure
-				super
-			end
-			
-			# Send `SIGINT` to the child process.
-			def interrupt!
-				unless @status
-					::Process.kill(:INT, @pid)
-				end
-			end
-			
-			# Send `SIGTERM` to the child process.
-			def terminate!
-				unless @status
-					::Process.kill(:TERM, @pid)
-				end
-			end
-			
-			# Wait for the child process to exit.
-			# @returns [::Process::Status] The process exit status.
-			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?
-						Console.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

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2020-2024, by Samuel Williams.
-# Copyright, 2020, by Olle Jonsson.
-
-require_relative 'channel'
-require_relative 'error'
-require_relative 'notify/pipe'
-
-module Async
-	module Container
-		# Represents a running child thread from the point of view of the parent container.
-		class Thread < Channel
-			# Used to propagate the exit status of a child process invoked by {Instance#exec}.
-			class Exit < Exception
-				# Initialize the exit status.
-				# @parameter status [::Process::Status] The process exit status.
-				def initialize(status)
-					@status = status
-				end
-				
-				# The process exit status.
-				# @attribute [::Process::Status]
-				attr :status
-				
-				# The process exit status if it was an error.
-				# @returns [::Process::Status | Nil]
-				def error
-					unless status.success?
-						status
-					end
-				end
-			end
-			
-			# Represents a running child thread from the point of view of the child thread.
-			class Instance < Notify::Pipe
-				# Wrap an instance around the {Thread} instance from within the threaded child.
-				# @parameter thread [Thread] The thread intance to wrap.
-				def self.for(thread)
-					instance = self.new(thread.out)
-					
-					return instance
-				end
-				
-				def initialize(io)
-					@name = nil
-					@thread = ::Thread.current
-					
-					super
-				end
-				
-				# Set the name of the thread.
-				# @parameter value [String] The name to set.
-				def name= value
-					@thread.name = value
-				end
-				
-				# Get the name of the thread.
-				# @returns [String]
-				def name
-					@thread.name
-				end
-				
-				# Execute a child process using {::Process.spawn}. In order to simulate {::Process.exec}, an {Exit} instance is raised to propagage exit status.
-				# This creates the illusion that this method does not return (normally).
-				def exec(*arguments, ready: true, **options)
-					if ready
-						self.ready!(status: "(spawn)")
-					else
-						self.before_spawn(arguments, options)
-					end
-					
-					begin
-						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
-			
-			# Initialize the thread.
-			# @parameter name [String] The name to use for the child thread.
-			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
-			
-			# Set the name of the thread.
-			# @parameter value [String] The name to set.
-			def name= value
-				@thread.name = value
-			end
-			
-			# Get the name of the thread.
-			# @returns [String]
-			def name
-				@thread.name
-			end
-			
-			# A human readable representation of the thread.
-			# @returns [String]
-			def to_s
-				"\#<#{self.class} #{@thread.name}>"
-			end
-			
-			# Invoke {#terminate!} and then {#wait} for the child thread to exit.
-			def close
-				self.terminate!
-				self.wait
-			ensure
-				super
-			end
-			
-			# Raise {Interrupt} in the child thread.
-			def interrupt!
-				@thread.raise(Interrupt)
-			end
-			
-			# Raise {Terminate} in the child thread.
-			def terminate!
-				@thread.raise(Terminate)
-			end
-			
-			# Wait for the thread to exit and return he exit status.
-			# @returns [Status]
-			def wait
-				if @waiter
-					@waiter.join
-					@waiter = nil
-				end
-				
-				return @status
-			end
-			
-			# A pseudo exit-status wrapper.
-			class Status
-				# Initialise the status.
-				# @parameter error [::Process::Status] The exit status of the child thread.
-				def initialize(error = nil)
-					@error = error
-				end
-				
-				# Whether the status represents a successful outcome.
-				# @returns [Boolean]
-				def success?
-					@error.nil?
-				end
-				
-				# A human readable representation of the status.
-				def to_s
-					"\#<#{self.class} #{success? ? "success" : "failure"}>"
-				end
-			end
-			
-			protected
-			
-			# Invoked by the @waiter thread to indicate the outcome of the child thread.
-			def finished(error = nil)
-				if error
-					Console.logger.error(self) {error}
-				end
-				
-				@status = Status.new(error)
-				self.close_write
-			end
-		end
-	end
-end