async-io 1.23.1 → 1.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9e9cbb377148d6f0ff52896452064a5868202f389ac19270dac9540ac68394d
-  data.tar.gz: c205d75250c9ad2b1ad9187d21e3a3d11a102d7ab677156b9b591120dec09268
+  metadata.gz: b0dbae8c805f1cd5878161490bbb70a211ecf7ebd3252a55c81f8c901b583b82
+  data.tar.gz: 5691a8fa37149cd0a79d9363e4b3a98588bf3f48f8df3ba8a683f0adc1fc1548
 SHA512:
-  metadata.gz: 61572f82e2720942866429556e299da485fbd9d74ed8ff19f6c3fa0ea0e593a214319e6bdf276a408f0d8e098efc8b0d351653ba8d06f5dd7a59c59b1528ee01
-  data.tar.gz: 2de4971bf4275376cee035f6b677bbac48388ff379f0ae492652526c60e10202a1b5fbf6f28574d81beb6a12725a7eda959e5577ceb7f8990c502d8cc179bf82
+  metadata.gz: 49c21510120fe04d90283bdcf1041bd510057cf107b2d535e2d822d4aff0baff1c7e52f511903f7c8cc3e196985c2effc607b377bbd33dc8ccd50a34bae44785
+  data.tar.gz: 3bbefda69345a03fdee012b84466d15788686e5944b53b5c835176d81c230b5ed521290f555d98ffe9f54a72bb113f3069f7d93cd0c3ad1263606b840d414d79

data/README.md

@@ -36,12 +36,13 @@ def echo_server(endpoint)
 		# This is a synchronous block within the current task:
 		endpoint.accept do |client|
 			# This is an asynchronous block within the current reactor:
-			data = client.read(512)
+			data = client.read
 			
 			# This produces out-of-order responses.
 			task.sleep(rand * 0.01)
 			
 			client.write(data.reverse)
+			client.close_write
 		end
 	end
 end
@@ -49,9 +50,10 @@ end
 def echo_client(endpoint, data)
 	Async do |task|
 		endpoint.connect do |peer|
-			result = peer.write(data)
+			peer.write(data)
+			peer.close_write
 			
-			message = peer.read(512)
+			message = peer.read
 			
 			puts "Sent #{data}, got response: #{message}"
 		end
@@ -78,7 +80,7 @@ Timeouts add a temporal limit to the execution of your code. If the IO doesn't r
 ```ruby
 message = task.with_timeout(5) do
 	begin
-		peer.read(512)
+		peer.read
 	rescue Async::TimeoutError
 		nil # The timeout was triggered.
 	end
@@ -93,7 +95,7 @@ Asynchronous operations may block forever. You can assign a per-wrapper operatio
 
 ```ruby
 peer.timeout = 1
-peer.read(512) # If this takes more than 1 second, Async::TimeoutError will be raised.
+peer.read # 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.

data/lib/async/io.rb

@@ -26,3 +26,13 @@ require_relative "io/version"
 
 require_relative "io/endpoint"
 require_relative "io/endpoint/each"
+
+module Async
+	module IO
+		@file_descriptor_limit = nil
+		
+		def self.file_descriptor_limit
+			@file_descriptor_limit ||= Integer(`ulimit -n`) rescue nil
+		end
+	end
+end

data/lib/async/io/generic.rb

@@ -90,7 +90,7 @@ module Async
 				end
 			end
 			
-			wraps ::IO, :external_encoding, :internal_encoding, :autoclose?, :autoclose=, :pid, :stat, :binmode, :flush, :set_encoding, :to_io, :to_i, :reopen, :fileno, :fsync, :fdatasync, :sync, :sync=, :tell, :seek, :rewind, :pos, :pos=, :eof, :eof?, :close_on_exec?, :close_on_exec=, :closed?, :close_read, :close_write, :isatty, :tty?, :binmode?, :sysseek, :advise, :ioctl, :fcntl, :nread, :ready?, :pread, :pwrite, :pathconf
+			wraps ::IO, :external_encoding, :internal_encoding, :autoclose?, :autoclose=, :pid, :stat, :binmode, :flush, :set_encoding, :set_encoding_by_bom, :to_io, :to_i, :reopen, :fileno, :fsync, :fdatasync, :sync, :sync=, :tell, :seek, :rewind, :pos, :pos=, :eof, :eof?, :close_on_exec?, :close_on_exec=, :closed?, :close_read, :close_write, :isatty, :tty?, :binmode?, :sysseek, :advise, :ioctl, :fcntl, :nread, :ready?, :pread, :pwrite, :pathconf
 			
 			# Read the specified number of bytes from the input stream. This is fast path.
 			# @example

