libuv 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92b6998b59e0b62ec3f3b0d480d462cf27e49a7c
-  data.tar.gz: 765ec08ee8b2671c4eecb803a675d423e473f258
+  metadata.gz: 8b69d133fc3c1af085d7028273dd69cb700a8d4d
+  data.tar.gz: 19271270d05dab8ad4a49eabacc269d2198c9447
 SHA512:
-  metadata.gz: c868aa873424adc30707451529efc8922a0b0dc4521f738b47fbea99e536565e231bb4a4624c03a0beeb0320270d5b716584de527f84d37d0643c7f2e6f106a9
-  data.tar.gz: e357deaf8a7d560632c358f84df00f27c54c3fc1bce954562a8946e82309a2d48f3986db221c6423765a7f0704841009979d050d6812fd8cbfcd929ddb98995b
+  metadata.gz: c3f1a81309e2a576b1b1315b8bea853354b0a5d7fad86afb296c9aeda9bb5458ca88c6579d9cf73e16702f1810b58f768eb6900a29b31d0465d38b5b4d2fdde8
+  data.tar.gz: a3366d0120f38dcbc7ef7bf91c8e95e3adbf68a28535ef32ddfff202c089e1c36cab21dc33b855c53b121af11bcb4d535fa916f22b4b7b1ca1272f09ccdda799

data/.travis.yml

@@ -4,7 +4,7 @@ rvm:
   - "2.2"
   - ruby-head
   - rbx-2
-  - jruby-20mode
+  - jruby-head
 branches:
   only:
     - master

data/lib/libuv/async.rb

@@ -2,12 +2,17 @@ module Libuv
     class Async < Handle
 
 
-        # @param loop [::Libuv::Loop] loop this async callback will be associated
-        def initialize(loop, callback = nil, &blk)
-            @loop = loop
+        define_callback function: :on_async
+
+
+        # @param thread [::Libuv::Loop] loop this async callback will be associated
+        def initialize(thread, callback = nil, &blk)
+            @loop = thread
             @callback = callback || blk
+
             async_ptr = ::Libuv::Ext.allocate_handle_async
-            error = check_result(::Libuv::Ext.async_init(loop.handle, async_ptr, callback(:on_async)))
+            on_async = callback(:on_async, async_ptr.address)
+            error = check_result(::Libuv::Ext.async_init(loop.handle, async_ptr, on_async))
 
             super(async_ptr, error)
         end

data/lib/libuv/check.rb

@@ -2,6 +2,9 @@ module Libuv
     class Check < Handle
 
 
+        define_callback function: :on_check
+
+
         # @param loop [::Libuv::Loop] loop this check will be associated
         # @param callback [Proc] callback to be called on loop check
         def initialize(loop, callback = nil, &blk)

data/lib/libuv/dns.rb

@@ -3,6 +3,9 @@ module Libuv
         include Resource, Listener, Net
 
 
+        define_callback function: :on_complete, params: [:pointer, :int, Ext::UvAddrinfo.by_ref]
+
+
         attr_reader :results
         attr_reader :domain
         attr_reader :port
@@ -38,7 +41,9 @@ module Libuv
             @pointer = ::Libuv::Ext.allocate_request_getaddrinfo
             @error = nil    # error in callback
 
+            @instance_id = @pointer.address
             error = check_result ::Libuv::Ext.getaddrinfo(@loop, @pointer, callback(:on_complete), domain, port.to_s, HINTS[hint])
+
             if error
                 ::Libuv::Ext.free(@pointer)
                 @complete = true
@@ -80,7 +85,7 @@ module Libuv
             end
 
             # Clean up references
-            clear_callbacks
+            cleanup_callbacks
         end
     end
 end

data/lib/libuv/ext/ext.rb

@@ -142,6 +142,7 @@ module Libuv
         attach_function :pipe_pending_count, :uv_pipe_pending_count, [:uv_pipe_t], :int, :blocking => true
         attach_function :pipe_pending_type, :uv_pipe_pending_type, [:uv_pipe_t], :uv_handle_type, :blocking => true
         attach_function :pipe_getsockname, :uv_pipe_getsockname, [:uv_pipe_t, :pointer, :pointer], :int, :blocking => true
