libuv 2.0.12 → 3.0.0

data/lib/libuv/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Error < StandardError
         class E2BIG < Error; end

data/lib/libuv/ext/ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'ffi'
 
@@ -13,28 +15,23 @@ module Libuv
             extend FFI::Library
             ffi_lib(FFI::Library::LIBC).first
 
-            attach_function :malloc, [:size_t], :pointer, :blocking => true
-            attach_function :free, [:pointer], :void, :blocking => true
+            attach_function :malloc, [:size_t], :pointer
+            attach_function :free, [:pointer], :void
         end
-        
+        def_delegators :LIBC, :malloc, :free
+        module_function :malloc, :free
 
-        def self.malloc(size)
-            LIBC.malloc(size)
-        end
 
-        def self.free(data)
-            LIBC.free(data)
+        def self.path_to_internal_libuv
+            @path_to_internal_libuv ||= ::File.expand_path("../../../../ext/libuv/lib/libuv.#{FFI::Platform::LIBSUFFIX}", __FILE__)
         end
 
 
         begin
             # bias the library discovery to a path inside the gem first, then
             # to the usual system paths
-
-            path_to_internal_libuv = ::File.dirname(__FILE__) + '/../../../ext/libuv/lib'
-
             paths = [
-                path_to_internal_libuv,
+                ::File.expand_path('../', path_to_internal_libuv),
                 '/usr/local/lib',
                 '/opt/local/lib',
                 '/usr/lib64'
@@ -63,16 +60,11 @@ module Libuv
         end
 
 
-        def self.path_to_internal_libuv
-            @path_to_internal_libuv ||= ::File.expand_path("../../../../ext/libuv/lib/libuv.#{FFI::Platform::LIBSUFFIX}", __FILE__)
-        end
-
-
         require 'libuv/ext/types'
 
 
-        attach_function :handle_size, :uv_handle_size, [:uv_handle_type], :size_t, :blocking => true
-        attach_function :req_size, :uv_req_size, [:uv_req_type], :size_t, :blocking => true
+        attach_function :handle_size, :uv_handle_size, [:uv_handle_type], :size_t
+        attach_function :req_size, :uv_req_size, [:uv_req_type], :size_t
 
 
         # We need to calculate where the FS request data is located using req_size
@@ -89,8 +81,8 @@ module Libuv
         callback :uv_fs_cb, [FsRequest.by_ref], :void
 
 
-        attach_function :version_number, :uv_version, [], :uint, :blocking => true
-        attach_function :version_string, :uv_version_string, [], :string, :blocking => true
+        attach_function :version_number, :uv_version, [], :uint
+        attach_function :version_string, :uv_version_string, [], :string
 
         attach_function :loop_new, :uv_loop_new, [], :uv_loop_t, :blocking => true
         attach_function :loop_delete, :uv_loop_delete, [:uv_loop_t], :void, :blocking => true
@@ -98,18 +90,18 @@ module Libuv
         attach_function :run, :uv_run, [:uv_loop_t, :uv_run_mode], :int, :blocking => true
         attach_function :stop, :uv_stop, [:uv_loop_t], :void, :blocking => true
         attach_function :update_time, :uv_update_time, [:uv_loop_t], :void, :blocking => true
-        attach_function :now, :uv_now, [:uv_loop_t], :uint64, :blocking => true
+        attach_function :now, :uv_now, [:uv_loop_t], :uint64
 
         attach_function :backend_timeout, :uv_backend_timeout, [:uv_loop_t], :int, :blocking => true
         attach_function :backend_fd, :uv_backend_fd, [:uv_loop_t], :int, :blocking => true
 
-        attach_function :strerror, :uv_strerror, [:int], :string, :blocking => true
-        attach_function :err_name, :uv_err_name, [:int], :string, :blocking => true
+        attach_function :strerror, :uv_strerror, [:int], :string
+        attach_function :err_name, :uv_err_name, [:int], :string
 
-        attach_function :ref, :uv_ref, [:uv_handle_t], :void, :blocking => true
-        attach_function :unref, :uv_unref, [:uv_handle_t], :void, :blocking => true
-        attach_function :has_ref, :uv_has_ref, [:uv_handle_t], :int, :blocking => true
-        attach_function :is_active, :uv_is_active, [:uv_handle_t], :int, :blocking => true
+        attach_function :ref, :uv_ref, [:uv_handle_t], :void
+        attach_function :unref, :uv_unref, [:uv_handle_t], :void
+        attach_function :has_ref, :uv_has_ref, [:uv_handle_t], :int
+        attach_function :is_active, :uv_is_active, [:uv_handle_t], :int
         attach_function :walk, :uv_walk, [:uv_loop_t, :uv_walk_cb, :pointer], :void, :blocking => true
         attach_function :close, :uv_close, [:uv_handle_t, :uv_close_cb], :void, :blocking => true
         attach_function :is_closing, :uv_is_closing, [:uv_handle_t], :int, :blocking => true
@@ -119,7 +111,7 @@ module Libuv
         # https://github.com/joyent/libuv/commit/4ca9a363897cfa60f4e2229e4f15ac5abd7fd103
         # uv_fileno
 
-        attach_function :buf_init, :uv_buf_init, [:pointer, :size_t], UvBuf.by_value, :blocking => true
+        attach_function :buf_init, :uv_buf_init, [:pointer, :size_t], UvBuf.by_value
 
         attach_function :listen, :uv_listen, [:uv_stream_t, :int, :uv_connection_cb], :int, :blocking => true
         attach_function :accept, :uv_accept, [:uv_stream_t, :uv_stream_t], :int, :blocking => true
@@ -195,8 +187,8 @@ module Libuv
         attach_function :timer_set_repeat, :uv_timer_set_repeat, [:uv_timer_t, :int64_t], :void, :blocking => true
         attach_function :timer_get_repeat, :uv_timer_get_repeat, [:uv_timer_t], :int64_t, :blocking => true
         #:addrinfo
-        attach_function :getaddrinfo, :uv_getaddrinfo, [:uv_loop_t, :uv_getaddrinfo_t, :uv_getaddrinfo_cb, :string, :string, UvAddrinfo.by_ref], :int, :blocking => true
-        attach_function :freeaddrinfo, :uv_freeaddrinfo, [UvAddrinfo.by_ref], :void, :blocking => true
+        attach_function :getaddrinfo, :uv_getaddrinfo, [:uv_loop_t, :uv_getaddrinfo_t, :uv_getaddrinfo_cb, :string, :string, UvAddrinfo.by_ref], :int
+        attach_function :freeaddrinfo, :uv_freeaddrinfo, [UvAddrinfo.by_ref], :void
 
         attach_function :spawn, :uv_spawn, [:uv_loop_t, :uv_process_t, :uv_options_t], :int, :blocking => true
         attach_function :process_kill, :uv_process_kill, [:uv_process_t, :int], :int, :blocking => true
@@ -246,10 +238,10 @@ module Libuv
 
         attach_function :fs_event_init, :uv_fs_event_init, [:uv_loop_t, :uv_fs_event_t, :string, :uv_fs_event_cb, :int], :int, :blocking => true
 
-        attach_function :ip4_addr, :uv_ip4_addr, [:string, :int, :sockaddr_in4], :int, :blocking => true
-        attach_function :ip6_addr, :uv_ip6_addr, [:string, :int, :sockaddr_in6], :int, :blocking => true
-        attach_function :ip4_name, :uv_ip4_name, [:sockaddr_in4, :pointer, :size_t], :int, :blocking => true
-        attach_function :ip6_name, :uv_ip6_name, [:sockaddr_in6, :pointer, :size_t], :int, :blocking => true
+        attach_function :ip4_addr, :uv_ip4_addr, [:string, :int, :sockaddr_in4], :int
+        attach_function :ip6_addr, :uv_ip6_addr, [:string, :int, :sockaddr_in6], :int
+        attach_function :ip4_name, :uv_ip4_name, [:sockaddr_in4, :pointer, :size_t], :int
+        attach_function :ip6_name, :uv_ip6_name, [:sockaddr_in6, :pointer, :size_t], :int
         #TODO:: attach_function :inet_ntop, :uv_inet_ntop, [:int, :pointer, ]
         #TODO:: attach_function :uv_inet_pton
 
@@ -300,4 +292,4 @@ module Libuv
             define_singleton_method(:"allocate_request_#{request_type}") { LIBC.malloc(request_size) }
         end
     end
-end
+end

data/lib/libuv/ext/platform/darwin_x64.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     module Ext
         class UvFSStat < FFI::Struct

data/lib/libuv/ext/platform/unix.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     module Ext
         typedef :int, :uv_os_sock_t

data/lib/libuv/ext/platform/windows.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     module Ext
         typedef :uint32_t, :in_addr_t

data/lib/libuv/ext/tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FFI::Platform
     def self.ia32?
         ARCH == "i386"

data/lib/libuv/ext/tasks/mac.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 file 'ext/libuv/uv.xcodeproj' => 'ext/libuv/build/gyp' do
     target_arch = 'ia32'if FFI::Platform.ia32?
     target_arch = 'x64' if FFI::Platform.x64?

data/lib/libuv/ext/tasks/unix.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 file 'ext/libuv/out' => 'ext/libuv/build/gyp' do
     target_arch = 'ia32'if FFI::Platform.ia32?
     target_arch = 'x64' if FFI::Platform.x64?

data/lib/libuv/ext/tasks/win.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 file "ext/libuv/Release/libuv.#{FFI::Platform::LIBSUFFIX}" do
     target_arch = 'ia32'
     target_arch = 'x64' if FFI::Platform.x64?

data/lib/libuv/ext/types.rb

@@ -1,5 +1,6 @@
-require 'socket'    # Addrinfo
+# frozen_string_literal: true
 
+require 'socket'    # Addrinfo
 
 module Libuv
     module Ext

data/lib/libuv/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class File < Q::DeferredPromise
         include Assertions, Resource, Listener, FsChecks
@@ -20,14 +22,14 @@ module Libuv
         define_callback function: :on_stat, **fs_params
 
 
-        EOF = "0\r\n\r\n".freeze
-        CRLF = "\r\n".freeze
+        EOF = "0\r\n\r\n"
+        CRLF = "\r\n"
 
 
         attr_reader :fileno, :closed
 
 
-        def initialize(thread, path, flags = 0, mode = 0)
+        def initialize(thread, path, flags = 0, mode: 0, wait: true, &blk)
             super(thread, thread.defer)
 
             @fileno = -1
@@ -36,21 +38,27 @@ module Libuv
             @request_refs = {}
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @defer, request, ::Libuv::Ext.fs_open(@loop, request, @path, @flags, @mode, callback(:on_open, request.address))
-            nil
+            pre_check @defer, request, ::Libuv::Ext.fs_open(@reactor, request, @path, @flags, @mode, callback(:on_open, request.address))
+
+            if block_given?
+                self.progress blk
+            elsif wait
+                @coroutine = @reactor.defer
+                co @coroutine.promise
+            end
         end
 
         def close
             @closed = true
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check(@defer, request, ::Libuv::Ext.fs_close(@loop.handle, request, @fileno, callback(:on_close, request.address)))
-            nil # pre-check returns a promise
+            pre_check(@defer, request, ::Libuv::Ext.fs_close(@reactor.handle, request, @fileno, callback(:on_close, request.address)))
+            self
         end
 
-        def read(length, offset = 0)
+        def read(length, offset = 0, wait: true)
             assert_type(Integer, length, "length must be an Integer")
             assert_type(Integer, offset, "offset must be an Integer")
-            deferred = @loop.defer
+            deferred = @reactor.defer
 
             buffer1 = FFI::MemoryPointer.new(length)
             buffer  = ::Libuv::Ext.buf_init(buffer1, length)
@@ -58,13 +66,14 @@ module Libuv
 
             @request_refs[request.address] = [deferred, buffer1]
 
-            pre_check(deferred, request, ::Libuv::Ext.fs_read(@loop.handle, request, @fileno, buffer, 1, offset, callback(:on_read, request.address)))
+            promise = pre_check(deferred, request, ::Libuv::Ext.fs_read(@reactor.handle, request, @fileno, buffer, 1, offset, callback(:on_read, request.address)))
+            wait ? co(promise) : promise
         end
 
-        def write(data, offset = 0)
+        def write(data, offset = 0, wait: true)
             assert_type(String, data, "data must be a String")
             assert_type(Integer, offset, "offset must be an Integer")
-            deferred = @loop.defer
+            deferred = @reactor.defer
 
             length = data.respond_to?(:bytesize) ? data.bytesize : data.size
 
@@ -74,84 +83,87 @@ module Libuv
 
             @request_refs[request.address] = [deferred, buffer1]
 
-            pre_check(deferred, request, ::Libuv::Ext.fs_write(@loop.handle, request, @fileno, buffer, 1, offset, callback(:on_write, request.address)))
+            respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_write(@reactor.handle, request, @fileno, buffer, 1, offset, callback(:on_write, request.address)))
         end
 
