libuv 0.10.2 → 0.10.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 769f10cadb566b542368277dfee691a5aa2af059
+  data.tar.gz: 8114fb75a4da94c6341e6ead1faf5d59182c9245
+SHA512:
+  metadata.gz: 33e0394111e14048717934b2cffbc6f37d660117f6bc871eb7bb4da8089c0a303629b28febb6ee762f870039968029f620c35303b68302f1b8e1fc18bdbd2522
+  data.tar.gz: b1d5f5af132c26fdb88d732c188f6b067714512e3466feb63bef970f56374f961810c1a63d8d5e8c9301af28f23e0b70aae7a6bf917e07fd38c0b6e806565216

data/lib/libuv/ext/ext.rb

@@ -85,9 +85,7 @@ module Libuv
         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
 
-        attach_function :buf_init, :uv_buf_init, [:pointer, :size_t], :uv_buf_t, :blocking => true
-        attach_function :strlcpy, :uv_strlcpy, [:string, :string, :size_t], :size_t, :blocking => true
-        attach_function :strlcat, :uv_strlcat, [:string, :string, :size_t], :size_t, :blocking => true
+        attach_function :buf_init, :uv_buf_init, [:pointer, :size_t], UvBuf.by_value, :blocking => true
 
         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
@@ -101,21 +99,18 @@ module Libuv
         attach_function :shutdown, :uv_shutdown, [:uv_shutdown_t, :uv_stream_t, :uv_shutdown_cb], :int, :blocking => true
 
         attach_function :tcp_init, :uv_tcp_init, [:uv_loop_t, :uv_tcp_t], :int, :blocking => true
-        #attach_function :tcp_open, :uv_tcp_open, [:uv_tcp_t, :uv_os_sock_t], :int, :blocking => true
+        attach_function :tcp_open, :uv_tcp_open, [:uv_tcp_t, :uv_os_sock_t], :int, :blocking => true
         attach_function :tcp_nodelay, :uv_tcp_nodelay, [:uv_tcp_t, :int], :int, :blocking => true
         attach_function :tcp_keepalive, :uv_tcp_keepalive, [:uv_tcp_t, :int, :uint], :int, :blocking => true
         attach_function :tcp_simultaneous_accepts, :uv_tcp_simultaneous_accepts, [:uv_tcp_t, :int], :int, :blocking => true
         attach_function :tcp_bind, :uv_tcp_bind, [:uv_tcp_t, :sockaddr_in], :int, :blocking => true
-        attach_function :tcp_bind6, :uv_tcp_bind6, [:uv_tcp_t, :sockaddr_in6], :int, :blocking => true
         attach_function :tcp_getsockname, :uv_tcp_getsockname, [:uv_tcp_t, :pointer, :pointer], :int, :blocking => true
         attach_function :tcp_getpeername, :uv_tcp_getpeername, [:uv_tcp_t, :pointer, :pointer], :int, :blocking => true
         attach_function :tcp_connect, :uv_tcp_connect, [:uv_connect_t, :uv_tcp_t, :sockaddr_in, :uv_connect_cb], :int, :blocking => true
-        attach_function :tcp_connect6, :uv_tcp_connect6, [:uv_connect_t, :uv_tcp_t, :sockaddr_in6, :uv_connect_cb], :int, :blocking => true
 
         attach_function :udp_init, :uv_udp_init, [:uv_loop_t, :uv_udp_t], :int, :blocking => true
-        #attach_function :udp_open, :uv_udp_open, [:uv_udp_t, :uv_os_sock_t], :int, :blocking => true
+        attach_function :udp_open, :uv_udp_open, [:uv_udp_t, :uv_os_sock_t], :int, :blocking => true
         attach_function :udp_bind, :uv_udp_bind, [:uv_udp_t, :sockaddr_in, :uint], :int, :blocking => true
-        attach_function :udp_bind6, :uv_udp_bind6, [:uv_udp_t, :sockaddr_in6, :uint], :int, :blocking => true
         attach_function :udp_getsockname, :uv_udp_getsockname, [:uv_udp_t, :pointer, :pointer], :int, :blocking => true
         attach_function :udp_set_membership, :uv_udp_set_membership, [:uv_udp_t, :string, :string, :uv_membership], :int, :blocking => true
         attach_function :udp_set_multicast_loop, :uv_udp_set_multicast_loop, [:uv_udp_t, :int], :int, :blocking => true
@@ -123,7 +118,6 @@ module Libuv
         attach_function :udp_set_broadcast, :uv_udp_set_broadcast, [:uv_udp_t, :int], :int, :blocking => true
         attach_function :udp_set_ttl, :uv_udp_set_ttl, [:uv_udp_t, :int], :int, :blocking => true
         attach_function :udp_send, :uv_udp_send, [:uv_udp_send_t, :uv_udp_t, :pointer, :int, :sockaddr_in, :uv_udp_send_cb], :int, :blocking => true
