libuv 0.10.0

data/lib/libuv/resource.rb

@@ -0,0 +1,28 @@
+module Libuv
+    module Resource
+
+
+        def resolve(deferred, rc)
+            if rc.nil? || rc >= 0
+                deferred.resolve(nil)
+            else
+                deferred.reject(@loop.lookup_error(rc))
+            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/simple_async.rb

@@ -0,0 +1,28 @@
+module Libuv
+    class SimpleAsync < Async
+
+
+        def initialize(loop, callback = nil, &blk)
+            @callback = callback || blk
+            super(loop)
+        end
+
+
+        private
+
+
+        def on_async(handle, status)
+            e = check_result(status)
+
+            if e
+                reject(e)
+            else
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @loop.log :error, :simple_async_cb, e
+                end
+            end
+        end
+    end
+end

data/lib/libuv/stream.rb

@@ -0,0 +1,124 @@
+module Libuv
+    module Stream
+
+
+        BACKLOG_ERROR = "backlog must be an Integer".freeze
+        WRITE_ERROR = "data must be a String".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
+            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
+            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
+            error = check_result ::Libuv::Ext.shutdown(::Libuv::Ext.create_request(:uv_shutdown), handle, callback(:on_shutdown))
+            reject(error) if error
+        end
+
+        def write(data)
+            deferred = @loop.defer
+            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 = @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
+            deferred.promise
+        end
+
+        def readable?
+            ::Libuv::Ext.is_readable(handle) > 0
+        end
+
+        def writable?
+            ::Libuv::Ext.is_writable(handle) > 0
+        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)
+            ::Libuv::Ext.buf_init(::Libuv::Ext.malloc(suggested_size), suggested_size)
+        end
+
+        def on_read(handle, nread, buf)
+            e = check_result(nread)
+            base = buf[:base]
+
+            if e
+                ::Libuv::Ext.free(base)
+                reject(e)
+            else
+                data = base.read_string(nread)
+                ::Libuv::Ext.free(base)
+                defer.notify(data)   # stream the data
+            end
+        end
+
+        def on_shutdown(req, status)
+            ::Libuv::Ext.free(req)
+            @close_error = check_result(status)
+            close
+        end
+    end
+end

data/lib/libuv/tcp.rb

