The Ruby IO documentation is not 100% clear on how this buffering works, but this is what you can extract from the documentation:
- Ruby IO has its own internal buffer
- In addition to that the underlying operating system may or may not further buffer data.
The relevant methods to look at:
IO. I also looked at the Ruby source and a call to
IO.flushalso calls the underlying OS
fflush(). This should be enough to get the file cached, but does not guarantee physical data to disk.
IO.sync=: If set to
true, no Ruby internal buffering is done. Everything is immidiately sent to the OS, and
fflush()is called for each write.
IO.sync: Returns the current sync setting (
IO.fsync: Flushes both the Ruby buffers + calls
fsync()on the OS (if it supports it). This will guarantee a full flush all the way to the physical disk file.
IO.close: Closes the Ruby
IOand writes pending data to the OS. Note that this does not imply
fsync(). The POSIX documentation on
close()says that it does NOT guarantee data is physically written to the file. So you need to use an explicit
fsync()call for that.
close should be enough to get the file cached so that it can be read fully by another process or operation. To get the file all the way to the physical media with certainty, you need to call
Other related methods:
IO.syswrite: Bypass Ruby internal buffers and do a straight OS
write. If you use this then do not mix it with
IO.sysread: Same as above, but for reading.