-        attach_function :udp_send6, :uv_udp_send6, [:uv_udp_send_t, :uv_udp_t, :pointer, :int, :sockaddr_in6, :uv_udp_send_cb], :int, :blocking => true
         attach_function :udp_recv_start, :uv_udp_recv_start, [:uv_udp_t, :uv_alloc_cb, :uv_udp_recv_cb], :int, :blocking => true
         attach_function :udp_recv_stop, :uv_udp_recv_stop, [:uv_udp_t], :int, :blocking => true
 
@@ -211,10 +205,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_in, :blocking => true
-        attach_function :ip6_addr, :uv_ip6_addr, [:string, :int], :sockaddr_in6, :blocking => true
-        attach_function :ip4_name, :uv_ip4_name, [SockaddrIn.by_ref, :pointer, :size_t], :int, :blocking => true
-        attach_function :ip6_name, :uv_ip6_name, [SockaddrIn6.by_ref, :pointer, :size_t], :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
         #TODO:: attach_function :inet_ntop, :uv_inet_ntop, [:int, :pointer, ]
         #TODO:: attach_function :uv_inet_pton
 

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

@@ -1,5 +1,7 @@
 module Libuv
     module Ext
+        typedef :int, :uv_os_sock_t
+        
         class UvBuf < FFI::Struct
             layout :base, :pointer, :len, :size_t
         end
@@ -10,5 +12,7 @@ module Libuv
                     :st_blksize, :blksize_t, :st_blocks, :blkcnt_t, :st_atime, :time_t,
                     :st_mtime, :time_t, :st_ctime, :time_t
         end
+
+        attach_function :ntohs, [:ushort], :ushort, :blocking => true
     end
 end

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

@@ -3,6 +3,8 @@ module Libuv
         typedef :uint32_t, :in_addr_t
         typedef :uint16, :in_port_t
         typedef :int, :mode_t
+        # http://stackoverflow.com/questions/1953639/is-it-safe-to-cast-socket-to-int-under-win64
+        typedef :int, :uv_os_sock_t
 
         module WS2
             extend FFI::Library

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

@@ -5,7 +5,7 @@ file 'ext/libuv/uv.xcodeproj' => 'ext/libuv/build/gyp' do
     abort "Don't know how to build on #{FFI::Platform::ARCH} (yet)" unless target_arch
 
     Dir.chdir("ext/libuv") do |path|
-        system "./gyp_uv -f xcode -Dtarget_arch=#{target_arch} -Dlibrary=shared_library -Dcomponent=shared_library"
+        system "./gyp_uv.py -f xcode -Dtarget_arch=#{target_arch} -Dlibrary=shared_library -Dcomponent=shared_library"
     end
 end
 

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

@@ -5,7 +5,7 @@ file 'ext/libuv/out' => 'ext/libuv/build/gyp' do
     abort "Don't know how to build on #{FFI::Platform::ARCH} (yet)" unless target_arch
 
     Dir.chdir("ext/libuv") do |path|
-        system "./gyp_uv -f make -Dtarget_arch=#{target_arch} -Dlibrary=shared_library -Dcomponent=shared_library"
+        system "./gyp_uv.py -f make -Dtarget_arch=#{target_arch} -Dlibrary=shared_library -Dcomponent=shared_library"
     end
 end
 

data/lib/libuv/ext/types.rb

@@ -9,11 +9,7 @@ module Libuv
         require 'libuv/ext/platform/linux.rb' if FFI::Platform.linux?
         require 'libuv/ext/platform/unix.rb' if FFI::Platform.unix?
         require 'libuv/ext/platform/darwin_x64.rb' if FFI::Platform.mac? and FFI::Platform::ARCH == 'x86_64'
-        if FFI::Platform.windows?
-            require 'libuv/ext/platform/windows.rb'
-        else
-            attach_function :ntohs, [:ushort], :ushort, :blocking => true
-        end
+        require 'libuv/ext/platform/windows.rb' if FFI::Platform.windows?
 
         enum :uv_handle_type, [
             :uv_unknown_handle, 0,
@@ -92,8 +88,7 @@ module Libuv
             :UV_RUN_NOWAIT
         ]
 
-        typedef UvBuf.by_value, :uv_buf_t
-        typedef UvFSStat.by_value, :uv_fs_stat_t
+        typedef UvBuf.by_ref, :uv_buf_t
 
 
         class Sockaddr < FFI::Struct
@@ -114,7 +109,7 @@ module Libuv
                    :sin_zero, [:char, 8]
         end
 
-        typedef SockaddrIn.by_value, :sockaddr_in
+        typedef SockaddrIn.by_ref, :sockaddr_in4
 
         class U6Addr < FFI::Union
             layout :__u6_addr8, [:uint8, 16],
@@ -134,7 +129,7 @@ module Libuv
                    :sin6_scope_id, :uint32
         end
 
-        typedef SockaddrIn6.by_value, :sockaddr_in6
+        typedef SockaddrIn6.by_ref, :sockaddr_in6
 
 
         class UvTimespec < FFI::Struct
@@ -161,8 +156,7 @@ module Libuv
                     :st_birthtim, UvTimespec
         end
 
