async-io 1.17.2 → 1.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac60f3c447092c125c2bada2e45757ef028828c3dcfa35aebc69dde2f6cf3a3e
-  data.tar.gz: 9c40c940f5550265375556c156f925a7a7a05cadfeff2fe819cdae8b09cbac29
+  metadata.gz: 123cd8404fb47fe4beed0cac26b5b1f6825eb34b6a7e9952ef571c6103f72fab
+  data.tar.gz: c2313c72cd403abddfc5a7235f82c7983639501db2ce664792e46d09cfca7ebe
 SHA512:
-  metadata.gz: e1c3cf6b86633efe3812b91300a273738f5e01ed5fa1c5ee2fba691cb04abc39f6e69562cc0e382511510052a4a120a901bdf385a48aabe150fddc1644e7f332
-  data.tar.gz: 4fd20b81655da735b8f327db0bffa3162d452beebcc8bc9da05c88bd097119206da45da1f9b4aa000acac030fa60a0b70e55d2d7e669f3c1bf21e898dc78b63e
+  metadata.gz: 7fa15dba98d1c12d00ddfdfd2410cefa1767ef946d58751c2a1498b4226ee74a10255f38749c618275116f2b49f081a9d07518cfe4eb1f82416618db27d04426
+  data.tar.gz: df87e800a13784df609488498dba29c72220aac213745e470628f650d0f031dc321b2463e079502a553e5a32aea7d95b6c690d229aa9d5f6201c3e8e45063575

data/.travis.yml

@@ -1,12 +1,7 @@
 language: ruby
-sudo: false
-dist: trusty
+dist: xenial
 cache: bundler
 
-before_script: 
-  - gem update --system
-  - gem install bundler
-
 matrix:
   include:
     - rvm: 2.3
@@ -17,9 +12,7 @@ matrix:
     - rvm: jruby-head
       env: JRUBY_OPTS="--debug -X+O"
     - rvm: ruby-head
-    - rvm: rbx-3
   allow_failures:
     - rvm: ruby-head
     - rvm: truffleruby
     - rvm: jruby-head
-    - rvm: rbx-3

data/README.md

@@ -87,6 +87,40 @@ end
 
 Any `yield` operation can cause a timeout to trigger. Non-`async` functions might not timeout because they are outside the scope of `async`.
 
+#### Wrapper Timeouts
+
+Asynchronous operations may block forever. You can assign a per-wrapper operation timeout duration. All asynchronous operations will be bounded by this timeout.
+
+```ruby
+peer.timeout_duration = 1
+peer.read(512) # If this takes more than 1 second, Async::TimeoutError will be raised.
+```
+
+The benefit of this approach is that it applies to all operations. Typically, this would be configured by the user, and set to something pretty high, e.g. 120 seconds.
+
+### Reading Characters
+
+This example shows how to read one character at a time as the user presses it on the keyboard, and echos it back out as uppercase:
+
+```ruby
+require 'async'
+require 'async/io/stream'
+require 'io/console'
+
+$stdin.raw!
+$stdin.echo = false
+
+Async do |task|
+	stdin = Async::IO::Stream.new(
+		Async::IO::Generic.new($stdin)
+	)
+	
+	while character = stdin.read(1)
+		$stdout.write character.upcase
+	end
+end
+```
+
 ## Contributing
 
 1. Fork it

data/async-io.gemspec

@@ -1,4 +1,4 @@
-# coding: utf-8
+
 require_relative 'lib/async/io/version'
 
 Gem::Specification.new do |spec|
@@ -15,12 +15,12 @@ Gem::Specification.new do |spec|
 	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 	spec.require_paths = ["lib"]
 
-	spec.add_dependency "async", "~> 1.3"
+	spec.add_dependency "async", "~> 1.14"
 	spec.add_development_dependency "async-rspec", "~> 1.10"
 
 	spec.required_ruby_version = '~> 2.3'
 
-	spec.add_development_dependency "bundler", "~> 1.3"
+	spec.add_development_dependency "bundler"
 	spec.add_development_dependency "rake", "~> 10.0"
 	spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/async/io/endpoint.rb