+        attach_function :pipe_getpeername, :uv_pipe_getpeername, [:uv_pipe_t, :pointer, :pointer], :int, :blocking => true
 
         attach_function :prepare_init, :uv_prepare_init, [:uv_loop_t, :uv_prepare_t], :int, :blocking => true
         attach_function :prepare_start, :uv_prepare_start, [:uv_prepare_t, :uv_prepare_cb], :int, :blocking => true

data/lib/libuv/ext/tasks.rb

@@ -15,7 +15,7 @@ end
 file 'ext/libuv/build/gyp' => 'ext/libuv/build' do
     result = true
     if not File.directory?('ext/libuv/build/gyp')
-        result = system "svn", "export", "-r1824", "http://gyp.googlecode.com/svn/trunk", "ext/libuv/build/gyp"
+        result = system "git", "clone", "https://chromium.googlesource.com/external/gyp", "ext/libuv/build/gyp"
     end
     raise 'unable to download gyp' unless result
 end

data/lib/libuv/file.rb

@@ -3,6 +3,23 @@ module Libuv
         include Assertions, Resource, Listener, FsChecks
 
 
+        fs_params = {
+            params: [Ext::FsRequest.by_ref],
+            lookup: :fs_lookup
+        }
+        define_callback function: :on_open, **fs_params
+        define_callback function: :on_close, **fs_params
+        define_callback function: :on_read, **fs_params
+        define_callback function: :on_write, **fs_params
+        define_callback function: :on_sync, **fs_params
+        define_callback function: :on_datasync, **fs_params
+        define_callback function: :on_truncate, **fs_params
+        define_callback function: :on_utime, **fs_params
+        define_callback function: :on_chmod, **fs_params
+        define_callback function: :on_chown, **fs_params
+        define_callback function: :on_stat, **fs_params
+
+
         EOF = "0\r\n\r\n".freeze
         CRLF = "\r\n".freeze
 
@@ -10,8 +27,8 @@ module Libuv
         attr_reader :fileno, :closed
 
 
-        def initialize(loop, path, flags = 0, mode = 0)
-            super(loop, loop.defer)
+        def initialize(thread, path, flags = 0, mode = 0)
+            super(thread, thread.defer)
 
             @fileno = -1
             @closed = true 
@@ -19,14 +36,14 @@ 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))
+            pre_check @defer, request, ::Libuv::Ext.fs_open(@loop, request, @path, @flags, @mode, callback(:on_open, request.address))
             nil
         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)))
+            pre_check(@defer, request, ::Libuv::Ext.fs_close(@loop.handle, request, @fileno, callback(:on_close, request.address)))
             nil # pre-check returns a promise
         end
 
@@ -41,7 +58,7 @@ 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)))
+            pre_check(deferred, request, ::Libuv::Ext.fs_read(@loop.handle, request, @fileno, buffer, 1, offset, callback(:on_read, request.address)))
         end
 
         def write(data, offset = 0)
@@ -57,7 +74,7 @@ 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)))
+            pre_check(deferred, request, ::Libuv::Ext.fs_write(@loop.handle, request, @fileno, buffer, 1, offset, callback(:on_write, request.address)))
         end
 
         def sync
@@ -66,7 +83,7 @@ module Libuv
             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))
+            pre_check deferred, request, ::Libuv::Ext.fs_fsync(@loop.handle, request, @fileno, callback(:on_sync, request.address))
         end
 
         def datasync
@@ -75,7 +92,7 @@ module Libuv
             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))
+            pre_check deferred, request, ::Libuv::Ext.fs_fdatasync(@loop.handle, request, @fileno, callback(:on_datasync, request.address))
         end
 
         def truncate(offset)
@@ -85,7 +102,7 @@ module Libuv
             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))