-        typedef UvStat.by_value, :uv_stat_t
-
+        typedef :pointer, :sockaddr_in
         typedef :pointer, :uv_handle_t
         typedef :pointer, :uv_fs_event_t
         typedef :pointer, :uv_fs_poll_t
@@ -205,7 +199,7 @@ module Libuv
         typedef :int,     :events
         typedef :int,     :signal
 
-        callback :uv_alloc_cb,       [:uv_handle_t, :size_t],                            :uv_buf_t
+        callback :uv_alloc_cb,       [:uv_handle_t, :size_t, :uv_buf_t],                 :void
         callback :uv_read_cb,        [:uv_stream_t, :ssize_t, :uv_buf_t],                :void
         callback :uv_read2_cb,       [:uv_pipe_t, :ssize_t, :uv_buf_t, :uv_handle_type], :void
         callback :uv_write_cb,       [:uv_write_t, :status],                             :void
@@ -227,9 +221,8 @@ module Libuv
         callback :uv_after_work_cb,  [:uv_work_t, :int],                                 :void
         callback :uv_fs_event_cb,    [:uv_fs_event_t, :string, :int, :int],              :void
         callback :uv_fs_poll_cb,     [:uv_fs_poll_t, :status, :uv_stat_t, :uv_stat_t],   :void
-        #callback :uv_signal_cb,      []
         callback :uv_udp_send_cb,    [:uv_udp_send_t, :int],                             :void
-        callback :uv_udp_recv_cb,    [:uv_udp_t, :ssize_t, :uv_buf_t, Sockaddr, :uint],  :void
+        callback :uv_udp_recv_cb,    [:uv_udp_t, :ssize_t, :uv_buf_t, Sockaddr.by_ref, :uint],  :void
         callback :uv_cb,             [],                                                 :void
     end
 end

data/lib/libuv/loop.rb

@@ -5,19 +5,22 @@ module Libuv
         include Resource, Assertions
 
 
+        LOOPS = ThreadSafe::Cache.new
+
+
         module ClassMethods
             # Get default loop
             # 
             # @return [::Libuv::Loop]
             def default
-                create(::Libuv::Ext.default_loop)
+                return current || create(::Libuv::Ext.default_loop)
             end
 
             # Create new Libuv loop
             # 
             # @return [::Libuv::Loop]
             def new
-                create(::Libuv::Ext.loop_new)
+                return current || create(::Libuv::Ext.loop_new)
             end
 
             # Build a Ruby Libuv loop from an existing loop pointer
@@ -26,6 +29,13 @@ module Libuv
             def create(pointer)
                 allocate.tap { |i| i.send(:initialize, FFI::AutoPointer.new(pointer, ::Libuv::Ext.method(:loop_delete))) }
             end
+
+            # Checks for the existence of a loop on the current thread
+            #
+            # @return [::Libuv::Loop | nil]
+            def current
+                LOOPS[Thread.current]
+            end
         end
         extend ClassMethods
 
@@ -59,6 +69,8 @@ module Libuv
 
             # Create an async call for ending the loop
             @stop_loop = Async.new @loop do
+                LOOPS.delete(@reactor_thread)
+                @reactor_thread = nil
                 @process_queue.close
                 @stop_loop.close
                 @next_tick.close
@@ -75,17 +87,19 @@ module Libuv
         # @yieldparam promise [::Libuv::Q::Promise] Yields a promise that can be used for logging unhandled
         #   exceptions on the loop.
         def run(run_type = :UV_RUN_DEFAULT)
-            @loop_notify = @loop.defer
-
-            begin
-                @reactor_thread = Thread.current
-                yield  @loop_notify.promise if block_given?
-                ::Libuv::Ext.run(@pointer, run_type)  # This is blocking
-            ensure
-                @reactor_thread = nil
-                @run_queue.clear
+            if @reactor_thread.nil?
+                @loop_notify = @loop.defer
+
+                begin
+                    @reactor_thread = Thread.current
+                    LOOPS[@reactor_thread] = @loop
+                    yield  @loop_notify.promise if block_given?
+                    ::Libuv::Ext.run(@pointer, run_type)  # This is blocking
+                ensure
+                    @reactor_thread = nil
+                    @run_queue.clear
+                end
             end
-
             @loop
         end
 
@@ -139,7 +153,7 @@ module Libuv
             ::Libuv::Ext.update_time(@pointer)
         end
 
-        # Get current time in microseconds
+        # Get current time in milliseconds
         # 
         # @return [Fixnum]
         def now
@@ -204,15 +218,15 @@ module Libuv
         # Get a new Prepare handle
         # 
         # @return [::Libuv::Prepare]
-        def prepare
-            Prepare.new(@loop)
+        def prepare(callback = nil, &blk)
+            Prepare.new(@loop, callback || blk)
         end
 
         # Get a new Check handle
         # 
         # @return [::Libuv::Check]
-        def check
-            Check.new(@loop)
+        def check(callback = nil, &blk)
+            Check.new(@loop, callback || blk)
         end
 
         # Get a new Idle handle
