utils.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <filesystem>
#include <ranges>
#include <chrono>
#include <thread>
 
#include "../std/expected.hpp"
#include "../macro.hpp"

namespace ns_filesystems::ns_utils
{
 
namespace
{
 
namespace fs = std::filesystem;
 
}

inline bool is_busy(fs::path const& path_dir)
{
  [[maybe_unused]] auto __expected_fn = [](auto&&){ return std::nullopt; };
  // Check all processes in /proc
  std::vector<std::string> const pids = std::filesystem::directory_iterator("/proc")
    // Get directories only
    | std::views::filter([](auto&& e){ return fs::is_directory(e); })
    // Get string file names
    | std::views::transform([](auto&& e){ return e.path().filename().string(); })
    // Drop empty strings
    | std::views::filter([](auto&& e){ return not e.empty(); })
    // Filter & transform to pid
    | std::views::filter([](auto&& e){ return Catch(std::stoi(e)).has_value(); })
    | std::ranges::to<std::vector<std::string>>();
 
  for (std::string const& pid : pids)
  {
    // Open mountinfo file
    std::ifstream file_info("/proc/" + pid + "/mountinfo");
    continue_if(not file_info.is_open());
    // Iterate through file lines
    auto lines = std::ranges::istream_view<std::string>(file_info);
    auto it = std::ranges::find_if(lines, [&](auto const& line)
    {
      return line.find(path_dir) != std::string::npos;
    });
    return_if(it != lines.end(), true, "D::Busy '{}' due to '{}'", path_dir, *it);
  }
  return false;
}

[[nodiscard]] inline Value<void> wait_busy(fs::path const& path_dir, std::chrono::nanoseconds timeout)
{
  using namespace std::chrono;
 
  auto const start_time = steady_clock::now();
  constexpr auto poll_interval = milliseconds(100);
 
  while(true)
  {
    if(!is_busy(path_dir))
    {
      return {}; // Directory is no longer busy
    }
 
    auto const elapsed = steady_clock::now() - start_time;
    if(elapsed >= timeout)
    {
      auto const timeout_ms = duration_cast<milliseconds>(timeout).count();
      return Error("C::Another instance is running on {} (timeout after {}ms)", path_dir, timeout_ms);
    }
 
    std::this_thread::sleep_for(poll_interval);
  }
}

struct Instance
{
  pid_t pid;  
  fs::path path; 
};

[[nodiscard]] inline std::vector<Instance> get_instances(fs::path const& path_dir_instances)
{
  // List instances
  auto f_pid = [&](auto&& e) { return Catch(std::stoi(e.path().filename().string())).value_or(0); };
  // Get instances
  auto instances = fs::directory_iterator(path_dir_instances)
    | std::views::transform([&](auto&& e){ return Instance(f_pid(e), e.path()); })
    | std::views::filter([&](auto&& e){ return e.pid > 0; })
    | std::views::filter([&](auto&& e){ return fs::exists(fs::path{"/proc"} / std::to_string(e.pid)); })
    | std::views::filter([&](auto&& e){ return e.pid != getpid(); })
    | std::ranges::to<std::vector<Instance>>();
  // Sort by pid (filename is a directory named as the pid of that instance)
  std::ranges::sort(instances, {}, [](auto&& e){ return e.pid; });
  return instances;
}

[[nodiscard]] inline std::vector<fs::path> get_mounted_layers(fs::path const& path_dir_layers)
{
  std::vector<fs::path> vec_path_dir_layer = fs::directory_iterator(path_dir_layers)
    | std::views::filter([](auto&& e){ return fs::is_directory(e.path()); })
    | std::views::transform([](auto&& e){ return e.path(); })
    | std::ranges::to<std::vector<fs::path>>();
  std::ranges::sort(vec_path_dir_layer);
  return vec_path_dir_layer;
}
 
 
 
} // namespace ns_filesystems::ns_utils