@@ -0,0 +1,194 @@
+require 'ipaddr'
+
+
+module Libuv
+    class TCP < Handle
+        include Stream, Net
+
+
+        KEEPALIVE_ARGUMENT_ERROR = "delay must be an Integer".freeze
+
+
+        def initialize(loop, acceptor = nil)
+            @loop = loop
+
+            tcp_ptr = ::Libuv::Ext.create_handle(:uv_tcp)
+            error = check_result(::Libuv::Ext.tcp_init(loop.handle, tcp_ptr))
+            error = check_result(::Libuv::Ext.accept(acceptor, tcp_ptr)) if acceptor && error.nil?
+            
+            super(tcp_ptr, error)
+        end
+
+        def bind(ip, port, callback = nil, &blk)
+            @on_listen = callback || blk
+            assert_type(String, ip, IP_ARGUMENT_ERROR)
+            assert_type(Integer, port, PORT_ARGUMENT_ERROR)
+
+            begin
+                @tcp_socket = create_socket(IPAddr.new(ip), port)
+                @tcp_socket.bind
+            rescue Exception => e
+                reject(e)
+            end
+        end
+
+        def accept(callback = nil, &blk)
+            tcp = nil
+            begin
+                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
+            end
+            nil
+        end
+
+        def connect(ip, port, callback = nil, &blk)
+            @callback = callback || blk
+            assert_type(String, ip, IP_ARGUMENT_ERROR)
+            assert_type(Integer, port, PORT_ARGUMENT_ERROR)
+            
+            begin
+                @tcp_socket = create_socket(IPAddr.new(ip), port)
+                @tcp_socket.connect(callback(:on_connect))
+            rescue Exception => e
+                reject(e)
+            end
+        end
+
+        def sockname
+            sockaddr, len = get_sockaddr_and_len
+            check_result! ::Libuv::Ext.tcp_getsockname(handle, sockaddr, len)
+            get_ip_and_port(::Libuv::Sockaddr.new(sockaddr), len.get_int(0))
+        end
+
+        def peername
+            sockaddr, len = get_sockaddr_and_len
+            check_result! ::Libuv::Ext.tcp_getpeername(handle, sockaddr, len)
+            get_ip_and_port(::Libuv::Sockaddr.new(sockaddr), len.get_int(0))
+        end
+
+        def enable_nodelay
+            check_result ::Libuv::Ext.tcp_nodelay(handle, 1)
+        end
+
+        def disable_nodelay
+            check_result ::Libuv::Ext.tcp_nodelay(handle, 0)
+        end
+
+        def enable_keepalive(delay)
+            assert_type(Integer, delay, KEEPALIVE_ARGUMENT_ERROR)
+            check_result ::Libuv::Ext.tcp_keepalive(handle, 1, delay)
+        end
+
+        def disable_keepalive
+            check_result ::Libuv::Ext.tcp_keepalive(handle, 0, 0)
+        end
+
+        def enable_simultaneous_accepts
+            check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 1)
+        end
+
+        def disable_simultaneous_accepts
+            check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 0)
+        end
+
+
+        private
+
+
+        def create_socket(ip, port)
+            if ip.ipv4?
+                Socket4.new(loop, handle, ip.to_s, port)
+            else
+                Socket6.new(loop, handle, ip.to_s, port)
+            end
+        end
+
+        def on_connect(req, status)
+            ::Libuv::Ext.free(req)
+            @callback.call(self)
+        end
+
+
+        class SocketBase
+            include Resource
+
+            def initialize(loop, tcp, ip, port)
+                @tcp, @sockaddr = tcp, ip_addr(ip, port)
+            end
+
+            def bind
+                check_result!(tcp_bind)
+            end
+
+            def connect(callback)
+                check_result!(tcp_connect(callback))
+            end
+
+
+            private
+
+
+            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(
+                  connect_req,
+                  @tcp,
+                  @sockaddr,
+                  callback
+                )
+            end
+        end
+
+
+        class Socket6 < SocketBase
+
+
+            private
+
+
+            def ip_addr(ip, port)
+                ::Libuv::Ext.ip6_addr(ip, port)
+            end
+
+            def tcp_bind
+                ::Libuv::Ext.tcp_bind6(@tcp, @sockaddr)
+            end
+
+            def tcp_connect(callback)
+                ::Libuv::Ext.tcp_connect6(
+                  connect_req,
+                  @tcp,
+                  @sockaddr,
+                  callback
+                )
+            end
+        end
+    end
+end

data/lib/libuv/timer.rb

@@ -0,0 +1,75 @@
+module Libuv
+    class Timer < Handle
+        include Assertions
+
+
+        TIMEOUT_ERROR = "timeout must be an Integer".freeze
+        REPEAT_ERROR = "repeat must be an Integer".freeze
+
+
+        def initialize(loop, callback = nil)
+            @loop, @callback = loop, callback
+            
+            timer_ptr = ::Libuv::Ext.create_handle(:uv_timer)
+            error = check_result(::Libuv::Ext.timer_init(loop.handle, timer_ptr))
+
+            super(timer_ptr, error)
+        end
+
+        def start(timeout, repeat = 0)
+            return if @closed
+            
+            assert_type(Integer, timeout, TIMEOUT_ERROR)
+            assert_type(Integer, repeat, REPEAT_ERROR)
+
+            error = check_result ::Libuv::Ext.timer_start(handle, callback(:on_timer), timeout, repeat)
+            reject(error) if error
+        end
+
+        def stop
+            return if @closed
+            error = check_result ::Libuv::Ext.timer_stop(handle)
+            reject(error) if error
+        end
+
+        def again
+            return if @closed
+            error = check_result ::Libuv::Ext.timer_again(handle)
+            reject(error) if error
+        end
+
+        def repeat=(repeat)
+            return if @closed
+            assert_type(Integer, repeat, REPEAT_ERROR)
+            check_result ::Libuv::Ext.timer_set_repeat(handle, repeat)
+            reject(error) if error
+        end
+
+        def repeat
+            return if @closed
+            ::Libuv::Ext.timer_get_repeat(handle)
+        end
+
+        def progress(callback = nil, &blk)
+            @callback = callback || blk
+        end
+
+
+        private
+
+
+        def on_timer(handle, status)
+            e = check_result(status)
+
+            if e
+                reject(e)
+            else
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @loop.log :error, :timer_cb, e
+                end
+            end
+        end
+    end
+end