libuv 2.0.12 → 3.0.0

data/lib/libuv/tty.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module Libuv
     class TTY < Handle
         include Stream
 
 
-        def initialize(loop, fileno, readable)
-            @loop = loop
+        def initialize(reactor, fileno, readable)
+            @reactor = reactor
 
             tty_ptr = ::Libuv::Ext.allocate_handle_tty
-            error = check_result(::Libuv::Ext.tty_init(loop.handle, tty_ptr, fileno, readable ? 1 : 0))
+            error = check_result(::Libuv::Ext.tty_init(reactor.handle, tty_ptr, fileno, readable ? 1 : 0))
             
             super(tty_ptr, error)
         end
@@ -15,15 +17,18 @@ module Libuv
         def enable_raw_mode
             return if @closed
             check_result ::Libuv::Ext.tty_set_mode(handle, 1)
+            self
         end
 
         def disable_raw_mode
             return if @closed
             check_result ::Libuv::Ext.tty_set_mode(handle, 0)
+            self
         end
 
         def reset_mode
             ::Libuv::Ext.tty_reset_mode
+            self
         end
 
         def winsize

data/lib/libuv/udp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ipaddr'
 
 
@@ -11,18 +13,19 @@ module Libuv
         define_callback function: :send_complete, params: [:pointer, :int]
 
 
-        SEND_DATA_ERROR = "data must be a String".freeze
-        TTL_ARGUMENT_ERROR = "ttl must be an Integer".freeze
-        MULTICAST_ARGUMENT_ERROR = "multicast_address must be a String".freeze
-        INTERFACE_ARGUMENT_ERROR = "interface_address must be a String".freeze
-        HANDLE_CLOSED_ERROR = "unable to send as handle closed".freeze
+        SEND_DATA_ERROR = "data must be a String"
+        TTL_ARGUMENT_ERROR = "ttl must be an Integer"
+        MULTICAST_ARGUMENT_ERROR = "multicast_address must be a String"
+        INTERFACE_ARGUMENT_ERROR = "interface_address must be a String"
+        HANDLE_CLOSED_ERROR = "unable to send as handle closed"
 
 
-        def initialize(loop)
-            @loop = loop
+        def initialize(reactor, progress: nil)
+            @reactor = reactor
+            @progress = progress
 
             udp_ptr = ::Libuv::Ext.allocate_handle_udp
-            error = check_result(::Libuv::Ext.udp_init(loop.handle, udp_ptr))
+            error = check_result(::Libuv::Ext.udp_init(reactor.handle, udp_ptr))
             @request_refs = {}
 
             super(udp_ptr, error)
@@ -36,12 +39,16 @@ module Libuv
             sockaddr = create_sockaddr(ip, port)
             error = check_result ::Libuv::Ext.udp_bind(handle, sockaddr, 0)
             reject(error) if error
+
+            self
         end
 
         def open(fd, binding = true, callback = nil, &blk)
             return if @closed
             error = check_result UV.udp_open(handle, fd)
             reject(error) if error
+
+            self
         end
 
         def sockname
@@ -58,6 +65,7 @@ module Libuv
 
             error = check_result ::Libuv::Ext.udp_set_membership(handle, multicast_address, interface_address, :uv_join_group)
             reject(error) if error
+            self
         end
 
         def leave(multicast_address, interface_address)
@@ -67,6 +75,7 @@ module Libuv
 
             error = check_result ::Libuv::Ext.udp_set_membership(handle, multicast_address, interface_address, :uv_leave_group)
             reject(error) if error
+            self
         end
 
         # Starts reading from the handle
@@ -75,6 +84,7 @@ module Libuv
             return if @closed
             error = check_result ::Libuv::Ext.udp_recv_start(handle, callback(:on_allocate), callback(:on_recv))
             reject(error) if error
+            self
         end
 
         # Stops reading from the handle
@@ -83,6 +93,7 @@ module Libuv
             return if @closed
             error = check_result ::Libuv::Ext.udp_recv_stop(handle)
             reject(error) if error
+            self
         end
 
         def try_send(ip, port, data)
@@ -108,9 +119,9 @@ module Libuv
             return result
         end
 
