LockFile.cpp

/*
** libutil++
** $Id: LockFile.cpp 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: LockFile.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "LockFile.h"
#include "CommonMacro.h"
#include "String.h"
#include "File.h"

#include <sys/file.h>

using namespace sella::util;

LockFile::LockFile(const std::string &fullpath, useconds_t stale, bool removeStale, uid_t uid, gid_t gid, int mode) throw () :
        fullpath(fullpath),
        stale(stale),
        removeStale(removeStale),
        uid(uid),
        gid(gid),
        mode(mode),
        fd(0)
{ }

LockFile::~LockFile() {
        try {
                unlock();
        } catch (...) {
                close();
        }
}

void LockFile::setStaleAge(useconds_t stale) throw () {
        if (stale > 0) {
                this->stale = stale;
        } else {
                this->stale = -1;
        }
}

void LockFile::setUID(uid_t uid) throw () {
        if (uid > (__UID_T_TYPE) -1) {
                this->uid = uid;
        } else {
                this->uid = (__UID_T_TYPE) -1;
        }
}

void LockFile::setGID(gid_t gid) throw () {
        if (gid > (__GID_T_TYPE) -1) {
                this->gid = gid;
        } else {
                this->gid = (__GID_T_TYPE) -1;
        }
}

void LockFile::setMode(int mode) throw () {
        if (mode > -1 && mode < 7777) {
                this->mode = mode;
        } else {
                this->mode = 0644;
        }
}

bool LockFile::lock(useconds_t interval) throw (FileException) {
        return tryLockCount(-1, interval);
}

bool LockFile::tryLock(void) throw (FileException) {
        std::lock_guard<std::mutex> lg(mutex);

        return lock_nonblock();
}

bool LockFile::tryLockUntil(time_t timeout, useconds_t interval) throw (FileException) {
        time_t now = time(NULL);
        std::lock_guard<std::mutex> lg(mutex);

        do {
                if (lock_nonblock()) {
                        return true;
                }

                usleep(interval);
        } while (now < timeout);

        return false;
}

bool LockFile::tryLockFor(time_t duration, useconds_t interval) throw (FileException) {
        time_t now = time(NULL);
        time_t timeout = now + duration;
        std::lock_guard<std::mutex> lg(mutex);

        do {
                if (lock_nonblock()) {
                        return true;
                }

                usleep(interval);
        } while (now < timeout);

        return false;
}

bool LockFile::tryLockCount(int64_t retries, useconds_t interval)  throw (FileException) {
        int64_t r = 0;
        std::lock_guard<std::mutex> lg(mutex);

        do {
                if (lock_nonblock()) {
                        return true;
                }

                usleep(interval);
        } while (fd < 1 && (retries < 1 || r++ < retries));

        return false;

}

bool LockFile::unlock(void) throw (FileException) {
        std::lock_guard<std::mutex> lg(mutex);

        if (fd > 0) { // Only unlock if we own the lock
                if (!unlink()) {
                        close();

                        THROW2(FileException, "Failed to remove lockfile '%s'", fullpath.c_str());
                }

                close(); // Releases flock

                return true;
        }

        return false;
}

bool LockFile::remove(void) throw () {
        std::lock_guard<std::mutex> lg(mutex);

        if (fd > 0) {
                return false;
        }

        return unlink();
}

bool LockFile::ownLock(void) throw () {
        return (fd > 0);
}

bool LockFile::isLocked(void) throw () {
        if (ownLock()) {
                return true;
        }

        return File::exists(fullpath, false) && File::isRegularFile(fullpath, false);
}

bool LockFile::isStale(void) throw () {
        if (stale > 0) {
                try {
                        if (File::exists(fullpath, false) && File::isRegularFile(fullpath, false)) {
                                return (time(NULL) - File::getCTime(fullpath, false) > stale);
                        }
                } catch (...) { } // Handle missing or unaccessable file.
        }

        return false;
}

bool LockFile::lock_nonblock() throw (FileException) {
        int pid;
        struct stat st0, st1;
        const std::string directory = File::getDirName(fullpath);

        if (removeStale && isStale()) {
                unlink();
                close();
        }

        if (isLocked()) { // Already locked
                return false;
        }

        while (1) { // Prevent race condition
                if (File::exists(fullpath, false) && !File::isRegularFile(fullpath, false)) {
                        THROW(FileException, "Lockfile '%s' must be a regular file or not exist", fullpath.c_str());
                } else if (!File::exists(directory, false) || !File::isDirectory(directory, false)) {
                        THROW(FileException, "Path to lockfile '%s' must exist and be a directory", fullpath.c_str());
                }

                if ((fd = open(fullpath.c_str(), O_WRONLY|O_CREAT|O_DSYNC, mode)) < 0) {
                        THROW2(FileException, "Failed to open or create lockfile '%s'", fullpath.c_str());
                }

                if (flock(fd, LOCK_EX|LOCK_NB) != 0) {
                        close();

                        if (errno == EWOULDBLOCK) {
                                return false;
                        }

                        THROW2(FileException, "Failed to lock '%s'", fullpath.c_str());
                }

                if (fstat(fd, &st0) < 0 || stat(fullpath.c_str(), &st1) < 0) {
                        close();
                } else if (st0.st_ino == st1.st_ino) { // Ensure we have the lock
                        break;
                }
        }

        pid = getpid();

        char buf[16] = { 0 };
        snprintf(buf, sizeof(buf), "%d\n", pid);

        if (write(fd, buf, strlen(buf)) < 1) {
                unlink();
                close();

                THROW2(FileException, "Failed to write pid %d to lockfile '%s'", pid, fullpath.c_str());
        }

        if (uid != (__UID_T_TYPE) -1 || gid != (__GID_T_TYPE) -1) {
                if (fchown(fd, uid, gid) != 0) {
                        unlink();
                        close();

                        THROW2(FileException, "Failed to change owner of lockfile '%s' to %d:%d", fullpath.c_str(), uid, gid);
                }
        }

        return true;
}

bool LockFile::unlink(void) throw () {
        int save = errno; /* Preserve errno */
        bool res = false;

        if (File::exists(fullpath, false) && File::isRegularFile(fullpath, false)) {
                res = (::unlink(fullpath.c_str()) == 0);
        }

        errno = save;

        return res;
}

void LockFile::close(void) throw () {
        int save = errno; /* Preserve errno */

        if (fd > 0) {
                ::close(fd);
                fd = 0;
        }

        errno = save;
}

/*
** vim: noet ts=3 sw=3
*/