libuv 0.10.0

data/lib/libuv/tty.rb

@@ -0,0 +1,34 @@
+module Libuv
+    class TTY < Handle
+        include Stream
+
+
+        def initialize(loop, fileno, readable)
+            @loop = loop
+
+            tty_ptr = ::Libuv::Ext.create_handle(:uv_tty)
+            error = check_result(::Libuv::Ext.tty_init(loop.handle, tty_ptr, fileno, readable ? 1 : 0))
+            
+            super(tty_ptr, error)
+        end
+
+        def enable_raw_mode
+            check_result ::Libuv::Ext.tty_set_mode(handle, 1)
+        end
+
+        def disable_raw_mode
+            check_result ::Libuv::Ext.tty_set_mode(handle, 0)
+        end
+
+        def reset_mode
+            ::Libuv::Ext.tty_reset_mode
+        end
+
+        def winsize
+            width = FFI::MemoryPointer.new(:int)
+            height = FFI::MemoryPointer.new(:int)
+            ::Libuv::Ext.tty_get_winsize(handle, width, height)
+            [width.get_int(0), height.get_int(0)]
+        end
+    end
+end

data/lib/libuv/udp.rb

@@ -0,0 +1,256 @@
+module Libuv
+    class UDP < Handle
+        include Net
+
+
+        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
+        INTERFACE_ARGUMENT_ERROR = "interface_address must be a String".freeze
+
+
+        def initialize(loop)
+            @loop = loop
+
+            udp_ptr = ::Libuv::Ext.create_handle(:uv_udp)
+            error = check_result(::Libuv::Ext.udp_init(loop.handle, udp_ptr))
+
+            super(udp_ptr, error)
+        end
+
+        def bind(ip, port, ipv6_only = false)
+            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
+        end
+
+        def sockname
+            sockaddr, len = get_sockaddr_and_len
+            check_result! ::Libuv::Ext.udp_getsockname(handle, sockaddr, len)
+            get_ip_and_port(UV::Sockaddr.new(sockaddr), len.get_int(0))
+        end
+
+        def join(multicast_address, interface_address)
+            assert_type(String, multicast_address, MULTICAST_ARGUMENT_ERROR)
+            assert_type(String, interface_address, INTERFACE_ARGUMENT_ERROR)
+
+            error = check_result ::Libuv::Ext.udp_set_membership(handle, multicast_address, interface_address, :uv_join_group)
+            reject(error) if error
+        end
+
+        def leave(multicast_address, interface_address)
+            assert_type(String, multicast_address, MULTICAST_ARGUMENT_ERROR)
+            assert_type(String, interface_address, INTERFACE_ARGUMENT_ERROR)
+
+            error = check_result ::Libuv::Ext.udp_set_membership(handle, multicast_address, interface_address, :uv_leave_group)
+            reject(error) if error
+        end
+
+        def start_recv
+            error = check_result ::Libuv::Ext.udp_recv_start(handle, callback(:on_allocate), callback(:on_recv))
+            reject(error) if error
+        end
+
+        def stop_recv
+            error = check_result ::Libuv::Ext.udp_recv_stop(handle)
+            reject(error) if error
+        end
+
+        def send(ip, port, data)
+            deferred = @loop.defer
+            begin
+                assert_type(String, ip, IP_ARGUMENT_ERROR)
+                assert_type(Integer, port, PORT_ARGUMENT_ERROR)
+                assert_type(String, data, SEND_DATA_ERROR)
+
+                @udp_socket = create_socket(IPAddr.new(ip), port)
+
+                # local as this variable will be avaliable until the handle is closed
+                @sent_callbacks = @sent_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 sends are done in order
+                    promise = @sent_callbacks.shift[0]
+                    resolve promise, status
+                end
+
+                #
+                # Save the callback and return the promise
+                #
+                begin
+                    @sent_callbacks << [deferred, callback]
+                    @udp_socket.send(data, callback)
+                rescue Exception => e
+                    @sent_callbacks.pop
+                    deferred.reject(e)
+
+                    reject(e)       # close the handle
+                end
+            rescue Exception => e
+                deferred.reject(e)
+            end
+            deferred.promise
+        end
+
+        def enable_multicast_loop
+            error = check_result ::Libuv::Ext.udp_set_multicast_loop(handle, 1)
+            reject(error) if error
+        end
+
+        def disable_multicast_loop
+            error = check_result ::Libuv::Ext.udp_set_multicast_loop(handle, 0)
+            reject(error) if error
+        end
+
+        def multicast_ttl=(ttl)
+            assert_type(Integer, ttl, TTL_ARGUMENT_ERROR)
+            error = check_result ::Libuv::Ext.udp_set_multicast_ttl(handle, ttl)
+            reject(error) if error
+        end
+
+        def enable_broadcast
+            error = check_result ::Libuv::Ext.udp_set_broadcast(handle, 1)
+            reject(error) if error
+        end
+
+        def disable_broadcast
+            error = check_result ::Libuv::Ext.udp_set_broadcast(handle, 0)
+            reject(error) if error
+        end
+
+        def ttl=(ttl)
+            assert_type(Integer, ttl, TTL_ARGUMENT_ERROR)
+            error = check_result ::Libuv::Ext.udp_set_ttl(handle, Integer(ttl))
+            reject(error) if error
+        end
+
+
+        private
+
+
+        def on_allocate(client, suggested_size)
+            ::Libuv::Ext.buf_init(::Libuv::Ext.malloc(suggested_size), suggested_size)
+        end
+
+        def on_recv(handle, nread, buf, sockaddr, flags)
+            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)
+                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
+                )
+            end
+        end
+    end
+end

