async-io 1.25.0 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e01be4ac327bd569ca94ab2dee892e146d09dcba53d07602b01b77362c2601d
-  data.tar.gz: cef6ce9421a1f1d8ce9848390e998c251d2972de5915ed47459f8c5352620aca
+  metadata.gz: 8c73625346e61dc5ca64794c5fe70343437cf18e2f019a1fb7bba89d76eaaba6
+  data.tar.gz: 3fb2fbe3c6b50642b8ad3650b7829119c7f5b41ee8837569571e01a30364a4cf
 SHA512:
-  metadata.gz: d3d5506e50c9d3ea3259a87a90943565071317f11d277b08608bbfc35ce5b85441e0521950716cd37f20d56a2591544a376624e9bf8d029c338ce748ecef6c9b
-  data.tar.gz: 45114022177aba3e1caf2680cb49754b1ad511487a4327f66851c30fca4a832255545169c275c1dd387aff6c7c241a3286a5241f77de6d4c89b759fc50ec264e
+  metadata.gz: aca0fe4641f3066d1eb564b788a31ce5644a318281725342c8ee98f581d8af110c0c9b302e4d9b6e5816802234213d62da53dc34f0fc2715c173e9de79e03ad0
+  data.tar.gz: f318d5debbba3f6cad57d948cc3a16fb716c4bb79f5a84ec0cca5eee3edaadad983103c8188e3b6d83bb4db14393941c1750ba7955903efd8a7f79321e51d6e2

data/examples/echo/client.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
+
+require 'async'
+require 'async/io/trap'
+require 'async/io/host_endpoint'
+require 'async/io/stream'
+
+endpoint = Async::IO::Endpoint.tcp('localhost', 4578)
+
+Async do |task|
+	endpoint.connect do |peer|
+		stream = Async::IO::Stream.new(peer)
+		
+		while true
+			task.sleep 1
+			stream.puts "Hello World!"
+			puts stream.gets.inspect
+		end
+	end
+end

data/examples/echo/server.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
+
+require 'async'
+require 'async/io/trap'
+require 'async/io/host_endpoint'
+require 'async/io/stream'
+
+endpoint = Async::IO::Endpoint.tcp('localhost', 4578)
+
+interrupt = Async::IO::Trap.new(:INT)
+
+Async do |top|
+	interrupt.install!
+	
+	endpoint.bind do |server, task|
+		Async.logger.info(server) {"Accepting connections on #{server.local_address.inspect}"}
+		
+		task.async do |subtask|
+			interrupt.wait
+			
+			Async.logger.info(server) {"Closing server socket..."}
+			server.close
+			
+			interrupt.default!
+			
+			Async.logger.info(server) {"Waiting for connections to close..."}
+			subtask.sleep(4)
+			
+			Async.logger.info(server) do |buffer|
+				buffer.puts "Stopping all tasks..."
+				task.print_hierarchy(buffer)
+				buffer.puts "", "Reactor Hierarchy"
+				task.reactor.print_hierarchy(buffer)
+			end
+			
+			task.stop
+		end
+		
+		server.listen(128)
+		
+		server.accept_each do |peer|
+			stream = Async::IO::Stream.new(peer)
+			
+			while chunk = stream.read_partial
+				Async.logger.debug(self) {chunk.inspect}
+				stream.write(chunk)
+				stream.flush
+				
+				Async.logger.info(server) do |buffer|
+					task.reactor.print_hierarchy(buffer)
+				end
+			end
+		end
+	end
+end

data/lib/async/io/stream.rb

@@ -38,10 +38,13 @@ module Async
 				end
 			end
 			
-			def initialize(io, block_size: BLOCK_SIZE, maximum_read_size: MAXIMUM_READ_SIZE, sync: true)
+			def initialize(io, block_size: BLOCK_SIZE, maximum_read_size: MAXIMUM_READ_SIZE, sync: true, deferred: nil)
 				@io = io
 				@eof = false
 				
+				@deferred = deferred
+				@pending = 0
+				
 				# We don't want Ruby to do any IO buffering.
 				@io.sync = sync
 				
@@ -55,6 +58,8 @@ module Async
 				@input_buffer = Buffer.new
 			end
 			
+			attr_accessor :reactor
+			
 			attr :io
 			attr :block_size
 			
@@ -161,11 +166,34 @@ module Async
 			# Flushes buffered data to the stream.
 			def flush
 				unless @write_buffer.empty?
-					@io.write(@write_buffer)
-					@write_buffer.clear
+					if @deferred and task = Task.current
+						if @pending.zero?
+							task.reactor << self
+						end
+						
+						@pending += 1
+					else
+						Async.logger.debug(self) {"Flushing immediate write (#{@write_buffer.bytesize} bytes)..."}
+						
+						@io.write(@write_buffer)
+						@write_buffer.clear
+						@pending = 0
+					end
 				end
 			end
 			