-        def sync
-            deferred = @loop.defer
+        def sync(wait: false)
+            deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
             @request_refs[request.address] = deferred
 
-            pre_check deferred, request, ::Libuv::Ext.fs_fsync(@loop.handle, request, @fileno, callback(:on_sync, request.address))
+            respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fsync(@reactor.handle, request, @fileno, callback(:on_sync, request.address)))
         end
 
-        def datasync
-            deferred = @loop.defer
+        def datasync(wait: false)
+            deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
             @request_refs[request.address] = deferred
 
-            pre_check deferred, request, ::Libuv::Ext.fs_fdatasync(@loop.handle, request, @fileno, callback(:on_datasync, request.address))
+            respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fdatasync(@reactor.handle, request, @fileno, callback(:on_datasync, request.address)))
         end
 
-        def truncate(offset)
+        def truncate(offset, wait: true)
             assert_type(Integer, offset, "offset must be an Integer")
-            deferred = @loop.defer
+            deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
             @request_refs[request.address] = deferred
 
-            pre_check deferred, request, ::Libuv::Ext.fs_ftruncate(@loop.handle, request, @fileno, offset, callback(:on_truncate, request.address))
+            respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_ftruncate(@reactor.handle, request, @fileno, offset, callback(:on_truncate, request.address)))
         end
 