data/lib/async/io/host_endpoint.rb

@@ -35,6 +35,10 @@ module Async
 				"\#<#{self.class} name=#{nodename.inspect} service=#{service.inspect} family=#{family.inspect} type=#{socktype.inspect} protocol=#{protocol.inspect} flags=#{flags.inspect}>"
 			end
 			
+			def address
+				@specification
+			end
+			
 			def hostname
 				@specification.first
 			end

data/lib/async/io/ssl_endpoint.rb

@@ -40,6 +40,10 @@ module Async
 				"\#<#{self.class} #{@endpoint}>"
 			end
 			
+			def address
+				@endpoint.address
+			end
+			
 			def hostname
 				@options[:hostname] || @endpoint.hostname
 			end

data/lib/async/io/stream.rb

@@ -195,7 +195,6 @@ module Async
 					flush
 				rescue
 					# We really can't do anything here unless we want #close to raise exceptions.
-					Async.logger.error(self) {$!}
 				ensure
 					@io.close
 				end

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.23.1"
+		VERSION = "1.23.3"
 	end
 end

data/spec/async/io/c10k_spec.rb

@@ -20,16 +20,28 @@
 
 require 'async/io'
 require 'benchmark'
+require 'open3'
 
-require 'ruby-prof'
+# require 'ruby-prof'
 
-RSpec.describe "echo client/server" do
+RSpec.describe "echo client/server", if: Process.respond_to?(:fork) do
 	# macOS has a rediculously hard time to do this.
 	# sudo sysctl -w net.inet.ip.portrange.first=10000
 	# sudo sysctl -w net.inet.ip.portrange.hifirst=10000
 	# Probably due to the use of select.
 	
-	let(:repeats) {RUBY_PLATFORM =~ /darwin/ ? 1000 : 10000}
+	let(:repeats) do
+		if limit = Async::IO.file_descriptor_limit
+			if limit > 1024*10
+				10_000
+			else
+				[1, limit - 100].max
+			end
+		else
+			10_000
+		end
+	end
+	
 	let(:server_address) {Async::IO::Address.tcp('0.0.0.0', 10101)}
 	
 	def echo_server(server_address)

data/spec/async/io/generic_examples.rb

@@ -1,7 +1,26 @@
+# Copyright, 2019, 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.
 
 RSpec.shared_examples Async::IO::Generic do |ignore_methods|
-	let(:instance_methods) {described_class.wrapped_klass.instance_methods(false) - (ignore_methods || [])}
-	let(:wrapped_instance_methods) {described_class.instance_methods}
+	let(:instance_methods) {described_class.wrapped_klass.public_instance_methods(false) - (ignore_methods || [])}
+	let(:wrapped_instance_methods) {described_class.public_instance_methods}
 	
 	it "should wrap a class" do
 		expect(described_class.wrapped_klass).to_not be_nil

data/spec/async/io/generic_spec.rb

@@ -27,10 +27,12 @@ RSpec.describe Async::IO::Generic do
 	include_context Async::RSpec::Reactor
 	
 	CONSOLE_METHODS = [:beep, :cooked, :cooked!, :cursor, :cursor=, :echo=, :echo?,:getch, :getpass, :goto, :iflush, :ioflush, :noecho, :oflush,:pressed?, :raw, :raw!, :winsize, :winsize=]
+	# On TruffleRuby, IO#encode_with needs to be defined for YAML.dump as a public method, allow it
+	ignore = [:encode_with]
 	
 	it_should_behave_like Async::IO::Generic, [
 		: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
+	] + CONSOLE_METHODS + ignore
 	
 	let(:message) {"Hello World!"}
 	
@@ -64,7 +66,7 @@ RSpec.describe Async::IO::Generic do
 					input.wait(1, :read)
 				end
 				
-				expect(duration).to be_within(10).percent_of(wait_duration)
+				expect(duration).to be_within(50).percent_of(wait_duration)
 				expect(input.read(1024)).to be == message
 				
 				input.close
@@ -90,7 +92,7 @@ RSpec.describe Async::IO::Generic do
 					expect(input.wait(wait_duration, :read)).to be_nil
 				end
 				
