libuv 0.11.22 → 0.12.0

data/lib/libuv/mixins/assertions.rb

@@ -1,23 +1,23 @@
-module Libuv
-    module Assertions
-        MSG_NO_PROC = 'no block given'
-
-        def assert_block(proc, msg = MSG_NO_PROC)
-            raise ArgumentError, msg, caller unless proc.respond_to? :call
-        end
-
-        def assert_type(type, actual, msg = nil)
-            if not actual.kind_of?(type)
-                msg ||= "value #{actual.inspect} is not a valid #{type}"
-                raise ArgumentError, msg, caller
-            end
-        end
-
-        def assert_boolean(actual, msg = nil)
-            if not (actual.kind_of?(TrueClass) || actual.kind_of?(FalseClass))
-                msg ||= "value #{actual.inspect} is not a valid Boolean"
-                raise ArgumentError, msg, caller
-            end
-        end
-    end
-end
+module Libuv
+    module Assertions
+        MSG_NO_PROC = 'no block given'
+
+        def assert_block(proc, msg = MSG_NO_PROC)
+            raise ArgumentError, msg, caller unless proc.respond_to? :call
+        end
+
+        def assert_type(type, actual, msg = nil)
+            if not actual.kind_of?(type)
+                msg ||= "value #{actual.inspect} is not a valid #{type}"
+                raise ArgumentError, msg, caller
+            end
+        end
+
+        def assert_boolean(actual, msg = nil)
+            if not (actual.kind_of?(TrueClass) || actual.kind_of?(FalseClass))
+                msg ||= "value #{actual.inspect} is not a valid Boolean"
+                raise ArgumentError, msg, caller
+            end
+        end
+    end
+end

data/lib/libuv/mixins/fs_checks.rb

@@ -1,58 +1,60 @@
-
-module Libuv
-    module FsChecks
-
-
-        def stat
-            @stat_deferred = @loop.defer
-
-            request = ::Libuv::Ext.create_request(:uv_fs)
-            pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@loop.handle, request, @fileno, callback(:on_stat))
-            @stat_deferred.promise
-        end
-
-
-        private
-
-
-        def on_stat(req)
-            if post_check(req, @stat_deferred)
-                uv_stat = req[:stat]
-                uv_members = uv_stat.members
-
-                stats = {}
-                uv_members.each do |key|
-                    stats[key] = uv_stat[key]
-                end
-
-                cleanup(req)
-                @stat_deferred.resolve(stats)
-            end
-            @stat_deferred = nil
-        end
-
-        def pre_check(deferrable, request, result)
-            error = check_result result
-            if error
-                ::Libuv::Ext.free(request)
-                deferrable.reject(error)
-            end
-        end
-
-        def cleanup(req)
-            ::Libuv::Ext.fs_req_cleanup(req)
-            ::Libuv::Ext.free(req)
-        end
-
-        def post_check(req, deferrable)
-            error = check_result(req[:result])
-            if error
-                cleanup(req)
-                deferrable.reject(error)
-                false
-            else
-                true
-            end
-        end
-    end
-end
+
+module Libuv
+    module FsChecks
+
+
+        def stat
+            @stat_deferred = @loop.defer
+
+            request = ::Libuv::Ext.create_request(:uv_fs)
+            pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@loop.handle, request, @fileno, callback(:on_stat))
+            @stat_deferred.promise
+        end
+
+
+        private
+
+
+        def on_stat(req)
+            if post_check(req, @stat_deferred)
+                uv_stat = req[:stat]
+                uv_members = uv_stat.members
+
+                stats = {}
+                uv_members.each do |key|
+                    stats[key] = uv_stat[key]
+                end
+
+                cleanup(req)
+                @stat_deferred.resolve(stats)
+            end
+            @stat_deferred = nil
+        end
+
+        def pre_check(deferrable, request, result)
+            error = check_result result
+            if error
+                @request_refs.delete request.address
+                ::Libuv::Ext.free(request)
+                deferrable.reject(error)
+            end
+            deferrable.promise
+        end
+
+        def cleanup(req)
+            ::Libuv::Ext.fs_req_cleanup(req)
+            ::Libuv::Ext.free(req)
+        end
+
+        def post_check(req, deferrable)
+            error = check_result(req[:result])
+            if error
+                cleanup(req)
+                deferrable.reject(error)
+                false
+            else
+                true
+            end
+        end
+    end
+end

data/lib/libuv/mixins/listener.rb