+            pre_check deferred, request, ::Libuv::Ext.fs_ftruncate(@loop.handle, request, @fileno, offset, callback(:on_truncate, request.address))
         end
 
         def utime(atime, mtime)
@@ -96,7 +113,7 @@ module Libuv
             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))
+            pre_check deferred, request, ::Libuv::Ext.fs_futime(@loop.handle, request, @fileno, atime, mtime, callback(:on_utime, request.address))
         end
 
         def chmod(mode)
@@ -106,7 +123,7 @@ module Libuv
             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))
+            pre_check deferred, request, ::Libuv::Ext.fs_fchmod(@loop.handle, request, @fileno, mode, callback(:on_chmod, request.address))
         end
 
         def chown(uid, gid)
@@ -117,7 +134,7 @@ module Libuv
             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))
+            pre_check deferred, request, ::Libuv::Ext.fs_fchown(@loop.handle, request, @fileno, uid, gid, callback(:on_chown, request.address))
         end
 
         def send_file(stream, type = :raw, chunk_size = 4096)

data/lib/libuv/filesystem.rb

@@ -3,8 +3,26 @@ module Libuv
         include Assertions, Resource, Listener, FsChecks
 
 
-        def initialize(loop)
-            @loop = loop
+        fs_params = {
+            params: [Ext::FsRequest.by_ref],
+            lookup: :fs_lookup
+        }
+        define_callback function: :on_unlink, **fs_params
+        define_callback function: :on_mkdir, **fs_params
+        define_callback function: :on_rmdir, **fs_params
+        define_callback function: :on_readdir, **fs_params
+        define_callback function: :on_rename, **fs_params
+        define_callback function: :on_chmod, **fs_params
+        define_callback function: :on_utime, **fs_params
+        define_callback function: :on_stat, **fs_params
+        define_callback function: :on_link, **fs_params
+        define_callback function: :on_symlink, **fs_params
+        define_callback function: :on_readlink, **fs_params
+        define_callback function: :on_chown, **fs_params
+
+
+        def initialize(thread)
+            @loop = thread
         end
 
         def unlink(path)
@@ -12,7 +30,7 @@ module Libuv
             @unlink_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @unlink_deferred, request, ::Libuv::Ext.fs_unlink(@loop, request, path, callback(:on_unlink))
+            pre_check @unlink_deferred, request, ::Libuv::Ext.fs_unlink(@loop, request, path, callback(:on_unlink, request.address))
             @unlink_deferred.promise
         end
 
@@ -22,7 +40,7 @@ module Libuv
             @mkdir_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @mkdir_deferred, request, ::Libuv::Ext.fs_mkdir(@loop, request, path, mode, callback(:on_mkdir))
+            pre_check @mkdir_deferred, request, ::Libuv::Ext.fs_mkdir(@loop, request, path, mode, callback(:on_mkdir, request.address))
             @mkdir_deferred.promise
         end
 
@@ -31,7 +49,7 @@ module Libuv
             @rmdir_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @rmdir_deferred, request, ::Libuv::Ext.fs_rmdir(@loop, request, path, callback(:on_rmdir))
+            pre_check @rmdir_deferred, request, ::Libuv::Ext.fs_rmdir(@loop, request, path, callback(:on_rmdir, request.address))
             @rmdir_deferred.promise
         end
 
@@ -40,7 +58,7 @@ module Libuv
             @readdir_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @readdir_deferred, request, ::Libuv::Ext.fs_readdir(@loop, request, path, 0, callback(:on_readdir))
+            pre_check @readdir_deferred, request, ::Libuv::Ext.fs_readdir(@loop, request, path, 0, callback(:on_readdir, request.address))
             @readdir_deferred.promise
         end
 
@@ -50,7 +68,7 @@ module Libuv
             @rename_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @rename_deferred, request, ::Libuv::Ext.fs_rename(@loop, request, old_path, new_path, callback(:on_rename))
+            pre_check @rename_deferred, request, ::Libuv::Ext.fs_rename(@loop, request, old_path, new_path, callback(:on_rename, request.address))
             @rename_deferred.promise
         end
 
