group_metadata.hpp

Go to the documentation of this file.

 
#ifndef SNBMODULES_INCLUDE_SNBMODULES_GROUP_METADATA_HPP_
#define SNBMODULES_INCLUDE_SNBMODULES_GROUP_METADATA_HPP_
 
#include "appfwk/cmd/Nljs.hpp"
#include "snbmodules/common/protocols_enum.hpp"
#include "snbmodules/metadata_abstract.hpp"
#include "snbmodules/transfer_metadata.hpp"
 
#include <filesystem>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
namespace dunedaq::snbmodules {
class GroupMetadata : public MetadataAbstract
{
 
public:
  static const std::string m_file_extension;
 
  void generate_metadata_file(std::filesystem::path dest) override;
  void load_metadata_from_meta_file(std::filesystem::path src) override;
  std::string export_to_string() override;
  void from_string(const std::string&) override;
 
  status_type::e_status get_group_status() const
  {
    status_type::e_status status = status_type::e_status::PREPARING;
    for (const auto& transfer : get_transfers_meta()) {
      if (transfer->get_status() > status) {
        status = transfer->get_status();
      }
    }
    return status;
  }
 
  GroupMetadata(std::string group_id,
                std::string source,
                const IPFormat& source_ip,
                protocol_type::e_protocol_type protocol,
                const nlohmann::json& protocol_options = nlohmann::json(),
                const std::vector<std::shared_ptr<TransferMetadata>>& transfers_meta =
                  std::vector<std::shared_ptr<TransferMetadata>>())
    : m_group_id(std::move(group_id))
    , m_protocol(protocol)
    , m_transfers_meta(transfers_meta)
    , m_expected_files(std::set<std::string>())
    , m_source_id(std::move(source))
    , m_source_ip(source_ip)
  {
    set_protocol_options(protocol_options);
  }
 
  explicit GroupMetadata(const std::filesystem::path& src, bool is_path = true)
  {
    if (is_path) {
      load_metadata_from_meta_file(src);
    } else {
      from_string(src.string());
    }
  }
 
  virtual ~GroupMetadata() = default;
 
  bool operator==(MetadataAbstract const& other) const override
  {
    auto o = dynamic_cast<const GroupMetadata&>(other);
    return m_group_id == o.m_group_id;
  }
 
  bool operator<(MetadataAbstract const& other) const override
  {
    auto o = dynamic_cast<const GroupMetadata&>(other);
    return m_group_id.compare(o.m_group_id);
  }
 
  // Setters
  inline void set_group_id(std::string transfer_id) { m_group_id = std::move(transfer_id); }
  inline void set_protocol(protocol_type::e_protocol_type protocol) { m_protocol = protocol; }
  inline void set_transfers_meta(std::vector<std::shared_ptr<TransferMetadata>> files_meta)
  {
    m_transfers_meta = std::move(files_meta);
  }
  inline void set_protocol_options(nlohmann::json protocol_options)
  {
    m_protocol_options = std::move(protocol_options);
  }
  inline void set_source_id(std::string source_id) { m_source_id = std::move(source_id); }
  inline void set_expected_files(std::set<std::string> expected_files) { m_expected_files = std::move(expected_files); }
  TransferMetadata& add_file(std::shared_ptr<TransferMetadata> meta);
  void add_expected_file(const std::filesystem::path& file)
  {
    // remove all occurences of ./ in the file path
    std::string file_path_str = file.string();
    std::string x = "./";
 
    size_t pos = 0;
    while (true) {
      pos = file_path_str.find(x, pos);
      if (pos == std::string::npos) {
        break;
      }
 
      file_path_str.replace(pos, x.length(), "");
    }
 
    m_expected_files.insert(std::filesystem::absolute(file_path_str));
  }
 
  // Getters
  inline std::string get_group_id() const { return m_group_id; }
  inline protocol_type::e_protocol_type get_protocol() const { return m_protocol; }
  inline std::vector<std::shared_ptr<TransferMetadata>>& get_transfers_meta() { return m_transfers_meta; }
  inline const std::vector<std::shared_ptr<TransferMetadata>>& get_transfers_meta() const { return m_transfers_meta; }
  TransferMetadata& get_transfer_meta_from_file_path(const std::string& file_path);
  inline const std::set<std::string>& get_expected_files() const { return m_expected_files; }
  inline nlohmann::json get_protocol_options() const { return m_protocol_options; }
  inline std::string get_source_id() const { return m_source_id; }
  inline IPFormat get_source_ip() const { return m_source_ip; }
  std::string to_string() const;
 
private:
  std::string m_group_id;
 
  protocol_type::e_protocol_type m_protocol;
 
  nlohmann::json m_protocol_options;
 
  std::vector<std::shared_ptr<TransferMetadata>> m_transfers_meta;
 
  std::set<std::string> m_expected_files;
 
  std::string m_source_id;
 
  IPFormat m_source_ip;
};
 
} // namespace dunedaq::snbmodules
#endif // SNBMODULES_INCLUDE_SNBMODULES_GROUP_METADATA_HPP_