-        def send(ip, port, data)
+        def send(ip, port, data, wait: false)
             # NOTE:: Similar to stream.rb -> write
-            deferred = @loop.defer
+            deferred = @reactor.defer
             if !@closed
                 begin
                     assert_type(String, ip, IP_ARGUMENT_ERROR)
@@ -149,18 +160,27 @@ module Libuv
                 deferred.reject(RuntimeError.new(HANDLE_CLOSED_ERROR))
             end
             deferred.promise
+
+            if wait
+                return deferred.promise if wait == :promise
+                co deferred.promise
+            end
+
+            self
         end
 
-        def enable_multicast_loop
+        def enable_multicast_reactor
             return if @closed
-            error = check_result ::Libuv::Ext.udp_set_multicast_loop(handle, 1)
+            error = check_result ::Libuv::Ext.udp_set_multicast_reactor(handle, 1)
             reject(error) if error
+            self
         end
 
-        def disable_multicast_loop
+        def disable_multicast_reactor
             return if @closed
-            error = check_result ::Libuv::Ext.udp_set_multicast_loop(handle, 0)
+            error = check_result ::Libuv::Ext.udp_set_multicast_reactor(handle, 0)
             reject(error) if error
+            self
         end
 
         def multicast_ttl=(ttl)
@@ -168,18 +188,21 @@ module Libuv
             assert_type(Integer, ttl, TTL_ARGUMENT_ERROR)
             error = check_result ::Libuv::Ext.udp_set_multicast_ttl(handle, ttl)
             reject(error) if error
+            self
         end
 
         def enable_broadcast
             return if @closed
             error = check_result ::Libuv::Ext.udp_set_broadcast(handle, 1)
             reject(error) if error
+            self
         end
 
         def disable_broadcast
             return if @closed
             error = check_result ::Libuv::Ext.udp_set_broadcast(handle, 0)
             reject(error) if error
+            self
         end
 
         def ttl=(ttl)
@@ -187,10 +210,12 @@ module Libuv
             assert_type(Integer, ttl, TTL_ARGUMENT_ERROR)
             error = check_result ::Libuv::Ext.udp_set_ttl(handle, Integer(ttl))
             reject(error) if error
+            self
         end
 
         def progress(callback = nil, &blk)
             @progress = callback || blk
+            self
         end
 
 
@@ -239,18 +264,20 @@ module Libuv
             e = check_result(nread)
 
             if e
-                reject(e)   # Will call close
+                ::Fiber.new { reject(e) }.resume   # Will call close
             elsif nread > 0
                 data = @receive_buff.read_string(nread)
                 unless sockaddr.null?
                     ip, port = get_ip_and_port(sockaddr)
                 end
-                
-                begin
-                    @progress.call data, ip, port, self
-                rescue Exception => e
-                    @loop.log :error, :udp_progress_cb, e
-                end
+
+                ::Fiber.new {
+                    begin
+                        @progress.call data, ip, port, self
+                    rescue Exception => e
+                        @reactor.log e, 'performing UDP data received callback'
+                    end
+                }.resume
             else
                 ::Libuv::Ext.free(@receive_buff)
                 @receive_buff = nil
@@ -265,7 +292,7 @@ module Libuv
             ::Libuv::Ext.free(req)
             buffer1.free
 
-            resolve deferred, status
+            ::Fiber.new { resolve deferred, status }.resume
         end
     end
 end

data/lib/libuv/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
-    VERSION = '2.0.12'
+    VERSION = '3.0.0'
 end

data/lib/libuv/work.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Work < Q::DeferredPromise
         include Resource, Listener
@@ -11,7 +13,7 @@ module Libuv
         define_callback function: :on_complete, params: [:pointer, :int]
 
 
-        # @param thread [::Libuv::Loop] thread this work request will be associated
+        # @param thread [::Libuv::Reactor] thread this work request will be associated
         # @param work [Proc] callback to be called in the thread pool
         def initialize(thread, work)
             super(thread, thread.defer)
@@ -23,7 +25,7 @@ module Libuv
 
             @instance_id = @pointer.address
 