@@ -60,7 +78,7 @@ module Libuv
             @chmod_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @chmod_deferred, request, ::Libuv::Ext.fs_chmod(@loop, request, path, mode, callback(:on_chmod))
+            pre_check @chmod_deferred, request, ::Libuv::Ext.fs_chmod(@loop, request, path, mode, callback(:on_chmod, request.address))
             @chmod_deferred.promise
         end
 
@@ -71,7 +89,7 @@ module Libuv
             @utime_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @utime_deferred, request, ::Libuv::Ext.fs_utime(@loop, request, path, atime, mtime, callback(:on_utime))
+            pre_check @utime_deferred, request, ::Libuv::Ext.fs_utime(@loop, request, path, atime, mtime, callback(:on_utime, request.address))
             @utime_deferred.promise
         end
 
@@ -80,7 +98,7 @@ module Libuv
             @stat_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @stat_deferred, request, ::Libuv::Ext.fs_lstat(@loop, request, path, callback(:on_stat))
+            pre_check @stat_deferred, request, ::Libuv::Ext.fs_lstat(@loop, request, path, callback(:on_stat, request.address))
             @stat_deferred.promise
         end
 
@@ -90,7 +108,7 @@ module Libuv
             @link_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @link_deferred, request, ::Libuv::Ext.fs_link(@loop, request, old_path, new_path, callback(:on_link))
+            pre_check @link_deferred, request, ::Libuv::Ext.fs_link(@loop, request, old_path, new_path, callback(:on_link, request.address))
             @link_deferred.promise
         end
 
@@ -100,7 +118,7 @@ module Libuv
             @symlink_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @symlink_deferred, request, ::Libuv::Ext.fs_symlink(@loop, request, old_path, new_path, 0, callback(:on_symlink))
+            pre_check @symlink_deferred, request, ::Libuv::Ext.fs_symlink(@loop, request, old_path, new_path, 0, callback(:on_symlink, request.address))
             @symlink_deferred.promise
         end
 
@@ -109,7 +127,7 @@ module Libuv
             @readlink_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @readlink_deferred, request, ::Libuv::Ext.fs_readlink(@loop, request, path, callback(:on_readlink))
+            pre_check @readlink_deferred, request, ::Libuv::Ext.fs_readlink(@loop, request, path, callback(:on_readlink, request.address))
             @readlink_deferred.promise
         end
 
@@ -120,7 +138,7 @@ module Libuv
             @chown_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @chown_deferred, request, ::Libuv::Ext.fs_chown(@loop, request, path, uid, gid, callback(:on_chown))
+            pre_check @chown_deferred, request, ::Libuv::Ext.fs_chown(@loop, request, path, uid, gid, callback(:on_chown, request.address))
             @chown_deferred.promise
         end
 

data/lib/libuv/fs_event.rb

@@ -2,14 +2,17 @@ module Libuv
     class FSEvent < Handle
 
 
+        define_callback function: :on_fs_event, params: [:pointer, :string, :int, :int]
+
+
         EVENTS = {1 => :rename, 2 => :change}.freeze
 
 
-        def initialize(loop, path)
-            @loop = loop
+        def initialize(thread, path)
+            @loop = thread
 
             fs_event_ptr = ::Libuv::Ext.allocate_handle_fs_event
-            error = check_result ::Libuv::Ext.fs_event_init(loop.handle, fs_event_ptr, path, callback(:on_fs_event), 0)
+            error = check_result ::Libuv::Ext.fs_event_init(thread.handle, fs_event_ptr, path, callback(:on_fs_event, fs_event_ptr.address), 0)
 
             super(fs_event_ptr, error)
         end

data/lib/libuv/handle.rb

@@ -8,8 +8,12 @@ module Libuv
         attr_reader :loop
 
 
+        define_callback function: :on_close
+
+
         def initialize(pointer, error)
             @pointer = pointer
