dunedaq::tdemodules::AMCProtocolClient Class Reference

#include <AMCProtocolClient.hpp>

Classes
struct	TFTP_Data_Header
struct	TFTP_Error_Header
struct	TFTP_Ack_Header

Public Types
enum	TFTPOpCode : uint16_t {   RRQ = 1 , WRQ = 2 , DAT = 3 , ACK = 4 ,   ERR = 5 }

Public Member Functions
	AMCProtocolClient (const std::string &server_ip, uint16_t port)
std::vector< uint8_t >	send_request (TFTPOpCode opcode, const std::vector< uint8_t > &payload)
std::vector< uint8_t >	send_rrq (const std::vector< uint8_t > &payload)
std::vector< uint8_t >	send_wrq (const std::vector< uint8_t > &payload)

Private Attributes
std::string	m_host
uint16_t	m_port
uint16_t	m_timeout
const std::string	m_log_prefix = "AMC with ip:" + m_host + " and port: " + std::to_string(m_port) + " | "
boost::asio::io_context	m_io_context
boost::asio::ip::udp::socket	m_socket
boost::asio::ip::udp::endpoint	m_server_endpoint

Detailed Description

Definition at line 32 of file AMCProtocolClient.hpp.

Member Enumeration Documentation

TFTPOpCode

enum dunedaq::tdemodules::AMCProtocolClient::TFTPOpCode : uint16_t

Enumerator
RRQ
WRQ
DAT
ACK
ERR

Definition at line 35 of file AMCProtocolClient.hpp.

  {
    RRQ = 1,
    WRQ = 2,
    DAT = 3,
    ACK = 4,
    ERR = 5,
  };

Constructor & Destructor Documentation

AMCProtocolClient()

dunedaq::tdemodules::AMCProtocolClient::AMCProtocolClient	(	const std::string &	server_ip,
		uint16_t	port )

Definition at line 12 of file AMCProtocolClient.cpp.

  : m_host(server_ip)
  , m_port(port)
  , m_timeout(50)
  , m_io_context()
  , m_socket(m_io_context)
{
 
  using boost::asio::ip::udp;
  udp::resolver resolver(m_io_context);
  m_server_endpoint = *resolver.resolve(udp::v4(), m_host, std::to_string(m_port)).begin();
 
  m_socket.open(udp::v4());
  m_socket.non_blocking(true);
}

Member Function Documentation

send_request()

std::vector< uint8_t > dunedaq::tdemodules::AMCProtocolClient::send_request	(	TFTPOpCode	opcode,
		const std::vector< uint8_t > &	payload )

Definition at line 29 of file AMCProtocolClient.cpp.