@@ -37,6 +37,14 @@ module Async
 				@options[:hostname]
 			end
 			
+			def reuse_port
+				@options[:reuse_port]
+			end
+			
+			def timeout
+				@options[:timeout]
+			end
+			
 			def each
 				return to_enum unless block_given?
 				

data/lib/async/io/generic.rb

@@ -97,7 +97,13 @@ module Async
 			alias syswrite write
 			alias << write
 			
-			def wait(timeout = nil, mode = :read)
+			def dup
+				super.tap do |copy|
+					copy.timeout = self.timeout
+				end
+			end
+			
+			def wait(timeout = self.timeout, mode = :read)
 				case mode
 				when :read
 					wait_readable(timeout)
@@ -106,12 +112,17 @@ module Async
 				else
 					wait_any(:rw, timeout)
 				end
+			rescue TimeoutError
+				return nil
 			end
 			
 			def nonblock
 				true
 			end
-			alias nonblock= nonblock
+			
+			def nonblock= value
+				true
+			end
 			
 			def nonblock?
 				true
@@ -121,17 +132,19 @@ module Async
 				!@io.closed?
 			end
 			
+			attr_accessor :timeout
+			
 			protected
 			
-			def async_send(*args)
+			def async_send(*args, timeout: self.timeout)
 				while true
 					result = @io.__send__(*args, exception: false)
 					
 					case result
 					when :wait_readable
-						wait_readable
+						wait_readable(timeout)
 					when :wait_writable
-						wait_writable
+						wait_writable(timeout)
 					else
 						return result
 					end

data/lib/async/io/shared_endpoint.rb

@@ -49,7 +49,9 @@ module Async
 				self.new(endpoint, [peer])
 			end
 			
-			def initialize(endpoint, wrappers)
+			def initialize(endpoint, wrappers, **options)
+				super(**options)
+				
 				@endpoint = endpoint
 				@wrappers = wrappers
 			end

data/lib/async/io/socket.rb

@@ -87,11 +87,11 @@ module Async
 		end
 		
 		module Server
-			def accept_each(task: Task.current)
+			def accept_each(timeout: nil, task: Task.current)
 				task.annotate "accepting connections #{self.local_address.inspect}"
 				
 				while true
-					self.accept(task: task) do |io, address|
+					self.accept(timeout: timeout, task: task) do |io, address|
 						yield io, address, task: task
 					end
 				end
@@ -115,10 +115,13 @@ module Async
 			
 			alias connect_nonblock connect
 			
-			def accept(task: Task.current)
-				peer, address = async_send(:accept_nonblock)
+			# @param duration [Numeric] the maximum time to wait for accepting a connection, if specified.
+			def accept(timeout: nil, task: Task.current)
+				peer, address = async_send(:accept_nonblock, timeout: timeout)
 				wrapper = Socket.new(peer, task.reactor)
 				
+				wrapper.timeout = self.timeout
+				
 				return wrapper, address unless block_given?
 				
 				task.async do |task|
@@ -126,8 +129,6 @@ module Async
 					
 					begin
 						yield wrapper, address
-					rescue
-						Async.logger.error(self) {$!}
 					ensure
 						wrapper.close
 					end
@@ -137,12 +138,15 @@ module Async
 			alias accept_nonblock accept
 			alias sysaccept accept
 			
-			def self.build(*args, task: Task.current)
+			def self.build(*args, timeout: nil, task: Task.current)
 				socket = wrapped_klass.new(*args)
 				
 				yield socket
 				
-				return self.new(socket, task.reactor)
+				wrapper = self.new(socket, task.reactor)
+				wrapper.timeout = timeout
+				
+				return wrapper
 			rescue Exception
 				socket.close if socket
 				
@@ -168,8 +172,6 @@ module Async
 					if local_address
 						socket.bind(local_address.to_sockaddr)
 					end
-					
-					self.new(socket, task.reactor)
 				end
 				
 				begin
@@ -199,7 +201,6 @@ module Async
 				Async.logger.debug(self) {"Binding to #{local_address.inspect}"}
 				
 				wrapper = build(local_address.afamily, local_address.socktype, protocol, **options) do |socket|
