Class: Libuv::File

Inherits:
Q::DeferredPromise show all
Includes:
Assertions, FsChecks, Listener, Resource
Defined in:
lib/libuv/file.rb

Constant Summary collapse

EOF = 
"0\r\n\r\n"
CRLF = 
"\r\n"

Constants included from Assertions

Assertions::MSG_NO_PROC

Constants inherited from Q::Promise

Q::Promise::MAKE_PROMISE

Instance Attribute Summary collapse

Attributes inherited from Q::Promise

#trace

Instance Method Summary collapse

Methods included from Assertions

#assert_block, #assert_boolean, #assert_type

Methods included from Resource

#check_result, #check_result!, #resolve, #to_ptr

Methods included from FsChecks

included, #stat

Methods inherited from Q::DeferredPromise

#resolved?, #then

Methods inherited from Q::Promise

#catch, #finally, #progress, #ruby_catch, #value

Constructor Details

#initialize(thread, path, flags = 0, mode: 0, wait: true, &blk) ⇒ File

Returns a new instance of File.



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/libuv/file.rb', line 32

def initialize(thread, path, flags = 0, mode: 0, wait: true, &blk)
    super(thread, thread.defer)

    @fileno = -1
    @closed = true 
    @path, @flags, @mode = path, flags, mode
    @request_refs = {}

    request = ::Libuv::Ext.allocate_request_fs
    pre_check @defer, request, ::Libuv::Ext.fs_open(@reactor, request, @path, @flags, @mode, callback(:on_open, request.address))

    if block_given?
        self.progress blk
    elsif wait
        @coroutine = @reactor.defer
        co @coroutine.promise
    end
end

Instance Attribute Details

#closed ⇒ Object (readonly)

Returns the value of attribute closed.



29
30
31
 
# File 'lib/libuv/file.rb', line 29

def closed
  @closed
end

#fileno ⇒ Object (readonly)

Returns the value of attribute fileno.



29
30
31
 
# File 'lib/libuv/file.rb', line 29

def fileno
  @fileno
end

Instance Method Details

#chmod(mode, wait: true) ⇒ Object 



129
130
131
132
133
134
135
136
137
 
# File 'lib/libuv/file.rb', line 129

def chmod(mode, wait: true)
    assert_type(Integer, mode, "mode must be an Integer")
    deferred = @reactor.defer

    request = ::Libuv::Ext.allocate_request_fs
    @request_refs[request.address] = deferred

    respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fchmod(@reactor.handle, request, @fileno, mode, callback(:on_chmod, request.address)))
end

#chown(uid:, gid:, wait: true) ⇒ Object 



139
140
141
142
143
144
145
146
147
148
 
# File 'lib/libuv/file.rb', line 139

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 = ::Libuv::Ext.allocate_request_fs
    @request_refs[request.address] = deferred

    respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fchown(@reactor.handle, request, @fileno, uid, gid, callback(:on_chown, request.address)))
end

#close ⇒ Object 



51
52
53
54
55
56
 
# File 'lib/libuv/file.rb', line 51

def close
    @closed = true
    request = ::Libuv::Ext.allocate_request_fs
    pre_check(@defer, request, ::Libuv::Ext.fs_close(@reactor.handle, request, @fileno, callback(:on_close, request.address)))
    self
end

#datasync(wait: false) ⇒ Object 



98
99
100
101
102
103
104
105
 
# File 'lib/libuv/file.rb', line 98

def datasync(wait: false)
    deferred = @reactor.defer

    request = ::Libuv::Ext.allocate_request_fs
    @request_refs[request.address] = deferred

    respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fdatasync(@reactor.handle, request, @fileno, callback(:on_datasync, request.address)))
end

#read(length, offset = 0, wait: true) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/libuv/file.rb', line 58

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  = ::Libuv::Ext.buf_init(buffer1, length)
    request = ::Libuv::Ext.allocate_request_fs

    @request_refs[request.address] = [deferred, buffer1]

    promise = pre_check(deferred, request, ::Libuv::Ext.fs_read(@reactor.handle, request, @fileno, buffer, 1, offset, callback(:on_read, request.address)))
    wait ? co(promise) : promise
end

#send_file(stream, using: :raw, chunk_size: 4096, wait: true) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/libuv/file.rb', line 150

def send_file(stream, using: :raw, chunk_size: 4096, wait: true)
    @transmit_failure ||= method(:transmit_failure)
    @transmit_data ||= method(:transmit_data)
    @start_transmit ||= method(:start_transmit)
    @next_chunk ||= method(:next_chunk)

    @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 &method(:clean_up_send)
    respond wait, promise
end

#sync(wait: false) ⇒ Object 



89
90
91
92
93
94
95
96
 
# File 'lib/libuv/file.rb', line 89

def sync(wait: false)
    deferred = @reactor.defer

    request = ::Libuv::Ext.allocate_request_fs
    @request_refs[request.address] = deferred

    respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_fsync(@reactor.handle, request, @fileno, callback(:on_sync, request.address)))
end

#truncate(offset, wait: true) ⇒ Object 



107
108
109
110
111
112
113
114
115
 
# File 'lib/libuv/file.rb', line 107

def truncate(offset, wait: true)
    assert_type(Integer, offset, "offset must be an Integer")
    deferred = @reactor.defer

    request = ::Libuv::Ext.allocate_request_fs
    @request_refs[request.address] = deferred

    respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_ftruncate(@reactor.handle, request, @fileno, offset, callback(:on_truncate, request.address)))
end

#utime(atime:, mtime:, wait: true) ⇒ Object 



117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/libuv/file.rb', line 117

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 = ::Libuv::Ext.allocate_request_fs
    @request_refs[request.address] = deferred

    promise = pre_check deferred, request, ::Libuv::Ext.fs_futime(@reactor.handle, request, @fileno, atime, mtime, callback(:on_utime, request.address))
    wait ? co(promise) : promise
end

#write(data, offset = 0, wait: true) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/libuv/file.rb', line 73

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  = ::Libuv::Ext.buf_init(buffer1, length)
    request = ::Libuv::Ext.allocate_request_fs

    @request_refs[request.address] = [deferred, buffer1]

    respond wait, pre_check(deferred, request, ::Libuv::Ext.fs_write(@reactor.handle, request, @fileno, buffer, 1, offset, callback(:on_write, request.address)))
end