FileLock.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <functional>
#include <memory>
#include <thread>
#include <filesystem>
 
#ifndef _WIN32
#include <fcntl.h>
#include <cstdio>
#include <unistd.h>
#include <sys/file.h>
#else
 
#define NOMINMAX
#include <windows.h>
#include <handleapi.h>
#endif
 
namespace stc {
 
class FileLock {
private:
#ifndef _WIN32
    int fd;
#else
    HANDLE fd;
#endif
 
    const std::filesystem::path lockPath;
 
    bool locked = false;
 
public:
    enum class Errors {
        OPEN_ERROR = 42,
        LOCK_ERROR = 43
    };
 
    FileLock(const std::filesystem::path& lockPath, bool lockNonblocking = true) : lockPath(lockPath) {
#ifndef _WIN32
        fd = open(lockPath.c_str(), O_RDWR | O_CREAT, 0666);
        if (fd < 0) {
            throw Errors::OPEN_ERROR;
        }
 
 
        // TODO: better error handling of flock()s return value.
        if ((locked = flock(fd, LOCK_EX | (lockNonblocking == true ? LOCK_NB : 0)) == 0) == false) {
            close(fd);
            fd = -1;
            // While removing the file here would look relevant, it isn't.
            // If the file is locked, it obviously shouldn't be removed.
        }
 
        if (!locked) {
            throw Errors::LOCK_ERROR;
        }
#else
        auto _cppStr = lockPath.string();
        auto str = _cppStr.c_str();
        fd = CreateFileA(
            str,
            GENERIC_WRITE,
            0,
            NULL,
            CREATE_ALWAYS,
            FILE_FLAG_DELETE_ON_CLOSE,
            NULL
        );
 
        if (fd == INVALID_HANDLE_VALUE) {
            DWORD err = GetLastError();
            if (err == 32) {
                throw Errors::LOCK_ERROR;
            }
            throw Errors::OPEN_ERROR;
        }
 
        locked = true;
#endif
 
    }
 
    ~FileLock() {
        unlock();
    }
 
    // I might add these in the future with some fancy move stuff
    // or whatever to allow for moving locks around.
    // For now, it sounds useless.
    FileLock(const FileLock&) = delete;
    FileLock& operator=(const FileLock&) = delete;
 
    bool hasLock() { return locked; }
 
    void unlock() {
        if (!locked) return;
 
        locked = false;
#ifndef _WIN32
        if (fd >= 0) {
            flock(fd, LOCK_UN);
            close(fd);
        }
        // TODO: this results in a race condition. Fix
        if (std::filesystem::exists(lockPath)) {
            std::filesystem::remove(lockPath);
        }
#else
        if (fd != INVALID_HANDLE_VALUE && CloseHandle(fd)) {
            auto _cppStr = lockPath.string();
            auto str = _cppStr.c_str();
 
            CloseHandle(fd);
        }
#endif
    }
 
    // Fuck you MSVC
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201907L) || __cplusplus >= 201907L)
    [[nodiscard("Ignoring the return value of dynamicAcquireLock results in the immediate unlock of the returned lock")]]
#else
    [[nodiscard]]
#endif
    static std::shared_ptr<FileLock> dynamicAcquireLock(
        const std::filesystem::path& path,
        std::function<bool()> control,
        unsigned int sleepSeconds = 1
    ) {
        while (control()) {
            try {
                std::shared_ptr<FileLock> lock = std::make_shared<FileLock>(path, true);
                if (lock->hasLock()) {
                    return lock;
                }
            } catch (const Errors& e) {
                if (e == Errors::OPEN_ERROR) {
                    return nullptr;
                }
            }
            if (sleepSeconds != 0) {
                std::this_thread::sleep_for(std::chrono::seconds(sleepSeconds));
            }
        }
        return nullptr;
    }
};
 
}