How to share text file (or a mutex/semaphore) between Ruby and another language?

Question

I have a C++ program that is writing data to a text file called "history.txt". I want it to write continuously, unless my Ruby process decides that it wants to read from it.

The solution to this problem is obviously a mutex, but I've only found examples of mutices being shared between processes written in the same language.

Do I have to implement this awkwardly with named pipes between the two processes or is there an easier way?

Answer 1

You should be able to accomplish what you desire by placing locks on "history.txt" by using flock in Ruby and C++ (this probably exists in many other languages as well, since it's a system call), although there does seem to be a few gotchas that may occur while using this method.

Here is the code I used to test the method.

Here is the Ruby code:

File.open("history.txt", "r+") do |file|
    puts "before the lock"
    file.flock(File::LOCK_EX)
    puts "Locking until you press enter"
    gets
    puts file.gets
    file.flock(File::LOCK_UN)
end

Here is the C++ code:

#include <iostream>
#include <fstream>
#include <sys/file.h>

int main()
{
    FILE *h; 
    h = fopen("history.txt","a"); //open the file
    std::cout << "Press enter to lock\n";
    std::cin.get();
    int hNum = fileno(h); //get the file handle from the FILE*
    int rt = flock(hNum, LOCK_EX); //Lock it down!
    std::cout << "Writing!"<<rt<<"\n";
    fprintf(h,"Shoop da woop!\n");
    std::cout << "Press enter to unlock\n";
    std::cin.get();
    rt = flock(hNum, LOCK_UN);
    fflush(h);
    fclose(h);
    return 0;
}

By running these two methods you can confirm that the Ruby process stops when the C++ process has locked the file and vice versa.