@@ -293,7 +307,7 @@ module Libuv
             callback ||= block
             assert_block(callback)
 
-            if @reactor_thread == Thread.current
+            if reactor_thread?
                 block.call
             else
                 @run_queue << callback
@@ -310,7 +324,7 @@ module Libuv
             assert_block(callback)
 
             @run_queue << callback
-            if @reactor_thread == Thread.current
+            if reactor_thread?
                 # Create a next tick timer
                 if not @next_tick_scheduled
                     @next_tick.start(0)
@@ -334,5 +348,26 @@ module Libuv
         def stop
             @stop_loop.call
         end
+
+        # True if the calling thread is the same thread as the reactor.
+        #
+        # @return [Boolean]
+        def reactor_thread?
+            @reactor_thread == Thread.current
+        end
+
+        # Exposed to allow joining on the thread, when run in a multithreaded environment. Performing other actions on the thread has undefined semantics (read: a dangerous endevor).
+        #
+        # @return [Thread]
+        def reactor_thread
+            @reactor_thread
+        end
+
+        # Tells you whether the Libuv reactor loop is currently running.
+        #
+        # @return [Boolean]
+        def reactor_running?
+            !@reactor_thread.nil?
+        end
     end
 end

data/lib/libuv/mixins/assertions.rb

@@ -3,7 +3,7 @@ module Libuv
         MSG_NO_PROC = 'no block given'
 
         def assert_block(proc, msg = MSG_NO_PROC)
-            raise ArgumentError, msg, caller if proc.nil?
+            raise ArgumentError, msg, caller unless proc.respond_to? :call
         end
 
         def assert_type(type, actual, msg = nil)

data/lib/libuv/mixins/resource.rb

@@ -3,10 +3,10 @@ module Libuv
 
 
         def resolve(deferred, rc)
-            if rc.nil? || rc >= 0
-                deferred.resolve(nil)
-            else
+            if rc && rc < 0
                 deferred.reject(@loop.lookup_error(rc))
+            else
+                deferred.resolve(nil)
             end
         end
 

data/lib/libuv/mixins/stream.rb

@@ -37,7 +37,7 @@ module Libuv
         end
 
         def write(data)
-            # NOTE:: Similar to udp.rb -> write
+            # NOTE:: Similar to udp.rb -> send
             deferred = @loop.defer
             if !@closed
                 begin
@@ -113,8 +113,9 @@ module Libuv
             end
         end
 
-        def on_allocate(client, suggested_size)
-            ::Libuv::Ext.buf_init(::Libuv::Ext.malloc(suggested_size), suggested_size)
+        def on_allocate(client, suggested_size, buffer)
+            buffer[:len] = suggested_size
+            buffer[:base] = ::Libuv::Ext.malloc(suggested_size)
         end
 
         def on_read(handle, nread, buf)
@@ -123,10 +124,16 @@ module Libuv
 
             if e
                 ::Libuv::Ext.free(base)
-                reject(e)
+                # I assume this is desirable behaviour
+                if e.is_a? ::Libuv::Error::EOF
+                    close   # Close gracefully 
+                else
+                    reject(e)
+                end
             else
                 data = base.read_string(nread)
                 ::Libuv::Ext.free(base)
+                
                 begin
                     @progress.call data, self
                 rescue Exception => e

data/lib/libuv/prepare.rb

@@ -9,7 +9,7 @@ module Libuv
             @callback = callback || blk
 
             prepare_ptr = ::Libuv::Ext.create_handle(:uv_prepare)
-            error = check_result(::Libuv::Ext.prepare_init(@pointer, prepare_ptr))
+            error = check_result(::Libuv::Ext.prepare_init(loop.handle, prepare_ptr))
 
             super(prepare_ptr, error)
         end

data/lib/libuv/q.rb

@@ -146,6 +146,10 @@ module Libuv
 				
 				result.promise
 			end
+
+			def resolved?
+				pending.nil?
+			end
 			
 			
 			private
@@ -181,14 +185,30 @@ module Libuv
 				
 				@loop.next_tick {
 					if @error
-						result.resolve(errback.nil? ? Q.reject(@loop, @response) : errback.call(@response))
+						begin
+							result.resolve(errback.nil? ? Q.reject(@loop, @response) : errback.call(@response))
+						rescue Exception => e
+							#warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+							result.reject(e)
+							@loop.log(:error, :q_reject_cb, e)
+						end
 					else
-						result.resolve(callback.nil? ? @response : callback.call(@response))
+						begin
+							result.resolve(callback.nil? ? @response : callback.call(@response))
+						rescue Exception => e
+							#warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+							result.reject(e)
+							@loop.log(:error, :q_resolve_cb, e)
+						end
 					end
 				}
 				
 				result.promise
 			end
+
+			def resolved?
+				true
+			end
 		end
 		
 		
@@ -241,7 +261,8 @@ module Libuv
 			# Creates a promise object associated with this deferred
 			#
 			def promise