{
 
  // Build TFTP RRQ or WRQ packet
  // Switch to uin8_t
  std::vector<uint8_t> request;
  // request.push_back(static_cast<char>(opcode >> 8));
  // request.push_back(static_cast<char>(opcode & 0xFF));
  // append_bigendian(request, opcode);
  append_big_uint16(request, opcode);
  request.insert(request.end(), payload.begin(), payload.end());
 
  std::stringstream request_str;
  for (size_t i = 0; i < request.size(); ++i) {
    request_str << std::setfill('0') << std::setw(2) << std::hex << +request[i] << " ";
  }
  TLOG() << "sending request to AMC: " << request_str.str();
 
  m_socket.send_to(boost::asio::buffer(request), m_server_endpoint);
 
  std::vector<uint8_t> reply(516); // TFTP packets max ~516 bytes
 
  boost::asio::ip::udp::endpoint sender_endpoint;
  boost::system::error_code ec;
 
  size_t len = 0;
  for (int i = 0; i < m_timeout; ++i) { // wait up to ~5 seconds total
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    len = m_socket.receive_from(boost::asio::buffer(reply), sender_endpoint, 0, ec);
    if (!ec)
      break;
  }
 
  if (ec) {
    throw AMCProtocolIssue(ERS_HERE, m_log_prefix, "TFTP receive error: " + ec.message());
  }
 
  if (len < 4) {
    throw AMCProtocolIssue(ERS_HERE, m_log_prefix, "Invalid TFTP reply: too short");
  }
  if (reply.size() < 4)
    throw std::runtime_error("Packet too short to be valid");
 
  // Parse returin code
  boost::endian::big_uint16_t rpl_opcode_be;
  std::memcpy(&rpl_opcode_be, reply.data(), sizeof(rpl_opcode_be));
 
  // A bit of overcasting here?
  TFTPOpCode rpl_opcode = static_cast<TFTPOpCode>(static_cast<uint16_t>(rpl_opcode_be));
 
  switch (rpl_opcode) {
    case TFTPOpCode::DAT: {
      if (reply.size() < sizeof(TFTP_Data_Header))
        throw AMCProtocolIssue(ERS_HERE, m_log_prefix, "Incomplete DATA packet");
 
      TFTP_Data_Header header;
      std::memcpy(&header, reply.data(), sizeof(header));
 
      TLOG() << "Received DATA packet:\n"
             << "  Block #: " << static_cast<uint16_t>(header.block) << "\n"
             << "  Payload size: " << reply.size() - sizeof(header) << " bytes\n";
 
      // Data starts at byte 3
      reply.resize(len);
      // Remove opcode
      reply.erase(reply.begin(), reply.begin() + 2);
 
      return reply;
    }
 
    case TFTPOpCode::ACK: {
      TFTP_Ack_Header header;
      std::memcpy(&header, reply.data(), sizeof(header));
 
      TLOG() << m_log_prefix << "Recieved Ack packet:\n" << static_cast<uint16_t>(header.block);
      return {};
    }
 
    case TFTPOpCode::ERR: {
      TFTP_Error_Header header;
      std::memcpy(&header, reply.data(), sizeof(header));
 
      std::string error_msg(reinterpret_cast<const char*>(reply.data() + sizeof(header)),
                            reply.size() - sizeof(header));
 
      ers::error(AMCResponseErr(ERS_HERE, m_log_prefix, static_cast<uint16_t>(header.error_code), error_msg));
      return {};
    }
 
    default:
      ers::error(AMCUnknownOpCode(ERS_HERE, m_log_prefix, static_cast<uint16_t>(opcode)));
 
      return {};
  }
}

send_rrq()

std::vector< uint8_t > dunedaq::tdemodules::AMCProtocolClient::send_rrq ( const std::vector< uint8_t > & payload )

inline

Definition at line 68 of file AMCProtocolClient.hpp.

{ return send_request(RRQ, payload); }

send_wrq()

std::vector< uint8_t > dunedaq::tdemodules::AMCProtocolClient::send_wrq ( const std::vector< uint8_t > & payload )

inline

Definition at line 70 of file AMCProtocolClient.hpp.

{ return send_request(WRQ, payload); }

Member Data Documentation

m_host

std::string dunedaq::tdemodules::AMCProtocolClient::m_host

private

Definition at line 73 of file AMCProtocolClient.hpp.

m_io_context

boost::asio::io_context dunedaq::tdemodules::AMCProtocolClient::m_io_context

private

Definition at line 79 of file AMCProtocolClient.hpp.

m_log_prefix

const std::string dunedaq::tdemodules::AMCProtocolClient::m_log_prefix = "AMC with ip:" + m_host + " and port: " + std::to_string(m_port) + " | "

private

Definition at line 77 of file AMCProtocolClient.hpp.

m_port

uint16_t dunedaq::tdemodules::AMCProtocolClient::m_port

private

Definition at line 74 of file AMCProtocolClient.hpp.

m_server_endpoint

boost::asio::ip::udp::endpoint dunedaq::tdemodules::AMCProtocolClient::m_server_endpoint

private

Definition at line 81 of file AMCProtocolClient.hpp.

m_socket

boost::asio::ip::udp::socket dunedaq::tdemodules::AMCProtocolClient::m_socket

private

Definition at line 80 of file AMCProtocolClient.hpp.

m_timeout

uint16_t dunedaq::tdemodules::AMCProtocolClient::m_timeout

private

Definition at line 75 of file AMCProtocolClient.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/tdemodules/include/tdemodules/AMCProtocolClient.hpp
• /github/workspace/dunedaq/sourcecode/tdemodules/src/AMCProtocolClient.cpp