config.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cctype>
#include <cstdint>
#include <memory>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <pwd.h>
#include <filesystem>
#include <format>
#include <unordered_map>
 
#include "bwrap/bwrap.hpp"
#include "filesystems/controller.hpp"
#include "filesystems/layers.hpp"
#include "db/portal/daemon.hpp"
#include "db/portal/dispatcher.hpp"
#include "lib/env.hpp"
#include "db/env.hpp"
#include "lib/log.hpp"
#include "macro.hpp"
#include "std/expected.hpp"
#include "std/enum.hpp"
#include "reserved/casefold.hpp"
#include "reserved/notify.hpp"
#include "reserved/overlay.hpp"
#include "std/filesystem.hpp"
 
// Version
#ifndef FIM_VERSION
#error "FIM_VERSION is undefined"
#endif
 
// Git commit hash
#ifndef FIM_COMMIT
#error "FIM_COMMIT is undefined"
#endif
 
// Distribution
#ifndef FIM_DIST
#error "FIM_DIST is undefined"
#endif
 
// Compilation timestamp
#ifndef FIM_TIMESTAMP
#error "FIM_TIMESTAMP is undefined"
#endif
 
// Json file with binary tools
#ifndef FIM_FILE_TOOLS
#error "FIM_FILE_TOOLS is undefined"
#endif
 
// Dependencies metadata
#ifndef FIM_FILE_META
#error "FIM_FILE_META is undefined"
#endif
 
// Size for the configuration reserved space in the flatimage
#ifndef FIM_RESERVED_SIZE
  #error "FIM_RESERVED_SIZE is undefined"
#endif
 
extern "C" uint32_t FIM_RESERVED_OFFSET;
 
using DaemonMode = ns_db::ns_portal::ns_daemon::Mode;

namespace ns_config
{
 
// Distribution enum
ENUM(Distribution, ARCH, ALPINE, BLUEPRINT)
 
namespace
{
 
namespace fs = std::filesystem;
 
} // namespace

class Path
{
  public:
  struct Dir
  {
    fs::path const self;            
    fs::path const global;          
    fs::path const app;             
    fs::path const app_bin;         
    fs::path const app_sbin;        
    fs::path const instance;        
    fs::path const portal;          
    fs::path const runtime;         
    fs::path const runtime_host;    
    fs::path const host_home;       
    fs::path const host_data;       
    fs::path const host_data_tmp;   
    fs::path const host_data_layers; 
 
    static Value<Dir> create()
    {
      // Get path to self
      fs::path path_bin_self = fs::path{Pop(ns_env::get_expected("FIM_BIN_SELF"))};
      // Compute all paths first
      fs::path self = path_bin_self.parent_path();
      fs::path global = fs::path("/tmp/fim");
      fs::path app = global / "app" / std::format("{}_{}", FIM_COMMIT, FIM_TIMESTAMP);
      fs::path app_bin = app / "bin";
      fs::path app_sbin = app / "sbin";
      fs::path instance = std::format("{}/{}/{}", app.string(), "instance", std::to_string(getpid()));
      fs::path portal = instance / "portal";
      fs::path runtime = fs::path("/tmp/fim/run");
      fs::path runtime_host = runtime / "host";
      fs::path host_home = fs::path{ns_env::get_expected("HOME").value()}.relative_path();
      fs::path host_data = getenv("FIM_DIR_DATA")?:
        self / std::format(".{}.data", path_bin_self.filename().string());
      fs::path host_data_tmp = host_data / "tmp";
      fs::path host_data_layers = host_data / "layers";
      // Side effect: create directories
      Pop(ns_fs::create_directories(host_data_tmp));
      Pop(ns_fs::create_directories(host_data_layers));
      // Aggregate initialization with const members
      return Dir
      {
        .self = std::move(self),
        .global = std::move(global),
        .app = std::move(app),
        .app_bin = std::move(app_bin),
        .app_sbin = std::move(app_sbin),
        .instance = std::move(instance),
        .portal = std::move(portal),
        .runtime = std::move(runtime),
        .runtime_host = std::move(runtime_host),
        .host_home = std::move(host_home),
        .host_data = std::move(host_data),
        .host_data_tmp = std::move(host_data_tmp),
        .host_data_layers = std::move(host_data_layers)
      };
    }
  } dir;

  struct File
  {
    fs::path const bashrc;  
    fs::path const passwd;  
 
    static File create(fs::path const& path_dir_instance)
    {
      return File{
        .bashrc = path_dir_instance / "bashrc",
        .passwd = path_dir_instance / "passwd"
      };
    }
  } file;

