libuv 0.10.0

data/lib/libuv/idle.rb

@@ -0,0 +1,49 @@
+module Libuv
+    class Idle < Handle
+
+
+        def initialize(loop, callback = nil, &blk)
+            @loop = loop
+            @callback = callback || blk
+
+            idle_ptr = ::Libuv::Ext.create_handle(:uv_idle)
+            error = check_result(::Libuv::Ext.idle_init(loop.handle, idle_ptr))
+
+            super(idle_ptr, error)
+        end
+
+        def start
+            return if @closed
+            error = check_result ::Libuv::Ext.idle_start(handle, callback(:on_idle))
+            reject(error) if error
+        end
+
+        def stop
+            return if @closed
+            error = check_result ::Libuv::Ext.idle_stop(handle)
+            reject(error) if error
+        end
+
+        def progress(callback = nil, &blk)
+            @callback = callback || blk
+        end
+
+
+        private
+
+
+        def on_idle(handle, status)
+            e = check_result(status)
+
+            if e
+                reject(e)
+            else
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @loop.log :error, :idle_cb, e
+                end
+            end
+        end
+    end
+end

data/lib/libuv/listener.rb

@@ -0,0 +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

data/lib/libuv/loop.rb

@@ -0,0 +1,310 @@
+require 'thread'
+
+module Libuv
+    class Loop
+        include Resource, Assertions
+
+
+        module ClassMethods
+            # Get default loop
+            # 
+            # @return [::Libuv::Loop]
+            def default
+                create(::Libuv::Ext.default_loop)
+            end
+
+            # Create new loop
+            # 
+            # @return [::Libuv::Loop]
+            def new
+                create(::Libuv::Ext.loop_new)
+            end
+
+            # Create custom loop from pointer
+            # 
+            # @return [::Libuv::Loop]
+            def create(pointer)
+                allocate.tap { |i| i.send(:initialize, FFI::AutoPointer.new(pointer, ::Libuv::Ext.method(:loop_delete))) }
+            end
+        end
+        extend ClassMethods
+
+
+        # Initialize a loop using an FFI::Pointer
+        # 
+        # @return [::Libuv::Loop]
+        def initialize(pointer) # :notnew:
+            @pointer = pointer
+            @loop = self
+
+            # Create an async call for scheduling work from other threads
+            @run_queue = Queue.new
+            @queue_proc = proc do
+                # Rubinius fix for promises
+                # Anything calling schedule will
+                # be delayed a tick outside of promise callbacks on rubinius (see https://github.com/ffi/ffi/issues/279)
+                #@reactor_thread = Thread.current # Should work in rubinius 2.0
+
+                # ensure we only execute what was required for this tick
+                length = @run_queue.length
+                length.times do
+                    begin
+                        run = @run_queue.pop true  # pop non-block
+                        run.call
+                    rescue Exception => e
+                        @loop.log :error, :next_tick_cb, e
+                    end
+                end
+            end
+            @process_queue = SimpleAsync.new(@loop, @queue_proc)
+
+            # Create a next tick timer
+            @next_tick = @loop.timer do
+                @next_tick_scheduled = false
+                @queue_proc.call
+            end
+
+            # Create an async call for ending the loop
+            @stop_loop = SimpleAsync.new @loop do
+                @process_queue.close
+                @stop_loop.close
+                @next_tick.close
+
+                ::Libuv::Ext.stop(@pointer)
+            end
+        end
+
+        def handle; @pointer; end
+
+        # Run the actual event loop. This method will block for the duration of event loop unless
+        # it is run inside an existing event loop, where a new thread will be created for it
+        #
+        # @param run_type [:UV_RUN_DEFAULT, :UV_RUN_ONCE, :UV_RUN_NOWAIT]
+        # @yieldparam promise [::Libuv::Loop] Yields a promise that can be used for logging unhandled
+        #   exceptions on the loop.
+        # @return [::Libuv::Q::Promise]
+        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
+            end
+
+            @loop
+        end
+
+
+        # Creates a deferred result object for where the result of an operation may only be returned 
+        # at some point in the future or is being processed on a different thread (thread safe)
+        #
+        # @return [::Libuv::Q::Deferred]
+        def defer
+            Q.defer(@loop)
+        end
+
+        # Combines multiple promises into a single promise that is resolved when all of the input
+        # promises are resolved. (thread safe)
+        #
+        # @param [*Promise] Promises a number of promises that will be combined into a single promise
+        # @return [Promise] Returns a single promise that will be resolved with an array of values,
+        #   each value corresponding to the promise at the same index in the `promises` array. If any of
+        #   the promises is resolved with a rejection, this resulting promise will be resolved with the
+        #   same rejection.
+        def all(*promises)
+            Q.all(@loop, *promises)
+        end
+
+        #
+        # Combines multiple promises into a single promise that is resolved when any of the input
+        # promises are resolved.
+        #
+        # @param [*Promise] Promises a number of promises that will be combined into a single promise
+        # @return [Promise] Returns a single promise
+        def any(*promises)
+            Q.any(@loop, *promises)
+        end
+
+        #
+        # Combines multiple promises into a single promise that is resolved when all of the input
+        # promises are resolved or rejected.
+        #
+        # @param [*Promise] Promises a number of promises that will be combined into a single promise
+        # @return [Promise] Returns a single promise that will be resolved with an array of values,
+        #   each [result, wasResolved] value pair corresponding to a at the same index in the `promises` array.
+        def finally(*promises)
+            Q.finally(@loop, *promises)
+        end
+        
+
+        # forces loop time update, useful for getting more granular times
+        # 
+        # @return nil
+        def update_time
+            ::Libuv::Ext.update_time(@pointer)
+        end
+
+        # Get current time in microseconds
+        # 
+        # @return [Fixnum]
+        def now
+            ::Libuv::Ext.now(@pointer)
+        end
+
+        # Lookup an error code and return is as an error object
+        #
+        # @param err [Integer] The error code to look up.
+        # @return [::Libuv::Error]
+        def lookup_error(err)
+            name = ::Libuv::Ext.err_name(err)
+            msg  = ::Libuv::Ext.strerror(err)
+
+            ::Libuv::Error.const_get(name.to_sym).new(msg)
+        rescue Exception => e
+            @loop.log :warn, :error_lookup_failed, e
+            ::Libuv::Error::UNKNOWN.new("error lookup failed for code #{err} #{name} #{msg}")
+        end
+
+        # Get a new TCP instance
+        # 
+        # @return [::Libuv::TCP]
+        def tcp
+            TCP.new(@loop)
+        end
+
+        # Get a new UDP instance
+        #
+        # @return [::Libuv::UDP]
+        def udp
+            UDP.new(@loop)
+        end
+
+        # Get a new TTY instance
+        # 
+        # @param fileno [Integer] Integer file descriptor of a tty device
+        # @param readable [true, false] Boolean indicating if TTY is readable
+        # @return [::Libuv::TTY]
+        def tty(fileno, readable = false)
+            assert_type(Integer, fileno, "io#fileno must return an integer file descriptor, #{fileno.inspect} given")
+
+            TTY.new(@loop, fileno, readable)
+        end
+
+        # Get a new Pipe instance
+        # 
+        # @param ipc [true, false]
+        #     indicate if a handle will be used for ipc, useful for sharing tcp socket between processes
+        # @return [::Libuv::Pipe]
+        def pipe(ipc = false)
+            Pipe.new(@loop, ipc)
+        end
+
+        # Get a new timer instance
+        # 
+        # @return [::Libuv::Timer]
+        def timer(callback = nil, &blk)
+            Timer.new(@loop, callback || blk)
+        end
+
+        # Get a new Prepare handle
+        # 
+        # @return [::Libuv::Prepare]
+        def prepare
+            Prepare.new(@loop)
+        end
+
+        # Get a new Check handle
+        # 
+        # @return [::Libuv::Check]
+        def check
+            Check.new(@loop)
+        end
+
+        # Get a new Idle handle
+        # 
+        # @return [::Libuv::Idle]
+        def idle(callback = nil, &block)
+            Idle.new(@loop, callback || block)
+        end
+
+        # Get a new Async handle
+        # 
+        # @return [::Libuv::Async]
+        def async(callback = nil, &block)
+            callback ||= block
+            handle = Async.new(@loop)
+            handle.progress callback if callback
+            handle
+        end
+
+        # Queue some work for processing in the libuv thread pool
+        #
+        # @return [::Libuv::Work]
+        # @raise [ArgumentError] if block is not given
+        def work(callback = nil, &block)
+            Work.new(@loop, callback || block)    # Work is a promise object
+        end
+
+        # Get a new FSEvent instance
+        # 
+        # @return [::Libuv::FSEvent]
+        def fs_event(path)
+            assert_type(String, path)
+            FSEvent.new(@loop, path)
+        end
+
+
+        # Schedule some work to be processed on the event loop (thread safe)
+        #
+        # @return [nil]
+        def schedule(&block)
+            assert_block(block)
+
+            if @reactor_thread == Thread.current
+                block.call
+            else
+                @run_queue << block
+                @process_queue.call
+            end
+        end
+
+        # Schedule some work to be processed in the next iteration of the event loop (thread safe)
+        #
+        # @return [nil]
+        def next_tick(&block)
+            assert_block(block)
+
+            @run_queue << block
+            if @reactor_thread == Thread.current
+                # Create a next tick timer
+                if not @next_tick_scheduled
+                    @next_tick.start(0)
+                    @next_tick_scheduled = true
+                end
+            else
+                @process_queue.call
+            end
+        end
+
+        # Notifies the loop there was an event that should be logged
+        #
+        # @param level [Symbol] the error level (info, warn, error etc)
+        # @param id [Object] some kind of identifying information
+        # @param *args [*args] any additional information
+        # @return [nil]
+        def log(level, id, *args)
+            @loop_notify.notify(level, id, *args)
+        end
+
+        # Closes handles opened by the loop class and completes the current loop iteration (thread safe)
+        # 
+        # @return [nil]
+        def stop
+            @stop_loop.call
+        end
+    end
+end