+            @instance_id = @pointer.address
 
             # Initialise the promise
             super(loop, loop.defer)
@@ -61,6 +65,7 @@ module Libuv
 
         def handle; @pointer; end
         def defer; @defer; end
+        def instance_id; @instance_id; end
 
 
         private
@@ -74,7 +79,8 @@ module Libuv
 
         def on_close(pointer)
             ::Libuv::Ext.free(pointer)
-            clear_callbacks
+            #clear_callbacks
+            cleanup_callbacks
 
             if @close_error
                 defer.reject(@close_error)

data/lib/libuv/idle.rb

@@ -2,14 +2,17 @@ module Libuv
     class Idle < Handle
 
 
-        # @param loop [::Libuv::Loop] loop this idle handler will be associated
+        define_callback function: :on_idle
+
+
+        # @param thread [::Libuv::Loop] loop this idle handler will be associated
         # @param callback [Proc] callback to be called when the loop is idle
-        def initialize(loop, callback = nil, &blk)
-            @loop = loop
+        def initialize(thread, callback = nil, &blk)
+            @loop = thread
             @callback = callback || blk
 
             idle_ptr = ::Libuv::Ext.allocate_handle_idle
-            error = check_result(::Libuv::Ext.idle_init(loop.handle, idle_ptr))
+            error = check_result(::Libuv::Ext.idle_init(thread.handle, idle_ptr))
 
             super(idle_ptr, error)
         end

data/lib/libuv/mixins/fs_checks.rb

@@ -3,11 +3,22 @@ module Libuv
     module FsChecks
 
 
+        module ClassMethods
+            def fs_lookup(ref)
+                ref.to_ptr.address
+            end
+        end
+
+        def self.included(base)
+            base.extend(ClassMethods)
+        end
+
+
         def stat
             @stat_deferred = @loop.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@loop.handle, request, @fileno, callback(:on_stat))
+            pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@loop.handle, request, @fileno, callback(:on_stat, request.address))
             @stat_deferred.promise
         end
 
@@ -42,6 +53,8 @@ module Libuv
         end
 
         def cleanup(req)
+            cleanup_callbacks req.to_ptr.address
+
             ::Libuv::Ext.fs_req_cleanup(req)
             ::Libuv::Ext.free(req)
         end

data/lib/libuv/mixins/listener.rb

@@ -8,27 +8,59 @@ module Libuv
         private
 
 
-        CALLBACKS = ThreadSafe::Cache.new
+        module ClassMethods
+            def dispatch_callback(func_name, lookup, args)
+                instance_id = __send__(lookup, *args)
+                inst = @callback_lookup[instance_id]
+                inst.__send__(func_name, *args)
+            end
 
+            def define_callback(function:, params: [:pointer], ret_val: :void, lookup: :default_lookup)
+                @callback_funcs[function] = FFI::Function.new(ret_val, params) do |*args|
+                    dispatch_callback(function, lookup, args)
+                end
+            end
+
+            # Much like include to support inheritance properly
+            # We keep existing callbacks and inherit the lookup (as this will never clash)
+            def inherited(subclass)
+                subclass.instance_variable_set(:@callback_funcs, {}.merge(@callback_funcs))
+                subclass.instance_variable_set(:@callback_lookup, @callback_lookup)
+            end
 
-        def callbacks
-            @callbacks ||= Set.new
-        end
 
-        def callback(name)
-            const_name = "#{name}_#{object_id}"
-            unless CALLBACKS[const_name]
-                callbacks << const_name
-                CALLBACKS[const_name] = method(name)
+            # Provide accessor methods to the class level instance variables
+            def callback_lookup
+                @callback_lookup
             end
-            CALLBACKS[const_name]
-        end
 
-        def clear_callbacks
-            callbacks.each do |name|
-                CALLBACKS.delete(name)
+            def callback_funcs
+                @callback_funcs
+            end
+
+
+            # This function is used to work out the instance the callback is for
+            def default_lookup(req, *args)
+                req.address
             end