-					
 					if reuse_address
 						socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, 1)
 					end

data/lib/async/io/ssl_socket.rb

@@ -84,6 +84,9 @@ module Async
 					# This ensures that when the internal IO is closed, it also closes the internal socket:
 					io.sync_close = true
 					
+					# Copy the timeout:
+					@timeout = socket.timeout
+					
 					super(io, socket.reactor)
 				end
 			end
@@ -102,7 +105,7 @@ module Async
 				self.class.new(@server.dup, @context)
 			end
 			
-			def_delegators :@server, :local_address, :setsockopt, :getsockopt, :close, :close_on_exec=, :reactor=
+			def_delegators :@server, :local_address, :setsockopt, :getsockopt, :close, :close_on_exec=, :reactor=, :timeout, :timeout=
 			
 			attr :server
 			attr :context
@@ -111,8 +114,8 @@ module Async
 				@server.listen(*args)
 			end
 			
-			def accept(task: Task.current)
-				peer, address = @server.accept
+			def accept(task: Task.current, **options)
+				peer, address = @server.accept(**options)
 				
 				wrapper = SSLSocket.new(peer, @context)
 				
@@ -126,8 +129,6 @@ module Async
 						wrapper.accept
 						
 						yield wrapper, address
-					rescue
-						Async.logger.error(self) {$!}
 					ensure
 						wrapper.close
 					end

data/lib/async/io/trap.rb

@@ -20,6 +20,8 @@
 
 require_relative 'notification'
 
+require 'thread'
+
 module Async
 	module IO
 		# A cross-reactor/process notification pipe.
@@ -27,12 +29,30 @@ module Async
 			def initialize(name)
 				@name = name
 				@notifications = []
+				
+				@installed = false
+				@mutex = Mutex.new
+			end
+			
+			# Ignore the trap within the current process. Can be invoked before forking and/or invoking `install!` to assert default behaviour.
+			def ignore!
+				Signal.trap(@name, "IGNORE")
 			end
 			
+			# Install the trap into the current process. Thread safe.
+			# @return [Boolean] whether the trap was installed or not. If the trap was already installed, returns nil.
 			def install!
-				Signal.trap(@name, &self.method(:trigger))
+				return if @installed
+				
+				@mutex.synchronize do
+					return if @installed
+					
+					Signal.trap(@name, &self.method(:trigger))
+					
+					@installed = true
+				end
 				
-				return self
+				return true
 			end
 			
 			# Block the calling task until the signal occurs.

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.17.2"
+		VERSION = "1.18.1"
 	end
 end

data/spec/async/io/c10k_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe "echo client/server" do
 	# sudo sysctl -w net.inet.ip.portrange.hifirst=10000
 	# Probably due to the use of select.
 	
-	let(:repeats) {RUBY_PLATFORM =~ /darwin/ ? 100 : 10000}
+	let(:repeats) {RUBY_PLATFORM =~ /darwin/ ? 200 : 10000}
 	let(:server_address) {Async::IO::Address.tcp('0.0.0.0', 10102)}
 	
 	def echo_server(server_address)
@@ -99,19 +99,7 @@ RSpec.describe "echo client/server" do
 			example.run
 		end
 		
-		example.reporter.message "Handled #{repeats} connections in #{duration}: #{repeats/duration}req/s"
-	end
-	
-	around(:each) do |example|
-		previous_level = Async.logger.level
-		# Supress logging:
-		Async.logger.level = Logger::WARN
-		
-		begin
-			example.run
-		ensure
-			Async.logger.level = previous_level
-		end
+		example.reporter.message "Handled #{repeats} connections in #{duration.round(2)}s: #{(repeats/duration).round(2)}req/s"
 	end
 	
 	it "should send/receive 10,000 messages" do

data/spec/async/io/endpoint_spec.rb

@@ -28,15 +28,23 @@ RSpec.describe Async::IO::Endpoint do
 		it "should have hostname" do
 			expect(subject.hostname).to be == "lolcathost"
 		end
+		
+		it "shouldn't have a timeout duration" do
+			expect(subject.timeout).to be_nil
+		end
 	end
 	
