libuv 2.0.12 → 3.0.0

data/lib/libuv/mixins/accessors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Libuv
+    module Accessors
+        def reactor
+            thread = Libuv::Reactor.current
+            if thread.nil?
+                thread = Libuv::Reactor.default
+                if thread.reactor_running?
+                    raise 'No reactor available on this thread'
+                end
+            end
+            thread.run { yield(thread) } if block_given?
+            thread
+        end
+
+        Functions = [
+            :defer, :all, :any, :finally, :update_time, :now, :lookup_error, :tcp,
+            :udp, :tty, :pipe, :timer, :prepare, :check, :idle, :async, :signal,
+            :work, :lookup, :fs_event, :file, :filesystem, :schedule, :next_tick,
+            :stop, :reactor_thread?, :reactor_running?, :run
+        ].freeze
+
+        Functions.each do |function|
+            define_method function do |*args|
+                thread = Libuv::Reactor.current
+
+                if thread
+                    thread.send(function, *args)
+                else
+                    thread = Libuv::Reactor.default
+                    if thread.reactor_running?
+                        raise 'attempted Libuv::Reactor access on non-reactor thread'
+                    else
+                       thread.send(function, *args) 
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/libuv/mixins/assertions.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Libuv
     module Assertions
-        MSG_NO_PROC = 'no block given'.freeze
+        MSG_NO_PROC = 'no block given'
 
         def assert_block(proc, msg = MSG_NO_PROC)
             raise ArgumentError, msg, caller unless proc.respond_to? :call

data/lib/libuv/mixins/fs_checks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Libuv
     module FsChecks
@@ -14,12 +15,27 @@ module Libuv
         end
 
 
-        def stat
-            @stat_deferred = @loop.defer
+        def stat(wait: true)
+            @stat_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@loop.handle, request, @fileno, callback(:on_stat, request.address))
-            @stat_deferred.promise
+            pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@reactor.handle, request, @fileno, callback(:on_stat, request.address))
+            promise = @stat_deferred.promise
+
+            wait ? co(promise) : promise
+        end
+
+
+        protected
+
+
+        def respond(wait, promise)
+            if wait
+                co(promise)
+                self
+            else
+                promise
+            end
         end
 
 
@@ -37,7 +53,7 @@ module Libuv
                 end
 
                 cleanup(req)
-                @stat_deferred.resolve(stats)
+                ::Fiber.new { @stat_deferred.resolve(stats) }.resume
             end
             @stat_deferred = nil
         end
@@ -63,7 +79,14 @@ module Libuv
             error = check_result(req[:result])
             if error
                 cleanup(req)
-                deferrable.reject(error)
+
+                ::Fiber.new {
+                    deferrable.reject(error)
+                    if @coroutine
+                        @coroutine.resolve(deferrable.promise)
+                        @coroutine = nil
+                    end
+                }.resume
                 false
             else
                 true

data/lib/libuv/mixins/listener.rb

@@ -1,4 +1,6 @@
-require 'thread_safe'
+# frozen_string_literal: true
+
+require 'concurrent'
 
 module Libuv
     module Listener
@@ -41,7 +43,7 @@ module Libuv
 
         def self.included(base)
             base.instance_variable_set(:@callback_funcs, {})
-            base.instance_variable_set(:@callback_lookup, ::ThreadSafe::Cache.new)
+            base.instance_variable_set(:@callback_lookup, ::Concurrent::Map.new)
             base.instance_variable_set(:@callback_lock, ::Mutex.new)
             base.extend(ClassMethods)
         end

data/lib/libuv/mixins/net.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'socket'
 
 module Libuv
     module Net
 
 
-        IP_ARGUMENT_ERROR = "ip must be a String".freeze                # Arguments specifying an IP address
-        PORT_ARGUMENT_ERROR = "port must be an Integer".freeze          # Arguments specifying an IP port
+        IP_ARGUMENT_ERROR = "ip must be a String"                # Arguments specifying an IP address
+        PORT_ARGUMENT_ERROR = "port must be an Integer"          # Arguments specifying an IP port
         INET_ADDRSTRLEN = 16
         INET6_ADDRSTRLEN = 46
 

data/lib/libuv/mixins/resource.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 module Libuv
     module Resource
 
 
         def resolve(deferred, rc)
             if rc && rc < 0
