mt-libuv 4.1.0

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

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    module Stream
+
+
+        def self.included(base)
+            base.define_callback function: :on_listen,      params: [:pointer, :int]
+            base.define_callback function: :write_complete, params: [:pointer, :int]
+            base.define_callback function: :on_shutdown,    params: [:pointer, :int]
+
+            base.define_callback function: :on_allocate, params: [:pointer, :size_t, Ext::UvBuf.by_ref]
+            base.define_callback function: :on_read,     params: [:pointer, :ssize_t, Ext::UvBuf.by_ref]
+        end
+
+
+
+        BACKLOG_ERROR = "backlog must be an Integer"
+        WRITE_ERROR = "data must be a String"
+        STREAM_CLOSED_ERROR = "unable to write to a closed stream"
+        CLOSED_HANDLE_ERROR = "handle closed before accept called"
+
+
+        def listen(backlog)
+            return self if @closed
+            assert_type(Integer, backlog, BACKLOG_ERROR)
+            error = check_result ::MTLibuv::Ext.listen(handle, Integer(backlog), callback(:on_listen))
+            reject(error) if error
+            self
+        end
+
+        # Starts reading from the handle
+        def start_read
+            return self if @closed
+            error = check_result ::MTLibuv::Ext.read_start(handle, callback(:on_allocate), callback(:on_read))
+            reject(error) if error
+            self
+        end
+
+        # Stops reading from the handle
+        def stop_read
+            return self if @closed
+            error = check_result ::MTLibuv::Ext.read_stop(handle)
+            reject(error) if error
+            self
+        end
+        alias_method :close_read, :stop_read
+
+        # Shutsdown the writes on the handle waiting until the last write is complete before triggering the callback
+        def shutdown
+            return self if @closed
+            req = ::MTLibuv::Ext.allocate_request_shutdown
+            error = check_result ::MTLibuv::Ext.shutdown(req, handle, callback(:on_shutdown, req.address))
+            reject(error) if error
+            self
+        end
+
+        def try_write(data)
+            assert_type(String, data, WRITE_ERROR)
+
+            buffer1 = ::FFI::MemoryPointer.from_string(data)
+            buffer  = ::MTLibuv::Ext.buf_init(buffer1, data.respond_to?(:bytesize) ? data.bytesize : data.size)
+
+            result = ::MTLibuv::Ext.try_write(handle, buffer, 1)
+            buffer1.free
+
+            error = check_result result
+            raise error if error
+            return result
+        end
+
+        def write(data, wait: false)
+            # NOTE:: Similar to udp.rb -> send
+            deferred = @reactor.defer
+            if !@closed
+                begin
+                    assert_type(String, data, WRITE_ERROR)
+
+                    buffer1 = ::FFI::MemoryPointer.from_string(data)
+                    buffer  = ::MTLibuv::Ext.buf_init(buffer1, data.bytesize)
+
+                    # local as this variable will be available until the handle is closed
+                    @write_callbacks ||= {}
+                    req = ::MTLibuv::Ext.allocate_request_write
+                    @write_callbacks[req.address] = [deferred, buffer1]
+                    error = check_result ::MTLibuv::Ext.write(req, handle, buffer, 1, callback(:write_complete, req.address))
+
+                    if error
+                        @write_callbacks.delete req.address
+                        cleanup_callbacks req.address
+
+                        ::MTLibuv::Ext.free(req)
+                        buffer1.free
+                        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
+
+            if wait
+                return deferred.promise if wait == :promise
+                deferred.promise.value
+            end
+
+            self
+        end
+        alias_method :puts, :write
+        alias_method :write_nonblock, :write
+
+        def readable?
+            return false if @closed
+            ::MTLibuv::Ext.is_readable(handle) > 0
+        end
+
+        def writable?
+            return false if @closed
+            ::MTLibuv::Ext.is_writable(handle) > 0
+        end
+
+        def progress(&blk)
+            @progress = blk
+            self
+        end
+
+        # Very basic IO emulation, in no way trying to be exact
+        def read(maxlen = nil, outbuf = nil)
+            raise ::EOFError.new('socket closed') if @closed
+            @read_defer = @reactor.defer
+
+            if @read_buffer.nil?
+                start_read
+                @read_buffer = String.new
+                self.finally do
+                    @read_defer.reject(::EOFError.new('socket closed'))
+                end
+            end
+
+            if check_read_buffer(maxlen, outbuf, @read_defer)
+                progress do |data|
+                    @read_buffer << data
+                    check_read_buffer(maxlen, outbuf, @read_defer)
+                end
+            end
+
+            @read_defer.promise.value
+        end
+        alias_method :read_nonblock, :read
+
+        # These are here purely for compatibility with rack hijack IO
+        def close_write; end
+        def flush
+            raise ::EOFError.new('socket closed') if @closed
+
+            @flush_defer = @reactor.defer
+            check_flush_buffer
+            @flush_defer.promise.value
+        end
+
+
+        private
+
+
+        def check_read_buffer(maxlen, outbuf, defer)
+            if maxlen && @read_buffer.bytesize >= maxlen
+                if outbuf
+                    outbuf << @read_buffer[0...maxlen]
+                    defer.resolve outbuf
+                else
+                    defer.resolve @read_buffer[0...maxlen]
+                end
+                @read_buffer = @read_buffer[maxlen..-1]
+                progress do |data|
+                    @read_buffer << data
+                end
+                false
+            elsif maxlen.nil?
+                defer.resolve @read_buffer
+                @read_buffer = String.new
+                progress do |data|
+                    @read_buffer << data
+                end
+                false
+            else
+                true
+            end
+        end
+
+        def check_flush_buffer
+            if @flush_defer && (@write_callbacks.nil? || @write_callbacks.empty?) && (@pending_writes.nil? || @pending_writes.empty?) && @pending_write.nil?
+                @flush_defer.resolve(nil)
+                @flush_defer = nil
+            end
+        end
+
+
+        def on_listen(server, status)
+            e = check_result(status)
+
+            @reactor.exec do
+                if e
+                    reject(e)   # is this cause for closing the handle?
+                else
+                    begin
+                        @on_listen.call(self)
+                    rescue Exception => e
+                        @reactor.log e, 'performing stream listening callback'
+                    end
+                end
+            end
+        end
+
+        def on_allocate(client, suggested_size, buffer)
+            buffer[:len] = suggested_size
+            buffer[:base] = ::MTLibuv::Ext.malloc(suggested_size)
+        end
+
+        def write_complete(req, status)
+            deferred, buffer1 = @write_callbacks.delete req.address
+            cleanup_callbacks req.address
+
+            ::MTLibuv::Ext.free(req)
+            buffer1.free
+
+            @reactor.exec do
+                resolve deferred, status
+                check_flush_buffer if @flush_defer
+            end
+        end
+
+        def on_read(handle, nread, buf)
+            e = check_result(nread)
+            base = buf[:base]
+
+            if e
+                ::MTLibuv::Ext.free(base)
+
+                @reactor.exec do
+                    # I assume this is desirable behaviour
+                    if e.is_a? ::MTLibuv::Error::EOF
+                        close   # Close gracefully 
+                    else
+                        reject(e)
+                    end
+                end
+            else
+                data = base.read_string(nread)
+                ::MTLibuv::Ext.free(base)
+                
+                @reactor.exec do
+                    if @tls.nil?
+                        begin
+                            @progress.call data, self
+                        rescue Exception => e
+                            @reactor.log e, 'performing stream read callback'
+                        end
+                    else
+                        @tls.decrypt(data)
+                    end
+                end
+            end
+        end
+
+        def on_shutdown(req, status)
+            cleanup_callbacks(req.address)
+            ::MTLibuv::Ext.free(req)
+            @close_error = check_result(status)
+
+            @reactor.exec { close }
+        end
+    end
+end

