async-io 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3b884696374f63d12ec25bbeddbb32bdb6fc9dda
+  data.tar.gz: 43be6b24df7e4e244afaac328fdea0f95ecf612b
+SHA512:
+  metadata.gz: 5d4a4c420cff06424564949249ee0c5c442f02c581eb94268902dd98f39d7187c1af4525ba0483ec9c438a9395182141838dab42bb7ca498d5d994f014ee3001
+  data.tar.gz: 1a75fce2c71dc1ad463ece49508068e9aff94529578b8c468b65fd679fc7857d15a2cc3c3f6b58d2dbd61f2aec06ad8940307daea6095965aeb5c008cfaf7a2b

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--warnings
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+sudo: false
+dist: trusty
+cache: bundler
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - jruby-head
+  - ruby-head
+  - rbx-3
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx-3

data/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in async-io.gemspec
+gemspec
+
+group :development do
+	gem 'pry'
+	gem 'guard-rspec'
+	gem 'guard-yard'
+	
+	gem 'yard'
+end
+
+group :test do
+	gem 'benchmark-ips'
+	gem 'ruby-prof', platforms: :mri
+	
+	gem 'simplecov'
+	gem 'coveralls', require: false
+end

data/README.md

@@ -0,0 +1,111 @@
+# Async::IO
+
+Async::IO provides builds on [async] and provides asynchronous wrappers for `IO`, `Socket`, and related classes.
+
+[async]: https://github.com/socketry/async
+
+[![Build Status](https://secure.travis-ci.org/socketry/async-io.svg)](http://travis-ci.org/socketry/async-io)
+[![Code Climate](https://codeclimate.com/github/socketry/async-io.svg)](https://codeclimate.com/github/socketry/async-io)
+[![Coverage Status](https://coveralls.io/repos/socketry/async-io/badge.svg)](https://coveralls.io/r/socketry/async-io)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'async-io'
+```
+
+And then execute:
+
+	$ bundle
+
+Or install it yourself as:
+
+	$ gem install async-socket
+
+## Usage
+
+Basic echo server (from `spec/async/io/echo_spec.rb`):
+
+```ruby
+require 'async/io'
+
+def echo_server(server_address)
+	Async::Reactor.run do |task|
+		# This is a synchronous block within the current task:
+		Async::IO::Socket.accept(server_address) do |client|
+			# This is an asynchronous block within the current reactor:
+			data = client.read(512)
+			
+			# This produces out-of-order responses.
+			task.sleep(rand * 0.01)
+			
+			client.write(data.reverse)
+		end
+	end
+end
+
+def echo_client(server_address, data)
+	Async::Reactor.run do |task|
+		Async::IO::Socket.connect(server_address) do |peer|
+			result = peer.write(data)
+			
+			message = peer.read(512)
+			
+			puts "Sent #{data}, got response: #{message}"
+		end
+	end
+end
+
+Async::Reactor.run do
+	server_address = Async::IO::Address.tcp('0.0.0.0', 9000)
+	
+	server = echo_server(server_address)
+	
+	5.times.collect do |i|
+		echo_client(server_address, "Hello World #{i}")
+	end.each(&:wait)
+	
+	server.stop
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## See Also
+
+- [async](https://github.com/socketry/async) — Asynchronous event-driven reactor.
+- [async-dns](https://github.com/socketry/async-dns) — Asynchronous DNS resolver and server.
+- [async-rspec](https://github.com/socketry/async-rspec) — Shared contexts for running async specs.
+- [rubydns](https://github.com/ioquatix/rubydns) — A easy to use Ruby DNS server.
+
+## License
+
+Released under the MIT license.
+
+Copyright, 2017, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
+
+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.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:test)
+
+task :default => :test

data/async-io.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+require_relative 'lib/async/io/version'
+
+Gem::Specification.new do |spec|
+	spec.name          = "async-io"
+	spec.version       = Async::IO::VERSION
+	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.has_rdoc      = "yard"
+
+	spec.add_dependency "async", "~> 0.14"
+	spec.add_development_dependency "async-rspec", "~> 1.0"
+
+	spec.add_development_dependency "bundler", "~> 1.13"
+	spec.add_development_dependency "rake", "~> 10.0"
+	spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/async/io.rb

@@ -0,0 +1,34 @@
+# 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'
+
+require_relative "io/generic"
+require_relative "io/socket"
+require_relative "io/address"
+require_relative "io/version"
+
+module Async
+	module IO
+		def self.try_convert(io)
+			Generic::WRAPPERS[io.class].wrap(io)
+		end
+	end
+end

data/lib/async/io/address.rb

@@ -0,0 +1,144 @@
+# 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_relative 'socket'
+
+module Async
+	module IO
+		class Address < Struct.new(:specification, :options)
+			include ::Socket::Constants
+			include Comparable
+			
+			class << self
+				def tcp(*args, **options)
+					self.new([:tcp, *args], **options)
+				end
+				
+				def udp(*args, **options)
+					self.new([:udp, *args], **options)
+				end
+				
+				def unix(*args, **options)
+					self.new([:unix, *args], **options)
+				end
+				
+				def each(specifications, &block)
+					specifications.each do |specification|
+						if specification.is_a? self
+							yield self
+						else
+							# Perhaps detect options here?
+							yield self.new(specification)
+						end
+					end
+				end
+			end
+			
+			def initialize(specification, **options)
+				super(specification, options)
+			end
+			
+			def == other
+				self.to_sockaddr == other.to_sockaddr
+			end
+			
+			def <=> other
+				self.to_sockaddr <=> other.to_sockaddr
+			end
+			
+			def to_sockaddr
+				addrinfo.to_sockaddr
+			end
+			
+			# This is how addresses are internally converted, e.g. within `Socket#sendto`.
+			alias to_str to_sockaddr
+			
+			def socktype
+				addrinfo.socktype
+			end
+			
+			# Preferred accessor for socket type.
+			alias type socktype
+			
+			def afamily
+				addrinfo.afamily
+			end
+			
+			# Preferred accessor for address family.
+			alias family afamily
+			
+			# def connect? accept? DatagramHandler StreamHandler
+			
+			def bind(&block)
+				case specification
+				when Addrinfo
+					Socket.bind(specification, **options, &block)
+				when Array
+					Socket.bind(Addrinfo.send(*specification), **options, &block)
+				when ::BasicSocket
+					yield Socket.new(specification)
+				when BasicSocket
+					yield specification
+				else
+					raise ArgumentError, "Not sure how to bind to #{specification}!"
+				end
+			end
+			
+			def accept(&block)
+				backlog = self.options.fetch(:backlog, SOMAXCONN)
+				
+				bind do |socket|
+					socket.listen(backlog)
+					socket.accept_each(&block)
+				end
+			end
+			
+			def connect(&block)
+				case specification
+				when Addrinfo, Array
+					Socket.connect(self, &block)
+				when ::BasicSocket
+					yield Async::IO.try_convert(specification)
+				when BasicSocket
+					yield specification
+				else
+					raise ArgumentError, "Not sure how to bind to #{specification}!"
+				end
+			end
+			
+			private
+			
+			def addrinfo
+				@addrinfo ||= case specification
+					when Addrinfo
+						specification
+					when Array
+						Addrinfo.send(*specification)
+					when ::BasicSocket
+						specification.local_address
+					when BasicSocket
+						specification.local_address
+				else
+					raise ArgumentError, "Not sure how to convert #{specification} into address!"
+				end
+			end
+		end
+	end
+end

data/lib/async/io/generic.rb

@@ -0,0 +1,127 @@
+# 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/wrapper'
+require 'forwardable'
+
+module Async
+	module IO
+		# Represents an asynchronous IO within a reactor.
+		class Generic < Wrapper
+			extend Forwardable
+			
+			WRAPPERS = {}
+			
+			class << self
+				# @!macro [attach] wrap_blocking_method
+				#   @method $1
+				#   Invokes `$2` on the underlying {io}. If the operation would block, the current task is paused until the operation can succeed, at which point it's resumed and the operation is completed.
+				def wrap_blocking_method(new_name, method_name, invert: true, &block)
+					define_method(new_name) do |*args|
+						async_send(method_name, *args)
+					end
+					
+					if invert
+						# We define the original _nonblock method to call the async variant. We ignore options.
+						# define_method(method_name) do |*args, **options|
+						# 	self.__send__(new_name, *args)
+						# end
+						def_delegators :@io, method_name
+					end
+				end
+				
+				attr :wrapped_klass
+				
+				def wraps(klass, *additional_methods)
+					@wrapped_klass = klass
+					WRAPPERS[klass] = self
+					
+					# These are methods implemented by the wrapped class, that we aren't overriding, that may be of interest:
+					# fallback_methods = klass.instance_methods(false) - instance_methods
+					# puts "Forwarding #{klass} methods #{fallback_methods} to @io"
+					
+					def_delegators :@io, *additional_methods
+				end
+				
+				# Instantiate a wrapped instance of the class, and optionally yield it to a given block, closing it afterwards.
+				def wrap(*args)
+					wrapper = self.new(@wrapped_klass.new(*args))
+					
+					if block_given?
+						begin
+							yield wrapper
+						ensure
+							wrapper.close
+						end
+					else
+						return wrapper
+					end
+				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
+			
+			# @example
+			#   data = io.read(512)
+			wrap_blocking_method :read, :read_nonblock
+			
+			# @example
+			#   io.write("Hello World")
+			wrap_blocking_method :write, :write_nonblock
+			
+			protected
+			
+			if RUBY_VERSION >= "2.3"
+				def async_send(*args)
+					async do
+						@io.__send__(*args, exception: false)
+					end
+				end
+			else
+				def async_send(*args)
+					async do
+						@io.__send__(*args)
+					end
+				end
+			end
+			
+			def async
+				while true
+					begin
+						result = yield
+						
+						case result
+						when :wait_readable
+							wait_readable
+						when :wait_writable
+							wait_writable
+						else
+							return result
+						end
+					rescue ::IO::WaitReadable
+						wait_readable
+					rescue ::IO::WaitWritable
+						wait_writable
+					end
+				end
+			end
+		end
+	end
+end