dunedaq::tdemodules::AMCProtocolClient Class Reference

#include <AMCProtocolClient.hpp>

Classes
struct	TFTP_Ack_Header
struct	TFTP_Data_Header
struct	TFTP_Error_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 38 of file AMCProtocolClient.hpp.

Member Enumeration Documentation

TFTPOpCode

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

Enumerator
RRQ
WRQ
DAT
ACK
ERR

Definition at line 40 of file AMCProtocolClient.hpp.

                    : uint16_t {
        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 13 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 31 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 72 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 76 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 82 of file AMCProtocolClient.hpp.

m_io_context

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

private

Definition at line 88 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 86 of file AMCProtocolClient.hpp.

m_port

uint16_t dunedaq::tdemodules::AMCProtocolClient::m_port

private

Definition at line 83 of file AMCProtocolClient.hpp.

m_server_endpoint

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

private

Definition at line 90 of file AMCProtocolClient.hpp.

m_socket

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

private

Definition at line 89 of file AMCProtocolClient.hpp.

m_timeout

uint16_t dunedaq::tdemodules::AMCProtocolClient::m_timeout

private

Definition at line 84 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