Program Listing for File fs_data.cpp

↰ Return to documentation for file (src/daemon/classes/fs_data.cpp)

/*
  Copyright 2018-2025, Barcelona Supercomputing Center (BSC), Spain
  Copyright 2015-2025, Johannes Gutenberg Universitaet Mainz, Germany

  This software was partially supported by the
  EC H2020 funded project NEXTGenIO (Project ID: 671951, www.nextgenio.eu).

  This software was partially supported by the
  ADA-FS project under the SPPEXA project funded by the DFG.

  This software was partially supported by the
  the European Union’s Horizon 2020 JTI-EuroHPC research and
  innovation programme, by the project ADMIRE (Project ID: 956748,
  admire-eurohpc.eu)

  This project was partially promoted by the Ministry for Digital Transformation
  and the Civil Service, within the framework of the Recovery,
  Transformation and Resilience Plan - Funded by the European Union
  -NextGenerationEU.

  This file is part of GekkoFS.

  GekkoFS is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  GekkoFS is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with GekkoFS.  If not, see <https://www.gnu.org/licenses/>.

  SPDX-License-Identifier: GPL-3.0-or-later
*/

#include <daemon/classes/fs_data.hpp>
#include <daemon/backend/metadata/db.hpp>

#include <spdlog/spdlog.h>