-            error = check_result ::Libuv::Ext.queue_work(@loop, @pointer, callback(:on_work), callback(:on_complete))
+            error = check_result ::Libuv::Ext.queue_work(@reactor, @pointer, callback(:on_work), callback(:on_complete))
             if error
                 ::Libuv::Ext.free(@pointer)
                 @complete = true
@@ -56,16 +58,18 @@ module Libuv
             @complete = true
             ::Libuv::Ext.free(req)
 
-            e = check_result(status)
-            if e
-                @defer.reject(e)
-            else
-                if @error
-                    @defer.reject(@error)
+            ::Fiber.new {
+                e = check_result(status)
+                if e
+                    @defer.reject(e)
                 else
-                    @defer.resolve(@result)
+                    if @error
+                        @defer.reject(@error)
+                    else
+                        @defer.resolve(@result)
+                    end
                 end
-            end
+            }.resume
             
             # Clean up references
             cleanup_callbacks @instance_id

data/libuv.gemspec

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 require File.expand_path("../lib/libuv/version", __FILE__)
 
 Gem::Specification.new do |gem|
     gem.name          = "libuv"
     gem.version       = Libuv::VERSION
     gem.license       = 'MIT'
-    gem.authors       = ["Bulat Shakirzyanov", "Stephen von Takach"]
-    gem.email         = ["mallluhuct@gmail.com", "steve@cotag.me"]
+    gem.authors       = ["Stephen von Takach"]
+    gem.email         = ["steve@cotag.me"]
     gem.homepage      = "https://github.com/cotag/libuv"
     gem.summary       = "libuv bindings for Ruby"
     gem.description   = "An opinionated wrapper around libuv for Ruby"
 
     gem.extensions << "ext/Rakefile"
 
-    gem.required_ruby_version = '>= 1.9.2'
+    gem.required_ruby_version = '>= 2.0.0'
     gem.require_paths = ["lib"]
 
-    gem.add_runtime_dependency     'ffi', '>= 1.9'
-    gem.add_runtime_dependency     'thread_safe'
-    gem.add_runtime_dependency     'ruby-tls', '>= 2.0.0'
+    gem.add_runtime_dependency     'ffi', '~> 1.9'
+    gem.add_runtime_dependency     'concurrent-ruby', '~> 1.0'
+    gem.add_runtime_dependency     'ruby-tls', '~> 2.1'
 
-    gem.add_development_dependency 'rspec', '>= 2.14'
-    gem.add_development_dependency 'rake', '>= 10.1'
-    gem.add_development_dependency 'yard'
+    gem.add_development_dependency 'rspec', '~> 3.5'
+    gem.add_development_dependency 'rake', '~> 11.2'
+    gem.add_development_dependency 'yard', '~> 0.9'
 
     gem.files         = `git ls-files`.split("\n")
     gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/async_spec.rb

@@ -6,25 +6,25 @@ describe Libuv::Async do
 		@log = []
 		@general_failure = []
 
-		@loop = Libuv::Loop.default
-		@call = @loop.pipe
-		@timeout = @loop.timer do
-			@loop.stop
+		@reactor = Libuv::Reactor.default
+		@call = @reactor.pipe
+		@timeout = @reactor.timer do
+			@reactor.stop
 			@general_failure << "test timed out"
 		end
 		@timeout.start(5000)
 
-		@loop.all(@server, @client, @timeout).catch do |reason|
+		@reactor.all(@server, @client, @timeout).catch do |reason|
 			@general_failure << reason.inspect
 			p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
 		end
 	end
 	
 	it "Should call the async function from the thread pool stopping the counter" do
