dunedaq::snbmodules::TransferSession Class Reference

TransferSession class contained in a client, is a wrapper for a transfer. extend notification interface because the session can communicate with bookkeeper via client initialized connection. More...

#include <transfer_session.hpp>

Inheritance diagram for dunedaq::snbmodules::TransferSession:

Collaboration diagram for dunedaq::snbmodules::TransferSession:

Public Member Functions
bool	update_metadatas_to_bookkeeper ()
bool	update_metadata_to_bookkeeper (TransferMetadata &f_meta)
bool	is_downloader ()
	Usefull to check if the session is a downloader.
bool	is_uploader ()
	Usefull to check if the session is a uploader.
bool	operator== (TransferSession const &other) const
	equal operator, used to compare sessions in a set (client)
bool	operator< (TransferSession const &other) const
	Operator <, used to compare sessions in a set (client)
	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 >())
	Constructor.
virtual	~TransferSession ()
	Destructor Kill all threads created by the session (TODO : useless ?)
const GroupMetadata &	get_transfer_options () const
GroupMetadata &	get_transfer_options ()
std::filesystem::path	get_work_dir () const
const std::set< std::string > &	get_target_clients () const
IPFormat	get_ip () const
std::string	get_session_id () const
std::string	to_string () const
void	set_target_clients (std::set< std::string > clients)
void	add_file (std::shared_ptr< TransferMetadata > fmeta)
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)
	Start the session by downloading or uploading files depending on the type of session TODO : separate thread ?
bool	start_all ()
bool	download_all (const std::filesystem::path &dest)
bool	download_file (TransferMetadata &f_meta, std::filesystem::path dest, bool is_multiple=false)
bool	upload_all ()
bool	upload_file (TransferMetadata &f_meta, bool is_multiple=false)
Public Member Functions inherited from dunedaq::snbmodules::NotificationInterface
	NotificationInterface (std::string connection_prefix="snbmodules", int timeout_send=10, int timeout_receive=100)
	NotificationInterface (std::vector< std::string > bk_conn, std::set< std::string > client_conn, const std::string &connection_prefix="snbmodules", int timeout_send=10, int timeout_receive=100)
virtual	~NotificationInterface ()=default
std::optional< NotificationData >	listen_for_notification (const std::string &id, const std::string &expected_from="", int timeout=-1, int tries=-1)
	Listen for a notification.
bool	send_notification (const notification_type::e_notification_type &notif, const std::string &src, const std::string &dst, const std::string &id_conn, const std::string &data="", int tries=-1)
	Send a notification during m_timeout_send ms.
void	lookups_connections ()
	Get the list of every connections, must have the prefix first in the name of the connection and the name of the connection must be in the format: prefix.*bookkeeper.* or prefix.*client.*.
const std::vector< std::string > &	get_bookkeepers_conn () const
	Init the connection interface, Only used for standalone application.
const std::set< std::string > &	get_clients_conn () const

Static Public Member Functions
static std::string	session_type_to_string (e_session_type e)

Private Member Functions
bool	action_on_receive_notification (NotificationData notif) override
	handle actions to be taken when a notification is received. The notification is passed as a parameter by the client because only 1 connection is opened (not possible to open connection after configuration)
bool	send_notification_to_targets (notification_type::e_notification_type type, const std::string &data="")
	Send a notification to every targets of the session, generally for the uploader.

Private Attributes
e_session_type	m_type
	Type of session, uploader or downloader. Used to block access to some functions.
std::string	m_session_id
	Unique identifier of the session, used to identify the session in the client and to target notification.
IPFormat	m_ip
	Ip of the client TODO : useless ? the session cannot have a unique connection.
std::unique_ptr< TransferInterfaceAbstract >	m_transfer_interface
	Abstract interface can reference to any protocol used to transfer data.
GroupMetadata	m_transfer_options
	A session must contain a transfer matadata. The session is basically a transfer wrapper.
