mt-libuv 4.1.0

data/lib/mt-libuv/handle.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Handle < Q::DeferredPromise
+        include Assertions, Resource, Listener
+
+
+        attr_accessor :storage  # A place for general storage
+        attr_reader :closed
+        attr_reader :reactor
+
+
+        define_callback function: :on_close
+
+
+        def initialize(pointer, error)
+            @pointer = pointer
+            @instance_id = @pointer.address
+
+            # Initialise the promise
+            super(reactor, reactor.defer)
+
+            # clean up on init error (always raise here)
+            if error
+                ::MTLibuv::Ext.free(pointer)
+                defer.reject(error)
+                @closed = true
+                raise error
+            end
+        end
+
+        # Public: Increment internal ref counter for the handle on the reactor. Useful for
+        # extending the reactor with custom watchers that need to make reactor not stop
+        # 
+        # Returns self
+        def ref
+            return self if @closed
+            ::MTLibuv::Ext.ref(handle)
+            self
+        end
+
+        # Public: Decrement internal ref counter for the handle on the reactor, useful to stop
+        # reactor even when there are outstanding open handles
+        # 
+        # Returns self
+        def unref
+            return self if @closed
+            ::MTLibuv::Ext.unref(handle)
+            self
+        end
+
+        def close
+            return self if @closed
+            @closed = true
+            ::MTLibuv::Ext.close(handle, callback(:on_close))
+            self
+        end
+
+        def closed?
+            !!@closed
+        end
+
+        def active?
+            ::MTLibuv::Ext.is_active(handle) > 0
+        end
+
+        def closing?
+            ::MTLibuv::Ext.is_closing(handle) > 0
+        end
+
+
+        protected
+
+
+        def handle; @pointer; end
+        def defer; @defer; end
+        def instance_id; @instance_id; end
+
+
+        private
+
+
+        # Clean up and throw an error
+        def reject(reason)
+            @close_error = reason
+            close
+        end
+
+        def on_close(pointer)
+            ::MTLibuv::Ext.free(pointer)
+            #clear_callbacks
+            cleanup_callbacks
+
+            @reactor.exec do
+                if @close_error
+                    defer.reject(@close_error)
+                else
+                    defer.resolve(nil)
+                end
+
+                if @coroutine
+                    @coroutine.resolve(self)
+                    @coroutine = nil
+                end
+            end
+        end
+    end
+end

data/lib/mt-libuv/idle.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Idle < Handle
+
+
+        define_callback function: :on_idle
+
+
+        # @param reactor [::MTLibuv::Reactor] reactor this idle handler will be associated
+        # @param callback [Proc] callback to be called when the reactor is idle
+        def initialize(reactor)
+            @reactor = reactor
+
+            idle_ptr = ::MTLibuv::Ext.allocate_handle_idle
+            error = check_result(::MTLibuv::Ext.idle_init(reactor.handle, idle_ptr))
+
+            super(idle_ptr, error)
+        end
+
+        # Enables the idle handler.
+        def start
+            return if @closed
+            error = check_result ::MTLibuv::Ext.idle_start(handle, callback(:on_idle))
+            reject(error) if error
+            self
+        end
+
+        # Disables the idle handler.
+        def stop
+            return if @closed
+            error = check_result ::MTLibuv::Ext.idle_stop(handle)
+            reject(error) if error
+            self
+        end
+
+        # Used to update the callback that will be triggered on idle
+        #
+        # @param callback [Proc] the callback to be called on idle trigger
+        def progress(&callback)
+            @callback = callback
+            self
+        end
+
+
+        private
+
+
+        def on_idle(handle)
+            @reactor.exec do
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @reactor.log e, 'performing idle callback'
+                end
+            end
+        end
+    end
+end