  struct Bin
  {
    fs::path const self;               
    fs::path const bash;               
    fs::path const janitor;            
    fs::path const portal_daemon;      
    fs::path const portal_dispatcher;  
 
    static Value<Bin> create(fs::path const& path_dir_app_bin)
    {
      return Bin
      {
        .self = Pop(ns_env::get_expected("FIM_BIN_SELF")),
        .bash = path_dir_app_bin / "bash",
        .janitor = path_dir_app_bin / "fim_janitor",
        .portal_daemon = path_dir_app_bin / "fim_portal_daemon",
        .portal_dispatcher = path_dir_app_bin / "fim_portal"
      };
    }
  } bin;

  static Value<Path> create()
  {
    auto dir = Pop(Dir::create());
    auto file = File::create(dir.instance);
    auto bin = Pop(Bin::create(dir.app_bin));
    return Path(dir, file, bin);
  }
 
  private:
  Path(Dir const& dir, File const& file, Bin const& bin)
    : dir(dir)
    , file(file)
    , bin(bin)
    {
    }
};

struct Logs
{
  ns_bwrap::ns_proxy::Logs const bwrap;                           
  ns_db::ns_portal::ns_daemon::ns_log::Logs const daemon_host;    
  ns_db::ns_portal::ns_daemon::ns_log::Logs const daemon_guest;   
  ns_db::ns_portal::ns_dispatcher::Logs const dispatcher;         
  ns_filesystems::ns_controller::Logs const filesystems;          
  fs::path const path_file_boot;                                  
 
  Logs() = delete;
  Logs(fs::path const& path_dir_log)
    : bwrap(path_dir_log / "bwrap")
    , daemon_host(path_dir_log / "daemon" / "host")
    , daemon_guest(path_dir_log / "daemon" / "guest")
    , dispatcher(path_dir_log / "dispatcher")
    , filesystems(ns_filesystems::ns_controller::Logs
      {
        .path_file_dwarfs = path_dir_log / "fuse" / "dwarfs.log",
        .path_file_ciopfs = path_dir_log / "fuse" / "ciopfs.log",
        .path_file_overlayfs = path_dir_log / "fuse" / "overlayfs.log",
        .path_file_unionfs = path_dir_log / "fuse" / "unionfs.log",
        .path_file_janitor = path_dir_log / "fuse" / "janitor.log",
      })
    , path_file_boot(path_dir_log / "boot.log")
  {
    fs::create_directories(path_dir_log);
    fs::create_directories(path_dir_log / "bwrap");
    fs::create_directories(path_dir_log / "daemon" / "host");
    fs::create_directories(path_dir_log / "fuse" / "guest");
    fs::create_directories(path_dir_log / "dispatcher");
  }
};

struct Config
{
  ns_filesystems::ns_controller::Config fuse;  

  struct Daemon
  {
    ns_db::ns_portal::ns_daemon::Daemon const host;   
    ns_db::ns_portal::ns_daemon::Daemon const guest;  
  } daemon;

