mt-libuv 4.1.0

data/lib/mt-libuv/file.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class File < Q::DeferredPromise
+        include Assertions, Resource, Listener, FsChecks
+
+
+        fs_params = {
+            params: [Ext::FsRequest.by_ref],
+            lookup: :fs_lookup
+        }
+        define_callback function: :on_open, **fs_params
+        define_callback function: :on_close, **fs_params
+        define_callback function: :on_read, **fs_params
+        define_callback function: :on_write, **fs_params
+        define_callback function: :on_sync, **fs_params
+        define_callback function: :on_datasync, **fs_params
+        define_callback function: :on_truncate, **fs_params
+        define_callback function: :on_utime, **fs_params
+        define_callback function: :on_chmod, **fs_params
+        define_callback function: :on_chown, **fs_params
+        define_callback function: :on_stat, **fs_params
+
+
+        EOF = "0\r\n\r\n"
+        CRLF = "\r\n"
+
+
+        attr_reader :fileno, :closed
+
+
+        def initialize(thread, path, flags = 0, mode: 0)
+            super(thread, thread.defer)
+
+            @fileno = -1
+            @closed = true 
+            @path, @flags, @mode = path, flags, mode
+            @request_refs = {}
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @defer, request, ::MTLibuv::Ext.fs_open(@reactor, request, @path, @flags, @mode, callback(:on_open, request.address))
+
+            if block_given?
+                self.progress &Proc.new
+            else
+                @coroutine = @reactor.defer
+                @coroutine.promise.value
+            end
+        end
+
+        def close
+            @closed = true
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check(@defer, request, ::MTLibuv::Ext.fs_close(@reactor.handle, request, @fileno, callback(:on_close, request.address)))
+            self
+        end
+
+        def read(length, offset = 0, wait: true)
+            assert_type(Integer, length, "length must be an Integer")
+            assert_type(Integer, offset, "offset must be an Integer")
+            deferred = @reactor.defer
+
+            buffer1 = FFI::MemoryPointer.new(length)
+            buffer  = ::MTLibuv::Ext.buf_init(buffer1, length)
+            request = ::MTLibuv::Ext.allocate_request_fs
+
+            @request_refs[request.address] = [deferred, buffer1]
+
+            promise = pre_check(deferred, request, ::MTLibuv::Ext.fs_read(@reactor.handle, request, @fileno, buffer, 1, offset, callback(:on_read, request.address)))
+            wait ? promise.value : promise
+        end
+
+        def write(data, offset = 0, wait: true)
+            assert_type(String, data, "data must be a String")
+            assert_type(Integer, offset, "offset must be an Integer")
+            deferred = @reactor.defer
+
+            length = data.respond_to?(:bytesize) ? data.bytesize : data.size
+
+            buffer1 = FFI::MemoryPointer.from_string(data)
+            buffer  = ::MTLibuv::Ext.buf_init(buffer1, length)
+            request = ::MTLibuv::Ext.allocate_request_fs
+
+            @request_refs[request.address] = [deferred, buffer1]
+
+            respond wait, pre_check(deferred, request, ::MTLibuv::Ext.fs_write(@reactor.handle, request, @fileno, buffer, 1, offset, callback(:on_write, request.address)))
+        end
+
+        def sync(wait: false)
+            deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            @request_refs[request.address] = deferred
+
+            respond wait, pre_check(deferred, request, ::MTLibuv::Ext.fs_fsync(@reactor.handle, request, @fileno, callback(:on_sync, request.address)))
+        end
+
+        def datasync(wait: false)
+            deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            @request_refs[request.address] = deferred
+
+            respond wait, pre_check(deferred, request, ::MTLibuv::Ext.fs_fdatasync(@reactor.handle, request, @fileno, callback(:on_datasync, request.address)))
+        end
+
+        def truncate(offset, wait: true)
+            assert_type(Integer, offset, "offset must be an Integer")
+            deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            @request_refs[request.address] = deferred
+
+            respond wait, pre_check(deferred, request, ::MTLibuv::Ext.fs_ftruncate(@reactor.handle, request, @fileno, offset, callback(:on_truncate, request.address)))
+        end
+
+        def utime(atime:, mtime:, wait: true)
+            assert_type(Integer, atime, "atime must be an Integer")
+            assert_type(Integer, mtime, "mtime must be an Integer")
+            deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            @request_refs[request.address] = deferred
+
+            promise = pre_check deferred, request, ::MTLibuv::Ext.fs_futime(@reactor.handle, request, @fileno, atime, mtime, callback(:on_utime, request.address))
+            wait ? promise.value : promise
+        end
+
+        def chmod(mode, wait: true)
+            assert_type(Integer, mode, "mode must be an Integer")
+            deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            @request_refs[request.address] = deferred
+
+            respond wait, pre_check(deferred, request, ::MTLibuv::Ext.fs_fchmod(@reactor.handle, request, @fileno, mode, callback(:on_chmod, request.address)))
+        end
+
+        def chown(uid:, gid:, wait: true)
+            assert_type(Integer, uid, "uid must be an Integer")
+            assert_type(Integer, gid, "gid must be an Integer")
+            deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            @request_refs[request.address] = deferred
+
+            respond wait, pre_check(deferred, request, ::MTLibuv::Ext.fs_fchown(@reactor.handle, request, @fileno, uid, gid, callback(:on_chown, request.address)))
+        end
+
+        def send_file(stream, using: :raw, chunk_size: 4096, wait: true)
+            @transmit_failure ||= proc { |reason| @sending_file.reject(reason) }
+            @start_transmit ||= proc { |stats|
+                @file_stream_total = stats[:st_size]
+                next_chunk
+            }
+            @transmit_data ||= proc { |data| transmit_data(data) }
+
+            @sending_file = @reactor.defer
+            @file_stream = stream
+            @file_stream_type = using
+            @file_chunk_size = chunk_size
+            @file_chunk_count = 0
+
+            stat(wait: false).then @start_transmit, @transmit_failure
+            
+            promise = @sending_file.promise
+            promise.finally { clean_up_send }
+            respond wait, promise
+        end
+
+
+        private
+
+
+        ##
+        # File transmit functions -------------
+        def transmit_data(data)
+            @file_chunk_count += 1
+            if @file_stream_type == :http
+                resp = String.new
+                resp << data.bytesize.to_s(16) << CRLF
+                resp << data
+                resp << CRLF
+                data = resp
+            end
+            @file_stream.write(data, wait: :promise).then(proc { next_chunk }, @transmit_failure)
+            nil
+        end
+
+        def next_chunk
+            next_size = @file_chunk_size
+            next_offset = @file_chunk_size * @file_chunk_count
+            
+            if next_offset >= @file_stream_total
+                if @file_stream_type == :http
+                    @file_stream.write(EOF, wait: :promise).then(proc {
+                        @sending_file.resolve(@file_stream_total)
+                    }, @transmit_failure)
+                else
+                    @sending_file.resolve(@file_stream_total)
+                end
+            else
+                if next_offset + next_size > @file_stream_total
+                    next_size = @file_stream_total - next_offset
+                end
+                read(next_size, next_offset, wait: false).then(@transmit_data, @transmit_failure)
+            end
+            nil
+        end
+
+        def clean_up_send
+            @sending_file = nil
+            @file_stream = nil
+            @file_stream_type = nil
+            @file_chunk_size = nil
+            @file_chunk_count = nil
+            @file_stream_total = nil
+        end
+        # -------------------------------------
+        ##
+
+
+        def on_open(req)
+            if post_check(req, @defer)
+                @fileno = req[:result]
+                cleanup(req)
+                @closed = false
+                @reactor.exec { @defer.notify(self) }
+
+                if @coroutine
+                    @coroutine.resolve(nil)
+                    @coroutine = nil
+                end
+            end
+        end
+
+        def on_close(req)
+            if post_check(req, @defer)
+                cleanup(req)
+                @reactor.exec { @defer.resolve(nil) }
+            end
+        end
+
+        def on_read(req)
+            deferred, buffer1 = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                data = buffer1.read_string(req[:result])
+                cleanup(req)
+                @reactor.exec { deferred.resolve(data) }
+            end
+        end
+
+        def on_write(req)
+            deferred, buffer1 = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                cleanup(req)
+                @reactor.exec { deferred.resolve(nil) }
+            end
+        end
+
+        def on_sync(req)
+            deferred = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                cleanup(req)
+                @reactor.exec { deferred.resolve(nil) }
+            end
+        end
+
+        def on_datasync(req)
+            deferred = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                cleanup(req)
+                @reactor.exec { deferred.resolve(nil) }
+            end
+        end
+
+        def on_truncate(req)
+            deferred = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                cleanup(req)
+                @reactor.exec { deferred.resolve(nil) }
+            end
+        end
+
+        def on_utime(req)
+            deferred = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                cleanup(req)
+                @reactor.exec { deferred.resolve(nil) }
+            end
+        end
+
+        def on_chmod(req)
+            deferred = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                cleanup(req)
+                @reactor.exec { deferred.resolve(nil) }
+            end
+        end
+
+        def on_chown(req)
+            deferred = @request_refs.delete req.to_ptr.address
+            if post_check(req, deferred)
+                cleanup(req)
+                @reactor.exec { deferred.resolve(nil) }
+            end
+        end
+    end
+end