-				DeferredPromise.new(@loop, self)
+				@promise ||= DeferredPromise.new(@loop, self)
+				@promise # Should only ever be one per deferred
 			end
 
 			#
@@ -260,6 +281,10 @@ module Libuv
 					end
 				end
 			end
+
+			def resolved?
+				@pending.nil?
+			end
 		end
 		
 		

data/lib/libuv/tcp.rb

@@ -33,20 +33,28 @@ module Libuv
             end
         end
 
+        def open(fd, binding = true, callback = nil, &blk)
+            return if @closed
+            if binding
+                @on_listen = callback || blk
+            else
+                @callback = callback || blk
+            end
+            error = check_result UV.tcp_open(handle, fd)
+            reject(error) if error
+        end
+
         def accept(callback = nil, &blk)
-            tcp = nil
             begin
                 raise RuntimeError, CLOSED_HANDLE_ERROR if @closed
                 tcp = TCP.new(loop, handle)
-            rescue Exception => e
-                @loop.log :info, :tcp_accept_failed, e
-            end
-            if tcp
                 begin
                     (callback || blk).call(tcp)
                 rescue Exception => e
                     @loop.log :error, :tcp_accept_cb, e
                 end
+            rescue Exception => e
+                @loop.log :info, :tcp_accept_failed, e
             end
             nil
         end
@@ -124,7 +132,11 @@ module Libuv
 
         def on_connect(req, status)
             ::Libuv::Ext.free(req)
-            @callback.call(self)
+            begin
+                @callback.call(self)
+            rescue Exception => e
+                @loop.log :error, :connect_cb, e
+            end
         end
 
 
@@ -144,28 +156,12 @@ module Libuv
             end
 
 
-            private
+            protected
 
 
             def connect_req
                 ::Libuv::Ext.create_request(:uv_connect)
             end
-        end
-
-
-        class Socket4 < SocketBase
-
-
-            private
-
-
-            def ip_addr(ip, port)
-                ::Libuv::Ext.ip4_addr(ip, port)
-            end
-
-            def tcp_bind
-                ::Libuv::Ext.tcp_bind(@tcp, @sockaddr)
-            end
 
             def tcp_connect(callback)
                 ::Libuv::Ext.tcp_connect(
@@ -175,30 +171,33 @@ module Libuv
                   callback
                 )
             end
-        end
-
 
-        class Socket6 < SocketBase
+            def tcp_bind
+                ::Libuv::Ext.tcp_bind(@tcp, @sockaddr)
+            end
+        end
 
 
-            private
+        class Socket4 < SocketBase
+            protected
 
 
             def ip_addr(ip, port)
-                ::Libuv::Ext.ip6_addr(ip, port)
+                addr = Ext::SockaddrIn.new
+                check_result! ::Libuv::Ext.ip4_addr(ip, port, addr)
+                addr
             end
+        end
 
-            def tcp_bind
-                ::Libuv::Ext.tcp_bind6(@tcp, @sockaddr)
-            end
 
-            def tcp_connect(callback)
-                ::Libuv::Ext.tcp_connect6(
-                  connect_req,
-                  @tcp,
-                  @sockaddr,
-                  callback
-                )
+        class Socket6 < SocketBase
+            protected
+
+
+            def ip_addr(ip, port)
+                addr = Ext::SockaddrIn6.new
+                check_result! ::Libuv::Ext.ip6_addr(ip, port, addr)
+                addr
             end
         end
     end

data/lib/libuv/timer.rb

@@ -14,6 +14,7 @@ module Libuv
             
             timer_ptr = ::Libuv::Ext.create_handle(:uv_timer)
             error = check_result(::Libuv::Ext.timer_init(loop.handle, timer_ptr))
+            @stopped = true
 
             super(timer_ptr, error)
         end
@@ -24,7 +25,8 @@ module Libuv
         # @param repeat [Fixnum] time in milliseconds between repeated callbacks after the first
         def start(timeout, repeat = 0)
             return if @closed
-            
+            @stopped = false
+
             assert_type(Integer, timeout, TIMEOUT_ERROR)
             assert_type(Integer, repeat, REPEAT_ERROR)
 
@@ -34,7 +36,8 @@ module Libuv
 
         # Disables the timer.
         def stop
-            return if @closed
+            return if @stopped || @closed
+            @stopped = true
             error = check_result ::Libuv::Ext.timer_stop(handle)
             reject(error) if error
         end

data/lib/libuv/udp.rb

@@ -19,17 +19,20 @@ module Libuv
             super(udp_ptr, error)
         end
 
-        def bind(ip, port, ipv6_only = false)
+        def bind(ip, port)
             return if @closed
             assert_type(String, ip, IP_ARGUMENT_ERROR)
             assert_type(Integer, port, PORT_ARGUMENT_ERROR)
 
-            begin
-                @udp_socket = create_socket(IPAddr.new(ip), port)
-                @udp_socket.bind(ipv6_only)
-            rescue Exception => e
-                reject(e)
-            end
+            sockaddr = create_sockaddr(ip, port)
+            error = check_result ::Libuv::Ext.udp_bind(handle, sockaddr, 0)
+            reject(error) if error
+        end
+
+        def open(fd, binding = true, callback = nil, &blk)
+            return if @closed
+            error = check_result UV.udp_open(handle, fd)
+            reject(error) if error
         end
 
         def sockname