data/lib/mt-libuv/pipe.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Pipe < Handle
+        include Stream
+
+
+        define_callback function: :on_connect, params: [:pointer, :int]
+        define_callback function: :write2_complete, params: [:pointer, :int]
+
+
+        WRITE2_ERROR = "data must be a String"
+
+
+        def initialize(reactor, ipc, acceptor = nil)
+            @reactor, @ipc = reactor, ipc
+
+            pipe_ptr = ::MTLibuv::Ext.allocate_handle_pipe
+            error = check_result(::MTLibuv::Ext.pipe_init(reactor.handle, pipe_ptr, ipc ? 1 : 0))
+            error = check_result(::MTLibuv::Ext.accept(acceptor, pipe_ptr)) if acceptor && error.nil?
+            
+            super(pipe_ptr, error)
+        end
+
+        def bind(name, &callback)
+            return if @closed
+            @on_accept = callback
+            @on_listen = proc { accept }
+
+            assert_type(String, name, "name must be a String")
+            name = windows_path name if FFI::Platform.windows?
+
+            error = check_result ::MTLibuv::Ext.pipe_bind(handle, name)
+            reject(error) if error
+
+            self
+        end
+
+        def open(fileno)
+            assert_type(Integer, fileno, 'fileno must be an integer file descriptor')
+
+            begin
+                raise RuntimeError, CLOSED_HANDLE_ERROR if @closed
+                check_result! ::MTLibuv::Ext.pipe_open(handle, fileno)
+
+                # Emulate on_connect behavior
+                if block_given?
+                    begin
+                        yield(self)
+                    rescue Exception => e
+                        @reactor.log e, 'performing pipe connect callback'
+                    end
+                end
+            rescue Exception => e
+                reject(e)
+                raise e unless block_given?
+            end
+
+            self
+        end
+
+        def connect(name)
+            return if @closed
+            assert_type(String, name, "name must be a String")
+
+            begin
+                name = windows_path name if FFI::Platform.windows?
+                req = ::MTLibuv::Ext.allocate_request_connect
+                ::MTLibuv::Ext.pipe_connect(req, handle, name, callback(:on_connect, req.address))
+            rescue Exception => e
+                reject(e)
+            end
+
+            if block_given?
+                @callback = Proc.new
+            else
+                @coroutine = @reactor.defer
+                @coroutine.promise.value
+            end
+
+            self
+        end
+
+        def write2(fd, data = ".", wait: false)
+            deferred = @reactor.defer
+            if @ipc && !@closed
+                begin
+                    assert_type(String, data, WRITE_ERROR)
+                    assert_type(Handle, fd, WRITE2_ERROR)
+
+                    size         = data.respond_to?(:bytesize) ? data.bytesize : data.size
+                    buffer       = ::MTLibuv::Ext.buf_init(FFI::MemoryPointer.from_string(data), size)
+
+                    # local as this variable will be avaliable until the handle is closed
+                    req = ::MTLibuv::Ext.allocate_request_write
+                    @write_callbacks ||= {}
+                    @write_callbacks[req.address] = deferred
+                    error = check_result ::MTLibuv::Ext.write2(req, handle, buffer, 1, fd.handle, callback(:write2_complete, req.address))
+
+                    if error
+                        @write_callbacks.delete(req.address)
+                        ::MTLibuv::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(TypeError.new('pipe not initialized for interprocess communication'))
+            end
+            
+            if wait
+                return deferred.promise if wait == :promise
+                deferred.promise.value
+            end
+
+            self
+        end
+
+        # Windows only
+        def pending_instances=(count)
+            return 0 if @closed
+            assert_type(Integer, count, "count must be an Integer")
+            ::MTLibuv::Ext.pipe_pending_instances(handle, count)
+        end
+
+        def check_pending(expecting = nil)
+            return nil if ::MTLibuv::Ext.pipe_pending_count(handle) <= 0
+
+            pending = ::MTLibuv::Ext.pipe_pending_type(handle).to_sym
+            raise TypeError, "IPC expecting #{expecting} and received #{pending}" if expecting && expecting.to_sym != pending
+
+            # Hide the accept logic
+            remote = nil
+            case pending
+            when :tcp
+                remote = TCP.new(reactor, handle)
+            when :pipe
+                remote = Pipe.new(reactor, @ipc, handle)
+            else
+                raise NotImplementedError, "IPC for handle #{pending} not supported"
+            end
+            remote
+        end
+
+        def getsockname
+            size = 256
+            len = FFI::MemoryPointer.new(:size_t)
+            len.put_int(0, size)
+            buffer = FFI::MemoryPointer.new(size)
+            check_result! ::MTLibuv::Ext.pipe_getsockname(handle, buffer, len)
+            buffer.read_string
+        end
+
+
+        private
+        
+
+        def accept
+            pipe = nil
+            begin
+                raise RuntimeError, CLOSED_HANDLE_ERROR if @closed
+                pipe = Pipe.new(reactor, @ipc, handle)
+            rescue Exception => e
+                @reactor.log e, 'pipe accept failed'
+            end
+            if pipe
+                @reactor.exec do
+                    begin
+                        @on_accept.call(pipe)
+                    rescue Exception => e
+                        @reactor.log e, 'performing pipe accept callback'
+                    end
+                end
+            end
+        end
+
+        def on_connect(req, status)
+            cleanup_callbacks req.address
+            ::MTLibuv::Ext.free(req)
+            e = check_result(status)
+
+            @reactor.exec do
+                if e
+                    reject(e)
+                else
+                    begin
+                        @callback.call(self)
+                    rescue Exception => e
+                        @reactor.log e, 'performing pipe connected callback'
+                    end
+                end
+            end
+        end
+
+        def write2_complete(req, status)
+            promise = @write_callbacks.delete(req.address)
+            cleanup_callbacks req.address
+
+            ::MTLibuv::Ext.free(req)
+            
+            @reactor.exec do
+                resolve promise, status
+            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

