async-io 1.29.0 → 1.30.0

data/async-io.gemspec

@@ -1,30 +0,0 @@
-
-require_relative 'lib/async/io/version'
-
-Gem::Specification.new do |spec|
-	spec.name          = "async-io"
-	spec.version       = Async::IO::VERSION
-	spec.licenses      = ["MIT"]
-	spec.authors       = ["Samuel Williams"]
-	spec.email         = ["samuel.williams@oriontransfer.co.nz"]
-
-	spec.summary       = "Provides support for asynchonous TCP, UDP, UNIX and SSL sockets."
-	spec.homepage      = "https://github.com/socketry/async-io"
-
-	spec.files         = `git ls-files`.split($/)
-	spec.executables   = spec.files.grep(%r{^bin/}).map{|f| File.basename(f)}
-	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-	spec.require_paths = ["lib"]
-
-	spec.add_dependency "async", "~> 1.14"
-	spec.add_development_dependency "async-rspec", "~> 1.10"
-
-	spec.required_ruby_version = '~> 2.5'
-	
-	spec.add_development_dependency "async-container", "~> 0.15"
-	
-	spec.add_development_dependency "covered"
-	spec.add_development_dependency "bundler"
-	spec.add_development_dependency "bake-bundler"
-	spec.add_development_dependency "rspec", "~> 3.0"
-end

data/examples/allocations/byteslice.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative 'memory'
-
-string = nil
-
-measure_memory("Initial allocation") do
-	string = "a" * 5*1024*1024
-	string.freeze
-end # => 5.0 MB
-
-measure_memory("Byteslice from start to middle") do
-	# Why does this need to allocate memory? Surely it can share the original allocation?
-	x = string.byteslice(0, string.bytesize / 2)
-end # => 2.5 MB
-
-measure_memory("Byteslice from middle to end") do
-	string.byteslice(string.bytesize / 2, string.bytesize)
-end # => 0.0 MB
-
-measure_memory("Slice! from start to middle") do
-	string.dup.slice!(0, string.bytesize / 2)
-end # => 7.5 MB
-
-measure_memory("Byte slice into two halves") do
-	head = string.byteslice(0, string.bytesize / 2) # 2.5 MB
-	remainder = string.byteslice(string.bytesize / 2, string.bytesize) # Shared
-end # 2.5 MB

data/examples/allocations/memory.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-def measure_memory(annotation = "Memory allocated")
-	GC.disable
-	
-	start_memory = `ps -p #{Process::pid} -o rss`.split("\n")[1].chomp.to_i
-
-	yield
-	
-ensure
-	end_memory = `ps -p #{Process::pid} -o rss`.split("\n")[1].chomp.to_i
-	memory_usage = (end_memory - start_memory).to_f / 1024
-	
-	puts "#{memory_usage.round(1)} MB: #{annotation}"
-	GC.enable
-end

data/examples/allocations/read_chunks.rb

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative 'memory'
-
-require_relative "../../lib/async/io/stream"
-require "stringio"
-
-measure_memory("Stream setup") do
-	@io = StringIO.new("a" * (50*1024*1024))
-	@stream = Async::IO::Stream.new(@io)
-end # 50.0 MB
-
-measure_memory("Read all chunks") do
-	while chunk = @stream.read_partial
-		chunk.clear
-	end
-end # 0.5 MB

data/examples/chat/client.rb

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path("../../lib", __dir__)
-
-require 'async'
-require 'async/notification'
-require 'async/io/stream'
-require 'async/io/host_endpoint'
-require 'async/io/protocol/line'
-
-class User < Async::IO::Protocol::Line
-end
-
-endpoint = Async::IO::Endpoint.parse(ARGV.pop || "tcp://localhost:7138")
-
-input = Async::IO::Protocol::Line.new(
-	Async::IO::Stream.new(
-		Async::IO::Generic.new($stdin)
-	)
-)
-
-Async do |task|
-	socket = endpoint.connect
-	stream = Async::IO::Stream.new(socket)
-	user = User.new(stream)
-	
-	# This is used to track whether either reading from stdin failed or reading from network failed.
-	finished = Async::Notification.new
-	
-	# Read lines from stdin and write to network.
-	terminal = task.async do
-		while line = input.read_line
-			user.write_lines line
-		end
-	rescue EOFError
-		# It's okay, we are disconnecting, because stdin has closed.
-	ensure
-		finished.signal
-	end
-	
-	# Read lines from network and write to stdout.
-	network = task.async do
-		while line = user.read_line
-			puts line
-		end
-	ensure
-		finished.signal
-	end
-	
-	# Wait for any of the above processes to finish:
-	finished.wait
-ensure
-	# Stop all the nested tasks if we are exiting:
-	network.stop if network
-	terminal.stop if terminal
-	user.close if user
-end

data/examples/chat/server.rb