-        def utime(atime, mtime)
+        def utime(atime:, mtime:, wait: true)
             assert_type(Integer, atime, "atime must be an Integer")
             assert_type(Integer, mtime, "mtime must be an Integer")
-            deferred = @loop.defer
+            deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
             @request_refs[request.address] = deferred
 
-            pre_check deferred, request, ::Libuv::Ext.fs_futime(@loop.handle, request, @fileno, atime, mtime, callback(:on_utime, request.address))
+            promise = pre_check deferred, request, ::Libuv::Ext.fs_futime(@reactor.handle, request, @fileno, atime, mtime, callback(:on_utime, request.address))
+            wait ? co(promise) : promise
         end
 
-        def chmod(mode)
+        def chmod(mode, wait: true)
             assert_type(Integer, mode, "mode must be an Integer")
-            deferred = @loop.defer
+            deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
             @request_refs[request.address] = deferred
 
-            pre_check deferred, request, ::Libuv::Ext.fs_fchmod(@loop.handle, request, @fileno, mode, callback(:on_chmod, request.address))
+            respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fchmod(@reactor.handle, request, @fileno, mode, callback(:on_chmod, request.address)))
         end
 
-        def chown(uid, gid)
+        def chown(uid:, gid:, wait: true)
             assert_type(Integer, uid, "uid must be an Integer")
             assert_type(Integer, gid, "gid must be an Integer")