std::filesystem::path	m_work_dir
	List of threads created by the session TODO : useless ? should be handle in client.
std::set< std::string >	m_target_clients
	clients that dowload the files, only used by uploader

Detailed Description

TransferSession class contained in a client, is a wrapper for a transfer. extend notification interface because the session can communicate with bookkeeper via client initialized connection.

Definition at line 45 of file transfer_session.hpp.

Constructor & Destructor Documentation

TransferSession() [1/2]

dunedaq::snbmodules::TransferSession::TransferSession ( TransferSession && )

default

TransferSession() [2/2]

dunedaq::snbmodules::TransferSession::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>() )

Constructor.

Parameters

transfer_options	group metadata
type	type of session
id	unique identifier of the session
ip	ip of the client (TODO : useless ?)

Definition at line 21 of file transfer_session.cpp.

  : NotificationInterface(std::move(bk_conn), std::move(client_conn))
  , m_type(type)
  , m_session_id(std::move(id))
  , m_ip(ip)
  , m_transfer_options(std::move(transfer_options))
  ,
  //   m_threads(std::vector<pid_t>()),
  m_work_dir(std::move(work_dir))
{
  std::filesystem::create_directories(m_work_dir);
 
  // Init transfer interface with the right protocol
  switch (m_transfer_options.get_protocol()) {
    case protocol_type::BITTORRENT:
 
      // check if port is set
      if (!m_transfer_options.get_protocol_options().contains("port")) {
        ers::fatal(ConfigError(ERS_HERE, "port is mandatory in Bittorrent protocol options"));
        return;
      }
 
      m_transfer_interface = std::make_unique<TransferInterfaceBittorrent>(
        m_transfer_options, type == e_session_type::Downloader, get_work_dir(), get_ip());
 
      // Generate torrent files and magnet links
      if (type == e_session_type::Uploader) {
        TLOG() << "Generating torrent files...";
        dynamic_cast<TransferInterfaceBittorrent&>(*m_transfer_interface).generate_torrents_files(m_work_dir, "");
 
        for (auto f_meta : m_transfer_options.get_transfers_meta()) {
          TLOG() << "Writing magnet link data into transfer Metadata "
                 << get_work_dir().append(f_meta->get_file_name() + ".torrent");
          lt::error_code ec;
          lt::torrent_info t(get_work_dir().append(f_meta->get_file_name() + ".torrent").string(), ec);
 
          if (ec) {
            ers::error(BittorrentInvalidTorrentFileError(ERS_HERE, ec.message()));
          }
 
          TLOG() << "Magnet link: " << lt::make_magnet_uri(t);
          f_meta->set_magnet_link(lt::make_magnet_uri(t) + "&x.pe=" + get_ip().get_ip() + ":" +
                                  m_transfer_options.get_protocol_options()["port"].get<std::string>());
        }
      }
      break;
 
    case protocol_type::SCP:
      m_transfer_interface =
        std::make_unique<TransferInterfaceSCP>(m_transfer_options, type == e_session_type::Uploader);
      break;
 
    case protocol_type::RCLONE: {
      m_transfer_interface = std::make_unique<TransferInterfaceRClone>(m_transfer_options, get_work_dir());
      break;
    }
 
    case protocol_type::dummy:
      m_transfer_interface = std::make_unique<TransferInterfaceDummy>(m_transfer_options);
      break;
 
    default:
      ers::error(InvalidProtocolError(
        ERS_HERE, get_session_id(), protocol_type::protocols_to_string(m_transfer_options.get_protocol())));
      break;
  }
 
  TLOG() << "debug : Transfer session " << get_session_id() << " created";
  update_metadatas_to_bookkeeper();
}

~TransferSession()

dunedaq::snbmodules::TransferSession::~TransferSession ( )

virtual

Destructor Kill all threads created by the session (TODO : useless ?)