@@ -57,13 +60,17 @@ module Libuv
             reject(error) if error
         end
 
-        def start_recv
+        # Starts reading from the handle
+        # Renamed to match Stream
+        def start_read
             return if @closed
             error = check_result ::Libuv::Ext.udp_recv_start(handle, callback(:on_allocate), callback(:on_recv))
             reject(error) if error
         end
 
-        def stop_recv
+        # Stops reading from the handle
+        # Renamed to match Stream
+        def stop_read
             return if @closed
             error = check_result ::Libuv::Ext.udp_recv_stop(handle)
             reject(error) if error
@@ -78,10 +85,10 @@ module Libuv
                     assert_type(Integer, port, PORT_ARGUMENT_ERROR)
                     assert_type(String, data, SEND_DATA_ERROR)
 
-                    @udp_socket = create_socket(IPAddr.new(ip), port)
+                    sockaddr = create_sockaddr(ip, port)
 
                     # local as this variable will be avaliable until the handle is closed
-                    @sent_callbacks = @sent_callbacks || []
+                    @sent_callbacks ||= []
 
                     #
                     # create the curried callback
@@ -97,16 +104,21 @@ module Libuv
                     #
                     # Save the callback and return the promise
                     #
-                    begin
-                        @sent_callbacks << [deferred, callback]
-                        @udp_socket.send(data, callback)
-                    rescue Exception => e
+                    @sent_callbacks << [deferred, callback]
+                    error = check_result ::Libuv::Ext.udp_send(
+                        send_req,
+                        handle,
+                        buf_init(data),
+                        1,
+                        sockaddr,
+                        callback
+                    )
+                    if error
                         @sent_callbacks.pop
-                        deferred.reject(e)
-
-                        reject(e)       # close the handle
+                        deferred.reject(error)
+                        reject(error)       # close the handle
                     end
-                rescue Exception => e
+                rescue StandardError => e
                     deferred.reject(e)
                 end
             else
@@ -153,12 +165,39 @@ module Libuv
             reject(error) if error
         end
 
+        def progress(callback = nil, &blk)
+            @progress = callback || blk
+        end
+
 
         private
 
 
-        def on_allocate(client, suggested_size)
-            ::Libuv::Ext.buf_init(::Libuv::Ext.malloc(suggested_size), suggested_size)
+        def send_req
+            ::Libuv::Ext.create_request(:uv_udp_send)
+        end
+
+        def buf_init(data)
+            ::Libuv::Ext.buf_init(FFI::MemoryPointer.from_string(data), data.respond_to?(:bytesize) ? data.bytesize : data.size)
+        end
+
+        def create_sockaddr(ip, port)
+            ips = IPAddr.new(ip)
+            if ips.ipv4?
+                addr = Ext::SockaddrIn.new
+                check_result! ::Libuv::Ext.ip4_addr(ip, port, addr)
+                addr
+            else
+                addr = Ext::SockaddrIn6.new
+                check_result! ::Libuv::Ext.ip6_addr(ip, port, addr)
+                addr
+            end
+        end
+
+
+        def on_allocate(client, suggested_size, buffer)
+            buffer[:len] = suggested_size
+            buffer[:base] = ::Libuv::Ext.malloc(suggested_size)
         end
 
         def on_recv(handle, nread, buf, sockaddr, flags)
@@ -174,100 +213,12 @@ module Libuv
                 unless sockaddr.null?
                     ip, port = get_ip_and_port(UV::Sockaddr.new(sockaddr))
                 end
-                defer.notify(data, ip, port)   # stream the data
-            end
-        end
-
-        def create_socket(ip, port)
-            if ip.ipv4?
-                Socket4.new(@loop, handle, ip, port)
-            else
-                Socket6.new(@loop, handle, ip, port)
-            end
-        end
-
-
-        module SocketMethods
-            include Resource
-
-            def initialize(loop, udp, ip, port)
-                @loop, @udp, @sockaddr = loop, udp, ip_addr(ip.to_s, port)
-            end
-
-            def bind(ipv6_only = false)
-                check_result! udp_bind(ipv6_only)
-            end
-
-            def send(data, callback)
-                check_result! udp_send(data, callback)
-            end
-
-
-            private
-
-
-            def send_req
-                ::Libuv::Ext.create_request(:uv_udp_send)
-            end
-
-            def buf_init(data)
-                ::Libuv::Ext.buf_init(FFI::MemoryPointer.from_string(data), data.respond_to?(:bytesize) ? data.bytesize : data.size)
-            end
-        end
-
-
-        class Socket4
-            include SocketMethods
-
-
-            private
-
-
-            def ip_addr(ip, port)
-                ::Libuv::Ext.ip4_addr(ip, port)
-            end
-
-            def udp_bind(ipv6_only)
-                ::Libuv::Ext.udp_bind(@udp, @sockaddr, 0)
-            end
-
-            def udp_send(data, callback)
-                ::Libuv::Ext.udp_send(
-                    send_req,
-                    @udp,
-                    buf_init(data),
-                    1,
-                    @sockaddr,
-                    callback
-                )
-            end
-        end
-
-
-        class Socket6 < Socket
-            include SocketMethods
-
-
-            private
-
-
-            def ip_addr(ip, port)
-                ::Libuv::Ext.ip6_addr(ip, port)
-            end
-
-            def udp_bind(ipv6_only)
-                ::Libuv::Ext.udp_bind6(@udp, @sockaddr, ipv6_only ? 1 : 0)
-            end
-
-            def udp_send(data, callback)
-                ::Libuv::Ext.udp_send6(
-                    send_req,
-                    @udp,
-                    buf_init(data),
-                    1,
-                    @sockaddr,
-                    callback
-                )
+                
+                begin
+                    @progress.call data, ip, port, self
+                rescue Exception => e
+                    @loop.log :error, :udp_progress_cb, e
+                end
             end
         end
     end