data/lib/libuv/net.rb

@@ -0,0 +1,38 @@
+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
+
+
+        private
+
+
+        def get_sockaddr_and_len
+            sockaddr = FFI::MemoryPointer.new(UV::Sockaddr)
+            len = FFI::MemoryPointer.new(:int)
+            len.put_int(0, UV::Sockaddr.size)
+            [sockaddr, len]
+        end
+
+        def get_ip_and_port(sockaddr, len=nil)
+            if sockaddr[:sa_family] == Socket::Constants::AF_INET6
+                len ||= Socket::Constants::INET6_ADDRSTRLEN
+                sockaddr_in6 = UV::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 ||= Socket::Constants::INET_ADDRSTRLEN
+                sockaddr_in = UV::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/pipe.rb

@@ -0,0 +1,97 @@
+module Libuv
+    class Pipe < Handle
+        include Stream
+
+
+        def initialize(loop, ipc, acceptor = nil)
+            @loop, @ipc = loop, ipc
+
+            pipe_ptr = ::Libuv::Ext.create_handle(:uv_pipe)
+            error = check_result(::Libuv::Ext.pipe_init(loop.handle, pipe_ptr, ipc ? 1 : 0))
+            error = check_result(::Libuv::Ext.accept(acceptor, pipe_ptr)) if acceptor && error.nil?
+            
+            super(pipe_ptr, error)
+        end
+
+        def bind(name, callback = nil, &blk)
+            @on_listen = callback || blk
+            assert_type(String, name, "name must be a String")
+            name = windows_path name if FFI::Platform.windows?
+
+            error = check_result ::Libuv::Ext.pipe_bind(handle, name)
+            reject(error) if error
+        end
+
+        def accept(callback = nil, &blk)
+            pipe = nil
+            begin
+                pipe = Pipe.new(loop, @ipc, handle)
+            rescue Exception => e
+                @loop.log :info, :pipe_accept_failed, e
+            end
+            if pipe
+                begin
+                    (callback || blk).call(pipe)
+                rescue Exception => e
+                    @loop.log :error, :pipe_accept_cb, e
+                end
+            end
+            nil
+        end
+
+        def open(fileno, callback = nil, &blk)
+            @callback = callback || blk
+            assert_type(Integer, fileno, "io#fileno must return an integer file descriptor")
+            begin
+                check_result! ::Libuv::Ext.pipe_open(handle, fileno)
+
+                # Emulate on_connect behavior
+                begin
+                    @callback.call(self)
+                rescue Exception => e
+                    @loop.log :error, :pipe_connect_cb, e
+                end
+            rescue Exception => e
+                reject(e)
+            end
+        end
+
+        def connect(name, callback = nil, &blk)
+            @callback = callback || blk
+            assert_type(String, name, "name must be a String")
+            begin
+                name = windows_path name if FFI::Platform.windows?
+                ::Libuv::Ext.pipe_connect(::Libuv::Ext.create_request(:uv_connect), handle, name, callback(:on_connect))
+            rescue Exception => e
+                reject(e)
+            end
+        end
+
+        # Windows only
+        def pending_instances=(count)
+            assert_type(Integer, count, "count must be an Integer")
+            ::Libuv::Ext.pipe_pending_instances(handle, count)
+        end
+
+
+        private
+
+
+        def on_connect(req, status)
+            ::Libuv::Ext.free(req)
+            begin
+                @callback.call(self)
+            rescue Exception => e
+                @loop.log :error, :pipe_connect_cb, e
+            end
+        end
+
+        def windows_path(name)
+            # test for \\\\.\\pipe
+            if not name =~ /(\/|\\){2}\.(\/|\\)pipe/i
+                name = ::File.join("\\\\.\\pipe", name)
+            end
+            name.gsub("/", "\\")
+        end
+    end
+end