Definition at line 98 of file transfer_session.cpp.

{
  // TLOG() << "Reaping children";
  // for (pid_t pid : m_threads)
  // {
  //     TLOG() << "Killing pid " << pid;
  //     kill(pid, SIGINT);
  //     kill(pid, SIGKILL);
  // }
  // for (pid_t pid : m_threads)
  // {
  //     TLOG() << "Waiting for pid " << pid;
  //     siginfo_t status;
  //     auto sts = waitid(P_PID, pid, &status, WEXITED);
 
  //     TLOG() << "Forked process " << pid << " exited with status " << status.si_status << " (wait status " << sts
  //            << ")";
  // }
 
  TLOG() << "DONE CLOSING SESSION " << get_session_id();
}

Member Function Documentation

action_on_receive_notification()

bool dunedaq::snbmodules::TransferSession::action_on_receive_notification ( NotificationData notif )

overrideprivatevirtual

handle actions to be taken when a notification is received. The notification is passed as a parameter by the client because only 1 connection is opened (not possible to open connection after configuration)

Parameters

notif

contain everything we need to know about the notification

Implements dunedaq::snbmodules::NotificationInterface.

Definition at line 121 of file transfer_session.cpp.

{
  (void)notif;
  // TODO : now in client
  return true;
}

add_file()

void dunedaq::snbmodules::TransferSession::add_file ( std::shared_ptr< TransferMetadata > fmeta )

inline

Definition at line 114 of file transfer_session.hpp.

  {
    TransferMetadata& moved_meta = get_transfer_options().add_file(std::move(fmeta));
    update_metadata_to_bookkeeper(moved_meta);
  }

cancel_all()

bool dunedaq::snbmodules::TransferSession::cancel_all

(

)

Definition at line 422 of file transfer_session.cpp.

{
  bool result = true;
  for (auto file : m_transfer_options.get_transfers_meta()) {
    result = result && cancel_file(*file, true);
  }
 
  send_notification_to_targets(notification_type::e_notification_type::CANCEL_TRANSFER);
  update_metadatas_to_bookkeeper();
  return result;
}

cancel_file()

bool dunedaq::snbmodules::TransferSession::cancel_file	(	TransferMetadata &	f_meta,
		bool	is_multiple = false )

Definition at line 287 of file transfer_session.cpp.

{
  if (f_meta.get_status() == status_type::e_status::FINISHED ||
      f_meta.get_status() == status_type::e_status::CANCELLED) {
    ers::warning(SessionWrongStateTransitionError(ERS_HERE,
                                                  get_session_id(),
                                                  f_meta.get_file_name(),
                                                  status_type::status_to_string(f_meta.get_status()),
                                                  status_type::status_to_string(status_type::e_status::CANCELLED)));
    return false;
  }
 
  f_meta.set_status(status_type::e_status::CANCELLED);
 
  bool res = m_transfer_interface->cancel_file(f_meta);
  if (!res) {
    f_meta.set_status(status_type::e_status::ERROR);
  }
 
  if (!is_multiple) {
    send_notification_to_targets(notification_type::e_notification_type::CANCEL_TRANSFER, f_meta.get_file_path());
    update_metadata_to_bookkeeper(f_meta);
  }
  return res;
}

download_all()

bool dunedaq::snbmodules::TransferSession::download_all

(

const std::filesystem::path &

dest

)

Definition at line 436 of file transfer_session.cpp.

{
  if (m_type != e_session_type::Downloader) {
    ers::warning(SessionAccessToIncorrectActionError(ERS_HERE, get_session_id(), "download_all"));
  }
 
  bool result = true;
  for (auto file : m_transfer_options.get_transfers_meta()) {
    result = result && download_file(*file, dest, true);
  }
  update_metadatas_to_bookkeeper();
  return result;
}

download_file()

bool dunedaq::snbmodules::TransferSession::download_file	(	TransferMetadata &	f_meta,
		std::filesystem::path	dest,
		bool	is_multiple = false )

