libuv 2.0.12 → 3.0.0

data/lib/libuv/signal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Signal < Handle
 
@@ -10,6 +12,8 @@ module Libuv
             :SIGHUP => 1,
             :INT => 2,
             :SIGINT => 2,
+            :TERM => 15,
+            :SIGTERM => 15,
             :BREAK => 21,
             :SIGBREAK => 21,
             :WINCH => 28,
@@ -17,13 +21,13 @@ module Libuv
         }
 
 
-        # @param loop [::Libuv::Loop] loop this signal handler will be associated
+        # @param reactor [::Libuv::Reactor] reactor this signal handler will be associated
         # @param callback [Proc] callback to be called when the signal is triggered
-        def initialize(loop)
-            @loop = loop
+        def initialize(reactor)
+            @reactor = reactor
 
             signal_ptr = ::Libuv::Ext.allocate_handle_signal
-            error = check_result(::Libuv::Ext.signal_init(loop.handle, signal_ptr))
+            error = check_result(::Libuv::Ext.signal_init(reactor.handle, signal_ptr))
 
             super(signal_ptr, error)
         end
@@ -34,6 +38,7 @@ module Libuv
             signal = SIGNALS[signal] if signal.is_a? Symbol
             error = check_result ::Libuv::Ext.signal_start(handle, callback(:on_sig), signal)
             reject(error) if error
+            self
         end
 
         # Disables the signal handler.
@@ -41,6 +46,7 @@ module Libuv
             return if @closed
             error = check_result ::Libuv::Ext.signal_stop(handle)
             reject(error) if error
+            self
         end
 
 
@@ -48,7 +54,9 @@ module Libuv
 
 
         def on_sig(handle, signal)
-            defer.notify(signal)   # notify of a call
+            ::Fiber.new {
+                defer.notify(signal)   # notify of a call
+            }.resume
         end
     end
 end

data/lib/libuv/tcp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ipaddr'
 require 'ruby-tls'
 
@@ -20,11 +22,12 @@ module Libuv
         def tls?; !@tls.nil?; end
 
 
-        def initialize(loop, acceptor = nil)
-            @loop = loop
+        def initialize(reactor, acceptor = nil, progress: nil)
+            @reactor = reactor
+            @progress = progress
 
             tcp_ptr = ::Libuv::Ext.allocate_handle_tcp
-            error = check_result(::Libuv::Ext.tcp_init(loop.handle, tcp_ptr))
+            error = check_result(::Libuv::Ext.tcp_init(reactor.handle, tcp_ptr))
 
             if acceptor && error.nil?
                 error = check_result(::Libuv::Ext.accept(acceptor, tcp_ptr))
@@ -42,7 +45,7 @@ module Libuv
         # --------------------------------------
         #
         def start_tls(args = {})
-            return unless @connected && @tls.nil?
+            return self unless @connected && @tls.nil?
 
             args[:verify_peer] = true if @on_verify
 
@@ -50,6 +53,7 @@ module Libuv
             @pending_writes = []
             @tls = ::RubyTls::SSL::Box.new(args[:server], self, args)
             @tls.start
+            self
         end
 
         # Push through any pending writes when handshake has completed
@@ -67,13 +71,14 @@ module Libuv
             begin
                 @on_handshake.call(self, protocol) if @on_handshake
             rescue => e
-                @loop.log :warn, :tls_handshake_callback_error, e
+                @reactor.log e, 'performing TLS handshake callback'
             end
         end
 
         # Provide a callback once the TLS handshake has completed
         def on_handshake(callback = nil, &blk)
             @on_handshake = callback || blk
+            self
         end
 
         # This is clear text data that has been decrypted
@@ -82,7 +87,7 @@ module Libuv
             begin
                 @progress.call data, self
             rescue Exception => e
-                @loop.log :error, :stream_progress_cb, e
+                @reactor.log e, 'performing TLS read data callback'
             end
         end
 
@@ -113,7 +118,7 @@ module Libuv
                 begin
                     return @on_verify.call cert
                 rescue => e
-                    @loop.log :warn, :tls_verify_callback_failed, e
+                    @reactor.log e, 'performing TLS verify callback'
                     return false
                 end
             end
