async-io 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b884696374f63d12ec25bbeddbb32bdb6fc9dda
-  data.tar.gz: 43be6b24df7e4e244afaac328fdea0f95ecf612b
+  metadata.gz: cc74a7c6901edc284210da8593a505e0eb87ff89
+  data.tar.gz: d5c4e46d022296613e94dfbcc6409727dc33dcb2
 SHA512:
-  metadata.gz: 5d4a4c420cff06424564949249ee0c5c442f02c581eb94268902dd98f39d7187c1af4525ba0483ec9c438a9395182141838dab42bb7ca498d5d994f014ee3001
-  data.tar.gz: 1a75fce2c71dc1ad463ece49508068e9aff94529578b8c468b65fd679fc7857d15a2cc3c3f6b58d2dbd61f2aec06ad8940307daea6095965aeb5c008cfaf7a2b
+  metadata.gz: 79274376a216fce20ee3a1d8f56f2767f9a9c6cc107d20bc9780ceb4ce29c5e32f7e5a34a7ac84b6d57d55eb28cd00d4d6fd8ee32208a7e1a7015b146f5e10b4
+  data.tar.gz: dc4e658c5411145c90359ef91dc565027b8c1ed36e22abd92e4907b20958f2e3b03e9cccb3a503c443c0cdfbceb58a4204226cd6d735681e3df6cec60c4317b6

data/async-io.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
 	spec.has_rdoc      = "yard"
 
 	spec.add_dependency "async", "~> 0.14"
-	spec.add_development_dependency "async-rspec", "~> 1.0"
+	spec.add_development_dependency "async-rspec", "~> 1.1"
 
 	spec.add_development_dependency "bundler", "~> 1.13"
 	spec.add_development_dependency "rake", "~> 10.0"

data/lib/async/io/address.rb

@@ -42,7 +42,7 @@ module Async
 				def each(specifications, &block)
 					specifications.each do |specification|
 						if specification.is_a? self
-							yield self
+							yield specification
 						else
 							# Perhaps detect options here?
 							yield self.new(specification)

data/lib/async/io/socket.rb

@@ -84,6 +84,18 @@ module Async
 				end
 			end
 			
+			def self.build(*args, task: Task.current)
+				socket = ::Socket.new(*args)
+				
+				yield socket
+				
+				return self.new(socket, task.reactor)
+			rescue Exception
+				socket.close if socket
+				
+				raise
+			end
+			
 			# Establish a connection to a given `remote_address`.
 			# @example
 			#  socket = Async::IO::Socket.connect(Async::IO::Address.tcp("8.8.8.8", 53))
@@ -93,21 +105,26 @@ module Async
 			def self.connect(remote_address, local_address = nil, protocol: 0, task: Task.current)
 				task.annotate "connecting to #{remote_address.inspect}"
 				
-				socket = ::Socket.new(remote_address.afamily, remote_address.socktype, protocol)
-				
-				if local_address
-					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
-					socket.bind(local_address.to_sockaddr) if local_address
+				wrapper = build(remote_address.afamily, remote_address.socktype, protocol) do |socket|
+					if local_address
+						socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
+						socket.bind(local_address.to_sockaddr) if local_address
+					end
+					
+					self.new(socket, task.reactor)
 				end
 				
-				wrapper = self.new(socket, task.reactor)
-				wrapper.connect(remote_address.to_sockaddr)
-				
-				task.annotate "connected to #{remote_address.inspect}"
+				begin
+					wrapper.connect(remote_address.to_sockaddr)
+					task.annotate "connected to #{remote_address.inspect}"
+				rescue
+					wrapper.close
+					raise
+				end
 				
 				if block_given?
 					begin
-						return yield(wrapper)
+						yield wrapper, task
 					ensure
 						wrapper.close
 					end
@@ -120,20 +137,20 @@ module Async
 			# @example
 			#  socket = Async::IO::Socket.bind(Async::IO::Address.tcp("0.0.0.0", 9090))
 			# @param local_address [Address] The local address to bind to.
-			# @option protcol [Integer] The socket protocol to use.
-			def self.bind(local_address, protocol: 0, task: Task.current, &block)
+			# @option protocol [Integer] The socket protocol to use.
+			# @option reuse_port [Boolean] Allow this port to be bound in multiple processes.
+			def self.bind(local_address, protocol: 0, reuse_port: false, task: Task.current, &block)
 				task.annotate "binding to #{local_address.inspect}"
 				