-            callbacks.clear
+        end
+
+        def self.included(base)
+            base.instance_variable_set(:@callback_funcs, {})
+            base.instance_variable_set(:@callback_lookup, ThreadSafe::Cache.new)
+            base.extend(ClassMethods)
+        end
+
+
+
+        def callback(name, instance_id = @instance_id)
+            klass = self.class
+            klass.callback_lookup[instance_id] ||= self
+            klass.callback_funcs[name]
+        end
+
+        def cleanup_callbacks(instance_id = @instance_id)
+            self.class.callback_lookup.delete(instance_id)
         end
     end
 end

data/lib/libuv/mixins/stream.rb

@@ -2,6 +2,17 @@ module Libuv
     module Stream
 
 
+        def self.included(base)
+            base.define_callback function: :on_listen,      params: [:pointer, :int]
+            base.define_callback function: :write_complete, params: [:pointer, :int]
+            base.define_callback function: :on_shutdown,    params: [:pointer, :int]
+
+            base.define_callback function: :on_allocate, params: [:pointer, :size_t, Ext::UvBuf.by_ref]
+            base.define_callback function: :on_read,     params: [:pointer, :ssize_t, Ext::UvBuf.by_ref]
+        end
+
+
+
         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
@@ -64,10 +75,12 @@ module Libuv
                     @write_callbacks ||= {}
                     req = ::Libuv::Ext.allocate_request_write
                     @write_callbacks[req.address] = [deferred, buffer1]
-                    error = check_result ::Libuv::Ext.write(req, handle, buffer, 1, callback(:write_complete))
+                    error = check_result ::Libuv::Ext.write(req, handle, buffer, 1, callback(:write_complete, req.address))
 
                     if error
                         @write_callbacks.delete req.address
+                        cleanup_callbacks req.address
+
                         ::Libuv::Ext.free(req)
                         buffer1.free
                         deferred.reject(error)
@@ -122,6 +135,7 @@ module Libuv
 
         def write_complete(req, status)
             deferred, buffer1 = @write_callbacks.delete req.address
+            cleanup_callbacks req.address
 
             ::Libuv::Ext.free(req)
             buffer1.free

data/lib/libuv/pipe.rb

@@ -3,6 +3,10 @@ module Libuv
         include Stream
 
 
+        define_callback function: :on_connect, params: [:pointer, :int]
+        define_callback function: :write2_complete, params: [:pointer, :int]
+
+
         WRITE2_ERROR = "data must be a String".freeze
 
 
@@ -68,7 +72,8 @@ module Libuv
             assert_type(String, name, "name must be a String")
             begin
                 name = windows_path name if FFI::Platform.windows?
-                ::Libuv::Ext.pipe_connect(::Libuv::Ext.allocate_request_connect, handle, name, callback(:on_connect))
+                req = ::Libuv::Ext.allocate_request_connect
+                ::Libuv::Ext.pipe_connect(req, handle, name, callback(:on_connect, req.address))
             rescue Exception => e
                 reject(e)
             end
@@ -85,26 +90,13 @@ module Libuv
                     buffer       = ::Libuv::Ext.buf_init(FFI::MemoryPointer.from_string(data), size)
 
                     # local as this variable will be avaliable until the handle is closed
-                    @write_callbacks = @write_callbacks || []
-
-                    #
-                    # create the curried callback
-                    #
-                    callback = FFI::Function.new(:void, [:pointer, :int]) do |req, status|
-                        ::Libuv::Ext.free(req)
-                        # remove the callback from the array
-                        # assumes writes are done in order
-                        promise = @write_callbacks.shift[0]
-                        resolve promise, status
-                    end
-
-
-                    @write_callbacks << [deferred, callback]
                     req = ::Libuv::Ext.allocate_request_write
-                    error = check_result ::Libuv::Ext.write2(req, handle, buffer, 1, fd.handle, callback)
+                    @write_callbacks ||= {}
+                    @write_callbacks[req.address] = deferred
+                    error = check_result ::Libuv::Ext.write2(req, handle, buffer, 1, fd.handle, callback(:write2_complete, req.address))
 
                     if error