  static Value<Config> create(
    ns_filesystems::ns_layers::Layers const& layers,
    bool const is_casefold,
    fs::path const& path_dir_instance,
    fs::path const& path_dir_host_data,
    fs::path const& path_bin_janitor,
    fs::path const& path_bin_self,
    fs::path const& path_bin_portal_daemon,
    fs::path const& path_dir_portal
  )
  {
    // Compute paths first
    auto path_dir_mount = path_dir_instance / "mount";
    auto path_dir_work = path_dir_host_data / "work" / std::to_string(getpid());
    auto path_dir_upper = path_dir_host_data / "root";
    auto path_dir_layers = path_dir_instance / "layers";
    auto path_dir_ciopfs = path_dir_host_data / "casefold";
 
    // Side effects: create directories
    fs::create_directories(path_dir_mount);
    fs::create_directories(path_dir_work);
    fs::create_directories(path_dir_upper);
    fs::create_directories(path_dir_layers);
    fs::create_directories(path_dir_ciopfs);
 
    // Configure overlay type
    using ns_reserved::ns_overlay::OverlayType;
    OverlayType overlay_type =
        ns_env::exists("FIM_OVERLAY", "unionfs")? ns_reserved::ns_overlay::OverlayType::UNIONFS
      : ns_env::exists("FIM_OVERLAY", "overlayfs")? ns_reserved::ns_overlay::OverlayType::OVERLAYFS
      : ns_env::exists("FIM_OVERLAY", "bwrap")? ns_reserved::ns_overlay::OverlayType::BWRAP
      : ns_reserved::ns_overlay::read(path_bin_self)
        .value_or(OverlayType::BWRAP).get();
    if(is_casefold and overlay_type == ns_reserved::ns_overlay::OverlayType::BWRAP)
    {
      logger("W::casefold cannot be used with bwrap overlayfs, falling back to unionfs");
      overlay_type = ns_reserved::ns_overlay::OverlayType::UNIONFS;
    }
 
    // Compression level configuration (clamps from 0 to 9, default is 7)
    uint32_t const compression_level = ({
      std::string str_compression_level = ns_env::get_expected<"D">("FIM_COMPRESSION_LEVEL").value_or("7");
      uint64_t level = Catch(std::stoull(str_compression_level)).value_or(7);
      std::clamp(level, uint64_t{0}, uint64_t{9});
    });
 
    // Construct configuration objects
    auto fuse = ns_filesystems::ns_controller::Config
    {
      .is_casefold = is_casefold,
      .compression_level = compression_level,
      .overlay_type = overlay_type,
      .path_dir_mount = std::move(path_dir_mount),
      .path_dir_work = std::move(path_dir_work),
      .path_dir_upper = std::move(path_dir_upper),
      .path_dir_layers = std::move(path_dir_layers),
      .path_dir_ciopfs = std::move(path_dir_ciopfs),
      .path_bin_janitor = path_bin_janitor,
      .path_bin_self = path_bin_self,
      .layers = layers,
    };
 
    auto daemon = Daemon
    {
      .host = ns_db::ns_portal::ns_daemon::Daemon(DaemonMode::HOST
        , path_bin_portal_daemon
        , path_dir_portal
      ),
      .guest = ns_db::ns_portal::ns_daemon::Daemon(DaemonMode::GUEST
        , path_bin_portal_daemon
        , path_dir_portal
      ),
    };
 
    return Config
    {
      .fuse = std::move(fuse),
      .daemon = std::move(daemon)
    };
  }
};

struct Flags
{
  private:
  Flags() = default;
 
  public:
  bool is_root;       
  bool is_debug;      
  bool is_casefold;   
  bool is_notify;     

  static Value<Flags> create(fs::path const& path_bin_self)
  {
    Flags flags;
    auto environment = ns_db::ns_env::map(Pop(ns_db::ns_env::get(path_bin_self)));
    flags.is_root = ns_env::exists("FIM_ROOT", "1")
      or (environment.contains("UID") and environment.at("UID") == "0");
    flags.is_casefold = ns_env::exists("FIM_CASEFOLD", "1")
      or Pop(ns_reserved::ns_casefold::read(path_bin_self));
    flags.is_notify = Pop(ns_reserved::ns_notify::read(path_bin_self));
    flags.is_debug = ns_env::exists("FIM_DEBUG", "1");
    return flags;
  }
};

struct FlatImage
{
  Distribution const distribution;  
  pid_t const pid;                  
  Flags flags;                      
  Logs logs;                        
  Config config;                    
  Path path;                        
 
  [[nodiscard]] Value<ns_bwrap::ns_proxy::User> configure_bwrap() const
  {
    using namespace ns_bwrap::ns_proxy;
    // Get environment variables saved in the binary
    auto variables = ns_db::ns_env::map(Pop(ns_db::ns_env::get(path.bin.self)));
    // Get user info for defaults
    struct passwd *pw = getpwuid(getuid());
    return_if(not pw, Error("E::Failed to get current user info"));
    // Get user id with this priority
    // 1. is_root
    // 1. Binary environment data
    // 2. pw
    Id id = flags.is_root? Id{.uid = 0, .gid = 0} : Id
    {
      .uid = static_cast<mode_t>(Catch(std::stoul(Catch(variables.at("UID")).or_default())).value_or(pw->pw_uid)),
      .gid = static_cast<mode_t>(Catch(std::stoul(Catch(variables.at("GID")).or_default())).value_or(pw->pw_gid)),
    };
    // Create user
    User user(User::UserData
    {
      .id = id,
      .name = (id.uid == 0)? "root"
        : variables.contains("USER")? variables.at("USER")
        : ns_env::get_expected("USER").value_or(pw->pw_name),
      .path_dir_home = (id.uid == 0)? "/root"
        : variables.contains("HOME")? variables.at("HOME")
        : ns_env::get_expected("HOME").value_or(pw->pw_dir),
      .path_file_shell = variables.contains("SHELL")? fs::path{variables.at("SHELL")}
        : path.bin.bash,
      .path_file_bashrc = path.file.bashrc,
      .path_file_passwd = path.file.passwd,
    });
    // Write files
    Pop(user.write_bashrc(path.file.bashrc, variables.contains("PS1")? variables.at("PS1") : ""));
    Pop(user.write_passwd(path.file.passwd));
    return user;
  }
 