-	describe Async::IO::Endpoint.tcp('0.0.0.0', 5234, reuse_port: true) do
+	describe Async::IO::Endpoint.tcp('0.0.0.0', 5234, reuse_port: true, timeout: 10) do
 		it "should be a tcp binding" do
 			subject.bind do |server|
 				expect(server.local_address.socktype).to be == ::Socket::SOCK_STREAM
 			end
 		end
 		
+		it "should have a timeout duration" do
+			expect(subject.timeout).to be 10
+		end
+		
 		it "should print nicely" do
 			expect(subject.to_s).to include('0.0.0.0', '5234')
 		end
@@ -48,6 +56,25 @@ RSpec.describe Async::IO::Endpoint do
 		it "has hostname" do
 			expect(subject.hostname).to be == '0.0.0.0'
 		end
+		
+		let(:message) {"Hello World!"}
+		
+		it "can connect to bound server" do
+			server_task = reactor.async do
+				subject.accept do |io|
+					expect(io.timeout).to be == 10
+					io.write message
+					io.close
+				end
+			end
+			
+			io = subject.connect
+			expect(io.timeout).to be == 10
+			expect(io.read(message.bytesize)).to be == message
+			io.close
+			
+			server_task.stop
+		end
 	end
 	
 	describe Async::IO::Endpoint.tcp('0.0.0.0', 0) do

data/spec/async/io/generic_spec.rb

@@ -19,6 +19,7 @@
 # THE SOFTWARE.
 
 require 'async/io'
+require 'async/clock'
 
 require_relative 'generic_examples'
 
@@ -31,25 +32,73 @@ RSpec.describe Async::IO::Generic do
 		:bytes, :chars, :codepoints, :each, :each_byte, :each_char, :each_codepoint, :each_line, :getbyte, :getc, :gets, :lineno, :lineno=, :lines, :print, :printf, :putc, :puts, :readbyte, :readchar, :readline, :readlines, :ungetbyte, :ungetc
 	] + CONSOLE_METHODS
 	
+	let(:message) {"Hello World!"}
+	
 	let(:pipe) {IO.pipe}
 	let(:input) {Async::IO::Generic.new(pipe.first)}
 	let(:output) {Async::IO::Generic.new(pipe.last)}
 	
 	it "should send and receive data within the same reactor" do
-		message = nil
+		received = nil
 		
 		output_task = reactor.async do
-			message = input.read(1024)
+			received = input.read(1024)
 		end
 		
 		reactor.async do
-			output.write("Hello World")
+			output.write(message)
 		end
 		
 		output_task.wait
-		expect(message).to be == "Hello World"
+		expect(received).to be == message
 		
 		input.close
 		output.close
 	end
+	
+	describe '#wait' do
+		let(:wait_duration) {0.1}
+		
+		it "can wait for :read and :write" do
+			reader = reactor.async do |task|
+				duration = Async::Clock.measure do
+					input.wait(1, :read)
+				end
+				
+				expect(duration).to be_within(10).percent_of(wait_duration)
+				expect(input.read(1024)).to be == message
+				
+				input.close
+			end
+			
+			writer = reactor.async do |task|
+				duration = Async::Clock.measure do
+					output.wait(1, :write)
+				end
+				
+				task.sleep(wait_duration)
+				
+				output.write(message)
+				output.close
+			end
+			
+			[reader, writer].each(&:wait)
+		end
+		
+		it "can return nil when timeout is exceeded" do
+			reader = reactor.async do |task|
+				duration = Async::Clock.measure do
+					expect(input.wait(wait_duration, :read)).to be_nil
+				end
+				
+				expect(duration).to be_within(10).percent_of(wait_duration)
+				
+				input.close
+			end
+			
+			[reader].each(&:wait)
+			
+			output.close
+		end
+	end
 end

data/spec/async/io/shared_endpoint/server_spec.rb

@@ -38,7 +38,7 @@ RSpec.shared_examples_for Async::IO::SharedEndpoint do |container_class|
 	let!(:bound_endpoint) do
 		Async::Reactor.run do
 			Async::IO::SharedEndpoint.bound(server_endpoint)