-		@loop.run { |logger|
-			logger.progress do |level, errorid, error|
+		@reactor.run { |reactor|
+			reactor.notifier do |error, context|
 				begin
-					p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					p "Log called: #{context}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
 				rescue Exception
 					p 'error in logger'
 				end
@@ -32,24 +32,24 @@ describe Libuv::Async do
 
 			@count = 0
 
-			timer = @loop.timer do
+			timer = @reactor.timer do
 				@count += 1
 			end
 			timer.start(0, 200)
 
-			callback = @loop.async do
-				stopper = @loop.timer do
+			callback = @reactor.async do
+				stopper = @reactor.timer do
 					timer.close
 					callback.close
 					stopper.close
 					@timeout.close
-					@loop.stop
+					@reactor.stop
 				end
 				stopper.start(1000)
 				callback.close
 			end
 
-			@loop.work(proc {
+			@reactor.work(proc {
 				callback.call
 			}).catch do |err|
 				@general_failure << err

data/spec/coroutines_spec.rb

@@ -10,10 +10,18 @@ if RUBY_PLATFORM != 'java'
 			@log = []
 			@general_failure = []
 
-			@loop = Libuv::Loop.default
-			@timeout = @loop.timer do
+			@reactor = Libuv::Reactor.default
+			@reactor.notifier do |error, context|
+				begin
+					@general_failure << "Log called: #{context}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
+				rescue Exception => e
+					@general_failure << "error in logger #{e.inspect}"
+				end
+			end
+
+			@timeout = @reactor.timer do
 				@timeout.close
-				@loop.stop
+				@reactor.stop
 				@general_failure << "test timed out"
 			end
 			@timeout.start(5000)
@@ -21,24 +29,15 @@ if RUBY_PLATFORM != 'java'
 		
 		describe 'serial execution' do
 			it "should wait for work to complete and return the result" do
-				@loop.run { |logger|
-					logger.progress do |level, errorid, error|
-						begin
-							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
-						rescue Exception => e
-							@general_failure << "error in logger #{e.inspect}"
-						end
-					end
+				@reactor.run { |reactor|
 
-
-					@log << co(@loop.work(proc {
+					@log << co(@reactor.work(proc {
 						sleep 1
 						'work done'
 					}))
 					@log << 'after work'
 
 					@timeout.close
-					@loop.stop
 				}
 
 				expect(@general_failure).to eq([])
@@ -46,17 +45,9 @@ if RUBY_PLATFORM != 'java'
 			end
 
 			it "should raise an error if the promise is rejected" do
-				@loop.run { |logger|
-					logger.progress do |level, errorid, error|
-						begin
-							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
-						rescue Exception => e
-							@general_failure << "error in logger #{e.inspect}"
-						end
-					end
-
+				@reactor.run { |reactor|
 					begin
-						@log << co(@loop.work(proc {
+						@log << co(@reactor.work(proc {
 							raise 'rejected'
 						}))
 						@log << 'after work'
@@ -65,7 +56,6 @@ if RUBY_PLATFORM != 'java'
 					end
 
 					@timeout.close
-					@loop.stop
 				}
 
 				expect(@general_failure).to eq([])
@@ -73,22 +63,13 @@ if RUBY_PLATFORM != 'java'
 			end
 
 			it "should return the results of multiple promises" do
-				@loop.run { |logger|
-					logger.progress do |level, errorid, error|
-						begin
-							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
-						rescue Exception => e
-							@general_failure << "error in logger #{e.inspect}"
-						end
-					end
-
-
-					job1 = @loop.work(proc {
+				@reactor.run { |reactor|
+					job1 = @reactor.work(proc {
 						sleep 1
 						'job1'
 					})
 
-					job2 = @loop.work(proc {
+					job2 = @reactor.work(proc {
 						sleep 1
 						'job2'
 					})
@@ -101,7 +82,6 @@ if RUBY_PLATFORM != 'java'
 					@log << 'after work'
 
 					@timeout.close
-					@loop.stop
 				}
 
 				expect(@general_failure).to eq([])
@@ -110,16 +90,8 @@ if RUBY_PLATFORM != 'java'
 
 
 			it "should provide a callback option for progress events" do
-				@loop.run { |logger|
-					logger.progress do |level, errorid, error|
-						begin
-							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
-						rescue Exception => e
-							@general_failure << "error in logger #{e.inspect}"
-						end
-					end
-
-					timer = @loop.timer
+				@reactor.run { |reactor|
+					timer = @reactor.timer
 					timer.start(0)
 					co(timer) do
 						@log << 'in timer'
@@ -127,9 +99,7 @@ if RUBY_PLATFORM != 'java'
 					end
 
 					@log << 'after timer'
-
 					@timeout.close
-					@loop.stop
 				}
 
 				expect(@log).to eq(['in timer', 'after timer'])