-            deferred = @loop.defer
+            deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
             @request_refs[request.address] = deferred
 
-            pre_check deferred, request, ::Libuv::Ext.fs_fchown(@loop.handle, request, @fileno, uid, gid, callback(:on_chown, request.address))
+            respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fchown(@reactor.handle, request, @fileno, uid, gid, callback(:on_chown, request.address)))
         end
 
-        def send_file(stream, type = :raw, chunk_size = 4096)
+        def send_file(stream, using: :raw, chunk_size: 4096, wait: true)
             @transmit_failure ||= method(:transmit_failure)
             @transmit_data ||= method(:transmit_data)
             @start_transmit ||= method(:start_transmit)
             @next_chunk ||= method(:next_chunk)
 
-            @sending_file = @loop.defer
+            @sending_file = @reactor.defer
             @file_stream = stream
-            @file_stream_type = type
+            @file_stream_type = using
             @file_chunk_size = chunk_size
             @file_chunk_count = 0
 
-            stat.then @start_transmit, @transmit_failure
+            stat(wait: false).then @start_transmit, @transmit_failure
             
-            @sending_file.promise.finally &method(:clean_up_send)
+            promise = @sending_file.promise
+            promise.finally &method(:clean_up_send)
+            respond wait, promise
         end
 
 