@@ -1,34 +1,34 @@
-require 'thread_safe'
-require 'set'
-
-module Libuv
-    module Listener
-
-
-        private
-
-
-        CALLBACKS = ThreadSafe::Cache.new
-
-
-        def callbacks
-            @callbacks ||= Set.new
-        end
-
-        def callback(name)
-            const_name = "#{name}_#{object_id}".to_sym
-            unless CALLBACKS[const_name]
-                callbacks << const_name
-                CALLBACKS[const_name] = method(name)
-            end
-            CALLBACKS[const_name]
-        end
-
-        def clear_callbacks
-            callbacks.each do |name|
-                CALLBACKS.delete(name)
-            end
-            callbacks.clear
-        end
-    end
-end
+require 'thread_safe'
+require 'set'
+
+module Libuv
+    module Listener
+
+
+        private
+
+
+        CALLBACKS = ThreadSafe::Cache.new
+
+
+        def callbacks
+            @callbacks ||= Set.new
+        end
+
+        def callback(name)
+            const_name = "#{name}_#{object_id}".to_sym
+            unless CALLBACKS[const_name]
+                callbacks << const_name
+                CALLBACKS[const_name] = method(name)
+            end
+            CALLBACKS[const_name]
+        end
+
+        def clear_callbacks
+            callbacks.each do |name|
+                CALLBACKS.delete(name)
+            end
+            callbacks.clear
+        end
+    end
+end

data/lib/libuv/mixins/net.rb

@@ -1,40 +1,40 @@
-require 'socket'
-
-module Libuv
-    module Net
-
-
-        IP_ARGUMENT_ERROR = "ip must be a String".freeze                # Arguments specifying an IP address
-        PORT_ARGUMENT_ERROR = "port must be an Integer".freeze          # Arguments specifying an IP port
-        INET_ADDRSTRLEN = 16
-        INET6_ADDRSTRLEN = 46
-
-
-        private
-
-
-        def get_sockaddr_and_len
-            sockaddr = FFI::MemoryPointer.new(::Libuv::Ext::Sockaddr)
-            len = FFI::MemoryPointer.new(:int)
-            len.put_int(0, ::Libuv::Ext::Sockaddr.size)
-            [sockaddr, len]
-        end
-
-        def get_ip_and_port(sockaddr, len = nil)
-            if sockaddr[:sa_family] == Socket::Constants::AF_INET6
-                len ||= INET6_ADDRSTRLEN
-                sockaddr_in6 = ::Libuv::Ext::SockaddrIn6.new(sockaddr.pointer)
-                ip_ptr = FFI::MemoryPointer.new(:char, len)
-                ::Libuv::Ext.ip6_name(sockaddr_in6, ip_ptr, len)
-                port = ::Libuv::Ext.ntohs(sockaddr_in6[:sin6_port])
-            else
-                len ||= INET_ADDRSTRLEN
-                sockaddr_in = ::Libuv::Ext::SockaddrIn.new(sockaddr.pointer)
-                ip_ptr = FFI::MemoryPointer.new(:char, len)
-                ::Libuv::Ext.ip4_name(sockaddr_in, ip_ptr, len)
-                port = ::Libuv::Ext.ntohs(sockaddr_in[:sin_port])
-            end
-            [ip_ptr.read_string, port]
-        end
-    end
-end
+require 'socket'
+
+module Libuv
+    module Net
+
+
+        IP_ARGUMENT_ERROR = "ip must be a String".freeze                # Arguments specifying an IP address
+        PORT_ARGUMENT_ERROR = "port must be an Integer".freeze          # Arguments specifying an IP port
+        INET_ADDRSTRLEN = 16
+        INET6_ADDRSTRLEN = 46
+
+
+        private
+
+
+        def get_sockaddr_and_len
+            sockaddr = FFI::MemoryPointer.new(::Libuv::Ext::Sockaddr)
+            len = FFI::MemoryPointer.new(:int)
+            len.put_int(0, ::Libuv::Ext::Sockaddr.size)
+            [sockaddr, len]
+        end
+
+        def get_ip_and_port(sockaddr, len = nil)
+            if sockaddr[:sa_family] == Socket::Constants::AF_INET6
+                len ||= INET6_ADDRSTRLEN
+                sockaddr_in6 = ::Libuv::Ext::SockaddrIn6.new(sockaddr.pointer)
+                ip_ptr = FFI::MemoryPointer.new(:char, len)
+                ::Libuv::Ext.ip6_name(sockaddr_in6, ip_ptr, len)
+                port = ::Libuv::Ext.ntohs(sockaddr_in6[:sin6_port])
+            else
+                len ||= INET_ADDRSTRLEN
+                sockaddr_in = ::Libuv::Ext::SockaddrIn.new(sockaddr.pointer)
+                ip_ptr = FFI::MemoryPointer.new(:char, len)
+                ::Libuv::Ext.ip4_name(sockaddr_in, ip_ptr, len)
+                port = ::Libuv::Ext.ntohs(sockaddr_in[:sin_port])
+            end
+            [ip_ptr.read_string, port]
+        end
+    end
+end

data/lib/libuv/mixins/resource.rb

