transfer_session.hpp

Go to the documentation of this file.

 
#ifndef SNBMODULES_INCLUDE_SNBMODULES_TRANSFER_SESSION_HPP_
#define SNBMODULES_INCLUDE_SNBMODULES_TRANSFER_SESSION_HPP_
 
#include "snbmodules/common/protocols_enum.hpp"
#include "snbmodules/group_metadata.hpp"
#include "snbmodules/notification_interface.hpp" // for notification data
#include "snbmodules/transfer_metadata.hpp"
 
// protocols
#include "snbmodules/interfaces/transfer_interface_RClone.hpp"
#include "snbmodules/interfaces/transfer_interface_SCP.hpp"
#include "snbmodules/interfaces/transfer_interface_abstract.hpp"
#include "snbmodules/interfaces/transfer_interface_bittorrent.hpp"
 
#include <fstream>
#include <memory>
#include <set>
#include <string>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <utility>
#include <vector>
 
namespace dunedaq::snbmodules {
enum e_session_type
{
  Downloader,
  Uploader,
};
 
class TransferSession : public NotificationInterface
{
 
public:
  bool update_metadatas_to_bookkeeper();
 
  bool update_metadata_to_bookkeeper(TransferMetadata& f_meta);
 
  bool is_downloader() { return m_type == e_session_type::Downloader; }
 
  bool is_uploader() { return m_type == e_session_type::Uploader; }
 
  bool operator==(TransferSession const& other) const { return m_session_id == other.m_session_id; }
 
  bool operator<(TransferSession const& other) const { return m_session_id.compare(other.m_session_id); }
 
  TransferSession(TransferSession&&) = default;
  TransferSession& operator=(TransferSession&&) = default;
 
  TransferSession(GroupMetadata transfer_options,
                  e_session_type type,
                  std::string id,
                  const IPFormat& ip,
                  std::filesystem::path work_dir,
                  std::vector<std::string> bk_conn = std::vector<std::string>(),
                  std::set<std::string> client_conn = std::set<std::string>());
 
  virtual ~TransferSession();
 
  // Getters
  inline const GroupMetadata& get_transfer_options() const { return m_transfer_options; }
  inline GroupMetadata& get_transfer_options() { return m_transfer_options; }
  inline std::filesystem::path get_work_dir() const { return m_work_dir; }
  inline const std::set<std::string>& get_target_clients() const { return m_target_clients; }
  inline IPFormat get_ip() const { return m_ip; }
  std::string get_session_id() const { return m_session_id; }
  std::string to_string() const;
  static std::string session_type_to_string(e_session_type e)
  {
    const std::map<e_session_type, std::string> MyEnumStrings{ { Downloader, "Downloader" }, { Uploader, "Uploader" } };
    auto it = MyEnumStrings.find(e);
    return it == MyEnumStrings.end() ? "Not supported" : it->second;
  }
 
  // Setters
  void set_target_clients(std::set<std::string> clients) { m_target_clients = std::move(clients); }
 
  // Interface for the transfer, TODO: add notifications : DO WE REALLY WANT THAT ?
  void add_file(std::shared_ptr<TransferMetadata> fmeta)
  {
    TransferMetadata& moved_meta = get_transfer_options().add_file(std::move(fmeta));
    update_metadata_to_bookkeeper(moved_meta);
  }
 
  bool pause_file(TransferMetadata& f_meta, bool is_multiple = false);
  bool resume_file(TransferMetadata& f_meta, bool is_multiple = false);
  bool hash_file(TransferMetadata& f_meta, bool is_multiple = false);
  bool cancel_file(TransferMetadata& f_meta, bool is_multiple = false);
 
  bool pause_all();
  bool resume_all();
  bool cancel_all();
 
  bool start_file(TransferMetadata& f_meta);
  bool start_all();
 
  // Downloaders only
  bool download_all(const std::filesystem::path& dest);
  bool download_file(TransferMetadata& f_meta, std::filesystem::path dest, bool is_multiple = false);
 
  // Uploaders only
  bool upload_all();
  bool upload_file(TransferMetadata& f_meta, bool is_multiple = false);
 
private:
  e_session_type m_type;
 
  std::string m_session_id;
 
  IPFormat m_ip;
 
  std::unique_ptr<TransferInterfaceAbstract> m_transfer_interface;
 
  GroupMetadata m_transfer_options;
 
  // std::vector<pid_t> m_threads;
 
  std::filesystem::path m_work_dir;
 
  std::set<std::string> m_target_clients;
 
  bool action_on_receive_notification(NotificationData notif) override;
 
  bool send_notification_to_targets(notification_type::e_notification_type type, const std::string& data = "");
};
 
} // namespace dunedaq::snbmodules
#endif // SNBMODULES_INCLUDE_SNBMODULES_TRANSFER_SESSION_HPP_