Definition at line 344 of file transfer_session.cpp.

{
  if (m_type != e_session_type::Downloader) {
    ers::warning(SessionAccessToIncorrectActionError(ERS_HERE, get_session_id(), "download_file"));
  }
 
  if (f_meta.get_status() != status_type::e_status::WAITING) {
    ers::warning(SessionWrongStateTransitionError(ERS_HERE,
                                                  get_session_id(),
                                                  f_meta.get_file_name(),
                                                  status_type::status_to_string(f_meta.get_status()),
                                                  status_type::status_to_string(status_type::e_status::DOWNLOADING)));
    return false;
  }
 
  // wait for the uploader to be ready
  std::this_thread::sleep_for(std::chrono::seconds(1));
 
  f_meta.set_status(status_type::e_status::DOWNLOADING);
 
  bool res = m_transfer_interface->download_file(f_meta, std::move(dest));
  if (!res) {
    f_meta.set_status(status_type::e_status::ERROR);
  }
  if (!is_multiple) {
    update_metadata_to_bookkeeper(f_meta);
  }
  return res;
}

get_ip()

IPFormat dunedaq::snbmodules::TransferSession::get_ip ( ) const

inline

Definition at line 100 of file transfer_session.hpp.

{ return m_ip; }

get_session_id()

std::string dunedaq::snbmodules::TransferSession::get_session_id ( ) const

inline

Definition at line 101 of file transfer_session.hpp.

{ return m_session_id; }

get_target_clients()

const std::set< std::string > & dunedaq::snbmodules::TransferSession::get_target_clients ( ) const

inline

Definition at line 99 of file transfer_session.hpp.

{ return m_target_clients; }

get_transfer_options() [1/2]

GroupMetadata & dunedaq::snbmodules::TransferSession::get_transfer_options ( )

inline

Definition at line 97 of file transfer_session.hpp.

{ return m_transfer_options; }

get_transfer_options() [2/2]

const GroupMetadata & dunedaq::snbmodules::TransferSession::get_transfer_options ( ) const

inline

Definition at line 96 of file transfer_session.hpp.

{ return m_transfer_options; }

get_work_dir()

std::filesystem::path dunedaq::snbmodules::TransferSession::get_work_dir ( ) const

inline

Definition at line 98 of file transfer_session.hpp.

{ return m_work_dir; }

hash_file()

bool dunedaq::snbmodules::TransferSession::hash_file	(	TransferMetadata &	f_meta,
		bool	is_multiple = false )

Definition at line 261 of file transfer_session.cpp.

{
  if (f_meta.get_status() != status_type::e_status::FINISHED) {
    ers::warning(SessionWrongStateTransitionError(ERS_HERE,
                                                  get_session_id(),
                                                  f_meta.get_file_name(),
                                                  status_type::status_to_string(f_meta.get_status()),
                                                  status_type::status_to_string(status_type::e_status::HASHING)));
    return false;
  }
 
  f_meta.set_status(status_type::e_status::HASHING);
 
  bool res = m_transfer_interface->hash_file(f_meta);
  if (!res) {
    f_meta.set_status(status_type::e_status::ERROR);
  }
 
  if (!is_multiple) {
    // send_notification_to_targets(notification_type::e_notification_type::HASH_TRANSFER, f_meta.get_file_path());
    update_metadata_to_bookkeeper(f_meta);
  }
  return res;
}

is_downloader()

bool dunedaq::snbmodules::TransferSession::is_downloader ( )

inline

Usefull to check if the session is a downloader.

Returns

true if the session is a downloader

Definition at line 59 of file transfer_session.hpp.

{ return m_type == e_session_type::Downloader; }

is_uploader()

bool dunedaq::snbmodules::TransferSession::is_uploader ( )

inline

Usefull to check if the session is a uploader.