+			def alive?
+				@pending > 0
+			end
+			
+			def resume
+				Async.logger.debug(self) {"Flushing #{@pending} writes (#{@write_buffer.bytesize} bytes)..."}
+				
+				@io.write(@write_buffer)
+				@write_buffer.clear
+				@pending = 0
+			end
+			
 			def gets(separator = $/, **options)
 				read_until(separator, **options)
 			end
@@ -191,7 +219,7 @@ module Async
 			end
 			
 			def close_write
-				flush
+				resume unless @write_buffer.empty?
 			ensure
 				@io.close_write
 			end
@@ -201,7 +229,7 @@ module Async
 				return if @io.closed?
 				
 				begin
-					flush
+					resume unless @write_buffer.empty?
 				rescue
 					# We really can't do anything here unless we want #close to raise exceptions.
 				ensure

data/lib/async/io/trap.rb

@@ -36,7 +36,11 @@ module Async
 			
 			# 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")
+				Signal.trap(@name, :IGNORE)
+			end
+			
+			def default!
+				Signal.trap(@name, :DEFAULT)
 			end
 			
 			# Install the trap into the current process. Thread safe.
@@ -55,17 +59,21 @@ module Async
 				return true
 			end
 			
-			# Block the calling task until the signal occurs.
-			def trap
-				task = Task.current
+			# Wait until the signal occurs. If a block is given, execute in a loop.
+			# @yield [Async::Task] the current task.
+			def wait(task: Task.current, &block)
 				task.annotate("waiting for signal #{@name}")
 				
 				notification = Notification.new
 				@notifications << notification
 				
-				while true
+				if block_given?
+					while true
+						notification.wait
+						yield task
+					end
+				else
 					notification.wait
-					yield
 				end
 			ensure
 				if notification
@@ -74,6 +82,15 @@ module Async
 				end
 			end
 			
+			# Deprecated.
+			alias trap wait
+			
+			def async(parent: Task.current, &block)
+				parent.async do |task|
+					self.trap(task: task, &block)
+				end
+			end
+			
 			# Signal all waiting tasks that the trap occurred.
 			# @return [void]
 			def trigger(signal_number = nil)

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.25.0"
+		VERSION = "1.26.0"
 	end
 end

data/spec/async/io/generic_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Async::IO::Generic do
 	
 	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]
+	ignore = [:encode_with, :check_winsize_changed, :clear_screen, :console_mode, :console_mode=, :cursor_down, :cursor_left, :cursor_right, :cursor_up, :erase_line, :erase_screen, :goto_column, :scroll_backward, :scroll_forward]
 	
 	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

data/spec/async/io/protocol/line_spec.rb

@@ -19,14 +19,19 @@
 # THE SOFTWARE.
 
 require 'async/io/protocol/line'
+require 'async/io/socket'
 
 RSpec.describe Async::IO::Protocol::Line do
-	let(:io) {StringIO.new}
-	let(:stream) {Async::IO::Stream.new(io)}
-	subject {described_class.new(stream, "\n")}
+	include_context Async::RSpec::Reactor
+	
+	let(:pipe) {@pipe = Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)}
+	let(:remote) {pipe.first}
+	subject {described_class.new(Async::IO::Stream.new(pipe.last, deferred: true), "\n")}
+	
+	after(:each) {@pipe&.each(&:close)}
 	
 	context "default line ending" do
-		subject {described_class.new(stream)}
+		subject {described_class.new(nil)}
 		
 		it "should have default eol terminator" do
 			expect(subject.eol).to_not be_nil
@@ -36,15 +41,16 @@ RSpec.describe Async::IO::Protocol::Line do
 	describe '#write_lines' do
 		it "should write line" do
 			subject.write_lines "Hello World"
+			subject.close
 			
-			expect(io.string).to be == "Hello World\n"
+			expect(remote.read).to be == "Hello World\n"
 		end
 	end
 	
 	describe '#read_line' do
 		before(:each) do
-			io.puts "Hello World"
-			io.seek(0)
+			remote.write "Hello World\n"
+			remote.close
 		end
 		
 		it "should read one line" do
@@ -58,8 +64,8 @@ RSpec.describe Async::IO::Protocol::Line do
 	
 	describe '#read_lines' do
 		before(:each) do
-			io << "Hello\nWorld\n"
-			io.seek(0)
+			remote.write "Hello\nWorld\n"
+			remote.close
 		end
 		
 		it "should read multiple lines" do

data/spec/async/io/trap_spec.rb

@@ -35,7 +35,7 @@ RSpec.describe Async::IO::Trap do
 		trapped = false
 		
 		waiting_task = reactor.async do
-			subject.trap do
+			subject.wait do
 				trapped = true
 				break
 			end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.25.0
+  version: 1.26.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-11 00:00:00.000000000 Z
+date: 2019-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -129,6 +129,8 @@ files:
 - examples/allocations/read_chunks.rb
 - examples/chat/client.rb
 - examples/chat/server.rb
+- examples/echo/client.rb
+- examples/echo/server.rb
 - examples/issues/broken_ssl.rb
 - examples/issues/pipes.rb
 - examples/millions/client.rb
@@ -206,7 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Provides support for asynchonous TCP, UDP, UNIX and SSL sockets.