data/lib/mt-libuv/filesystem.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Filesystem
+        include Assertions, Resource, Listener, FsChecks
+
+
+        fs_params = {
+            params: [Ext::FsRequest.by_ref],
+            lookup: :fs_lookup
+        }
+        define_callback function: :on_unlink, **fs_params
+        define_callback function: :on_mkdir, **fs_params
+        define_callback function: :on_rmdir, **fs_params
+        define_callback function: :on_readdir, **fs_params
+        define_callback function: :on_rename, **fs_params
+        define_callback function: :on_chmod, **fs_params
+        define_callback function: :on_utime, **fs_params
+        define_callback function: :on_stat, **fs_params
+        define_callback function: :on_link, **fs_params
+        define_callback function: :on_symlink, **fs_params
+        define_callback function: :on_readlink, **fs_params
+        define_callback function: :on_chown, **fs_params
+
+
+        def initialize(reactor)
+            @reactor = reactor
+        end
+
+        def unlink(path, wait: true)
+            assert_type(String, path, "path must be a String")
+            @unlink_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @unlink_deferred, request, ::MTLibuv::Ext.fs_unlink(@reactor, request, path, callback(:on_unlink, request.address))
+            respond wait, @unlink_deferred.promise
+        end
+
+        def mkdir(path, mode = 0777, wait: true)
+            assert_type(String, path, "path must be a String")
+            assert_type(Integer, mode, "mode must be an Integer")
+            @mkdir_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @mkdir_deferred, request, ::MTLibuv::Ext.fs_mkdir(@reactor, request, path, mode, callback(:on_mkdir, request.address))
+            respond wait, @mkdir_deferred.promise
+        end
+
+        def rmdir(path, wait: true)
+            assert_type(String, path, "path must be a String")
+            @rmdir_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @rmdir_deferred, request, ::MTLibuv::Ext.fs_rmdir(@reactor, request, path, callback(:on_rmdir, request.address))
+            respond wait, @rmdir_deferred.promise
+        end
+
+        def readdir(path, wait: true)
+            assert_type(String, path, "path must be a String")
+            @readdir_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @readdir_deferred, request, ::MTLibuv::Ext.fs_readdir(@reactor, request, path, 0, callback(:on_readdir, request.address))
+            respond wait, @readdir_deferred.promise
+        end
+
+        def rename(old_path, new_path, wait: true)
+            assert_type(String, old_path, "old_path must be a String")
+            assert_type(String, new_path, "new_path must be a String")
+            @rename_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @rename_deferred, request, ::MTLibuv::Ext.fs_rename(@reactor, request, old_path, new_path, callback(:on_rename, request.address))
+            respond wait, @rename_deferred.promise
+        end
+
+        def chmod(path, mode, wait: true)
+            assert_type(String, path, "path must be a String")
+            assert_type(Integer, mode, "mode must be an Integer")
+            @chmod_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @chmod_deferred, request, ::MTLibuv::Ext.fs_chmod(@reactor, request, path, mode, callback(:on_chmod, request.address))
+            respond wait, @chmod_deferred.promise
+        end
+
+        def utime(path, atime, mtime, wait: true)
+            assert_type(String, path, "path must be a String")
+            assert_type(Integer, atime, "atime must be an Integer")
+            assert_type(Integer, mtime, "mtime must be an Integer")
+            @utime_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @utime_deferred, request, ::MTLibuv::Ext.fs_utime(@reactor, request, path, atime, mtime, callback(:on_utime, request.address))
+            respond wait, @utime_deferred.promise
+        end
+
+        def lstat(path, wait: true)
+            assert_type(String, path, "path must be a String")
+            @stat_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @stat_deferred, request, ::MTLibuv::Ext.fs_lstat(@reactor, request, path, callback(:on_stat, request.address))
+            respond wait, @stat_deferred.promise
+        end
+
+        def link(old_path, new_path, wait: true)
+            assert_type(String, old_path, "old_path must be a String")
+            assert_type(String, new_path, "new_path must be a String")
+            @link_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @link_deferred, request, ::MTLibuv::Ext.fs_link(@reactor, request, old_path, new_path, callback(:on_link, request.address))
+            respond wait, @link_deferred.promise
+        end
+
+        def symlink(old_path, new_path, wait: true)
+            assert_type(String, old_path, "old_path must be a String")
+            assert_type(String, new_path, "new_path must be a String")
+            @symlink_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @symlink_deferred, request, ::MTLibuv::Ext.fs_symlink(@reactor, request, old_path, new_path, 0, callback(:on_symlink, request.address))
+            respond wait, @symlink_deferred.promise
+        end
+
+        def readlink(path, wait: true)
+            assert_type(String, path, "path must be a String")
+            @readlink_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @readlink_deferred, request, ::MTLibuv::Ext.fs_readlink(@reactor, request, path, callback(:on_readlink, request.address))
+            respond wait, @readlink_deferred.promise
+        end
+
+        def chown(path, uid, gid, wait: true)
+            assert_type(String, path, "path must be a String")
+            assert_type(Integer, uid, "uid must be an Integer")
+            assert_type(Integer, gid, "gid must be an Integer")
+            @chown_deferred = @reactor.defer
+
+            request = ::MTLibuv::Ext.allocate_request_fs
+            pre_check @chown_deferred, request, ::MTLibuv::Ext.fs_chown(@reactor, request, path, uid, gid, callback(:on_chown, request.address))
+            respond wait, @chown_deferred.promise
+        end
+
+
+        private
+
+
+        def on_unlink(req)
+            if post_check(req, @unlink_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @unlink_deferred.resolve(path) }
+            end
+            @unlink_deferred = nil
+        end
+
+        def on_mkdir(req)
+            if post_check(req, @mkdir_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @mkdir_deferred.resolve(path) }
+            end
+            @mkdir_deferred = nil
+        end
+
+        def on_rmdir(req)
+            if post_check(req, @rmdir_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @rmdir_deferred.resolve(path) }
+            end
+            @rmdir_deferred = nil
+        end
+
+        def on_readdir(req)
+            if post_check(req, @readdir_deferred)
+                num_files = req[:result]
+
+                info = ::MTLibuv::Ext::UvDirent.new
+                files = []
+                ret = 1
+                loop do
+                    ret = ::MTLibuv::Ext.fs_readdir_next(req, info)
+                    files << [info[:name], info[:type]]
+
+                    # EOF is the alternative
+                    break unless ret == 0
+                end
+
+                cleanup(req)
+                @reactor.exec { @readdir_deferred.resolve(files) }
+            end
+            @readdir_deferred = nil
+        end
+
+        def on_rename(req)
+            if post_check(req, @rename_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @rename_deferred.resolve(path) }
+            end
+            @rename_deferred = nil
+        end
+
+        def on_chmod(req)
+            if post_check(req, @chmod_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @chmod_deferred.resolve(path) }
+            end
+            @chmod_deferred = nil
+        end
+
+        def on_utime(req)
+            if post_check(req, @utime_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @utime_deferred.resolve(path) }
+            end
+            @utime_deferred = nil
+        end
+
+        def on_link(req)
+            if post_check(req, @link_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @link_deferred.resolve(path) }
+            end
+            @link_deferred = nil
+        end
+
+        def on_symlink(req)
+            if post_check(req, @symlink_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @symlink_deferred.resolve(path) }
+            end
+            @symlink_deferred = nil
+        end
+
+        def on_readlink(req)
+            if post_check(req, @readlink_deferred)
+                string_ptr = req[:ptr]
+                path = string_ptr.null? ? nil : string_ptr.read_string_to_null
+                cleanup(req)
+                @reactor.exec { @readlink_deferred.resolve(path) }
+            end
+            @readlink_deferred = nil
+        end
+
+        def on_chown(req)
+            if post_check(req, @chown_deferred)
+                path = req[:path]
+                cleanup(req)
+                @reactor.exec { @chown_deferred.resolve(path) }
+            end
+            @chown_deferred = nil
+        end
+    end
+end

data/lib/mt-libuv/fs_event.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class FSEvent < Handle
+
+
+        define_callback function: :on_fs_event, params: [:pointer, :string, :int, :int]
+
+
+        EVENTS = {1 => :rename, 2 => :change}.freeze
+
+
+        def initialize(reactor, path)
+            @reactor = reactor
+
+            fs_event_ptr = ::MTLibuv::Ext.allocate_handle_fs_event
+            error = check_result ::MTLibuv::Ext.fs_event_init(reactor.handle, fs_event_ptr, path, callback(:on_fs_event, fs_event_ptr.address), 0)
+
+            super(fs_event_ptr, error)
+        end
+
+
+        private
+
+
+        def on_fs_event(handle, filename, events, status)
+            e = check_result(status)
+
+            if e
+                reject(e)
+            else
+                # notify of a change
+                @reactor.exec { defer.notify(filename, EVENTS[events]) }
+            end
+        end
+    end
+end