-				socket = ::Socket.new(local_address.afamily, local_address.socktype, protocol)
-				
-				socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
-				socket.bind(local_address.to_sockaddr)
-				
-				wrapper = self.new(socket, task.reactor)
+				wrapper = build(local_address.afamily, local_address.socktype, protocol) do |socket|
+					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
+					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, true) if reuse_port
+					socket.bind(local_address.to_sockaddr)
+				end
 				
 				if block_given?
 					begin
-						return yield(wrapper, task)
+						yield wrapper, task
 					ensure
 						wrapper.close
 					end

data/lib/async/io/stream.rb

@@ -0,0 +1,307 @@
+# Copyright, 2017, 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 'socket'
+require_relative 'generic'
+
+module Async
+	module IO
+		class BinaryString < String
+			def initialize(*args)
+				super
+				
+				force_encoding(Encoding::BINARY)
+			end
+			
+			def << string
+				super
+				
+				force_encoding(Encoding::BINARY)
+			end
+			
+			alias concat <<
+		end
+		
+		class Stream
+			include Enumerable
+			
+			def initialize(io, block_size: 1024, eol: $/)
+				@io = io
+				@eof = false
+				@sync = false
+				
+				@block_size = block_size
+				@eol = eol
+				
+				@read_buffer = BinaryString.new
+				@write_buffer = BinaryString.new
+			end
+			
+			attr :io
+			
+			# The "sync mode" of the stream. See IO#sync for full details.
+			attr_accessor :sync
+			
+			# Reads `size` bytes from the stream.  If `buffer` is provided it must
+			# reference a string which will receive the data.
+			#
+			# See IO#read for full details.
+			def read(size = nil, output_buffer = nil)
+				if size == 0
+					if output_buffer
+						output_buffer.clear
+						return output_buffer
+					else
+						return ""
+					end
+				end
+
+				until @eof
+					break if size && size <= @read_buffer.size
+					fill_read_buffer
+					break unless size
+				end
+
+				buffer = consume_read_buffer(size)
+
+				if buffer && output_buffer
+					output_buffer.replace(buffer)
+					buffer = output_buffer
+				end
+
+				if size
+					return buffer
+				else
+					return buffer || ""
+				end
+			end
+
+			# Writes `string` to the buffer. When the buffer is full or #sync is true the
+			# buffer is flushed to the underlying `io`.
+			# @param string the string to write to the buffer.
+			# @return the number of bytes appended to the buffer.
+			def write(string)
+				@write_buffer << string
+				
+				if @sync || @write_buffer.size > @block_size
+					flush
+				end
+				
+				return string.bytesize
+			end
+
+			# Flushes buffered data to the stream.
+			def flush
+				syswrite(@write_buffer)
+			end
+
+			# Closes the stream and flushes any unwritten data.
+			def close
+				flush rescue nil
+				
+				@io.close
+			end
+
+			# Reads the next line from the stream. Lines are separated by +eol+. If
+			# +limit+ is provided the result will not be longer than the given number of
+			# bytes.
+			#
+			# +eol+ may be a String or Regexp.
+			#
+			# Unlike IO#gets the line read will not be assigned to +$_+.
+			#
+			# Unlike IO#gets the separator must be provided if a limit is provided.
+			def gets(eol = @eol, limit = nil)
+				index = @read_buffer.index(eol)
+				
+				until index || @eof
+					fill_read_buffer
+					index = @read_buffer.index(eol)
+				end
+
+				if eol.is_a?(Regexp)
+					size = index ? index+$&.bytesize : nil
+				else
+					size = index ? index+eol.bytesize : nil
+				end
+
+				if limit && limit >= 0
+					size = [size, limit].min
+				end
+
+				consume_read_buffer(size)
+			end
+
+			# Executes the block for every line in the stream where lines are separated
+			# by +eol+.
+			#
+			# See also #gets
+			def each(eol = @eol)
+				while line = self.gets(eol)
+					yield line
+				end
+			end
+			alias each_line each
+
+			# Reads lines from the stream which are separated by +eol+.
+			#
+			# See also #gets
+			def readlines(eol = @eol)
+				lines = []
+
+				while line = self.gets(eol)
+					lines << line
+				end
+
+				lines
+			end
+
+			# Reads a line from the stream which is separated by +eol+.
+			#
+			# Raises EOFError if at end of file.
+			def readline(eol=@eol)
+				gets(eol) or raise EOFError
+			end
+
+			# Reads one character from the stream.  Returns nil if called at end of
+			# file.
+			def getc
+				read(1)
+			end
+
+			# Calls the given block once for each byte in the stream.
+			def each_byte # :yields: byte
+				while c = getc
+					yield(c.ord)
+				end
+			end
+
+			# Reads a one-character string from the stream.  Raises an EOFError at end
+			# of file.
+			def readchar
+				getc or raise EOFError
+			end
+
+			# Returns true if the stream is at file which means there is no more data to be read.
+			def eof?
+				fill_read_buffer if !@eof && @read_buffer.empty?
+				
+				@eof && @read_buffer.empty?
+			end
+			alias eof eof?
+
+			# Writes `string` to the stream and returns self.
+			def <<(string)
+				write(string)
+				
+				return self
+			end
+
+			# Writes `args` to the stream along with a record separator. See `IO#puts` for full details.
+			def puts(*args, eol: @eol)
+				if args.empty?
+					write(eol)
+				else
+					args.each do |arg|
+						string = arg.to_s
+						if string.end_with? eol
+							write(string)
+						else
+							write(string)
+							write(eol)
+						end
+					end
+				end
+				
+				return nil
+			end
+
+			# Writes `args` to the stream. See `IO#print` for full details.
+			def print(*args)
+				args.each do |arg|
+					write(arg.to_s)
+				end
+				
+				return nil
+			end
+
+			# Formats and writes to the stream converting parameters under control of the format string. See `Kernel#sprintf` for format string details.
+			def printf(s, *args)
+				write(s % args)
+				
+				return nil
+			end
+
+			private
+			
+			# Write a buffer to the underlying stream.
+			# @param buffer [String] The string to write, any encoding is okay.
+			def syswrite(buffer)
+				remaining = buffer.bytesize
+				
+				# Fast path:
+				written = @io.write(buffer)
+				return if written == remaining
+				
+				# Slow path:
+				remaining -= written
+				
+				while remaining > 0
+					wrote = @io.write(buffer.byteslice(written, remaining))
+					
+					remaining -= wrote
+					written += wrote
+				end
+				
+				return written
+			end
+
+			# Fills the buffer from the underlying stream.
+			def fill_read_buffer
+				if buffer = @io.read(@block_size)
+					# We guarantee that the read_buffer remains ASCII-8BIT because read should always return ASCII-8BIT 
+					@read_buffer << buffer
+				else
+					@eof = true
+				end
+			end
+
+			# Consumes `size` bytes from the buffer.
+			# @param size [Integer|nil] The amount of data to consume. If nil, consume entire buffer.
+			def consume_read_buffer(size = nil)
+				# If we are at eof, and the read buffer is empty, we can't consume anything.
+				return nil if @eof && @read_buffer.empty?
+				
+				result = nil
+				
+				if size == nil || size == @read_buffer.size
+					# Consume the entire read buffer:
+					result = @read_buffer.dup
+					@read_buffer.clear
+				else
+					# Consume only part of the read buffer:
+					result = @read_buffer.slice!(0, size)
+				end
+				
+				return result
+			end
+		end
+	end
+end

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "0.1.0"
+		VERSION = "0.3.0"
 	end
 end