@@ -168,13 +180,13 @@ module Libuv
         def transmit_data(data)
             @file_chunk_count += 1
             if @file_stream_type == :http
-                resp = ''
+                resp = String.new
                 resp << data.bytesize.to_s(16) << CRLF
                 resp << data
                 resp << CRLF
                 data = resp
             end
-            @file_stream.write(data).then @next_chunk, @transmit_failure
+            @file_stream.write(data, wait: :promise).then @next_chunk, @transmit_failure
             nil
         end
 
@@ -184,7 +196,7 @@ module Libuv
             
             if next_offset >= @file_stream_total
                 if @file_stream_type == :http
-                    @file_stream.write(EOF.dup).then(proc {
+                    @file_stream.write(EOF, wait: :promise).then(proc {
                         @sending_file.resolve(@file_stream_total)
                     }, @transmit_failure)
                 else
@@ -194,7 +206,7 @@ module Libuv
                 if next_offset + next_size > @file_stream_total
                     next_size = @file_stream_total - next_offset
                 end
-                read(next_size, next_offset).then(@transmit_data, @transmit_failure)
+                read(next_size, next_offset, wait: false).then(@transmit_data, @transmit_failure)
             end
             nil
         end
@@ -220,14 +232,19 @@ module Libuv
                 @fileno = req[:result]
                 cleanup(req)
                 @closed = false
-                @defer.notify(self)
+                ::Fiber.new { @defer.notify(self) }.resume
+
+                if @coroutine
+                    @coroutine.resolve(nil)
+                    @coroutine = nil
+                end
             end
         end
 
         def on_close(req)
             if post_check(req, @defer)
                 cleanup(req)
-                @defer.resolve(nil)
+                ::Fiber.new { @defer.resolve(nil) }.resume
             end
         end
 
@@ -236,7 +253,7 @@ module Libuv
             if post_check(req, deferred)
                 data = buffer1.read_string(req[:result])
                 cleanup(req)
-                deferred.resolve(data)
+                ::Fiber.new { deferred.resolve(data) }.resume
             end
         end
 
@@ -244,7 +261,7 @@ module Libuv
             deferred, buffer1 = @request_refs.delete req.to_ptr.address
             if post_check(req, deferred)
                 cleanup(req)
-                deferred.resolve(nil)
+                ::Fiber.new { deferred.resolve(nil) }.resume
             end
         end
 
@@ -252,7 +269,7 @@ module Libuv
             deferred = @request_refs.delete req.to_ptr.address
             if post_check(req, deferred)
                 cleanup(req)
-                deferred.resolve(nil)
+                ::Fiber.new { deferred.resolve(nil) }.resume
             end
         end
 
@@ -260,7 +277,7 @@ module Libuv
             deferred = @request_refs.delete req.to_ptr.address
             if post_check(req, deferred)
                 cleanup(req)
-                deferred.resolve(nil)
+                ::Fiber.new { deferred.resolve(nil) }.resume
             end
         end
 
@@ -268,7 +285,7 @@ module Libuv
             deferred = @request_refs.delete req.to_ptr.address
             if post_check(req, deferred)
                 cleanup(req)
-                deferred.resolve(nil)
+                ::Fiber.new { deferred.resolve(nil) }.resume
             end
         end
 
@@ -276,7 +293,7 @@ module Libuv
             deferred = @request_refs.delete req.to_ptr.address
             if post_check(req, deferred)
                 cleanup(req)
-                deferred.resolve(nil)
+                ::Fiber.new { deferred.resolve(nil) }.resume
             end
         end
 
@@ -284,7 +301,7 @@ module Libuv
             deferred = @request_refs.delete req.to_ptr.address
             if post_check(req, deferred)
                 cleanup(req)
-                deferred.resolve(nil)
+                ::Fiber.new { deferred.resolve(nil) }.resume
             end
         end
 
@@ -292,7 +309,7 @@ module Libuv
             deferred = @request_refs.delete req.to_ptr.address
             if post_check(req, deferred)
                 cleanup(req)
-                deferred.resolve(nil)
+                ::Fiber.new { deferred.resolve(nil) }.resume
             end
         end
     end