-                        @write_callbacks.pop
+                        @write_callbacks.delete(req.address)
                         ::Libuv::Ext.free(req)
                         deferred.reject(error)
 
@@ -159,6 +151,7 @@ module Libuv
 
 
         def on_connect(req, status)
+            cleanup_callbacks req.address
             ::Libuv::Ext.free(req)
             e = check_result(status)
 
@@ -173,6 +166,15 @@ module Libuv
             end
         end
 
+        def write2_complete(req, status)
+            promise = @write_callbacks.delete(req.address)
+            cleanup_callbacks req.address
+
+            ::Libuv::Ext.free(req)
+            
+            resolve promise, status
+        end
+
         def windows_path(name)
             # test for \\\\.\\pipe
             if not name =~ /(\/|\\){2}\.(\/|\\)pipe/i

data/lib/libuv/prepare.rb

@@ -2,6 +2,9 @@ module Libuv
     class Prepare < Handle
 
 
+        define_callback function: :on_prepare
+
+
         # @param loop [::Libuv::Loop] loop this prepare handle will be associated
         # @param callback [Proc] callback to be called on loop preparation
         def initialize(loop, callback = nil, &blk)

data/lib/libuv/signal.rb

@@ -2,6 +2,9 @@ module Libuv
     class Signal < Handle
 
 
