fs.h

#ifndef UVW_FS_INCLUDE_H
#define UVW_FS_INCLUDE_H
 
#include <chrono>
#include <memory>
#include <string>
#include <utility>
#include <uv.h>
#include "loop.h"
#include "request.hpp"
#include "util.h"
 
namespace uvw {
 
namespace details {
 
enum class UVFsType : std::underlying_type_t<uv_fs_type> {
    UNKNOWN = UV_FS_UNKNOWN,
    CUSTOM = UV_FS_CUSTOM,
    OPEN = UV_FS_OPEN,
    CLOSE = UV_FS_CLOSE,
    READ = UV_FS_READ,
    WRITE = UV_FS_WRITE,
    SENDFILE = UV_FS_SENDFILE,
    STAT = UV_FS_STAT,
    LSTAT = UV_FS_LSTAT,
    FSTAT = UV_FS_FSTAT,
    FTRUNCATE = UV_FS_FTRUNCATE,
    UTIME = UV_FS_UTIME,
    FUTIME = UV_FS_FUTIME,
    ACCESS = UV_FS_ACCESS,
    CHMOD = UV_FS_CHMOD,
    FCHMOD = UV_FS_FCHMOD,
    FSYNC = UV_FS_FSYNC,
    FDATASYNC = UV_FS_FDATASYNC,
    UNLINK = UV_FS_UNLINK,
    RMDIR = UV_FS_RMDIR,
    MKDIR = UV_FS_MKDIR,
    MKDTEMP = UV_FS_MKDTEMP,
    RENAME = UV_FS_RENAME,
    SCANDIR = UV_FS_SCANDIR,
    LINK = UV_FS_LINK,
    SYMLINK = UV_FS_SYMLINK,
    READLINK = UV_FS_READLINK,
    CHOWN = UV_FS_CHOWN,
    FCHOWN = UV_FS_FCHOWN,
    REALPATH = UV_FS_REALPATH,
    COPYFILE = UV_FS_COPYFILE,
    LCHOWN = UV_FS_LCHOWN,
    OPENDIR = UV_FS_OPENDIR,
    READDIR = UV_FS_READDIR,
    CLOSEDIR = UV_FS_CLOSEDIR,
    STATFS = UV_FS_STATFS,
    MKSTEMP = UV_FS_MKSTEMP,
    LUTIME = UV_FS_LUTIME
};
 
enum class UVDirentTypeT : std::underlying_type_t<uv_dirent_type_t> {
    UNKNOWN = UV_DIRENT_UNKNOWN,
    FILE = UV_DIRENT_FILE,
    DIR = UV_DIRENT_DIR,
    LINK = UV_DIRENT_LINK,
    FIFO = UV_DIRENT_FIFO,
    SOCKET = UV_DIRENT_SOCKET,
    CHAR = UV_DIRENT_CHAR,
    BLOCK = UV_DIRENT_BLOCK
};
 
enum class UVFileOpenFlags : int {
    APPEND = UV_FS_O_APPEND,
    CREAT = UV_FS_O_CREAT,
    DIRECT = UV_FS_O_DIRECT,
    DIRECTORY = UV_FS_O_DIRECTORY,
    DSYNC = UV_FS_O_DSYNC,
    EXCL = UV_FS_O_EXCL,
    EXLOCK = UV_FS_O_EXLOCK,
    FILEMAP = UV_FS_O_FILEMAP,
    NOATIME = UV_FS_O_NOATIME,
    NOCTTY = UV_FS_O_NOCTTY,
    NOFOLLOW = UV_FS_O_NOFOLLOW,
    NONBLOCK = UV_FS_O_NONBLOCK,
    RANDOM = UV_FS_O_RANDOM,
    RDONLY = UV_FS_O_RDONLY,
    RDWR = UV_FS_O_RDWR,
    SEQUENTIAL = UV_FS_O_SEQUENTIAL,
    SHORT_LIVED = UV_FS_O_SHORT_LIVED,
    SYMLINK = UV_FS_O_SYMLINK,
    SYNC = UV_FS_O_SYNC,
    TEMPORARY = UV_FS_O_TEMPORARY,
    TRUNC = UV_FS_O_TRUNC,
    WRONLY = UV_FS_O_WRONLY
};
 
enum class UVCopyFileFlags : int {
    EXCL = UV_FS_COPYFILE_EXCL,
    FICLONE = UV_FS_COPYFILE_FICLONE,
    FICLONE_FORCE = UV_FS_COPYFILE_FICLONE_FORCE
};
 
enum class UVSymLinkFlags : int {
    DIR = UV_FS_SYMLINK_DIR,
    JUNCTION = UV_FS_SYMLINK_JUNCTION
};
 
} // namespace details
 
template<details::UVFsType e>
struct FsEvent {
    FsEvent(const char *pathname) noexcept
        : path{pathname} {}
 
    const char *path; 
};
 
template<>
struct FsEvent<details::UVFsType::READ> {
    FsEvent(const char *pathname, std::unique_ptr<const char[]> buf, std::size_t sz) noexcept
        : path{pathname}, data{std::move(buf)}, size{sz} {}
 
    const char *path;                   
    std::unique_ptr<const char[]> data; 
    std::size_t size;                   
};
 
template<>
struct FsEvent<details::UVFsType::WRITE> {
    FsEvent(const char *pathname, std::size_t sz) noexcept
        : path{pathname}, size{sz} {}
 
    const char *path; 
    std::size_t size; 
};
 
template<>
struct FsEvent<details::UVFsType::SENDFILE> {
    FsEvent(const char *pathname, std::size_t sz) noexcept
        : path{pathname}, size{sz} {}
 
    const char *path; 
    std::size_t size; 
};
 
template<>
struct FsEvent<details::UVFsType::STAT> {
    FsEvent(const char *pathname, Stat curr) noexcept
        : path{pathname}, stat{std::move(curr)} {}
 
    const char *path; 
    Stat stat;        
};
 
template<>
struct FsEvent<details::UVFsType::FSTAT> {
    FsEvent(const char *pathname, Stat curr) noexcept
        : path{pathname}, stat{std::move(curr)} {}
 
    const char *path; 
    Stat stat;        
};
 
template<>
struct FsEvent<details::UVFsType::LSTAT> {
    FsEvent(const char *pathname, Stat curr) noexcept
        : path{pathname}, stat{std::move(curr)} {}
 
    const char *path; 
    Stat stat;        
};
 
template<>
struct FsEvent<details::UVFsType::STATFS> {
    FsEvent(const char *pathname, Statfs curr) noexcept
        : path{pathname}, statfs{std::move(curr)} {}
 
    const char *path; 
    Statfs statfs;    
};
 
template<>
struct FsEvent<details::UVFsType::MKSTEMP> {
    FsEvent(const char *pathname, std::size_t desc) noexcept
        : path{pathname}, descriptor{desc} {}
 
    const char *path;       
    std::size_t descriptor; 
};
 
template<>
struct FsEvent<details::UVFsType::SCANDIR> {
    FsEvent(const char *pathname, std::size_t sz) noexcept
        : path{pathname}, size{sz} {}
 
    const char *path; 
    std::size_t size; 
};
 
template<>
struct FsEvent<details::UVFsType::READLINK> {
    explicit FsEvent(const char *pathname, const char *buf, std::size_t sz) noexcept
        : path{pathname}, data{buf}, size{sz} {}
 
    const char *path; 
    const char *data; 
    std::size_t size; 
};
 
template<>
struct FsEvent<details::UVFsType::READDIR> {
    using EntryType = details::UVDirentTypeT;
 
    FsEvent(const char *name, EntryType type, bool eos) noexcept
        : name{name}, type{type}, eos{eos} {}
 
    const char *name; 
    EntryType type;   
    bool eos;         
};
 
template<typename T>
class FsRequest: public Request<T, uv_fs_t> {
protected:
    template<details::UVFsType e>
    static void fsGenericCallback(uv_fs_t *req) {
        if(auto ptr = Request<T, uv_fs_t>::reserve(req); req->result < 0) {
            ptr->publish(ErrorEvent{req->result});
        } else {
            ptr->publish(FsEvent<e>{req->path});
        }
    }
 
    template<details::UVFsType e>
    static void fsResultCallback(uv_fs_t *req) {
        if(auto ptr = Request<T, uv_fs_t>::reserve(req); req->result < 0) {
            ptr->publish(ErrorEvent{req->result});
        } else {
            ptr->publish(FsEvent<e>{req->path, static_cast<std::size_t>(req->result)});
        }
    }
 
    template<details::UVFsType e>
    static void fsStatCallback(uv_fs_t *req) {
        if(auto ptr = Request<T, uv_fs_t>::reserve(req); req->result < 0) {
            ptr->publish(ErrorEvent{req->result});
        } else {
            ptr->publish(FsEvent<e>{req->path, req->statbuf});
        }
    }
 
    static void fsStatfsCallback(uv_fs_t *req) {
        if(auto ptr = Request<T, uv_fs_t>::reserve(req); req->result < 0) {
            ptr->publish(ErrorEvent{req->result});
        } else {
            ptr->publish(FsEvent<Type::STATFS>{req->path, *static_cast<Statfs *>(req->ptr)});
        }
    }
 
    template<typename... Args>
    void cleanupAndInvoke(Args &&...args) {
        uv_fs_req_cleanup(this->get());
        this->invoke(std::forward<Args>(args)...);
    }
 
    template<typename F, typename... Args>
    void cleanupAndInvokeSync(F &&f, Args &&...args) {
        uv_fs_req_cleanup(this->get());
        std::forward<F>(f)(std::forward<Args>(args)..., nullptr);
    }
 
public:
    using Time = std::chrono::duration<double>;
    using Type = details::UVFsType;
    using EntryType = details::UVDirentTypeT;
 
    using Request<T, uv_fs_t>::Request;
};
 
class FileReq final: public FsRequest<FileReq> {
    static constexpr uv_file BAD_FD = -1;
 
    static void fsOpenCallback(uv_fs_t *req);
    static void fsCloseCallback(uv_fs_t *req);
    static void fsReadCallback(uv_fs_t *req);
 
public:
    using FileOpen = details::UVFileOpenFlags;
 
    using FsRequest::FsRequest;
 
    ~FileReq() noexcept;
 
    void close();
 
    bool closeSync();
 
    void open(const std::string &path, Flags<FileOpen> flags, int mode);
 
    bool openSync(const std::string &path, Flags<FileOpen> flags, int mode);
 
    void read(int64_t offset, unsigned int len);
 
    std::pair<bool, std::pair<std::unique_ptr<const char[]>, std::size_t>> readSync(int64_t offset, unsigned int len);
 
    void write(std::unique_ptr<char[]> buf, unsigned int len, int64_t offset);
 
    void write(char *buf, unsigned int len, int64_t offset);
 
    std::pair<bool, std::size_t> writeSync(std::unique_ptr<char[]> buf, unsigned int len, int64_t offset);
 
    void stat();
 
    std::pair<bool, Stat> statSync();
 
    void sync();
 
    bool syncSync();
 
    void datasync();
 
    bool datasyncSync();
 
    void truncate(int64_t offset);
 
    bool truncateSync(int64_t offset);
 
    void sendfile(FileHandle out, int64_t offset, std::size_t length);
 
    std::pair<bool, std::size_t> sendfileSync(FileHandle out, int64_t offset, std::size_t length);
 
    void chmod(int mode);
 
    bool chmodSync(int mode);
 
    void futime(Time atime, Time mtime);
 
    bool futimeSync(Time atime, Time mtime);
 
    void chown(Uid uid, Gid gid);
 
    bool chownSync(Uid uid, Gid gid);
 
    operator FileHandle() const noexcept;
 
private:
    std::unique_ptr<char[]> current{nullptr};
    uv_buf_t buffer{};
    uv_file file{BAD_FD};
};
 
class FsReq final: public FsRequest<FsReq> {
    static void fsReadlinkCallback(uv_fs_t *req);
    static void fsReaddirCallback(uv_fs_t *req);
 
public:
    using CopyFile = details::UVCopyFileFlags;
    using SymLink = details::UVSymLinkFlags;
 
    using FsRequest::FsRequest;
 
    ~FsReq() noexcept;
 
    void unlink(const std::string &path);
 
    bool unlinkSync(const std::string &path);
 
    void mkdir(const std::string &path, int mode);
 
    bool mkdirSync(const std::string &path, int mode);
 
    void mkdtemp(const std::string &tpl);
 
    std::pair<bool, const char *> mkdtempSync(const std::string &tpl);
 
    void mkstemp(const std::string &tpl);
 
    std::pair<bool, std::pair<std::string, std::size_t>> mkstempSync(const std::string &tpl);
 
    void lutime(const std::string &path, Time atime, Time mtime);
 
    bool lutimeSync(const std::string &path, Time atime, Time mtime);
 
    void rmdir(const std::string &path);
 
    bool rmdirSync(const std::string &path);
 
    void scandir(const std::string &path, int flags);
 
    std::pair<bool, std::size_t> scandirSync(const std::string &path, int flags);
 
    std::pair<bool, std::pair<EntryType, const char *>> scandirNext();
 
    void stat(const std::string &path);
 
    std::pair<bool, Stat> statSync(const std::string &path);
 
    void lstat(const std::string &path);
 
    std::pair<bool, Stat> lstatSync(const std::string &path);
 
    void statfs(const std::string &path);
 
    std::pair<bool, Statfs> statfsSync(const std::string &path);
 
    void rename(const std::string &old, const std::string &path);
 
    bool renameSync(const std::string &old, const std::string &path);
 
    void copyfile(const std::string &old, const std::string &path, Flags<CopyFile> flags = Flags<CopyFile>{});
 
    bool copyfileSync(const std::string &old, const std::string &path, Flags<CopyFile> flags = Flags<CopyFile>{});
 
    void access(const std::string &path, int mode);
 
    bool accessSync(const std::string &path, int mode);
 
    void chmod(const std::string &path, int mode);
 
    bool chmodSync(const std::string &path, int mode);
 
    void utime(const std::string &path, Time atime, Time mtime);
 
    bool utimeSync(const std::string &path, Time atime, Time mtime);
 
    void link(const std::string &old, const std::string &path);
 
    bool linkSync(const std::string &old, const std::string &path);
 
    void symlink(const std::string &old, const std::string &path, Flags<SymLink> flags = Flags<SymLink>{});
 
    bool symlinkSync(const std::string &old, const std::string &path, Flags<SymLink> flags = Flags<SymLink>{});
 
    void readlink(const std::string &path);
 
    std::pair<bool, std::pair<const char *, std::size_t>> readlinkSync(const std::string &path);
 
    void realpath(const std::string &path);
 
    std::pair<bool, const char *> realpathSync(const std::string &path);
 
    void chown(const std::string &path, Uid uid, Gid gid);
 
    bool chownSync(const std::string &path, Uid uid, Gid gid);
 
    void lchown(const std::string &path, Uid uid, Gid gid);
 
    bool lchownSync(const std::string &path, Uid uid, Gid gid);
 
    void opendir(const std::string &path);
 
    bool opendirSync(const std::string &path);
 
    void closedir();
 
    bool closedirSync();
 
    void readdir();
 
    std::pair<bool, std::pair<EntryType, const char *>> readdirSync();
 
private:
    uv_dirent_t dirents[1];
};
 
struct FsHelper {
    static OSFileDescriptor handle(FileHandle file) noexcept;
 
    static FileHandle open(OSFileDescriptor descriptor) noexcept;
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "fs.cpp"
#endif
 
#endif // UVW_FS_INCLUDE_H