dunedaq::iomanager Namespace Reference

Namespaces
namespace	opmon

Classes
class	ConfigClient
struct	ConnectionId
struct	ConnectionInfo
struct	ConnectionRegistration
struct	ConnectionRequest
struct	ConnectionResponse
class	FollyQueue
class	IOManager
class	NetworkManager
class	NetworkReceiverModel
class	NetworkSenderModel
class	Queue
	Implementations of the Queue class are responsible for relaying data between DAQModules within a DAQ Application. More...
class	QueueBase
	The QueueBase class allows to address generic behavior of any Queue implementation. More...
class	QueueReceiverModel
class	QueueRegistry
	The QueueRegistry class manages all Queue instances and gives out handles to the Queues upon request. More...
class	QueueSenderModel
class	Receiver
class	ReceiverConcept
class	Sender
class	SenderConcept
class	StdDeQueue
	A Queue Implementation that uses a std::deque as its backend. More...

Typedefs
template<typename T >
using	FollySPSCQueue = FollyQueue<T, folly::DSPSCQueue>
template<typename T >
using	FollyMPMCQueue = FollyQueue<T, folly::DMPMCQueue>

Enumerations
enum class	ConnectionType : int { kSendRecv = 0 , kPubSub = 1 , kInvalid = 2 }

Functions
ConnectionType	string_to_connection_type_enum (std::string type)
bool	operator< (ConnectionRegistration const &l, ConnectionRegistration const &r)
bool	operator< (ConnectionId const &l, ConnectionId const &r)
bool	operator== (ConnectionId const &l, ConnectionId const &r)
bool	is_match (ConnectionId const &search, ConnectionId const &check)
std::string	to_string (const ConnectionId &conn_id)
std::string	get_uri_for_connection (const confmodel::NetworkConnection *netCon)

Typedef Documentation

FollyMPMCQueue

template<typename T >

using dunedaq::iomanager::FollyMPMCQueue = FollyQueue<T, folly::DMPMCQueue>

Definition at line 99 of file FollyQueue.hpp.

FollySPSCQueue

template<typename T >

using dunedaq::iomanager::FollySPSCQueue = FollyQueue<T, folly::DSPSCQueue>

Definition at line 96 of file FollyQueue.hpp.

Enumeration Type Documentation

ConnectionType

enum class dunedaq::iomanager::ConnectionType : int

strong

Enumerator
kSendRecv
kPubSub
kInvalid

Definition at line 20 of file ConfigClientStructs.hpp.

{
kSendRecv = 0,
kPubSub = 1,
kInvalid = 2,
};

Function Documentation

get_uri_for_connection()

std::string dunedaq::iomanager::get_uri_for_connection ( const confmodel::NetworkConnection * netCon )

inline

Definition at line 97 of file SchemaUtils.hpp.

{
  std::string uri = "";
  if (netCon) {
    TLOG_DEBUG(45) << "Getting URI for network connection " << netCon->UID();
    auto service = netCon->get_associated_service();
    if (service->get_protocol() == "tcp") {
 
      std::string port = "*";
      if (service->get_port() && service->get_port() != 0) {
        port = std::to_string(service->get_port());
      }
      std::string ipaddr = "0.0.0.0";
      char hostname[256];
      if (gethostname(&hostname[0], 256) == 0) {
        ipaddr = std::string(hostname);
      }
      auto iface = service->get_eth_device_name();
      if (iface != "") {
        // Work out which ip address goes with this device
        struct ifaddrs* ifaddr;
        getifaddrs(&ifaddr);
        for (auto ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
          if (ifa->ifa_addr == NULL) {
            continue;
          }
          if (std::string(ifa->ifa_name) == iface) {
            char ip[NI_MAXHOST];
            int status =
              getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
            if (status != 0) {
              continue;
            }
            ipaddr = std::string(ip);
            break;
          }
        }
        freeifaddrs(ifaddr);
      }
      uri = std::string(service->get_protocol() + "://" + ipaddr + ":" + port);
    } else if (service->get_protocol() == "inproc") {
      uri = std::string(service->get_protocol() + "://" + service->get_path());
    }
  }
  return uri;
}

is_match()

bool dunedaq::iomanager::is_match ( ConnectionId const & search, ConnectionId const & check )

inline

Definition at line 74 of file SchemaUtils.hpp.

{
  if (search.data_type != check.data_type)
    return false;
 
  if (search.session != check.session && search.session != "" && check.session != "")
    return false;
 
  std::regex search_ex(search.uid);
  return std::regex_match(check.uid, search_ex);
}

operator<() [1/2]

bool dunedaq::iomanager::operator< ( ConnectionId const & l, ConnectionId const & r )

inline

Definition at line 52 of file SchemaUtils.hpp.

{
  if (l.session == r.session || l.session == "" || r.session == "") {
    if (l.data_type == r.data_type) {
      if (l.uid == r.uid) {
        return l.tag < r.tag;
      }
      return l.uid < r.uid;
    }
    return l.data_type < r.data_type;
  }
  return l.session < r.session;
}

operator<() [2/2]

bool dunedaq::iomanager::operator< ( ConnectionRegistration const & l, ConnectionRegistration const & r )

inline

Definition at line 112 of file ConfigClientStructs.hpp.

{
  if (l.data_type == r.data_type) {
    return l.uid < r.uid;
  }
  return l.data_type < r.data_type;
}

operator==()

bool dunedaq::iomanager::operator== ( ConnectionId const & l, ConnectionId const & r )

inline

Definition at line 67 of file SchemaUtils.hpp.

{
  return (l.session == "" || r.session == "" || l.session == r.session) && l.uid == r.uid && l.tag == r.tag &&
         l.data_type == r.data_type;
}

string_to_connection_type_enum()

ConnectionType dunedaq::iomanager::string_to_connection_type_enum ( std::string type )

inline

Definition at line 28 of file ConfigClientStructs.hpp.

{
  if (type == confmodel::NetworkConnection::Connection_type::KPubSub)
    return ConnectionType::kPubSub;
  if (type == confmodel::NetworkConnection::Connection_type::KSendRecv)
    return ConnectionType::kSendRecv;
 
  return ConnectionType::kInvalid;
}

to_string()

std::string dunedaq::iomanager::to_string ( const ConnectionId & conn_id )

inline

Definition at line 87 of file SchemaUtils.hpp.

{
  if (conn_id.session != "") {
    return conn_id.session + "/" + conn_id.uid + (conn_id.tag != "" ? "+" + conn_id.tag : "") + "@@" +
           conn_id.data_type;
  }
  return conn_id.uid + (conn_id.tag != "" ? "+" + conn_id.tag : "") + "@@" + conn_id.data_type;
}