-				expect(duration).to be_within(10).percent_of(wait_duration)
+				expect(duration).to be_within(50).percent_of(wait_duration)
 				
 				input.close
 			end

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

@@ -65,7 +65,7 @@ RSpec.shared_examples_for Async::IO::SharedEndpoint do |container_class|
 	end
 end
 
-RSpec.describe Async::Container::Forked do
+RSpec.describe Async::Container::Forked, if: Process.respond_to?(:fork) do
 	it_behaves_like Async::IO::SharedEndpoint, described_class
 end
 

data/spec/async/io/ssl_server_spec.rb

@@ -36,6 +36,10 @@ RSpec.describe Async::IO::SSLServer do
 		
 		let(:data) {"What one programmer can do in one month, two programmers can do in two months."}
 		
+		it "can see through to address" do
+			expect(server_endpoint.address).to be == endpoint.address
+		end
+		
 		it 'can accept_each connections' do
 			# Accept a single incoming connection and then finish.
 			server_task = reactor.async do |task|

data/spec/async/io/trap_spec.rb

@@ -23,12 +23,12 @@ require 'async/io/trap'
 RSpec.describe Async::IO::Trap do
 	include_context Async::RSpec::Reactor
 	
-	subject {described_class.new(:USR1)}
+	subject {described_class.new(:USR2)}
 	
 	it "can ignore signal" do
 		subject.ignore!
 		
-		Process.kill(:USR1, Process.pid)
+		Process.kill(:USR2, Process.pid)
 	end
 	
 	it "should wait for signal" do

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

@@ -49,7 +49,8 @@ module Wrap
 	end
 end
 
-RSpec.describe Async::IO::TCPSocket do
+# TruffleRuby uses Socket.tcp in Net::HTTP.get_response, not TCPSocket.open
+RSpec.describe Async::IO::TCPSocket, if: RUBY_ENGINE != "truffleruby" do
 	describe "inside reactor" do
 		include_context Async::RSpec::Reactor
 		

data/spec/spec_helper.rb

@@ -1,12 +1,5 @@
 
 require 'covered/rspec'
-
-if RUBY_ENGINE == "truffleruby"
-	warn "Workarounds for TruffleRuby enabled..."
-	require_relative 'truffle'
-end
-
-# Shared rspec helpers:
 require "async/rspec"
 
 require_relative 'addrinfo'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.23.1
+  version: 1.23.3
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-09 00:00:00.000000000 Z
+date: 2019-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -187,7 +187,6 @@ files:
 - spec/async/io/wrap/http_rb_spec.rb
 - spec/async/io/wrap/tcp_spec.rb
 - spec/spec_helper.rb
-- spec/truffle.rb
 homepage: https://github.com/socketry/async-io
 licenses: []
 metadata: {}
@@ -206,7 +205,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Provides support for asynchonous TCP, UDP, UNIX and SSL sockets.
@@ -238,4 +237,3 @@ test_files:
 - spec/async/io/wrap/http_rb_spec.rb
 - spec/async/io/wrap/tcp_spec.rb
 - spec/spec_helper.rb
-- spec/truffle.rb

data/spec/truffle.rb

@@ -1,58 +0,0 @@
-
-require 'socket'
-
-class IO
-	def write_nonblock(data, exception: true)
-		ensure_open_and_writable
-
-		data = String data
-		return 0 if data.empty?
-
-		@ibuffer.unseek!(self) unless @sync
-
-		self.nonblock = true
-
-		begin
-			Truffle::POSIX.write_string_nonblock(self, data)
-		rescue Errno::EAGAIN
-			if exception
-				raise EAGAINWaitWritable
-			else
-				return :wait_writable
-			end
-		end
-	end
-end
-
-class IO::BidirectionalPipe
-	def write_nonblock(*args, **options)
-		@write.write_nonblock(*args, **options)
-	end
-end
-
-class Socket
-	def connect_nonblock(sockaddr, exception: true)
-		fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK)
-
-		if sockaddr.is_a?(Addrinfo)
-			sockaddr = sockaddr.to_sockaddr
-		end
-
-		status = Truffle::Socket::Foreign.connect(descriptor, sockaddr)
-
-		# There should be a better way to do this than raising an exception!?
-		if Errno.errno == Errno::EISCONN::Errno
-			raise Errno::EISCONN
-		end
-
-		if status < 0
-			if exception
-				Truffle::Socket::Error.write_nonblock('connect(2)')
-			else
-				:wait_writable
-			end
-		else
-			0
-		end
-	end
-end