namespace gkfs::daemon {

FsData::FsData() {
    ABT_mutex_create(&maintenance_mode_mutex_);
}

FsData::~FsData() {
    ABT_mutex_free(&maintenance_mode_mutex_);
}

// getter/setter

const std::shared_ptr<spdlog::logger>&
FsData::spdlogger() const {
    return spdlogger_;
}

void
FsData::spdlogger(const std::shared_ptr<spdlog::logger>& spdlogger) {
    FsData::spdlogger_ = spdlogger;
}

const std::shared_ptr<gkfs::metadata::MetadataDB>&
FsData::mdb() const {
    return mdb_;
}

void
FsData::mdb(const std::shared_ptr<gkfs::metadata::MetadataDB>& mdb) {
    mdb_ = mdb;
}

void
FsData::close_mdb() {
    mdb_.reset();
}

const std::shared_ptr<gkfs::data::ChunkStorage>&
FsData::storage() const {
    return storage_;
}

void
FsData::storage(const std::shared_ptr<gkfs::data::ChunkStorage>& storage) {
    storage_ = storage;
}

const std::string&
FsData::rootdir() const {
    return rootdir_;
}

void
FsData::rootdir(const std::string& rootdir) {
    FsData::rootdir_ = rootdir;
}

const std::string&
FsData::rootdir_suffix() const {
    return rootdir_suffix_;
}

void
FsData::rootdir_suffix(const std::string& rootdir_suffix) {
    FsData::rootdir_suffix_ = rootdir_suffix;
}

const std::string&
FsData::mountdir() const {
    return mountdir_;
}

void
FsData::mountdir(const std::string& mountdir) {
    FsData::mountdir_ = mountdir;
}

const std::string&
FsData::metadir() const {
    return metadir_;
}

void
FsData::metadir(const std::string& metadir) {
    FsData::metadir_ = metadir;
}

std::string_view
FsData::dbbackend() const {
    return dbbackend_;
}

void
FsData::dbbackend(const std::string& dbbackend) {
    FsData::dbbackend_ = dbbackend;
}

const std::string&
FsData::rpc_protocol() const {
    return rpc_protocol_;
}

void
FsData::rpc_protocol(const std::string& rpc_protocol) {
    rpc_protocol_ = rpc_protocol;
}

const std::string&
FsData::proxy_rpc_protocol() const {
    return proxy_rpc_protocol_;
}
void
FsData::proxy_rpc_protocol(const std::string& proxy_rpc_protocol) {
    proxy_rpc_protocol_ = proxy_rpc_protocol;
}

const std::string&
FsData::bind_addr() const {
    return bind_addr_;
}

void
FsData::bind_addr(const std::string& addr) {
    bind_addr_ = addr;
}

const std::string&
FsData::bind_proxy_addr() const {
    return bind_proxy_addr_;
}

void
FsData::bind_proxy_addr(const std::string& proxy_addr) {
    bind_proxy_addr_ = proxy_addr;
}

const std::string&
FsData::hosts_file() const {
    return hosts_file_;
}

void
FsData::hosts_file(const std::string& lookup_file) {
    hosts_file_ = lookup_file;
}

bool
FsData::use_auto_sm() const {
    return use_auto_sm_;
}

void
FsData::use_auto_sm(bool use_auto_sm) {
    use_auto_sm_ = use_auto_sm;
}

bool
FsData::atime_state() const {
    return atime_state_;
}

void
FsData::atime_state(bool atime_state) {
    FsData::atime_state_ = atime_state;
}

bool
FsData::mtime_state() const {
    return mtime_state_;
}

void
FsData::mtime_state(bool mtime_state) {
    FsData::mtime_state_ = mtime_state;
}

bool
FsData::ctime_state() const {
    return ctime_state_;
}

void
FsData::ctime_state(bool ctime_state) {
    FsData::ctime_state_ = ctime_state;
}

bool
FsData::link_cnt_state() const {
    return link_cnt_state_;
}

void
FsData::link_cnt_state(bool link_cnt_state) {
    FsData::link_cnt_state_ = link_cnt_state;
}

bool
FsData::blocks_state() const {
    return blocks_state_;
}

void
FsData::blocks_state(bool blocks_state) {
    FsData::blocks_state_ = blocks_state;
}

unsigned long long
FsData::parallax_size_md() const {
    return parallax_size_md_;
}

void
FsData::parallax_size_md(unsigned int size_md) {
    FsData::parallax_size_md_ = static_cast<unsigned long long>(
            size_md * 1024ull * 1024ull * 1024ull);
}

const std::shared_ptr<gkfs::utils::Stats>&
FsData::stats() const {
    return stats_;
}

void
FsData::stats(const std::shared_ptr<gkfs::utils::Stats>& stats) {
    FsData::stats_ = stats;
}

void
FsData::close_stats() {
    stats_.reset();
}

bool
FsData::enable_stats() const {
    return enable_stats_;
}

void
FsData::enable_stats(bool enable_stats) {
    FsData::enable_stats_ = enable_stats;
}

bool
FsData::enable_chunkstats() const {
    return enable_chunkstats_;
}

void
FsData::enable_chunkstats(bool enable_chunkstats) {
    FsData::enable_chunkstats_ = enable_chunkstats;
}

bool
FsData::enable_forwarding() const {
    return enable_forwarding_;
}

void
FsData::enable_forwarding(bool enable_forwarding) {
    FsData::enable_forwarding_ = enable_forwarding;
}
bool
FsData::enable_prometheus() const {
    return enable_prometheus_;
}

void
FsData::enable_prometheus(bool enable_prometheus) {
    FsData::enable_prometheus_ = enable_prometheus;
}

const std::string&
FsData::stats_file() const {
    return stats_file_;
}

void
FsData::stats_file(const std::string& stats_file) {
    FsData::stats_file_ = stats_file;
}

const std::string&
FsData::prometheus_gateway() const {
    return prometheus_gateway_;
}

void
FsData::prometheus_gateway(const std::string& prometheus_gateway) {
    FsData::prometheus_gateway_ = prometheus_gateway;
}

bool
FsData::maintenance_mode() const {
    return maintenance_mode_;
}

void
FsData::maintenance_mode(bool maintenance_mode) {
    ABT_mutex_lock(maintenance_mode_mutex_);
    if(maintenance_mode && maintenance_mode_) {
        auto err_str =
                "Critical error: Maintenance mode enabled twice, e.g., due to multiple expand requests. This is not a allowed and should not happen.";
        spdlogger()->error(err_str);
        throw std::runtime_error(err_str);
    }
    maintenance_mode_ = maintenance_mode;
    ABT_mutex_unlock(maintenance_mode_mutex_);
}

bool
FsData::redist_running() const {
    return redist_running_;
}

void
FsData::redist_running(bool redist_running) {
    redist_running_ = redist_running;
}

const std::shared_ptr<gkfs::malleable::MalleableManager>&
FsData::malleable_manager() const {
    return malleable_manager_;
}

void
FsData::malleable_manager(
        const std::shared_ptr<gkfs::malleable::MalleableManager>&
                malleable_manager) {
    malleable_manager_ = malleable_manager;
}

} // namespace gkfs::daemon