Simple lock-file mechanism for nodeJS

simple-lockfile-for-nodejs.js

var fs = require('fs');
var path = require('path');

if (typeof exports === 'undefined') var exports = {};

exports.exists = function(filename) {
	try {
		return (fs.lstatSync(filename) ? true : false);
	}
	catch (err) {
		return false;
	}
};

exports.create = function(filename,  contents) {
	try {
		if (!contents) contents = '';
		fs.writeFileSync(filename, contents);
		return true;
	}
	catch (err) {
		return false;
	}
};

exports.remove = function(filename) {	
	try {
		return fs.unlinkSync(filename);
	}
	catch (err) {
		return false;
	}
};

Allows to easily create a lock-file in NodeJS, check for its existance, and remove it once it's no longer needed. Great when trying to avoid two (identical) node processes from executing and doing the same stuff at the same time. It proves very useful for me, and I hope it helps someone else as well :)

var path = require('path');

path never used.

What exactly has this in relation to file locking? Do you even know how that works 😓

@adminy This was done 9 years ago so a lot has happened since then. I'd have to be honest and admit this stuff is all outdated here :)

@martintajur Code lives on ... provide a nice gist to others, something like:

const { promises, constants } = require('fs')
const lockFile = path => {
    const lockPath = `${path}.lock`
    return promises.open(lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_RDWR).catch(() => lockFile(path))
}
const unlockFile = path => {
    const lockPath = `${path}.lock`
    return promises.unlink(lockPath).catch(() => unlockFile(path)
}

Usage:

const main = async () => {
    const path = 'some/path/to/file'
    await lockFile(path)
    // Do something with the file
    // ...
    await unlockFile(path)
}
main()

Proper locking mechanisms are probably more intricate than that, taking in consideration oses and their filesystems but It is nice to have a simple example to find somewhere.