  ns_reserved::ns_overlay::OverlayType overlay_type()
  {
    // Configure overlay type
    using ns_reserved::ns_overlay::OverlayType;
    OverlayType overlay_type = ns_env::exists("FIM_OVERLAY", "unionfs")? ns_reserved::ns_overlay::OverlayType::UNIONFS
      : ns_env::exists("FIM_OVERLAY", "overlayfs")? ns_reserved::ns_overlay::OverlayType::OVERLAYFS
      : ns_env::exists("FIM_OVERLAY", "bwrap")? ns_reserved::ns_overlay::OverlayType::BWRAP
      : ns_reserved::ns_overlay::read(path.bin.self).value_or(OverlayType::BWRAP).get();
 
    // Check for case folding usage constraints
    if(flags.is_casefold and overlay_type == ns_reserved::ns_overlay::OverlayType::BWRAP)
    {
      logger("W::casefold cannot be used with bwrap overlayfs, falling back to unionfs");
      overlay_type = ns_reserved::ns_overlay::OverlayType::UNIONFS;
    }
    return overlay_type;
  }
}; // struct FlatImage

[[nodiscard]] inline Value<std::shared_ptr<FlatImage>> config()
{
  // Distribution
  Distribution const distribution = Pop(Distribution::from_string(FIM_DIST));
 
  // Standard paths
  Path path = Pop(Path::create());
 
  // Flags
  Flags flags = Pop(Flags::create(path.bin.self));
 
  // Log files
  Logs logs = Try(Logs(path.dir.instance / "logs"));
 
  // Gather layers
  ns_filesystems::ns_layers::Layers layers;
  layers.push_binary(path.bin.self, FIM_RESERVED_OFFSET + FIM_RESERVED_SIZE);
  layers.push_from_var("FIM_LAYERS").discard("W::Failed to setup FIM_LAYERS");
  layers.push(path.dir.host_data_layers).discard("W::Failed to setup host_data_layers");
 
  // Module configuration
  Config config = Pop(Config::create(
    layers,
    flags.is_casefold,
    path.dir.instance,
    path.dir.host_data,
    path.bin.janitor,
    path.bin.self,
    path.bin.portal_daemon,
    path.dir.portal
  ));
 
  // LD_LIBRARY_PATH
  if ( auto ret = ns_env::get_expected<"D">("LD_LIBRARY_PATH") )
  {
    ns_env::set("LD_LIBRARY_PATH"
      , std::format("/usr/lib/x86_64-linux-gnu:/usr/lib/i386-linux-gnu:{}", ret.value())
      , ns_env::Replace::Y
    );
  }
  else
  {
    ns_env::set("LD_LIBRARY_PATH"
      , "/usr/lib/x86_64-linux-gnu:/usr/lib/i386-linux-gnu"
      , ns_env::Replace::Y
    );
  }
 
  // PATH
  std::string env_path = path.dir.app_bin.string()
    + ":"
    + ns_env::get_expected("PATH").value_or("")
    + ":"
    + "/sbin:/usr/sbin:/usr/local/sbin:/bin:/usr/bin:/usr/local/bin"
    + ":"
    + path.dir.app_sbin.string();
  ns_env::set("PATH", env_path, ns_env::Replace::Y);
 
  // Get the current instance's pid
  pid_t pid = getpid();
 
  // Set environment variables
  Pop(ns_env::get_expected("FIM_BIN_SELF"), "C::Path to self is not defined");
  ns_env::set("FIM_DIR_SELF", path.dir.self, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_GLOBAL", path.dir.global, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_APP", path.dir.app, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_APP_BIN", path.dir.app_bin, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_APP_SBIN", path.dir.app_sbin, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_INSTANCE", path.dir.instance, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_LAYERS", path.dir.host_data_layers, ns_env::Replace::Y);
  ns_env::set("FIM_PID", pid, ns_env::Replace::Y);
  ns_env::set("FIM_DIST", FIM_DIST, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_RUNTIME", path.dir.runtime, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_RUNTIME_HOST", path.dir.runtime_host, ns_env::Replace::Y);
  ns_env::set("FIM_DIR_DATA", path.dir.host_data, ns_env::Replace::Y);
 
  // Create FlatImage object
  return std::shared_ptr<FlatImage>(new FlatImage{
    .distribution = distribution,
    .pid = pid,
    .flags = flags,
    .logs = logs,
    .config = config,
    .path = path,
  });
}
 
} // namespace ns_config
 
 
/* vim: set expandtab fdm=marker ts=2 sw=2 tw=100 et :*/