preventing simultaneous fwrite

jeofoyster

If two users hit a script that fopen's a file and then fwrite's to that file at the exact same second ... what kind of error will this call when the script tries to write to a file that is already open for writing?

Is there a php way that I'm not seeing that tests if a file is already open for writing, or is this just not a problem at all?

devinemke

[man]flock[/man]

MarkR

What you will need to do is:

Open the file in a writeable mode such as r+
Use flock() to immediately obtain an exclusive lock on the file
Do whatever reading you require
Do whatever writing you require (if you like, use ftruncate to truncate the file and start writing it from the beginning) - but don't close it and open a new handle to do this - use the same already-open handle
Close the file when finished.

This will mean that the other process will wait.

Mark

jeofoyster

can another process read the file while it's open for writing? Or is the file completely out of commission even for reading during this process?

MarkR

Another process can read a file while it's open for writing (depending on operating system, file opening mode, etc).

To avoid reading a half-written file, the reading process should acquire a shared lock on the file after opening. This will block if the file is being read, but enable several readers to have shared locks at once.

Mark

neerav

MarkR wrote:
To avoid reading a half-written file, the reading process should acquire a shared lock on the file after opening. This will block if the file is being read, but enable several readers to have shared locks at once.

MarkR,

I have the same question as jeofoyster, and understand your first post. Could you please explain this quoted part in your last post?

MarkR

A process which just wants to read the file should get a LOCK_SH lock on the file (shared lock) - typically used for reading as it will block other writers but not readers.

A process which wants to read and write the file, needs a LOCK_EX lock, which will block everyone - including other readers. This means that they can then read, truncate and write the file without anyone else getting in the way.

Under Unix, file locks are normally discretionary, e.g. they don't actually stop anyone from doing anything, physically stopping another process opening the file, but they only stop someone from taking their own lock.

Therefore all users of the file need to use the same locking strategy. This is what Unix normally does with mailboxes etc.

Mark

neerav

Thanks for explaining it (much better than the manual!).

Since the file is used only by one app and only one script, the flock solution will work. And I need to ensure a half written file isn't being read. My understanding is that this will correctly work only when handling the file using a file handle. How would you recommend changing the following?

$some_array = file("filename");

I would think something like:

$fp = fopen("filename","r");
flock($fp, LOCK_SH);
$contents = fread($fp, filesize("filename"));
fclose($fp);
$some_array = explode("\n",$contents);

Though, the manual states that using file (or file_get_contents) is better for performance.

For the process which is writing, I have:

$fd = fopen("filename", "w");
flock($fd,LOCK_EX);  // trying to use file lock
ftruncate($fd,0);
fseek($fd,0);
fwrite($fd, "new data here");
fclose($fd);

Am I missing anything for a successful lock and safe data integrity?

MarkR

No, that all looks good. But you should test it:

Put a massive sleep in between the lock and the write (or the write and the close)
Run the other script at the same time (I'd recommend running both from the CLI for testing purposes)
Ensure that it really is blocked.

You've also missed something important: If you need to read, modify and write the file, you must not use two different file handles - you need to keep the same one open:

$f = fopen("somefile.txt", "r+");
flock($f, LOCK_EX);
// Do some reading
ftruncate($f, 0);
fseek($f, 0);
// Do some writing ...
fclose($f);

Note that I may have got the above syntax somewhat wrong.

Finally,

$contents = fread($fp, filesize("filename"));

Could be

$contents = stream_get_contents($fp);

stream_get_contents being the PHP stream function which reads a stream until the end. No need to use filesize() then.

Mark

neerav

Thank you MarkR. Everything seems to be working fine. I wanted to make sure it was working under heavy load before jumping the gun and considering this a success.