+        define_callback function: :on_sig, params: [:pointer, :int]
+
+
         SIGNALS = {
             :HUP => 1,
             :SIGHUP => 1,

data/lib/libuv/tcp.rb

@@ -7,10 +7,15 @@ module Libuv
         include Stream, Net
 
 
+        define_callback function: :on_connect, params: [:pointer, :int]
+
+
         TLS_ERROR = "TLS write failed".freeze
 
 
         attr_reader :connected
+        attr_reader :protocol
+
         # Check if tls active on the socket
         def tls?; !@tls.nil?; end
 
@@ -48,14 +53,27 @@ module Libuv
         end
 
         # Push through any pending writes when handshake has completed
-        def handshake_cb
+        def handshake_cb(protocol = nil)
             @handshake = true
+            @protocol = protocol
+
             writes = @pending_writes
             @pending_writes = nil
             writes.each do |deferred, data|
                 @pending_write = deferred
                 @tls.encrypt(data)
             end
+
+            begin
+                @on_handshake.call(self, protocol) if @on_handshake
+            rescue => e
+                @loop.log :warn, :tls_handshake_callback_error, e
+            end
+        end
+
+        # Provide a callback once the TLS handshake has completed
+        def on_handshake(callback = nil, &blk)
+            @on_handshake = callback || blk
         end
 
         # This is clear text data that has been decrypted
@@ -211,7 +229,7 @@ module Libuv
             
             begin
                 @tcp_socket = create_socket(IPAddr.new(ip), port)
-                @tcp_socket.connect(callback(:on_connect))
+                @tcp_socket.connect(callback(:on_connect, @tcp_socket.connect_req.address))
             rescue Exception => e
                 reject(e)
             end
@@ -274,6 +292,7 @@ module Libuv
         end
 
         def on_connect(req, status)
+            cleanup_callbacks req.address
             ::Libuv::Ext.free(req)
             e = check_result(status)
 
@@ -307,13 +326,14 @@ module Libuv
                 check_result!(tcp_connect(callback))
             end
 
+            def connect_req
+                @req ||= ::Libuv::Ext.allocate_request_connect
+                @req
+            end
 
-            protected
 
+            protected
 
-            def connect_req
-                ::Libuv::Ext.allocate_request_connect
-            end
 
             def tcp_connect(callback)
                 ::Libuv::Ext.tcp_connect(

data/lib/libuv/timer.rb

@@ -1,6 +1,10 @@
 module Libuv
     class Timer < Handle
 
+
+        define_callback function: :on_timer
+
+
         # @param loop [::Libuv::Loop] loop this timer will be associated
         # @param callback [Proc] callback to be called when the timer is triggered
         def initialize(loop, callback = nil)

data/lib/libuv/udp.rb

@@ -3,6 +3,11 @@ module Libuv
         include Net
 
 
+        define_callback function: :on_allocate, params: [:pointer, :size_t, Ext::UvBuf.by_ref]
+        define_callback function: :on_recv, params: [:pointer, :ssize_t, Ext::UvBuf.by_ref, Ext::Sockaddr.by_ref, :uint]
+        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
@@ -124,10 +129,11 @@ module Libuv
                         buffer,
                         1,
                         sockaddr,
-                        callback(:send_complete)
+                        callback(:send_complete, req.address)
                     )
                     if error
                         @request_refs.delete req.address
+                        cleanup_callbacks req.address
                         ::Libuv::Ext.free(req)
                         buffer1.free
                         deferred.reject(error)
@@ -251,6 +257,7 @@ module Libuv
 
         def send_complete(req, status)
             deferred, buffer1 = @request_refs.delete req.address
+            cleanup_callbacks req.address
 
             ::Libuv::Ext.free(req)
             buffer1.free

data/lib/libuv/version.rb

@@ -1,3 +1,3 @@
 module Libuv
-    VERSION = '1.2.0'
+    VERSION = '1.3.0'
 end

data/lib/libuv/work.rb

@@ -7,16 +7,22 @@ module Libuv
         attr_reader :result
 
 
-        # @param loop [::Libuv::Loop] loop this work request will be associated
+        define_callback function: :on_work
+        define_callback function: :on_complete, params: [:pointer, :int]
+
+
+        # @param thread [::Libuv::Loop] thread this work request will be associated
         # @param work [Proc] callback to be called in the thread pool
-        def initialize(loop, work)
-            super(loop, loop.defer)
+        def initialize(thread, work)
+            super(thread, thread.defer)
 
             @work = work
             @complete = false
             @pointer = ::Libuv::Ext.allocate_request_work
             @error = nil    # error in callback
 
+            @instance_id = @pointer.address
+
             error = check_result ::Libuv::Ext.queue_work(@loop, @pointer, callback(:on_work), callback(:on_complete))
             if error
                 ::Libuv::Ext.free(@pointer)
@@ -62,7 +68,7 @@ module Libuv
             end
             
             # Clean up references
-            clear_callbacks
+            cleanup_callbacks @instance_id
         end
 
         def on_work(req)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libuv
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Bulat Shakirzyanov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-06 00:00:00.000000000 Z
+date: 2015-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -152,6 +152,7 @@ files:
 - ext/libuv/docs/src/process.rst
 - ext/libuv/docs/src/request.rst
 - ext/libuv/docs/src/signal.rst
+- ext/libuv/docs/src/sphinx-plugins/manpage.py
 - ext/libuv/docs/src/static/architecture.png
 - ext/libuv/docs/src/static/diagrams.key/Data/st0-311.jpg
 - ext/libuv/docs/src/static/diagrams.key/Data/st1-475.jpg
@@ -367,6 +368,7 @@ files:
 - ext/libuv/test/test-pipe-getsockname.c
 - ext/libuv/test/test-pipe-sendmsg.c
 - ext/libuv/test/test-pipe-server-close.c
+- ext/libuv/test/test-pipe-set-non-blocking.c
 - ext/libuv/test/test-platform-output.c
 - ext/libuv/test/test-poll-close-doesnt-corrupt-stack.c
 - ext/libuv/test/test-poll-close.c
@@ -395,6 +397,7 @@ files:
 - ext/libuv/test/test-tcp-connect-timeout.c
 - ext/libuv/test/test-tcp-connect6-error.c
 - ext/libuv/test/test-tcp-flags.c
+- ext/libuv/test/test-tcp-oob.c
 - ext/libuv/test/test-tcp-open.c
 - ext/libuv/test/test-tcp-read-stop.c
 - ext/libuv/test/test-tcp-shutdown-after-write.c