-		end.result
+		end.wait
 	end
 	
 	it "can use bound endpoint in container" do

data/spec/async/io/shared_endpoint_spec.rb

@@ -21,32 +21,45 @@
 require 'async/io/host_endpoint'
 require 'async/io/shared_endpoint'
 
+require 'pry'
+
 RSpec.describe Async::IO::SharedEndpoint do
 	include_context Async::RSpec::Reactor
 	
 	describe '#bound' do
-		let(:endpoint) {Async::IO::Endpoint.tcp("localhost", 5123)}
+		let(:endpoint) {Async::IO::Endpoint.tcp("localhost", 5123, timeout: 10)}
 		
 		it "can bind to shared endpoint" do
 			bound_endpoint = described_class.bound(endpoint)
-			
 			expect(bound_endpoint.wrappers).to_not be_empty
-			expect(bound_endpoint.wrappers.first).to be_a Async::IO::Socket
+			
+			wrapper = bound_endpoint.wrappers.first
+			expect(wrapper).to be_a Async::IO::Socket
+			expect(wrapper.timeout).to be == endpoint.timeout
 			
 			bound_endpoint.close
 		end
 	end
 	
 	describe '#connected' do
-		let(:endpoint) {Async::IO::Endpoint.tcp("www.google.com", 80)}
+		let(:endpoint) {Async::IO::Endpoint.tcp("localhost", 5124, timeout: 10)}
 		
 		it "can connect to shared endpoint" do
-			connected_endpoint = described_class.connected(endpoint)
+			server_task = reactor.async do
+				endpoint.accept do |io|
+					io.close
+				end
+			end
 			
+			connected_endpoint = described_class.connected(endpoint)
 			expect(connected_endpoint.wrappers).to_not be_empty
-			expect(connected_endpoint.wrappers.first).to be_a Async::IO::Socket
+			
+			wrapper = connected_endpoint.wrappers.first
+			expect(wrapper).to be_a Async::IO::Socket
+			expect(wrapper.timeout).to be == endpoint.timeout
 			
 			connected_endpoint.close
+			server_task.stop
 		end
 	end
 end

data/spec/async/io/socket_spec.rb

@@ -37,7 +37,7 @@ RSpec.describe Async::IO::Socket do
 		it "should fail to connect if no listening server" do
 			expect do
 				Async::IO::Socket.connect(address)
-			end.to raise_error(Errno::ECONNREFUSED)
+			end.to raise_exception(Errno::ECONNREFUSED)
 		end
 		
 		it "should close the socket when interrupted by a timeout" do
@@ -47,7 +47,7 @@ RSpec.describe Async::IO::Socket do
 			expect(wrapper).to receive(:close)
 			expect do
 				Async::IO::Socket.connect(address)
-			end.to raise_error(Async::TimeoutError)
+			end.to raise_exception(Async::TimeoutError)
 		end
 	end
 	
@@ -57,7 +57,7 @@ RSpec.describe Async::IO::Socket do
 			
 			expect do
 				Async::IO::Socket.bind(address)
-			end.to raise_error(Errno::EACCES)
+			end.to raise_exception(Errno::EACCES)
 		end
 		
 		it "can bind to port 0" do
@@ -84,6 +84,21 @@ RSpec.describe Async::IO::Socket do
 		end
 	end
 	
+	describe '#timeout' do
+		subject{described_class.pair(:UNIX, :STREAM, 0)}
+		
+		it "should timeout while waiting to receive data" do
+			s1, s2 = *subject
+			
+			s2.timeout = 1
+			
+			expect{s2.recv(32)}.to raise_exception(Async::TimeoutError, "execution expired")
+			
+			s1.close
+			s2.close
+		end
+	end
+	
 	describe '.pair' do
 		subject{described_class.pair(:UNIX, :STREAM, 0)}
 		

data/spec/async/io/ssl_server_spec.rb

@@ -115,7 +115,7 @@ RSpec.describe Async::IO::SSLServer do
 				expect do
 					invalid_client_endpoint.connect do |client|
 					end
-				end.to raise_error(OpenSSL::SSL::SSLError, /handshake failure/)
+				end.to raise_exception(OpenSSL::SSL::SSLError, /handshake failure/)
 				
 				server_task.stop
 			end