data/lib/mt-libuv/prepare.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Prepare < Handle
+
+
+        define_callback function: :on_prepare
+
+
+        # @param reactor [::MTLibuv::Reactor] reactor this prepare handle will be associated
+        # @param callback [Proc] callback to be called on reactor preparation
+        def initialize(reactor)
+            @reactor = reactor
+
+            prepare_ptr = ::MTLibuv::Ext.allocate_handle_prepare
+            error = check_result(::MTLibuv::Ext.prepare_init(reactor.handle, prepare_ptr))
+
+            super(prepare_ptr, error)
+        end
+
+        # Enables the prepare handler.
+        def start
+            return if @closed
+            error = check_result ::MTLibuv::Ext.prepare_start(handle, callback(:on_prepare))
+            reject(error) if error
+            self
+        end
+
+        # Disables the prepare handler.
+        def stop
+            return if @closed
+            error = check_result ::MTLibuv::Ext.prepare_stop(handle)
+            reject(error) if error
+            self
+        end
+
+        # Used to update the callback that will be triggered on reactor prepare
+        #
+        # @param callback [Proc] the callback to be called on reactor prepare
+        def progress(&callback)
+            @callback = callback
+            self
+        end
+
+
+        private
+
+
+        def on_prepare(handle)
+            @reactor.exec do
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @reactor.log e, 'performing prepare callback'
+                end
+            end
+        end
+    end
+end