-                deferred.reject(@loop.lookup_error(rc))
+                deferred.reject(@reactor.lookup_error(rc))
             else
                 deferred.resolve(nil)
             end
         end
 
         def check_result!(rc)
-            e = @loop.lookup_error(rc) unless rc.nil? || rc >= 0
+            e = @reactor.lookup_error(rc) unless rc.nil? || rc >= 0
             raise e if e
         end
 
         def check_result(rc)
-            @loop.lookup_error(rc) unless rc.nil? || rc >= 0
+            @reactor.lookup_error(rc) unless rc.nil? || rc >= 0
         end
 
         def to_ptr

data/lib/libuv/mixins/stream.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     module Stream
 
@@ -13,39 +15,44 @@ module Libuv
 
 
 
-        BACKLOG_ERROR = "backlog must be an Integer".freeze
-        WRITE_ERROR = "data must be a String".freeze
-        STREAM_CLOSED_ERROR = "unable to write to a closed stream".freeze
-        CLOSED_HANDLE_ERROR = "handle closed before accept called".freeze
+        BACKLOG_ERROR = "backlog must be an Integer"
+        WRITE_ERROR = "data must be a String"
+        STREAM_CLOSED_ERROR = "unable to write to a closed stream"
+        CLOSED_HANDLE_ERROR = "handle closed before accept called"
 
 
         def listen(backlog)
-            return if @closed
+            return self if @closed
             assert_type(Integer, backlog, BACKLOG_ERROR)
             error = check_result ::Libuv::Ext.listen(handle, Integer(backlog), callback(:on_listen))
             reject(error) if error
+            self
         end
 
         # Starts reading from the handle
         def start_read
-            return if @closed
+            return self if @closed
             error = check_result ::Libuv::Ext.read_start(handle, callback(:on_allocate), callback(:on_read))
             reject(error) if error
+            self
         end
 
         # Stops reading from the handle
         def stop_read
-            return if @closed
+            return self if @closed
             error = check_result ::Libuv::Ext.read_stop(handle)
             reject(error) if error
+            self
         end
+        alias_method :close_read, :stop_read
 
         # Shutsdown the writes on the handle waiting until the last write is complete before triggering the callback
         def shutdown
-            return if @closed
+            return self if @closed
             req = ::Libuv::Ext.allocate_request_shutdown
             error = check_result ::Libuv::Ext.shutdown(req, handle, callback(:on_shutdown, req.address))
             reject(error) if error
+            self
         end
 
         def try_write(data)
@@ -62,9 +69,9 @@ module Libuv
             return result
         end
 
-        def write(data)
+        def write(data, wait: false)
             # NOTE:: Similar to udp.rb -> send
-            deferred = @loop.defer
+            deferred = @reactor.defer
             if !@closed
                 begin
                     assert_type(String, data, WRITE_ERROR)
@@ -94,9 +101,16 @@ module Libuv
             else
                 deferred.reject(RuntimeError.new(STREAM_CLOSED_ERROR))
             end
-            deferred.promise
+
+            if wait
+                return deferred.promise if wait == :promise
+                co deferred.promise
+            end
+
+            self
         end
         alias_method :puts, :write
+        alias_method :write_nonblock, :write
 
         def readable?
             return false if @closed
@@ -110,24 +124,94 @@ module Libuv
 
         def progress(callback = nil, &blk)
             @progress = callback || blk
+            self
+        end
+
+        # Very basic IO emulation, in no way trying to be exact
+        def read(maxlen = nil, outbuf = nil)
+            raise ::EOFError.new('socket closed') if @closed
+            @read_defer = @reactor.defer
+
+            if @read_buffer.nil?
+                start_read
+                @read_buffer = String.new
+                self.finally do
+                    @read_defer.reject(::EOFError.new('socket closed'))
+                end
+            end
+
+            if check_read_buffer(maxlen, outbuf, @read_defer)
+                progress do |data|
+                    @read_buffer << data
+                    check_read_buffer(maxlen, outbuf, @read_defer)
+                end
+            end
+
+            co @read_defer.promise
+        end
+        alias_method :read_nonblock, :read
+
+        # These are here purely for compatibility with rack hijack IO
+        def close_write; end
+        def flush
+            raise ::EOFError.new('socket closed') if @closed
+
+            @flush_defer = @reactor.defer
+            check_flush_buffer
+            co @flush_defer.promise
         end
 
 
         private
 
 
+        def check_read_buffer(maxlen, outbuf, defer)
+            if maxlen && @read_buffer.bytesize >= maxlen
+                if outbuf
+                    outbuf << @read_buffer[0...maxlen]
+                    defer.resolve outbuf
+                else
+                    defer.resolve @read_buffer[0...maxlen]
+                end
+                @read_buffer = @read_buffer[maxlen..-1]
+                progress do |data|
+                    @read_buffer << data
+                end
+                false
+            elsif maxlen.nil?
+                defer.resolve @read_buffer
+                @read_buffer = String.new
+                progress do |data|
+                    @read_buffer << data
+                end
+                false
+            else
+                true
+            end
+        end
+
+        def check_flush_buffer
+            if @flush_defer && (@write_callbacks.nil? || @write_callbacks.empty?) && (@pending_writes.nil? || @pending_writes.empty?) && @pending_write.nil?
+                @flush_defer.resolve(nil)
+                @flush_defer = nil
+            end
+        end
+
+
         def on_listen(server, status)
             e = check_result(status)
 
-            if e
-                reject(e)   # is this cause for closing the handle?
-            else
-                begin
-                    @on_listen.call(self)
-                rescue Exception => e
-                    @loop.log :error, :stream_listen_cb, e
+            ::Fiber.new {
+                if e
+                    reject(e)   # is this cause for closing the handle?
+                else
+                    begin
+                        @on_listen.call(self)
+                    rescue Exception => e
+                        @reactor.log e, 'performing stream listening callback'
+                    end
                 end
-            end
+            }.resume
         end
 
         def on_allocate(client, suggested_size, buffer)
@@ -142,7 +226,10 @@ module Libuv
             ::Libuv::Ext.free(req)
             buffer1.free
 
-            resolve deferred, status
+            ::Fiber.new {
+                resolve deferred, status
+                check_flush_buffer if @flush_defer
+            }.resume
         end
 
         def on_read(handle, nread, buf)
@@ -151,25 +238,30 @@ module Libuv
 
             if e
                 ::Libuv::Ext.free(base)
-                # I assume this is desirable behaviour
-                if e.is_a? ::Libuv::Error::EOF
-                    close   # Close gracefully 
-                else
-                    reject(e)
-                end
+
+                ::Fiber.new { 
+                    # I assume this is desirable behaviour
+                    if e.is_a? ::Libuv::Error::EOF
+                        close   # Close gracefully 
+                    else
+                        reject(e)
+                    end
+                }.resume
             else
                 data = base.read_string(nread)
                 ::Libuv::Ext.free(base)
                 
-                if @tls.nil?
-                    begin
-                        @progress.call data, self
-                    rescue Exception => e
-                        @loop.log :error, :stream_progress_cb, e
+                ::Fiber.new {
+                    if @tls.nil?
+                        begin
+                            @progress.call data, self
+                        rescue Exception => e
+                            @reactor.log e, 'performing stream read callback'
+                        end
+                    else
+                        @tls.decrypt(data)
                     end
-                else
-                    @tls.decrypt(data)
-                end
+                }.resume
             end
         end
 
@@ -177,7 +269,8 @@ module Libuv
             cleanup_callbacks(req.address)
             ::Libuv::Ext.free(req)
             @close_error = check_result(status)
-            close
+
+            ::Fiber.new { close }.resume
         end
     end
 end

data/lib/libuv/pipe.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Pipe < Handle
         include Stream
@@ -7,14 +9,14 @@ module Libuv
         define_callback function: :write2_complete, params: [:pointer, :int]
 
 
-        WRITE2_ERROR = "data must be a String".freeze
+        WRITE2_ERROR = "data must be a String"
 
 
-        def initialize(loop, ipc, acceptor = nil)
-            @loop, @ipc = loop, ipc
+        def initialize(reactor, ipc, acceptor = nil)
+            @reactor, @ipc = reactor, ipc
 
             pipe_ptr = ::Libuv::Ext.allocate_handle_pipe