data/spec/async/io/c10k_spec.rb

@@ -0,0 +1,129 @@
+# Copyright, 2017, 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 'async/io'
+require 'benchmark'
+
+RSpec.describe "echo client/server" do
+	let(:repeats) {10000}
+	let(:server_address) {Async::IO::Address.tcp('0.0.0.0', 9000)}
+	
+	def echo_server(server_address)
+		Async::Reactor.run do |task|
+			connection_count = 0
+			
+			connections_complete = task.async do
+				last_count = 0
+				
+				while connection_count < repeats
+					if connection_count != last_count
+						puts "#{connection_count}/#{repeats} simultaneous connections."
+						last_count = connection_count
+					end
+					
+					task.sleep(1.0)
+				end
+				
+				puts "Releasing all connections..."
+			end
+			
+			# This is a synchronous block within the current task:
+			Async::IO::Socket.accept(server_address) do |client|
+				connection_count += 1
+				
+				# Wait until we've got all the connections:
+				connections_complete.wait
+				
+				# This is an asynchronous block within the current reactor:
+				data = client.read(512)
+				client.write(data)
+			end
+		end
+	end
+	
+	def echo_client(server_address, data, responses)
+		Async::Reactor.run do |task|
+			begin
+				Async::IO::Socket.connect(server_address) do |peer|
+					result = peer.write(data)
+					
+					message = peer.read(512)
+					
+					responses << message
+				end
+			rescue Errno::ECONNREFUSED
+				puts "Connection refused..."
+				# If the connection was refused, it means the server probably can't accept connections any faster than it currently is, so we simply retry.
+				retry
+			end
+		end
+	end
+	
+	def fork_server
+		pid = fork do
+			echo_server(server_address)
+		end
+		
+		yield
+	ensure
+		Process.kill(:KILL, pid)
+		Process.wait(pid)
+	end
+	
+	around(:each) do |example|
+		duration = Benchmark.realtime 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
+	end
+	
+	it "should send/receive 10,000 messages" do
+		fork_server do
+			Async::Reactor.run do |task|
+				responses = []
+				
+				tasks = repeats.times.collect do |i|
+					# puts "Starting client #{i} on #{task}..." if (i % 1000) == 0
+					
+					echo_client(server_address, "Hello World #{i}", responses)
+				end
+				
+				# task.reactor.print_hierarchy
+				
+				tasks.each(&:wait)
+				
+				expect(responses.count).to be repeats
+			end
+		end
+	end
+end

