transfer_client.hpp

Go to the documentation of this file.

 
#ifndef SNBMODULES_INCLUDE_SNBMODULES_TRANSFER_CLIENT_HPP_
#define SNBMODULES_INCLUDE_SNBMODULES_TRANSFER_CLIENT_HPP_
 
#include "snbmodules/ip_format.hpp"
#include "snbmodules/transfer_session.hpp"
 
#include "snbmodules/common/notification_enum.hpp"
#include "snbmodules/notification_interface.hpp"
 
// errors handling
#include "logging/Logging.hpp"
#include "snbmodules/common/errors_declaration.hpp"
 
#include <filesystem>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unistd.h>
#include <utility>
 
namespace dunedaq::snbmodules {
class TransferClient : public NotificationInterface
{
 
public:
  TransferClient(const IPFormat& listening_ip,
                 const std::string& client_id,
                 const std::filesystem::path& listening_dir,
                 const std::string& connection_prefix = "snbmodules",
                 int timeout_send = 10,
                 int timeout_receive = 100);
 
  ~TransferClient();
 
  bool start(int timeout);
 
  bool do_work(std::atomic<bool>& running_flag);
 
  void create_new_transfer(const std::string& transfer_id,
                           const std::string& protocol,
                           const std::set<std::string>& dest_clients,
                           const std::set<std::filesystem::path>& files,
                           const nlohmann::json& protocol_options = nlohmann::json());
 
  void start_transfer(const std::string& transfer_id);
  void pause_transfer(const std::string& transfer_id);
  void resume_transfer(const std::string& transfer_id);
  void cancel_transfer(const std::string& transfer_id);
 
  TransferSession& create_session(GroupMetadata transfer_options,
                                  e_session_type type,
                                  std::string id,
                                  const std::filesystem::path& work_dir,
                                  IPFormat ip = IPFormat(),
                                  const std::set<std::string>& dest_clients = std::set<std::string>());
 
  void scan_available_files(std::set<std::filesystem::path>& previous_scan,
                            bool nested = false,
                            std::filesystem::path folder = std::filesystem::path());
 
  // Getters
  inline IPFormat get_ip() const { return m_listening_ip; }
  inline std::string get_client_id() const { return m_client_id; }
  inline std::filesystem::path get_listening_dir() const { return m_listening_dir; }
  TransferSession* get_session(std::string transfer_id);
  inline std::vector<TransferSession>& get_sessions() { return m_sessions; }
  inline const std::vector<TransferSession>& get_sessions() const { return m_sessions; }
  std::string get_my_conn();
 
  // Setters
  inline void set_ip(const std::string& ip) { m_listening_ip.set_ip(ip); }
  inline void set_port(int port) { m_listening_ip.set_port(port); }
  inline void set_client_id(std::string client_id) { m_client_id = std::move(client_id); }
  inline void set_listening_dir(const std::filesystem::path& listening_dir)
  {
    // remove all occurences of ./ in the file path
    std::string file_path_str = listening_dir.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_listening_dir = std::filesystem::absolute(file_path_str);
  }
 
private:
  IPFormat m_listening_ip;
 
  std::string m_client_id;
 
  std::filesystem::path m_listening_dir;
 
  std::vector<TransferSession> m_sessions;
 
  std::map<std::string, std::shared_ptr<TransferMetadata>> m_available_files;
 
  std::string m_my_conn = "";
 
  std::string generate_session_id(const std::string& transferid, const std::string& dest = "");
 
  // TransferSession &add_session(TransferSession session);
 
  void remove_session(const std::string& session_id);
 
  bool action_on_receive_notification(NotificationData notif) override;
 
  void share_available_files(const std::set<std::filesystem::path>& to_share, const std::string& dest);
 
  std::shared_ptr<TransferMetadata> create_metadata_from_file(const std::filesystem::path& src);
};
} // namespace dunedaq::snbmodules
#endif // SNBMODULES_INCLUDE_SNBMODULES_TRANSFER_CLIENT_HPP_