@@ -1,28 +1,28 @@
-module Libuv
-    module Resource
-
-
-        def resolve(deferred, rc)
-            if rc && rc < 0
-                deferred.reject(@loop.lookup_error(rc))
-            else
-                deferred.resolve(nil)
-            end
-        end
-
-        def check_result!(rc)
-            e = @loop.lookup_error(rc) unless rc.nil? || rc >= 0
-            raise e if e
-        end
-
-        def check_result(rc)
-            @loop.lookup_error(rc) unless rc.nil? || rc >= 0
-        end
-
-        def to_ptr
-            @pointer
-        end
-
-
-    end
+module Libuv
+    module Resource
+
+
+        def resolve(deferred, rc)
+            if rc && rc < 0
+                deferred.reject(@loop.lookup_error(rc))
+            else
+                deferred.resolve(nil)
+            end
+        end
+
+        def check_result!(rc)
+            e = @loop.lookup_error(rc) unless rc.nil? || rc >= 0
+            raise e if e
+        end
+
+        def check_result(rc)
+            @loop.lookup_error(rc) unless rc.nil? || rc >= 0
+        end
+
+        def to_ptr
+            @pointer
+        end
+
+
+    end
 end

data/lib/libuv/mixins/stream.rb

@@ -1,155 +1,154 @@
-module Libuv
-    module Stream
-
-
-        BACKLOG_ERROR = "backlog must be an Integer".freeze
-        WRITE_ERROR = "data must be a String".freeze
-        STREAM_CLOSED_ERROR = "unable to write to a closed stream".freeze
-        CLOSED_HANDLE_ERROR = "handle closed before accept called".freeze
-
-
-        def listen(backlog)
-            return if @closed
-            assert_type(Integer, backlog, BACKLOG_ERROR)
-            error = check_result ::Libuv::Ext.listen(handle, Integer(backlog), callback(:on_listen))
-            reject(error) if error
-        end
-
-        # Starts reading from the handle
-        def start_read
-            return if @closed
-            error = check_result ::Libuv::Ext.read_start(handle, callback(:on_allocate), callback(:on_read))
-            reject(error) if error
-        end
-
-        # Stops reading from the handle
-        def stop_read
-            return if @closed
-            error = check_result ::Libuv::Ext.read_stop(handle)
-            reject(error) if error
-        end
-
-        # Shutsdown the writes on the handle waiting until the last write is complete before triggering the callback
-        def shutdown
-            return if @closed
-            error = check_result ::Libuv::Ext.shutdown(::Libuv::Ext.create_request(:uv_shutdown), handle, callback(:on_shutdown))
-            reject(error) if error
-        end
-
-        def write(data)
-            # NOTE:: Similar to udp.rb -> send
-            deferred = @loop.defer
-            if !@closed
-                begin
-                    assert_type(String, data, WRITE_ERROR)
-
-                    size         = data.respond_to?(:bytesize) ? data.bytesize : data.size
-                    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 ||= []
-
-                    #
-                    # 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.create_request(:uv_write)
-                    error = check_result ::Libuv::Ext.write(req, handle, buffer, 1, callback)
-
-                    if error
-                        @write_callbacks.pop
-                        ::Libuv::Ext.free(req)
-                        deferred.reject(error)
-
-                        reject(error)       # close the handle
-                    end
-                rescue Exception => e
-                    deferred.reject(e)  # this write exception may not be fatal
-                end
-            else
-                deferred.reject(RuntimeError.new(STREAM_CLOSED_ERROR))
-            end
-            deferred.promise
-        end
-
-        def readable?
-            return false if @closed
-            ::Libuv::Ext.is_readable(handle) > 0
-        end
-
-        def writable?
-            return false if @closed
-            ::Libuv::Ext.is_writable(handle) > 0
-        end
-
-        def progress(callback = nil, &blk)
-            @progress = callback || blk
-        end
-
-
-        private
-
-
-        def on_listen(server, status)
-            e = check_result(status)
-
-            if e
-                reject(e)   # is this cause for closing the handle?
-            else
-                begin
-                    @on_listen.call(self)
-                rescue Exception => e
-                    @loop.log :error, :stream_listen_cb, e
-                end
-            end
-        end
-
-        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)
-            e = check_result(nread)
-            base = buf[:base]
-
-            if e
-                ::Libuv::Ext.free(base)
-                # I assume this is desirable behaviour
-                if e.is_a? ::Libuv::Error::EOF
-                    close   # Close gracefully 
-                else
-                    reject(e)
-                end
-            else
-                data = base.read_string(nread)
-                ::Libuv::Ext.free(base)
-                
-                if @tls.nil?
-                    begin
-                        @progress.call data, self
-                    rescue Exception => e
-                        @loop.log :error, :stream_progress_cb, e
-                    end
-                else
-                    @tls.decrypt(data)
-                end
-            end
-        end
-
-        def on_shutdown(req, status)
-            ::Libuv::Ext.free(req)
-            @close_error = check_result(status)
-            close
-        end
-    end
+module Libuv
+    module Stream
+
+
+        BACKLOG_ERROR = "backlog must be an Integer".freeze
+        WRITE_ERROR = "data must be a String".freeze
+        STREAM_CLOSED_ERROR = "unable to write to a closed stream".freeze
+        CLOSED_HANDLE_ERROR = "handle closed before accept called".freeze
+
+
+        def listen(backlog)
+            return if @closed
+            assert_type(Integer, backlog, BACKLOG_ERROR)
+            error = check_result ::Libuv::Ext.listen(handle, Integer(backlog), callback(:on_listen))
+            reject(error) if error
+        end
+
+        # Starts reading from the handle
+        def start_read
+            return if @closed
+            error = check_result ::Libuv::Ext.read_start(handle, callback(:on_allocate), callback(:on_read))
+            reject(error) if error
+        end
+
+        # Stops reading from the handle
+        def stop_read
+            return if @closed
+            error = check_result ::Libuv::Ext.read_stop(handle)
+            reject(error) if error
+        end
+
+        # Shutsdown the writes on the handle waiting until the last write is complete before triggering the callback
+        def shutdown
+            return if @closed
+            error = check_result ::Libuv::Ext.shutdown(::Libuv::Ext.create_request(:uv_shutdown), handle, callback(:on_shutdown))
+            reject(error) if error
+        end
+
+        def write(data)
+            # NOTE:: Similar to udp.rb -> send
+            deferred = @loop.defer
+            if !@closed
+                begin
+                    assert_type(String, data, WRITE_ERROR)
+
+                    size        = data.respond_to?(:bytesize) ? data.bytesize : data.size
+                    buffer1     = ::Libuv::Ext.malloc size
+                    buffer1.write_string data
+                    buffer      = ::Libuv::Ext.buf_init(buffer1, size)
+
+                    # local as this variable will be available until the handle is closed
+                    @write_callbacks ||= {}
+                    req = ::Libuv::Ext.create_request(:uv_write)
+                    @write_callbacks[req.address] = [deferred, buffer1]
+                    error = check_result ::Libuv::Ext.write(req, handle, buffer, 1, callback(:write_complete))
+
+                    if error
+                        @write_callbacks.delete req.address
+                        ::Libuv::Ext.free(req)
+                        ::Libuv::Ext.free(buffer1)
+                        deferred.reject(error)
+
+                        reject(error)       # close the handle
+                    end
+                rescue => e
+                    deferred.reject(e)  # this write exception may not be fatal
+                end
+            else
+                deferred.reject(RuntimeError.new(STREAM_CLOSED_ERROR))
+            end
+            deferred.promise
+        end
+
+        def readable?
+            return false if @closed
+            ::Libuv::Ext.is_readable(handle) > 0
+        end
+
+        def writable?
+            return false if @closed
+            ::Libuv::Ext.is_writable(handle) > 0
+        end
+
+        def progress(callback = nil, &blk)
+            @progress = callback || blk
+        end
+
+
+        private
+
+
+        def on_listen(server, status)
+            e = check_result(status)
+
+            if e
+                reject(e)   # is this cause for closing the handle?
+            else
+                begin
+                    @on_listen.call(self)
+                rescue Exception => e
+                    @loop.log :error, :stream_listen_cb, e
+                end
+            end
+        end
+
+        def on_allocate(client, suggested_size, buffer)
+            buffer[:len] = suggested_size
+            buffer[:base] = ::Libuv::Ext.malloc(suggested_size)
+        end
+
+        def write_complete(req, status)
+            deferred, buffer1 = @write_callbacks.delete req.address
+
+            ::Libuv::Ext.free(req)
+            ::Libuv::Ext.free(buffer1)
+
+            resolve deferred, status
+        end
+
+        def on_read(handle, nread, buf)
+            e = check_result(nread)
+            base = buf[:base]
+
+            if e
+                ::Libuv::Ext.free(base)
+                # I assume this is desirable behaviour
+                if e.is_a? ::Libuv::Error::EOF
+                    close   # Close gracefully 
+                else
+                    reject(e)
+                end
+            else
+                data = base.read_string(nread)
+                ::Libuv::Ext.free(base)
+                
+                if @tls.nil?
+                    begin
+                        @progress.call data, self
+                    rescue Exception => e
+                        @loop.log :error, :stream_progress_cb, e
+                    end
+                else
+                    @tls.decrypt(data)
+                end
+            end
+        end
+
+        def on_shutdown(req, status)
+            ::Libuv::Ext.free(req)
+            @close_error = check_result(status)
+            close
+        end
+    end
 end