data/lib/libuv/version.rb

@@ -1,3 +1,3 @@
 module Libuv
-    VERSION = '0.10.2'
+    VERSION = '0.10.3'
 end

data/lib/libuv/work.rb

@@ -3,6 +3,10 @@ module Libuv
         include Resource, Listener
 
 
+        attr_reader :error
+        attr_reader :result
+
+
         # @param loop [::Libuv::Loop] loop this work request will be associated
         # @param work [Proc] callback to be called in the thread pool
         def initialize(loop, work)
@@ -46,16 +50,21 @@ module Libuv
             @complete = true
             ::Libuv::Ext.free(req)
 
-            if @error
-                @defer.reject(@error)
+            e = check_result(status)
+            if e
+                @defer.reject(e)
             else
-                resolve @defer, status
+                if @error
+                    @defer.reject(@error)
+                else
+                    @defer.resolve(@result)
+                end
             end
         end
 
         def on_work(req)
             begin
-                @work.call
+                @result = @work.call
             rescue Exception => e
                 @error = e   # Catch errors for promise resolution
             end

data/spec/filesystem_spec.rb

@@ -17,9 +17,9 @@ describe Libuv::Filesystem do
 
 		@logger = proc { |level, errorid, error|
 			begin
-				p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+				@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
 			rescue Exception
-				p 'error in logger'
+				@general_failure << 'error in logger'
 			end
 		}
 
@@ -106,10 +106,15 @@ describe Libuv::Filesystem do
 			@loop.run { |logger|
 				logger.progress &@logger
 
-				@loop.filesystem.unlink(@thefile).then do
+				op = @loop.filesystem.unlink(@thefile)
+				op.then do
 					@loop.stop
 					@log = :success
 				end
+				op.catch do |error|
+					@general_failure << error
+					@loop.stop
+				end
 			}
 
 			@general_failure.should == []

data/spec/pipe_spec.rb

@@ -15,11 +15,11 @@ describe Libuv::Pipe do
 		end
 		@timeout.start(5000)
 
-		@pipefile = "/tmp/test-pipe.pipe"
+		@pipefile = "/tmp/test-pipes.pipe"
 
 		@loop.all(@server, @client, @timeout).catch do |reason|
 			@general_failure << reason.inspect
-			p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+			@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
 		end
 
 		begin
@@ -41,9 +41,9 @@ describe Libuv::Pipe do
 			@loop.run { |logger|
 				logger.progress do |level, errorid, error|
 					begin
-						p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace}\n"
 					rescue Exception
-						p 'error in logger'
+						@general_failure << 'error in logger'
 					end
 				end
 
@@ -62,7 +62,7 @@ describe Libuv::Pipe do
 					@general_failure << reason.inspect
 					@loop.stop
 
-					p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
 				end
 
 				# start listening
@@ -82,6 +82,13 @@ describe Libuv::Pipe do
 					@client.write('ping')
 				end
 
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+					@loop.stop
+
+					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
+				end
+
 				# Stop the loop once the client handle is closed
 				@client.finally do
 					@server.close
@@ -94,8 +101,8 @@ describe Libuv::Pipe do
 		end
 	end
 
-	# This test won't pass on jRuby as java won't expose file descriptors
-	describe 'unidirectional pipeline' do
+	# This test won't pass on windows as pipes don't work like this on windows
+	describe 'unidirectional pipeline', :unix_only => true do
 		before :each do
 			system "/usr/bin/mkfifo", @pipefile
 		end