@@ -1,83 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path("../../lib", __dir__)
-
-require 'set'
-
-require 'async'
-require 'async/io/host_endpoint'
-require 'async/io/protocol/line'
-
-class User < Async::IO::Protocol::Line
-	attr_accessor :name
-	
-	def login!
-		self.write_lines "Tell me your name, traveller:"
-		self.name = self.read_line
-	end
-	
-	def to_s
-		@name || "unknown"
-	end
-end
-
-class Server
-	def initialize
-		@users = Set.new
-	end
-	
-	def broadcast(*message)
-		puts *message
-		
-		@users.each do |user|
-			begin
-				user.write_lines(*message)
-			rescue EOFError
-				# In theory, it's possible this will fail if the remote end has disconnected. Each user has it's own task running `#connected`, and eventually `user.read_line` will fail. When it does, the disconnection logic will be invoked. A better way to do this would be to have a message queue, but for the sake of keeping this example simple, this is by far the better option.
-			end
-		end
-	end
-	
-	def connected(user)
-		user.login!
-		
-		broadcast("#{user} has joined")
-		
-		user.write_lines("currently connected: #{@users.map(&:to_s).join(', ')}")
-		
-		while message = user.read_line
-			broadcast("#{user.name}: #{message}")
-		end
-	rescue EOFError
-		# It's okay, client has disconnected.
-	ensure
-		disconnected(user)
-	end
-	
-	def disconnected(user, reason = "quit")
-		@users.delete(user)
-		
-		broadcast("#{user} has disconnected: #{reason}")
-	end
-	
-	def run(endpoint)
-		Async do |task|
-			endpoint.accept do |peer|
-				stream = Async::IO::Stream.new(peer)
-				user = User.new(stream)
-				
-				@users << user
-				
-				connected(user)
-			end
-		end
-	end
-end
-
-Async.logger.level = Logger::INFO
-Async.logger.info("Starting server...")
-server = Server.new
-
-endpoint = Async::IO::Endpoint.parse(ARGV.pop || "tcp://localhost:7138")
-server.run(endpoint)

data/examples/defer/worker.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/io/notification'
-
-def defer(*args, &block)
-	Async do
-		notification = Async::IO::Notification.new
-		
-		thread = Thread.new(*args) do
-			yield
-		ensure
-			notification.signal
-		end
-		
-		notification.wait
-		thread.join
-	end
-end
-
-Async do
-	10.times do
-		defer do
-			puts "I'm going to sleep"
-			sleep 1
-			puts "I'm going to wake up"
-		end
-	end
-end

data/examples/echo/client.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$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

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$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/examples/issues/broken_ssl.rb

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'socket'
-require 'openssl'
-
-server = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
-server.bind(Addrinfo.tcp('127.0.0.1', 4433))
-server.listen(128)
-
-ssl_server = OpenSSL::SSL::SSLServer.new(server, OpenSSL::SSL::SSLContext.new)
-
-puts ssl_server.addr
-
-# openssl/ssl.rb:234:in `addr': undefined method `addr' for #<Socket:fd 8> (NoMethodError)

data/examples/issues/pipes.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-# wat.rb
-require 'async'
-require_relative '../../lib/async/io'
-require 'digest/sha1'
-require 'securerandom'
-
-Async.run do |task|
-	r, w = IO.pipe.map { |io| Async::IO.try_convert(io) }
-
-	task.async do |subtask|
-		s = Digest::SHA1.new
-		l = 0
-		100.times do
-			bytes = SecureRandom.bytes(4000)
-			s << bytes
-			w << bytes
-			l += bytes.bytesize
-		end
-		w.close
-		p [:write, l, s.hexdigest]
-	end
-	
-	task.async do |subtask|
-		s = Digest::SHA1.new
-		l = 0
-		while b = r.read(4096)
-			s << b
-			l += b.bytesize
-		end
-		p [:read, l, s.hexdigest]
-	end
-end

data/examples/millions/client.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path("../../lib", __dir__)
-
-require 'async/reactor'
-require 'async/io/host_endpoint'
-
-require 'async/container'
-require 'async/container/forked'
-
-endpoint = Async::IO::Endpoint.parse(ARGV.pop || "tcp://localhost:7234")
-
-CONNECTIONS = 1_000_000
-
-CONCURRENCY = Async::Container.hardware_concurrency
-TASKS = 16
-REPEATS = (CONNECTIONS.to_f / (TASKS * CONCURRENCY)).ceil
-
-puts "Starting #{CONCURRENCY} processes, running #{TASKS} tasks, making #{REPEATS} connections."
-puts "Total number of connections: #{CONCURRENCY * TASKS * REPEATS}!"
-
-begin
-	container = Async::Container::Forked.new
-	
-	container.run(count: CONCURRENCY) do
-		Async do |task|
-			connections = []
-			
-			TASKS.times do
-				task.async do
-					REPEATS.times do
-						$stdout.write "."
-						connections << endpoint.connect
-					end
-				end
-			end
-		end
-	end
-	
-	container.wait
-ensure
-	container.stop if container
-end