@@ -124,12 +129,12 @@ module Libuv
         # overwrite the default close to ensure
         # pending writes are rejected
         def close
-            return if @closed
+            return self if @closed
 
             # Free tls memory
             # Next tick as may recieve data after closing
             if @tls
-                @loop.next_tick do
+                @reactor.next_tick do
                     @tls.cleanup
                 end
             end
@@ -148,12 +153,13 @@ module Libuv
         # Verify peers will be called for each cert in the chain
         def verify_peer(callback = nil, &blk)
             @on_verify = callback || blk
+            self
         end
 
         alias_method :direct_write, :write
-        def write(data)
+        def write(data, wait: false)
             if @tls
-                deferred = @loop.defer
+                deferred = @reactor.defer
                 
                 if @handshake
                     @pending_write = deferred
@@ -162,9 +168,14 @@ module Libuv
                     @pending_writes << [deferred, data]
                 end
 
-                deferred.promise
+                if wait
+                    return deferred.promise if wait == :promise
+                    co deferred.promise
+                end
+
+                self
             else
-                direct_write(data)
+                direct_write(data, wait: wait)
             end
         end
 
@@ -175,6 +186,7 @@ module Libuv
             else
                 do_shutdown
             end
+            self
         end
         #
         # END TLS Abstraction ------------------
@@ -182,7 +194,8 @@ module Libuv
         #
 
         def bind(ip, port, callback = nil, &blk)
-            return if @closed
+            return self if @closed
+
             @on_accept = callback || blk
             @on_listen = method(:accept)
 
@@ -195,22 +208,30 @@ module Libuv
             rescue Exception => e
                 reject(e)
             end
+
+            self
         end
 
         def open(fd, binding = true, callback = nil, &blk)
-            return if @closed
+            return self if @closed
+
             if binding
                 @on_listen = method(:accept)
                 @on_accept = callback || blk
             else
                 @callback = callback || blk
+                @coroutine = @reactor.defer if @callback.nil?
             end
             error = check_result UV.tcp_open(handle, fd)
             reject(error) if error
+            co @coroutine.promise if @coroutine
+
+            self
         end
 
         def connect(ip, port, callback = nil, &blk)
-            return if @closed
+            return self if @closed
+
             @callback = callback || blk
             assert_type(String, ip, IP_ARGUMENT_ERROR)
             assert_type(Integer, port, PORT_ARGUMENT_ERROR)
@@ -221,6 +242,13 @@ module Libuv
             rescue Exception => e
                 reject(e)
             end
+
+            if @callback.nil?
+                @coroutine = @reactor.defer
+                co @coroutine.promise
+            end
+
+            self
         end
 
         def sockname
@@ -238,33 +266,39 @@ module Libuv
         end
 
         def enable_nodelay
-            return if @closed
+            return self if @closed
             check_result ::Libuv::Ext.tcp_nodelay(handle, 1)
+            self
         end
 
         def disable_nodelay
-            return if @closed
+            return self if @closed
             check_result ::Libuv::Ext.tcp_nodelay(handle, 0)
+            self
         end
 
         def enable_keepalive(delay)
-            return if @closed                   # The to_i asserts integer
+            return self if @closed                   # The to_i asserts integer
             check_result ::Libuv::Ext.tcp_keepalive(handle, 1, delay.to_i)
+            self
         end
 
         def disable_keepalive
-            return if @closed
+            return self if @closed
             check_result ::Libuv::Ext.tcp_keepalive(handle, 0, 0)
+            self
         end
 
         def enable_simultaneous_accepts
-            return if @closed
+            return self if @closed
             check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 1)
+            self
         end
 
         def disable_simultaneous_accepts
-            return if @closed
+            return self if @closed
             check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 0)
+            self
         end
 
 
@@ -273,9 +307,9 @@ module Libuv
 
         def create_socket(ip, port)
             if ip.ipv4?
-                Socket4.new(loop, handle, ip.to_s, port)
+                Socket4.new(reactor, handle, ip.to_s, port)
             else
-                Socket6.new(loop, handle, ip.to_s, port)
+                Socket6.new(reactor, handle, ip.to_s, port)
             end
         end
 
@@ -284,30 +318,43 @@ module Libuv
             ::Libuv::Ext.free(req)
             e = check_result(status)
 
-            if e
-                reject(e)
-            else
-                @connected = true
-
-                begin
-                    @callback.call(self)
-                rescue Exception => e
-                    @loop.log :error, :connect_cb, e
+            ::Fiber.new {
+                if e
+                    reject(e)
+                else
+                    @connected = true
+
+                    begin
+                        if @callback
+                            @callback.call(self)
+                            @callback = nil
+                        elsif @coroutine
+                            @coroutine.resolve(nil)
+                            @coroutine = nil
+                        else
+                            raise ArgumentError, 'no callback provided'
+                        end
+                    rescue Exception => e
+                        @reactor.log e, 'performing TCP connection callback'
+                    end
                 end
-            end
+            }.resume
         end
 
         def accept(_)
             begin
                 raise RuntimeError, CLOSED_HANDLE_ERROR if @closed
-                tcp = TCP.new(loop, handle)
-                begin
-                    @on_accept.call(tcp)
-                rescue Exception => e
-                    @loop.log :error, :tcp_accept_cb, e
-                end
+                tcp = TCP.new(reactor, handle)
+
+                ::Fiber.new {
+                    begin
+                        @on_accept.call(tcp)
+                    rescue Exception => e
+                        @reactor.log e, 'performing TCP accept callback'
+                    end
+                }.resume
             rescue Exception => e
-                @loop.log :info, :tcp_accept_failed, e
+                @reactor.log e, 'failed to accept TCP connection'
             end
         end
 
@@ -315,21 +362,24 @@ module Libuv
         class SocketBase
             include Resource
 
-            def initialize(loop, tcp, ip, port)
-                @tcp, @sockaddr = tcp, ip_addr(ip, port)
-                @loop = loop
+            def initialize(reactor, tcp, ip, port)
+                @ip = ip
+                @port = port
+                @tcp = tcp
+                @reactor = reactor
+                @req = ::Libuv::Ext.allocate_request_connect
             end
 
             def bind
-                check_result!(tcp_bind)
+                check_result! ::Libuv::Ext.tcp_bind(@tcp, ip_addr, 0)
             end
 
             def connect(callback)
-                check_result!(tcp_connect(callback))
+                @callback = callback
+                check_result!(tcp_connect)
             end
 
             def connect_req
-                @req ||= ::Libuv::Ext.allocate_request_connect
                 @req
             end
 
@@ -337,18 +387,14 @@ module Libuv
             protected
 
 
-            def tcp_connect(callback)
+            def tcp_connect
                 ::Libuv::Ext.tcp_connect(
-                  connect_req,
+                  @req,
                   @tcp,
-                  @sockaddr,
-                  callback
+                  ip_addr,
+                  @callback
                 )
             end
-
-            def tcp_bind
-                ::Libuv::Ext.tcp_bind(@tcp, @sockaddr, 0)
-            end
         end
 
 
@@ -356,10 +402,10 @@ module Libuv
             protected
 
 
-            def ip_addr(ip, port)
-                addr = Ext::SockaddrIn.new
-                check_result! ::Libuv::Ext.ip4_addr(ip, port, addr)
-                addr
+            def ip_addr
+                @sockaddr = Ext::SockaddrIn.new
+                check_result! ::Libuv::Ext.ip4_addr(@ip, @port, @sockaddr)
+                @sockaddr
             end
         end
 
@@ -368,10 +414,10 @@ module Libuv
             protected
 
 
-            def ip_addr(ip, port)
-                addr = Ext::SockaddrIn6.new
-                check_result! ::Libuv::Ext.ip6_addr(ip, port, addr)
-                addr
+            def ip_addr
+                @sockaddr = Ext::SockaddrIn6.new
+                check_result! ::Libuv::Ext.ip6_addr(@ip, @port, @sockaddr)
+                @sockaddr
             end
         end
     end

data/lib/libuv/timer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Timer < Handle
 
@@ -5,13 +7,14 @@ module Libuv
         define_callback function: :on_timer
 
 
-        # @param loop [::Libuv::Loop] loop this timer will be associated
+        # @param reactor [::Libuv::Reactor] reactor this timer will be associated
         # @param callback [Proc] callback to be called when the timer is triggered
-        def initialize(loop, callback = nil)
-            @loop, @callback = loop, callback
+        def initialize(reactor, callback = nil, &blk)
+            @reactor = reactor
+            @callback = callback || blk
             
             timer_ptr = ::Libuv::Ext.allocate_handle_timer
-            error = check_result(::Libuv::Ext.timer_init(loop.handle, timer_ptr))
+            error = check_result(::Libuv::Ext.timer_init(reactor.handle, timer_ptr))
             @stopped = true
 
             super(timer_ptr, error)
@@ -19,22 +22,21 @@ module Libuv
 
         # Enables the timer. A repeat of 0 means no repeat
         #
-        # @param timeout [Fixnum] time in milliseconds before the timer callback is triggered the first time
-        # @param repeat [Fixnum] time in milliseconds between repeated callbacks after the first
+        # @param timeout [Integer|Fixnum] time in milliseconds before the timer callback is triggered the first time
+        # @param repeat [Integer|Fixnum] time in milliseconds between repeated callbacks after the first
         def start(timeout, repeat = 0)
             return if @closed
             @stopped = false
 
             # prevent timeouts less than 0 (very long time otherwise as cast to an unsigned)
             # and you probably don't want to wait a few lifetimes
-            timeout = 0 if timeout < 0
-
             timeout = timeout.to_i
-            repeat = repeat.to_i
+            timeout = 0 if timeout < 0
 
-            @loop.update_time
-            error = check_result ::Libuv::Ext.timer_start(handle, callback(:on_timer), timeout, repeat)
+            error = check_result ::Libuv::Ext.timer_start(handle, callback(:on_timer), timeout, repeat.to_i)
             reject(error) if error
+
+            self
         end
 
         # Disables the timer.
@@ -43,28 +45,42 @@ module Libuv
             @stopped = true
             error = check_result ::Libuv::Ext.timer_stop(handle)
             reject(error) if error
+
+            self
         end
 
         # Resets the current repeat
         def again
             return if @closed
-            @loop.update_time
             error = check_result ::Libuv::Ext.timer_again(handle)
             reject(error) if error
+
+            self
         end
 
-        # Updates the repeat timeout
-        def repeat=(repeat)
+        # Set the current repeat timeout
+        # Repeat is the time in milliseconds between repeated callbacks after the initial timeout fires
+        #
+        # @param time [Integer|Fixnum] time in milliseconds between repeated callbacks after the first
+        def repeat=(time)
             return if @closed
-            repeat = repeat.to_i
-            error = check_result ::Libuv::Ext.timer_set_repeat(handle, repeat)
+            error = check_result ::Libuv::Ext.timer_set_repeat(handle, time.to_i)
             reject(error) if error
+            time
         end
 
-        # Returns the current repeat timeout
-        def repeat
+        # Set or gets the current repeat timeout
+        # Repeat is the time in milliseconds between repeated callbacks after the initial timeout fires
+        #
+        # @param times [Integer|Fixnum] time in milliseconds between repeated callbacks after the first
+        def repeat(time = nil)
             return if @closed
-            ::Libuv::Ext.timer_get_repeat(handle)
+            if time.nil?
+                ::Libuv::Ext.timer_get_repeat(handle)
+            else
+                self.repeat = time
+                self
+            end
         end
 
         # Used to update the callback to be triggered by the timer
@@ -72,6 +88,8 @@ module Libuv
         # @param callback [Proc] the callback to be called by the timer
         def progress(callback = nil, &blk)
             @callback = callback || blk
+
+            self
         end
 
 
@@ -79,11 +97,13 @@ module Libuv
 
 
         def on_timer(handle)
-            begin
-                @callback.call
-            rescue Exception => e
-                @loop.log :error, :timer_cb, e
-            end
+            ::Fiber.new {
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @reactor.log e, 'performing timer callback'
+                end
+            }.resume
         end
     end
 end