@@ -103,7 +110,7 @@ describe Libuv::Pipe do
 		it "should send work to a consumer" do
 			@loop.run { |logger|
 				logger.progress do |level, errorid, error|
-					p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
 				end
 
 
@@ -120,7 +127,7 @@ describe Libuv::Pipe do
 					end
 				end
 				@file1.catch do |e|
-					p "Log called: #{level}: #{errorid}\n#{e.message}\n#{e.backtrace.join("\n")}\n"
+					@general_failure << "Log called: #{e.inspect} - #{e.message}\n"
 				end
 
 				@file2 = @loop.file(@pipefile, File::RDWR|File::NONBLOCK)

data/spec/tcp_spec.rb

@@ -35,9 +35,9 @@ describe Libuv::TCP do
 			@loop.run { |logger|
 				logger.progress do |level, errorid, error|
 					begin
-						p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
 					rescue Exception
-						p 'error in logger'
+						@general_failure << 'error in logger'
 					end
 				end
 
@@ -98,9 +98,9 @@ describe Libuv::TCP do
 		@loop.run { |logger|
 			logger.progress do |level, errorid, error|
 				begin
-					p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
 				rescue Exception
-					p 'error in logger'
+					@general_failure << 'error in logger'
 				end
 			end
 
@@ -167,9 +167,9 @@ describe Libuv::TCP do
 				@loop2.run do  |logger|
 					logger.progress do |level, errorid, error|
 						begin
-							p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
 						rescue Exception
-							p 'error in logger'
+							@general_failure << 'error in logger'
 						end
 					end
 			

metadata

@@ -1,97 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: libuv
 version: !ruby/object:Gem::Version
-  prerelease:
-  version: 0.10.2
+  version: 0.10.3
 platform: ruby
 authors:
 - Bulat Shakirzyanov
 - Stephen von Takach
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-03 00:00:00.000000000 Z
+date: 2013-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.9'
-    none: false
-  requirement: !ruby/object:Gem::Requirement
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.9'
-    none: false
-  prerelease: false
-  type: :runtime
 - !ruby/object:Gem::Dependency
   name: thread_safe
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  requirement: !ruby/object:Gem::Requirement
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  prerelease: false
-  type: :runtime
 - !ruby/object:Gem::Dependency
   name: rspec
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.14'
-    none: false
-  requirement: !ruby/object:Gem::Requirement
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.14'
-    none: false
-  prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency
   name: rake
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.1'
-    none: false
-  requirement: !ruby/object:Gem::Requirement
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.1'
-    none: false
-  prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency
   name: yard
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  requirement: !ruby/object:Gem::Requirement
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  prerelease: false
-  type: :development
 description: An opinionated wrapper around libuv for Ruby
 email:
 - mallluhuct@gmail.com
@@ -101,10 +90,10 @@ extensions:
 - ext/Rakefile
 extra_rdoc_files: []
 files:
-- .gitignore
-- .gitmodules
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".gitmodules"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -168,7 +157,7 @@ files:
 - ext/libuv/checksparse.sh
 - ext/libuv/common.gypi
 - ext/libuv/configure.ac
-- ext/libuv/gyp_uv
+- ext/libuv/gyp_uv.py
 - ext/libuv/include/pthread-fixes.h
 - ext/libuv/include/stdint-msvc2008.h
 - ext/libuv/include/tree.h
@@ -187,6 +176,7 @@ files:
 - ext/libuv/src/queue.h
 - ext/libuv/src/unix/aix.c
 - ext/libuv/src/unix/async.c
+- ext/libuv/src/unix/atomic-ops.h
 - ext/libuv/src/unix/core.c
 - ext/libuv/src/unix/darwin-proctitle.c
 - ext/libuv/src/unix/darwin.c
@@ -211,6 +201,7 @@ files:
 - ext/libuv/src/unix/proctitle.c
 - ext/libuv/src/unix/pthread-fixes.c
 - ext/libuv/src/unix/signal.c
+- ext/libuv/src/unix/spinlock.h
 - ext/libuv/src/unix/stream.c
 - ext/libuv/src/unix/sunos.c
 - ext/libuv/src/unix/tcp.c
@@ -292,6 +283,7 @@ files:
 - ext/libuv/test/test-barrier.c
 - ext/libuv/test/test-callback-order.c
 - ext/libuv/test/test-callback-stack.c
+- ext/libuv/test/test-close-order.c
 - ext/libuv/test/test-condvar.c
 - ext/libuv/test/test-connection-fail.c
 - ext/libuv/test/test-cwd-and-chdir.c
@@ -366,34 +358,32 @@ files:
 - ext/libuv/test/test-udp-open.c
 - ext/libuv/test/test-udp-options.c
 - ext/libuv/test/test-udp-send-and-recv.c
-- ext/libuv/test/test-util.c
 - ext/libuv/test/test-walk-handles.c
 - ext/libuv/uv.gyp
 - ext/libuv/vcbuild.bat
 homepage: https://github.com/cotag/libuv
 licenses:
 - MIT
-post_install_message:
+metadata: {}
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
-rubyforge_project:
-rubygems_version: 1.8.24
-signing_key:
-specification_version: 3
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
 summary: libuv bindings for Ruby
 test_files:
 - spec/async_spec.rb
@@ -403,4 +393,4 @@ test_files:
 - spec/idle_spec.rb
 - spec/pipe_spec.rb
 - spec/tcp_spec.rb
-has_rdoc:
+has_rdoc: