workspace.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_libdaq
 * @copyright (c) Copyright ESO 2022
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 *
 * @brief daq::Workspace interface and implementation declaration
 */
#include <daq/workspace.hpp>
 
#include <fstream>
#include <stdexcept>
#include <system_error>
 
#include <fmt/format.h>
#include <nlohmann/json.hpp>
 
#include <daq/json.hpp>
 
namespace fs = std::filesystem;
 
namespace daq {
namespace {
 
constexpr const std::string_view PATH_IN_PROGRESS = "in-progress";
constexpr const std::string_view PATH_ARCHIVE = "archive";
constexpr const std::string_view FILE_DAQ_LIST = "list.json";
constexpr const std::string_view SUFFIX_DAQ_CONTEXT = "-context.json";
constexpr const std::string_view SUFFIX_DAQ_STATUS = "-status.json";
constexpr const std::string_view FILE_TEMP_EXT = ".swap";
 
template <class T>
void SafeWrite(T const& content, fs::path const& destination) {
    try {
        auto temp = destination;
        auto temp_file = destination.filename().native();
        temp_file += FILE_TEMP_EXT;
        temp.replace_filename(temp_file);
        // Write to temporary file
        {
            std::fstream temp_file(temp, std::ios::out | std::ios::trunc);
            temp_file << std::setw(4) << content;
            if (!temp_file) {
                throw std::runtime_error(
                    fmt::format("File contains error after write: '{}'", temp.native()));
            }
            temp_file.close();
        }
        // Move (atomically) into location
        fs::rename(temp, destination);
    } catch (...) {
        std::throw_with_nested(
            std::runtime_error(fmt::format("Failed to write file '{}'", destination.native())));
    }
}
 
/**
 * Initialize workspace
 *
 * @note Is safe to run for existing and valid workspace.
 */
void InitRootWorkspace(fs::path const& root) {
    // If there are non-managed files refuse to initialize new worksace as we are misconfigured
    auto status = fs::status(root);
    if (fs::exists(status)) {
        if (!fs::is_directory(status)) {
            throw std::invalid_argument(
                fmt::format("Workspace root exist but is not a directory: {}", root.native()));
        }
 
        for (auto const& entry : fs::directory_iterator(root)) {
            if (entry.path().extension() == FILE_TEMP_EXT) {
                // Old temporary files -> delete
                fs::remove(entry);
                continue;
            }
            if (entry.path().filename() == FILE_DAQ_LIST) {
                continue;
            }
            if (entry.path().filename() == PATH_IN_PROGRESS) {
                continue;
            }
            if (entry.path().filename() == PATH_ARCHIVE) {
                continue;
            }
            throw std::invalid_argument(
                fmt::format("Workspace {} has unexpected contents - aborting to prevent filesystem "
                            "modifications due to misconfiguration",
                            root.native()));
        }
    }
 
    fs::create_directories(root);
    fs::create_directory(root / PATH_IN_PROGRESS);
    fs::create_directory(root / PATH_ARCHIVE);
}
 
}  // namespace
 
WorkspaceImpl::WorkspaceImpl(fs::path root) : m_root(std::move(root)) {
    auto status = fs::status(m_root);
    if (status.type() != fs::file_type::directory && status.type() != fs::file_type::not_found) {
        throw std::invalid_argument(
            fmt::format("Workspace root directory '{}' is not a directory", m_root.string())
                .c_str());
    }
 
    InitRootWorkspace(m_root);
    // Initialize empty DAQ list if necessary
    if (!fs::exists(m_root / FILE_DAQ_LIST)) {
        WorkspaceImpl::StoreList({});
    }
}
 
 
void WorkspaceImpl::RemoveDaq(std::string const& id) {
    fs::remove(MakePath(FileType::Context, id));
    fs::remove(MakePath(FileType::Status, id));
}
 
void WorkspaceImpl::ArchiveDaq(std::string const& id) {
    auto new_context = m_root / PATH_ARCHIVE / (id + std::string(SUFFIX_DAQ_CONTEXT));
    auto new_status = m_root / PATH_ARCHIVE / (id + std::string(SUFFIX_DAQ_STATUS));
 
    if (fs::exists(new_context)) {
        new_context += ".";
        for (auto idx = 1u; idx < 0xffff; ++idx) {
            auto tmp = new_context;
            tmp += std::to_string(idx);
            if (!fs::exists(tmp)) {
                new_context.swap(tmp);
                break;
            }
        }
    }
    if (fs::exists(new_status)) {
        new_context += ".";
        for (auto idx = 1u; idx < 0xffff; ++idx) {
            auto tmp = new_status;
            tmp += std::to_string(idx);
            if (!fs::exists(tmp)) {
                new_context.swap(tmp);
                break;
            }
        }
    }
    fs::rename(MakePath(FileType::Context, id), new_context);
    fs::rename(MakePath(FileType::Status, id), new_status);
}
 
auto WorkspaceImpl::LoadList() const -> std::vector<std::string> {
    auto file = m_root / FILE_DAQ_LIST;
    try {
        std::fstream fs(file, std::ios::in);
        auto json = nlohmann::json::parse(fs);
        return json.get<std::vector<std::string>>();
    } catch (...) {
        std::throw_with_nested(
            std::runtime_error(fmt::format("Failed to load DAQ list '{}'", file.native())));
    }
}
 
void WorkspaceImpl::StoreList(std::vector<std::string> const& list) const {
    try {
        nlohmann::json json;
        json = list;
        SafeWrite(json, m_root / FILE_DAQ_LIST);
    } catch (...) {
        std::throw_with_nested(std::runtime_error("Failed to store DAQ list"));
    }
}
 
auto WorkspaceImpl::LoadStatus(std::string const& id) const -> Status {
    try {
        std::fstream fs(MakePath(FileType::Status, id));
        auto json = nlohmann::json::parse(fs);
        return json.get<Status>();
    } catch (...) {
        std::throw_with_nested(std::runtime_error("Failed to load DAQ status"));
    }
}
 
void WorkspaceImpl::StoreStatus(Status const& status) const {
    try {
        nlohmann::json json;
        json = status;
        SafeWrite(json, MakePath(FileType::Status, status.id));
    } catch (...) {
        std::throw_with_nested(std::runtime_error("Failed to store DAQ status"));
    }
}
 
auto WorkspaceImpl::LoadContext(std::string const& id) const -> DaqContext {
    auto file = MakePath(FileType::Context, id);
    try {
        std::fstream fs(file, std::ios::in);
        auto json = nlohmann::json::parse(fs);
        DaqContext context;
        json.get_to(context);
        return context;
    } catch (...) {
        std::throw_with_nested(std::runtime_error(
            fmt::format("Failed to load DAQ Context '{}'", file.native())));
    }
}
 
void WorkspaceImpl::StoreContext(DaqContext const& context) const {
    try {
        nlohmann::json json;
        to_json(json, context);
        SafeWrite(json, MakePath(FileType::Context, context.id));
    } catch (...) {
        std::throw_with_nested(std::runtime_error("Failed to store DAQ status"));
    }
}
    
std::filesystem::path WorkspaceImpl::MakePath(FileType type, std::string const& id) const {
    switch (type) {
        case FileType::Context:
            return m_root / PATH_IN_PROGRESS / (id + std::string(SUFFIX_DAQ_CONTEXT));
        case FileType::Status:
            return m_root / PATH_IN_PROGRESS / (id + std::string(SUFFIX_DAQ_STATUS));
        default:
            assert(false);
    };
}
 
}  // namespace daq