data/lib/mt-libuv/mixins/accessors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    module Accessors
+        def reactor
+            thread = MTLibuv::Reactor.current
+            if thread.nil?
+                thread = MTLibuv::Reactor.default
+                if thread.reactor_running?
+                    raise 'No reactor available on this thread'
+                end
+            end
+            thread.run { yield(thread) } if block_given?
+            thread
+        end
+
+        Functions = [
+            :defer, :all, :any, :finally, :update_time, :now, :lookup_error, :tcp,
+            :udp, :tty, :pipe, :timer, :prepare, :check, :idle, :async, :signal,
+            :work, :lookup, :fs_event, :file, :filesystem, :schedule, :next_tick,
+            :stop, :reactor_thread?, :reactor_running?, :run
+        ].freeze
+
+        Functions.each do |function|
+            define_method function do |*args|
+                thread = MTLibuv::Reactor.current
+
+                if thread
+                    thread.send(function, *args)
+                else
+                    thread = MTLibuv::Reactor.default
+                    if thread.reactor_running?
+                        raise 'attempted MTLibuv::Reactor access on non-reactor thread'
+                    else
+                       thread.send(function, *args) 
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/mt-libuv/mixins/assertions.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    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/mt-libuv/mixins/fs_checks.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    module FsChecks
+
+
+        module ClassMethods
+            def fs_lookup(ref)
+                ref.to_ptr.address
+            end
+        end
+
+        def self.included(base)
+            base.extend(ClassMethods)
+        end
+
+
+        def stat(wait: true)
+            @stat_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @stat_deferred, request, ::MTLibuv::Ext.fs_fstat(@reactor.handle, request, @fileno, callback(:on_stat, request.address))
+            promise = @stat_deferred.promise
+
+            wait ? promise.value : promise
+        end
+
+
+        protected
+
+
+        def respond(wait, promise)
+            if wait
+                promise.value
+                self
+            else
+                promise
+            end
+        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)
+                @reactor.exec { @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
+                ::MTLibuv::Ext.free(request)
+                deferrable.reject(error)
+            end
+            deferrable.promise
+        end
+
+        def cleanup(req)
+            cleanup_callbacks req.to_ptr.address
+
+            ::MTLibuv::Ext.fs_req_cleanup(req)
+            ::MTLibuv::Ext.free(req)
+        end
+
+        def post_check(req, deferrable)
+            error = check_result(req[:result])
+            if error
+                cleanup(req)
+
+                @reactor.exec do
+                    deferrable.reject(error)
+                    if @coroutine
+                        @coroutine.resolve(deferrable.promise)
+                        @coroutine = nil
+                    end
+                end
+                false
+            else
+                true
+            end
+        end
+    end
+end

data/lib/mt-libuv/mixins/listener.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module MTLibuv
+    module Listener
+
+
+        private
+
+
+        module ClassMethods
+            def dispatch_callback(func_name, lookup, args)
+                instance_id = __send__(lookup, *args)
+                inst = @callback_lookup[instance_id]
+                inst.__send__(func_name, *args)
+            end
+
+            def define_callback(function:, params: [:pointer], ret_val: :void, lookup: :default_lookup)
+                @callback_funcs[function] = ::FFI::Function.new(ret_val, params) do |*args|
+                    dispatch_callback(function, lookup, args)
+                end
+            end
+
+            # Much like include to support inheritance properly
+            # We keep existing callbacks and inherit the lookup (as this will never clash)
+            def inherited(subclass)
+                subclass.instance_variable_set(:@callback_funcs, {}.merge(@callback_funcs))
+                subclass.instance_variable_set(:@callback_lookup, @callback_lookup)
+                subclass.instance_variable_set(:@callback_lock, @callback_lock)
+            end
+
+
+            # Provide accessor methods to the class level instance variables
+            attr_reader :callback_lookup, :callback_funcs, :callback_lock
+
+
+            # This function is used to work out the instance the callback is for
+            def default_lookup(req, *args)
+                req.address
+            end
+        end
+
+        def self.included(base)
+            base.instance_variable_set(:@callback_funcs, {})
+            base.instance_variable_set(:@callback_lookup, ::Concurrent::Hash.new)
+            base.instance_variable_set(:@callback_lock, ::Mutex.new)
+            base.extend(ClassMethods)
+        end
+
+
+
+        def callback(name, instance_id = @instance_id)
+            klass = self.class
+            klass.callback_lock.synchronize do
+                klass.callback_lookup[instance_id] = self
+            end
+            klass.callback_funcs[name]
+        end
+
+        def cleanup_callbacks(instance_id = @instance_id)
+            klass = self.class
+            klass.callback_lock.synchronize do
+                inst = klass.callback_lookup[instance_id]
+                klass.callback_lookup.delete(instance_id) if inst == self
+            end
+        end
+    end
+end

data/lib/mt-libuv/mixins/net.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module MTLibuv
+    module Net
+
+
+        IP_ARGUMENT_ERROR = "ip must be a String"                # Arguments specifying an IP address
+        PORT_ARGUMENT_ERROR = "port must be an Integer"          # Arguments specifying an IP port
+        INET_ADDRSTRLEN = 16
+        INET6_ADDRSTRLEN = 46
+
+
+        private
+
+
+        def get_sockaddr_and_len
+            sockaddr = FFI::MemoryPointer.new(::MTLibuv::Ext::Sockaddr)
+            len = FFI::MemoryPointer.new(:int)
+            len.put_int(0, ::MTLibuv::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 = ::MTLibuv::Ext::SockaddrIn6.new(sockaddr.pointer)
+                ip_ptr = FFI::MemoryPointer.new(:char, len)
+                ::MTLibuv::Ext.ip6_name(sockaddr_in6, ip_ptr, len)
+                port = ::MTLibuv::Ext.ntohs(sockaddr_in6[:sin6_port])
+            else
+                len ||= INET_ADDRSTRLEN
+                sockaddr_in = ::MTLibuv::Ext::SockaddrIn.new(sockaddr.pointer)
+                ip_ptr = FFI::MemoryPointer.new(:char, len)
+                ::MTLibuv::Ext.ip4_name(sockaddr_in, ip_ptr, len)
+                port = ::MTLibuv::Ext.ntohs(sockaddr_in[:sin_port])
+            end
+            [ip_ptr.read_string, port]
+        end
+    end
+end

data/lib/mt-libuv/mixins/resource.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    module Resource
+
+
+        def resolve(deferred, rc)
+            if rc && rc < 0
+                deferred.reject(@reactor.lookup_error(rc))
+            else
+                deferred.resolve(nil)
+            end
+        end
+
+        def check_result!(rc)
+            e = @reactor.lookup_error(rc) unless rc.nil? || rc >= 0
+            raise e if e
+        end
+
+        def check_result(rc)
+            @reactor.lookup_error(rc) unless rc.nil? || rc >= 0
+        end
+
+        def to_ptr
+            @pointer
+        end
+
+
+    end
+end