data/spec/async/io/socket_spec.rb

@@ -0,0 +1,45 @@
+# Copyright, 2017, 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 'async/io/socket'
+
+RSpec.describe Async::IO::Socket do
+	include_context Async::RSpec::Reactor
+	
+	describe '#connect' do
+		let(:address) {Async::IO::Address.tcp('127.0.0.1', 12345)}
+		
+		it "should fail to connect if no listening server" do
+			expect do
+				Async::IO::Socket.connect(address)
+			end.to raise_error(Errno::ECONNREFUSED)
+		end
+	end
+	
+	describe '#bind' do
+		let(:address) {Async::IO::Address.tcp('127.0.0.1', 1)}
+		
+		it "should fail to bind to port < 1024" do
+			expect do
+				Async::IO::Socket.bind(address)
+			end.to raise_error(Errno::EACCES)
+		end
+	end
+end

data/spec/async/io/stream_spec.rb

@@ -0,0 +1,65 @@
+# Copyright, 2017, 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 'async/io/stream'
+
+RSpec.describe Async::IO::Stream do
+	let(:io) {StringIO.new}
+	let(:stream) {Async::IO::Stream.new(io, eol: "\n")}
+	
+	describe '#puts' do
+		it "should write line" do
+			stream.puts "Hello World"
+			stream.flush
+			
+			expect(io.string).to be == "Hello World\n"
+		end
+	end
+	
+	describe '#readline' do
+		before(:each) do
+			io.puts "Hello World"
+			io.seek(0)
+		end
+		
+		it "should read one line" do
+			expect(stream.readline).to be == "Hello World\n"
+		end
+		
+		it "should be binary encoding" do
+			expect(stream.readline.encoding).to be == Encoding::BINARY
+		end
+	end
+	
+	describe '#readlines' do
+		before(:each) do
+			io << "Hello\nWorld\n"
+			io.seek(0)
+		end
+		
+		it "should read multiple lines" do
+			expect(stream.readlines).to be == ["Hello\n", "World\n"]
+		end
+		
+		it "should be binary encoding" do
+			expect(stream.readlines.first.encoding).to be == Encoding::BINARY
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-24 00:00:00.000000000 Z
+date: 2017-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -98,14 +98,18 @@ files:
 - lib/async/io/address.rb
 - lib/async/io/generic.rb
 - lib/async/io/socket.rb
+- lib/async/io/stream.rb
 - lib/async/io/tcp_socket.rb
 - lib/async/io/udp_socket.rb
 - lib/async/io/unix_socket.rb
 - lib/async/io/version.rb
 - lib/async/io/wrap/tcp.rb
 - spec/async/io/address_spec.rb
+- spec/async/io/c10k_spec.rb
 - spec/async/io/echo_spec.rb
 - spec/async/io/generic_spec.rb
+- spec/async/io/socket_spec.rb
+- spec/async/io/stream_spec.rb
 - spec/async/io/tcp_socket_spec.rb
 - spec/async/io/udp_socket_spec.rb
 - spec/async/io/unix_socket_spec.rb
@@ -136,8 +140,11 @@ specification_version: 4
 summary: Provides support for asynchonous TCP, UDP, UNIX and SSL sockets.
 test_files:
 - spec/async/io/address_spec.rb
+- spec/async/io/c10k_spec.rb
 - spec/async/io/echo_spec.rb
 - spec/async/io/generic_spec.rb
+- spec/async/io/socket_spec.rb
+- spec/async/io/stream_spec.rb
 - spec/async/io/tcp_socket_spec.rb
 - spec/async/io/udp_socket_spec.rb
 - spec/async/io/unix_socket_spec.rb