data/spec/async/io/ssl_socket_spec.rb

@@ -30,9 +30,9 @@ RSpec.describe Async::IO::SSLSocket do
 	it_should_behave_like Async::IO::Generic
 	
 	# Shared port for localhost network tests.
-	let(:endpoint) {Async::IO::Endpoint.tcp("127.0.0.1", 6779, reuse_port: true)}
-	let(:server_endpoint) {Async::IO::SSLEndpoint.new(endpoint, ssl_context: server_context)}
-	let(:client_endpoint) {Async::IO::SSLEndpoint.new(endpoint, ssl_context: client_context)}
+	let(:endpoint) {Async::IO::Endpoint.tcp("127.0.0.1", 6779, reuse_port: true, timeout: 10)}
+	let(:server_endpoint) {Async::IO::SSLEndpoint.new(endpoint, ssl_context: server_context, timeout: 20)}
+	let(:client_endpoint) {Async::IO::SSLEndpoint.new(endpoint, ssl_context: client_context, timeout: 20)}
 	
 	let(:data) {"The quick brown fox jumped over the lazy dog."}
 	
@@ -44,6 +44,8 @@ RSpec.describe Async::IO::SSLSocket do
 				
 				begin
 					server.accept do |peer, address|
+						expect(peer.timeout).to be == 10
+						
 						data = peer.read(512)
 						peer.write(data)
 					end
@@ -64,6 +66,7 @@ RSpec.describe Async::IO::SSLSocket do
 				reactor.async do
 					client_endpoint.connect do |client|
 						expect(client).to be_connected
+						expect(client.timeout).to be == 10
 						
 						client.write(data)
 						
@@ -82,7 +85,7 @@ RSpec.describe Async::IO::SSLSocket do
 				reactor.async do
 					expect do
 						client_endpoint.connect
-					end.to raise_error(OpenSSL::SSL::SSLError)
+					end.to raise_exception(OpenSSL::SSL::SSLError)
 				end
 			end
 		end

data/spec/async/io/stream_spec.rb

@@ -161,7 +161,7 @@ RSpec.describe Async::IO::Stream do
 		it "should terminate stream" do
 			expect do
 				stream.eof!
-			end.to raise_error(EOFError)
+			end.to raise_exception(EOFError)
 			
 			expect(stream).to be_eof
 		end
@@ -178,7 +178,7 @@ RSpec.describe Async::IO::Stream do
 			
 			expect do
 				stream.close
-			end.to_not raise_error
+			end.to_not raise_exception
 		end
 	end
 end

data/spec/async/io/trap_spec.rb

@@ -25,6 +25,12 @@ RSpec.describe Async::IO::Trap do
 	
 	subject {described_class.new(:USR1)}
 	
+	it "can ignore signal" do
+		subject.ignore!
+		
+		Process.kill(:USR1, Process.pid)
+	end
+	
 	it "should wait for signal" do
 		trapped = false
 		

data/spec/async/io/wrap/http_rb_spec.rb

@@ -39,7 +39,7 @@ RSpec.describe Async::IO do
 			expect do
 				response = HTTP.get('https://www.google.com', wrappers)
 				response.connection.close
-			end.to_not raise_error
+			end.to_not raise_exception
 		end
 	end
 end

data/spec/async/io/wrap/tcp_spec.rb

@@ -62,7 +62,7 @@ RSpec.describe Async::IO::TCPSocket do
 			
 			expect do
 				Net::HTTP.get_response('www.google.com', '/')
-			end.to_not raise_error
+			end.to_not raise_exception
 		end
 	end
 	
@@ -70,7 +70,7 @@ RSpec.describe Async::IO::TCPSocket do
 		it "should fetch page" do
 			expect do
 				Net::HTTP.get_response('www.google.com', '/')
-			end.to_not raise_error
+			end.to_not raise_exception
 		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.17.2
+  version: 1.18.1
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-06 00:00:00.000000000 Z
+date: 2019-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.14'
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -42,16 +42,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -171,8 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Provides support for asynchonous TCP, UDP, UNIX and SSL sockets.