data/lib/libuv/version.rb

@@ -0,0 +1,3 @@
+module Libuv
+    VERSION = '0.10.0'
+end

data/lib/libuv/work.rb

@@ -0,0 +1,62 @@
+module Libuv
+    class Work < Q::DeferredPromise
+        include Resource, Listener
+
+
+        def initialize(loop, work)
+            super(loop, loop.defer)
+
+            @work = work
+            @complete = false
+            @pointer = ::Libuv::Ext.create_request(:uv_work)
+            @error = nil    # error in callback
+
+            error = check_result ::Libuv::Ext.queue_work(@loop, @pointer, callback(:on_work), callback(:on_complete))
+            if error
+                ::Libuv::Ext.free(@pointer)
+                @complete = true
+                @defer.reject(error)
+            end
+        end
+
+        # Attempt to cancel the pending work. Returns true if the work has completed or was canceled.
+        #
+        # @return [true, false]
+        def cancel
+            if not @complete
+                @complete = ::Libuv::Ext.cancel(@pointer) >= 0
+            end
+            @complete
+        end
+
+        # Indicates is the work has completed yet or not.
+        #
+        # @return [true, false]
+        def completed?
+            return @complete
+        end
+
+
+        private
+
+
+        def on_complete(req, status)
+            @complete = true
+            ::Libuv::Ext.free(req)
+
+            if @error
+                @defer.reject(@error)
+            else
+                resolve @defer, status
+            end
+        end
+
+        def on_work(req)
+            begin
+                @work.call
+            rescue Exception => e
+                @error = e   # Catch errors for promise resolution
+            end
+        end
+    end
+end

data/libuv.gemspec

@@ -0,0 +1,54 @@
+require File.expand_path("../lib/libuv/version", __FILE__)
+
+Gem::Specification.new do |gem|
+    gem.name          = "libuv"
+    gem.version       = Libuv::VERSION
+    gem.license       = 'MIT'
+    gem.authors       = ["Bulat Shakirzyanov", "Stephen von Takach"]
+    gem.email         = ["mallluhuct@gmail.com", "steve@cotag.me"]
+    gem.homepage      = "https://github.com/cotag/libuv"
+    gem.summary       = "libuv bindings for Ruby"
+    gem.description   = "An opinionated wrapper around libuv for Ruby"
+
+    gem.extensions << "ext/Rakefile"
+
+    gem.required_ruby_version = '>= 1.9.2'
+    gem.require_paths = ["lib"]
+
+    gem.add_runtime_dependency     'ffi', '>= 1.9'
+    gem.add_runtime_dependency     'thread_safe'
+    gem.add_development_dependency 'rspec', '>= 2.14'
+    gem.add_development_dependency 'rake', '>= 10.1'
+    gem.add_development_dependency 'yard'
+
+    gem.files         = `git ls-files`.split("\n")
+    gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+    # Add the submodule to the gem
+    relative_path = File.expand_path("../", __FILE__) + '/'
+    `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
+
+        if (ENV['OS'] == 'Windows_NT') && submodule_path[0] == '/'
+            # Detect if cygwin path is being used by git
+            submodule_path = submodule_path[1..-1]
+            submodule_path.insert(1, ':')
+        end
+
+        # for each submodule, change working directory to that submodule
+        Dir.chdir(submodule_path) do
+            # Make the submodule path relative
+            submodule_path = submodule_path.gsub(/#{relative_path}/i, '')
+       
+            # issue git ls-files in submodule's directory
+            submodule_files = `git ls-files`.split($\)
+       
+            # prepend the submodule path to create relative file paths
+            submodule_files_paths = submodule_files.map do |filename|
+                File.join(submodule_path, filename)
+            end
+       
+            # add relative paths to gem.files
+            gem.files += submodule_files_paths
+        end
+    end
+end

data/spec/async_spec.rb

@@ -0,0 +1,60 @@
+require 'libuv'
+
+
+describe Libuv::Async do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@loop = Libuv::Loop.new
+		@call = @loop.pipe
+		@timeout = @loop.timer do
+			@loop.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@loop.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+			p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+		end
+	end
+	
+	it "Should call the async function from the thread pool stopping the counter" 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"
+				rescue Exception
+					p 'error in logger'
+				end
+			end
+
+			@count = 0
+
+			timer = @loop.timer do
+				@count += 1
+			end
+			timer.start(0, 200)
+
+			callback = @loop.async do
+				stopper = @loop.timer do
+					timer.close
+					callback.close
+					stopper.close
+					@loop.stop
+				end
+				stopper.start(1000)
+			end
+
+			@loop.work(proc {
+				callback.call
+			}).catch do |err|
+				@general_failure << err
+			end
+		}
+
+		@general_failure.should == []
+		(@count < 7 && @count > 3).should == true
+	end
+end