Returns

true if the session is an uploader

Definition at line 63 of file transfer_session.hpp.

{ return m_type == e_session_type::Uploader; }

operator<()

bool dunedaq::snbmodules::TransferSession::operator< ( TransferSession const & other ) const

inline

Operator <, used to compare sessions in a set (client)

Parameters

other

other session

Returns

is less than ?

Definition at line 73 of file transfer_session.hpp.

{ return m_session_id.compare(other.m_session_id); }

operator=()

TransferSession & dunedaq::snbmodules::TransferSession::operator= ( TransferSession && )

default

operator==()

bool dunedaq::snbmodules::TransferSession::operator== ( TransferSession const & other ) const

inline

equal operator, used to compare sessions in a set (client)

Parameters

other

other session

Returns

is equal ?

Definition at line 68 of file transfer_session.hpp.

{ return m_session_id == other.m_session_id; }

pause_all()

bool dunedaq::snbmodules::TransferSession::pause_all

(

)

Definition at line 388 of file transfer_session.cpp.

{
 
  send_notification_to_targets(notification_type::e_notification_type::PAUSE_TRANSFER);
 
  // wait 1 second
  std::this_thread::sleep_for(std::chrono::seconds(1));
 
  bool result = true;
  for (auto file : m_transfer_options.get_transfers_meta()) {
    result = result && pause_file(*file, true);
  }
 
  update_metadatas_to_bookkeeper();
  return result;
}

pause_file()

bool dunedaq::snbmodules::TransferSession::pause_file	(	TransferMetadata &	f_meta,
		bool	is_multiple = false )

Definition at line 202 of file transfer_session.cpp.

{
  if (f_meta.get_status() != status_type::e_status::DOWNLOADING &&
      f_meta.get_status() != status_type::e_status::UPLOADING) {
    ers::warning(SessionWrongStateTransitionError(ERS_HERE,
                                                  get_session_id(),
                                                  f_meta.get_file_name(),
                                                  status_type::status_to_string(f_meta.get_status()),
                                                  status_type::status_to_string(status_type::e_status::PAUSED)));
    return false;
  }
 
  f_meta.set_status(status_type::e_status::PAUSED);
 
  bool res = m_transfer_interface->pause_file(f_meta);
  if (!res) {
    f_meta.set_status(status_type::e_status::ERROR);
  }
 
  if (!is_multiple) {
    send_notification_to_targets(notification_type::e_notification_type::PAUSE_TRANSFER, f_meta.get_file_path());
    update_metadata_to_bookkeeper(f_meta);
  }
 
  return res;
}

resume_all()

bool dunedaq::snbmodules::TransferSession::resume_all

(

)

Definition at line 406 of file transfer_session.cpp.

{
  bool result = true;
  for (auto file : m_transfer_options.get_transfers_meta()) {
    result = result && resume_file(*file, true);
  }
 
  // wait 1 second
  std::this_thread::sleep_for(std::chrono::seconds(1));
 
  send_notification_to_targets(notification_type::e_notification_type::RESUME_TRANSFER);
  update_metadatas_to_bookkeeper();
  return result;
}

resume_file()

bool dunedaq::snbmodules::TransferSession::resume_file	(	TransferMetadata &	f_meta,
		bool	is_multiple = false )

Definition at line 230 of file transfer_session.cpp.

{
  if (f_meta.get_status() != status_type::e_status::PAUSED) {
    ers::warning(SessionWrongStateTransitionError(ERS_HERE,
                                                  get_session_id(),
                                                  f_meta.get_file_name(),
                                                  status_type::status_to_string(f_meta.get_status()),
                                                  "RESUMING"));
    return false;
  }
 
  if (is_downloader()) {
    f_meta.set_status(status_type::e_status::DOWNLOADING);
  } else if (is_uploader()) {
    f_meta.set_status(status_type::e_status::UPLOADING);
  }
 
  bool res = m_transfer_interface->resume_file(f_meta);
  if (!res) {
    f_meta.set_status(status_type::e_status::ERROR);
  }
 
  if (!is_multiple) {
    send_notification_to_targets(notification_type::e_notification_type::RESUME_TRANSFER, f_meta.get_file_path());
    update_metadata_to_bookkeeper(f_meta);
  }
 
  return res;
}

send_notification_to_targets()

bool dunedaq::snbmodules::TransferSession::send_notification_to_targets ( notification_type::e_notification_type type, const std::string & data = "" )

private

Send a notification to every targets of the session, generally for the uploader.

Parameters

type	type of notification to send
data	data to send, default empty

Returns

true if success

Definition at line 175 of file transfer_session.cpp.

{
  bool result = true;
  for (const std::string& client : get_target_clients()) {
    std::string session_name = client + "_ses" + m_transfer_options.get_group_id();
    result &= send_notification(type, get_session_id(), session_name, client, data);
  }
  return result;
}

session_type_to_string()

static std::string dunedaq::snbmodules::TransferSession::session_type_to_string ( e_session_type e )

inlinestatic

Definition at line 103 of file transfer_session.hpp.

  {
    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;
  }

set_target_clients()

void dunedaq::snbmodules::TransferSession::set_target_clients ( std::set< std::string > clients )

inline

Definition at line 111 of file transfer_session.hpp.

{ m_target_clients = std::move(clients); }

start_all()

bool dunedaq::snbmodules::TransferSession::start_all

(

)

Definition at line 375 of file transfer_session.cpp.

{
  if (is_downloader()) {
    return download_all(m_work_dir);
  } else if (is_uploader()) {
    return upload_all();
  } else {
    ers::error(SessionTypeNotSupportedError(ERS_HERE, get_session_id()));
    return false;
  }
}

start_file()

bool dunedaq::snbmodules::TransferSession::start_file

(

TransferMetadata &

f_meta

)

Start the session by downloading or uploading files depending on the type of session TODO : separate thread ?

Definition at line 187 of file transfer_session.cpp.

{
  bool res = false;
  if (is_downloader()) {
    res = download_file(f_meta, m_work_dir);
  } else if (is_uploader()) {
    res = upload_file(f_meta);
  } else {
    ers::error(SessionTypeNotSupportedError(ERS_HERE, get_session_id()));
  }
 
  return res;
}

to_string()

std::string dunedaq::snbmodules::TransferSession::to_string

(

)

const

Definition at line 129 of file transfer_session.cpp.

{
  std::string str;
  str += "Session " + get_session_id() + " ";
  str += "type " + TransferSession::session_type_to_string(m_type) + " ";
  str += "listening on " + m_ip.get_ip_port() + "\n";
 
  str += m_transfer_options.to_string();
 
  return str;
}

update_metadata_to_bookkeeper()

bool dunedaq::snbmodules::TransferSession::update_metadata_to_bookkeeper

(

TransferMetadata &

f_meta

)

Update the metadata of the given transfer metadata to the bookkeeper

Returns

true if success

Definition at line 161 of file transfer_session.cpp.

{
  bool result = true;
  for (const std::string& bk : get_bookkeepers_conn()) {
    result = result && send_notification(notification_type::e_notification_type::TRANSFER_METADATA,
                                         get_session_id(),
                                         bk,
                                         bk,
                                         f_meta.export_to_string_partial(false));
  }
  return result;
}

update_metadatas_to_bookkeeper()

bool dunedaq::snbmodules::TransferSession::update_metadatas_to_bookkeeper

(

)

Update the metadata of the session to the bookkeeper

Returns

true if success

Definition at line 142 of file transfer_session.cpp.

{
  bool result = true;
  for (const std::string& bk : get_bookkeepers_conn()) {
    result = result && send_notification(notification_type::e_notification_type::GROUP_METADATA,
                                         get_session_id(),
                                         bk,
                                         bk,
                                         get_transfer_options().export_to_string());
  }
 
  for (std::shared_ptr<TransferMetadata> f_meta : m_transfer_options.get_transfers_meta()) {
    result = result && update_metadata_to_bookkeeper(*f_meta);
  }
 
  return result;
}

upload_all()

bool dunedaq::snbmodules::TransferSession::upload_all

(

)

Definition at line 452 of file transfer_session.cpp.

{
  if (m_type != e_session_type::Uploader) {
    ers::warning(SessionAccessToIncorrectActionError(ERS_HERE, get_session_id(), "upload_all"));
  }
 
  bool result = true;
  for (auto file : m_transfer_options.get_transfers_meta()) {
    result = result && upload_file(*file, true);
  }
  send_notification_to_targets(notification_type::e_notification_type::START_TRANSFER);
  update_metadatas_to_bookkeeper();
  return result;
}

upload_file()

bool dunedaq::snbmodules::TransferSession::upload_file	(	TransferMetadata &	f_meta,
		bool	is_multiple = false )

Definition at line 314 of file transfer_session.cpp.

{
  if (m_type != e_session_type::Uploader) {
    ers::warning(SessionAccessToIncorrectActionError(ERS_HERE, get_session_id(), "upload_file"));
  }
 
  if (f_meta.get_status() != status_type::e_status::WAITING) {
    ers::warning(SessionWrongStateTransitionError(ERS_HERE,
                                                  get_session_id(),
                                                  f_meta.get_file_name(),
                                                  status_type::status_to_string(f_meta.get_status()),
                                                  status_type::status_to_string(status_type::e_status::UPLOADING)));
    return false;
  }
 
  f_meta.set_status(status_type::e_status::UPLOADING);
 
  bool res = m_transfer_interface->upload_file(f_meta);
  if (!res) {
    f_meta.set_status(status_type::e_status::ERROR);
  }
 
  if (!is_multiple) {
    send_notification_to_targets(notification_type::e_notification_type::START_TRANSFER, f_meta.get_file_path());
    update_metadata_to_bookkeeper(f_meta);
  }
  return res;
}

Member Data Documentation

m_ip

IPFormat dunedaq::snbmodules::TransferSession::m_ip

private

Ip of the client TODO : useless ? the session cannot have a unique connection.

Definition at line 153 of file transfer_session.hpp.

m_session_id

std::string dunedaq::snbmodules::TransferSession::m_session_id

private

Unique identifier of the session, used to identify the session in the client and to target notification.

Definition at line 149 of file transfer_session.hpp.

m_target_clients

std::set<std::string> dunedaq::snbmodules::TransferSession::m_target_clients

private

clients that dowload the files, only used by uploader

Definition at line 170 of file transfer_session.hpp.

m_transfer_interface

std::unique_ptr<TransferInterfaceAbstract> dunedaq::snbmodules::TransferSession::m_transfer_interface

private

Abstract interface can reference to any protocol used to transfer data.

Definition at line 156 of file transfer_session.hpp.

m_transfer_options

GroupMetadata dunedaq::snbmodules::TransferSession::m_transfer_options

private

A session must contain a transfer matadata. The session is basically a transfer wrapper.

Definition at line 160 of file transfer_session.hpp.

m_type

e_session_type dunedaq::snbmodules::TransferSession::m_type

private

Type of session, uploader or downloader. Used to block access to some functions.

Definition at line 145 of file transfer_session.hpp.

m_work_dir

std::filesystem::path dunedaq::snbmodules::TransferSession::m_work_dir

private

List of threads created by the session TODO : useless ? should be handle in client.

Dir where the session write files

Definition at line 167 of file transfer_session.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/snbmodules/include/snbmodules/transfer_session.hpp
• /github/workspace/dunedaq/sourcecode/snbmodules/src/client/transfer_session.cpp