-            error = check_result(::Libuv::Ext.pipe_init(loop.handle, pipe_ptr, ipc ? 1 : 0))
+            error = check_result(::Libuv::Ext.pipe_init(reactor.handle, pipe_ptr, ipc ? 1 : 0))
             error = check_result(::Libuv::Ext.accept(acceptor, pipe_ptr)) if acceptor && error.nil?
             
             super(pipe_ptr, error)
@@ -30,11 +32,13 @@ module Libuv
 
             error = check_result ::Libuv::Ext.pipe_bind(handle, name)
             reject(error) if error
+
+            self
         end
 
         def open(fileno, callback = nil, &blk)
             @callback = callback || blk
-            assert_type(Integer, fileno, 'fileno must be an integer file descriptor'.freeze)
+            assert_type(Integer, fileno, 'fileno must be an integer file descriptor')
 
             begin
                 raise RuntimeError, CLOSED_HANDLE_ERROR if @closed
@@ -44,11 +48,15 @@ module Libuv
                 begin
                     @callback.call(self) if @callback
                 rescue Exception => e
-                    @loop.log :error, :pipe_connect_cb, e
+                    @reactor.log e, 'performing pipe connect callback'
+                    raise e unless @callback
                 end
             rescue Exception => e
                 reject(e)
+                raise e unless @callback
             end
+
+            self
         end
 
         def connect(name, callback = nil, &blk)
@@ -62,10 +70,17 @@ module Libuv
             rescue Exception => e
                 reject(e)
             end
+
+            if @callback.nil?
+                @coroutine = @reactor.defer
+                co @coroutine.promise
+            end
+
+            self
         end
 
-        def write2(fd, data = ".")
-            deferred = @loop.defer
+        def write2(fd, data = ".", wait: false)
+            deferred = @reactor.defer
             if @ipc && !@closed
                 begin
                     assert_type(String, data, WRITE_ERROR)
@@ -93,7 +108,13 @@ module Libuv
             else
                 deferred.reject(TypeError.new('pipe not initialized for interprocess communication'))
             end
-            deferred.promise
+            
+            if wait
+                return deferred.promise if wait == :promise
+                co deferred.promise
+            end
+
+            self
         end
 
         # Windows only
@@ -113,9 +134,9 @@ module Libuv
             remote = nil
             case pending
             when :tcp
-                remote = TCP.new(loop, handle)
+                remote = TCP.new(reactor, handle)
             when :pipe
-                remote = Pipe.new(loop, @ipc, handle)
+                remote = Pipe.new(reactor, @ipc, handle)
             else
                 raise NotImplementedError, "IPC for handle #{pending} not supported"
             end
@@ -139,16 +160,18 @@ module Libuv
             pipe = nil
             begin
                 raise RuntimeError, CLOSED_HANDLE_ERROR if @closed
-                pipe = Pipe.new(loop, @ipc, handle)
+                pipe = Pipe.new(reactor, @ipc, handle)
             rescue Exception => e
-                @loop.log :info, :pipe_accept_failed, e
+                @reactor.log e, 'pipe accept failed'
             end
             if pipe
-                begin
-                    @on_accept.call(pipe)
-                rescue Exception => e
-                    @loop.log :error, :pipe_accept_cb, e
-                end
+                ::Fiber.new {
+                    begin
+                        @on_accept.call(pipe)
+                    rescue Exception => e
+                        @reactor.log e, 'performing pipe accept callback'
+                    end
+                }.resume
             end
         end
 
@@ -157,15 +180,17 @@ module Libuv
             ::Libuv::Ext.free(req)
             e = check_result(status)
 
-            if e
-                reject(e)
-            else
-                begin
-                    @callback.call(self)
-                rescue Exception => e
-                    @loop.log :error, :pipe_connect_cb, e
+            ::Fiber.new {
+                if e
+                    reject(e)
+                else
+                    begin
+                        @callback.call(self)
+                    rescue Exception => e
+                        @reactor.log e, 'performing pipe connected callback'
+                    end
                 end
-            end
+            }.resume
         end
 
         def write2_complete(req, status)
@@ -174,7 +199,9 @@ module Libuv
 
             ::Libuv::Ext.free(req)
             
-            resolve promise, status
+            ::Fiber.new {
+                resolve promise, status
+            }.resume
         end
 
         def windows_path(name)