1 #include "artdaq/DAQdata/Globals.hh"
2 #define TRACE_NAME "UDPReceiver"
4 #include "artdaq-ots/Generators/UDPReceiver.hh"
6 #include "artdaq-core/Utilities/SimpleLookupPolicy.hh"
7 #include "artdaq-ots/Overlays/FragmentType.hh"
8 #include "artdaq-ots/Overlays/UDPFragmentWriter.hh"
9 #include "artdaq/Generators/GeneratorMacros.hh"
10 #include "canvas/Utilities/Exception.h"
11 #include "fhiclcpp/ParameterSet.h"
12 #include "otsdaq/Macros/CoutMacros.h"
21 ots::UDPReceiver::UDPReceiver(fhicl::ParameterSet
const& ps)
22 : CommandableFragmentGenerator(ps)
23 , rawOutput_(ps.get<bool>(
"raw_output_enabled", false))
24 , rawPath_(ps.get<std::string>(
"raw_output_path",
"/tmp"))
25 , dataport_(ps.get<int>(
"port", 6343))
26 , ip_(ps.get<std::string>(
"ip",
"127.0.0.1"))
27 , rcvbuf_(ps.get<int>(
"rcvbuf", 0x1000000))
28 , expectedPacketNumber_(0)
29 , sendCommands_(ps.get<bool>(
"send_OtsUDP_commands", false))
30 , fragmentWindow_(ps.get<double>(
"fragment_time_window_ms", 1000))
31 , lastFrag_(std::chrono::high_resolution_clock::now())
33 TLOG(TLVL_DEBUG) <<
"Constructor.";
35 datasocket_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
38 throw art::Exception(art::errors::Configuration)
39 <<
"UDPReceiver: Error creating socket!";
43 struct sockaddr_in si_me_data;
44 si_me_data.sin_family = AF_INET;
45 si_me_data.sin_port = htons(dataport_);
46 si_me_data.sin_addr.s_addr = htonl(INADDR_ANY);
47 if(bind(datasocket_, (
struct sockaddr*)&si_me_data,
sizeof(si_me_data)) == -1)
49 throw art::Exception(art::errors::Configuration)
50 <<
"UDPReceiver: Cannot bind data socket to port " << dataport_;
60 setsockopt(datasocket_, SOL_SOCKET, SO_RCVBUF, &rcvbuf_,
sizeof(rcvbuf_)))
62 throw art::Exception(art::errors::Configuration)
63 <<
"UDPReceiver: Could not set receive buffer size: " << rcvbuf_;
67 si_data_.sin_family = AF_INET;
68 si_data_.sin_port = htons(dataport_);
69 if(inet_aton(ip_.c_str(), &si_data_.sin_addr) == 0)
71 throw art::Exception(art::errors::Configuration)
72 <<
"UDPReceiver: Could not translate provided IP Address: " << ip_;
75 TLOG(TLVL_INFO) <<
"UDP Receiver Construction Complete!";
77 TLOG(TLVL_DEBUG) <<
"Constructed.";
81 ots::UDPReceiver::~UDPReceiver()
83 TLOG(TLVL_DEBUG) <<
"Destructor.";
86 if(receiverThread_.joinable())
87 receiverThread_.join();
95 TLOG(TLVL_DEBUG) <<
"Destructed.";
99 void ots::UDPReceiver::start()
101 TLOG(TLVL_DEBUG) <<
"Starting...";
103 TLOG(TLVL_INFO) <<
"Starting...";
105 receiverThread_ = std::thread(&UDPReceiver::receiveLoop_,
this);
108 TLOG(TLVL_DEBUG) <<
"Started.";
112 void ots::UDPReceiver::receiveLoop_()
114 while(!should_stop())
116 struct pollfd ufds[1];
117 ufds[0].fd = datasocket_;
118 ufds[0].events = POLLIN | POLLPRI;
120 int rv = poll(ufds, 1, 1000);
123 TLOG(TLVL_TRACE) <<
"revents: " << ufds[0].revents
125 if(ufds[0].revents == POLLIN || ufds[0].revents == POLLPRI)
130 uint8_t peekBuffer[4];
131 socklen_t dataSz =
sizeof(si_data_);
132 recvfrom(datasocket_,
136 (
struct sockaddr*)&si_data_,
140 <<
"Received UDP Datagram with sequence number " << std::hex <<
"0x"
141 <<
static_cast<int>(peekBuffer[1]) <<
"!" << std::dec;
142 TLOG(TLVL_TRACE) <<
"peekBuffer[1] == expectedPacketNumber_: " << std::hex
143 <<
static_cast<int>(peekBuffer[1])
144 <<
" =?= " << (
int)expectedPacketNumber_;
146 << "peekBuffer: 0: " << std::hex << static_cast<
int>(peekBuffer[0])
147 << ", 1: " << std::hex << static_cast<
int>(peekBuffer[1])
148 << ", 2: " << std::hex << static_cast<
int>(peekBuffer[2])
149 << ", 3: " << std::hex << static_cast<
int>(peekBuffer[3]);
151 uint8_t seqNum = peekBuffer[1];
153 if(seqNum >= expectedPacketNumber_ ||
154 (seqNum < 64 && expectedPacketNumber_ > 192))
156 if(seqNum != expectedPacketNumber_)
158 int delta = seqNum - expectedPacketNumber_;
161 <<
"Sequence Number different than expected! (delta: "
163 expectedPacketNumber_ = seqNum;
166 packetBuffer_t receiveBuffer;
167 receiveBuffer.resize(1500);
168 int sts = recvfrom(datasocket_,
170 receiveBuffer.size(),
172 (
struct sockaddr*)&si_data_,
174 receiveBuffer.resize(sts);
178 TLOG(TLVL_WARNING) <<
"Error on socket: " << strerror(errno);
182 TLOG(TLVL_TRACE) <<
"Received " << sts <<
" bytes.";
185 std::unique_lock<std::mutex> lock(receiveBufferLock_);
187 <<
"Now placing UDP datagram with sequence number " << std::hex
188 << (int)seqNum <<
" into buffer." << std::dec;
189 receiveBuffers_.push_back(receiveBuffer);
191 ++expectedPacketNumber_;
197 <<
"Received out-of-order datagram: " << seqNum
198 <<
" != " << expectedPacketNumber_ <<
" (expected)";
199 packetBuffer_t receiveBuffer;
200 receiveBuffer.resize(1500);
201 int sts = recvfrom(datasocket_,
203 receiveBuffer.size(),
205 (
struct sockaddr*)&si_data_,
207 receiveBuffer.resize(sts);
212 TLOG(TLVL_INFO) <<
"receive Loop exiting...";
216 bool ots::UDPReceiver::getNext_(artdaq::FragmentPtrs& output)
224 std::unique_lock<std::mutex> lock(receiveBufferLock_);
225 std::move(receiveBuffers_.begin(),
226 receiveBuffers_.end(),
227 std::inserter(packetBuffers_, packetBuffers_.end()));
228 receiveBuffers_.clear();
231 if(packetBuffers_.size() > 0)
233 size_t packetBufferSize = 0;
234 for(
auto& buf : packetBuffers_)
236 packetBufferSize += buf.size();
238 TLOG(TLVL_TRACE) <<
"Calling ProcessData, packetBuffers_.size() == "
239 << std::to_string(packetBuffers_.size())
240 <<
", sz = " << std::to_string(packetBufferSize);
241 ProcessData_(output, packetBufferSize);
243 packetBuffers_.clear();
244 TLOG(TLVL_TRACE) <<
"Returning output of size " << output.size();
255 void ots::UDPReceiver::ProcessData_(artdaq::FragmentPtrs& output,
size_t totalSize)
257 TLOG(TLVL_TRACE) <<
"ProcessData_ start";
259 metadata.port = dataport_;
260 metadata.address = si_data_.sin_addr.s_addr;
262 std::size_t initial_payload_size = 0;
264 TLOG(TLVL_TRACE) <<
"Creating Fragment";
266 output.emplace_back(artdaq::Fragment::FragmentBytes(initial_payload_size,
269 ots::detail::FragmentType::UDP,
274 TLOG(TLVL_TRACE) <<
"Creating UDPFragmentWriter";
278 TLOG(TLVL_TRACE) <<
"Received data, now placing data with UDP sequence number "
279 << std::hex << static_cast<int>((packetBuffers_.front()).at(1))
280 <<
" into UDPFragment";
281 thisFrag.resize(totalSize + 1);
282 std::ofstream rawOutput;
285 std::string outputPath =
286 rawPath_ +
"/UDPReceiver-" + ip_ +
":" + std::to_string(dataport_) +
".bin";
287 rawOutput.open(outputPath, std::ios::out | std::ios::app | std::ios::binary);
290 DataType dataType = getDataType((packetBuffers_.front()).at(0));
291 thisFrag.set_hdr_type((
int)dataType);
293 for(
auto jj = packetBuffers_.begin(); jj != packetBuffers_.end(); ++jj)
295 for(
size_t ii = 0; ii < jj->size(); ++ii)
298 if((jj)->at(ii) == 0 &&
299 (dataType == DataType::JSON || dataType == DataType::String))
305 rawOutput.write((
char*)&((jj)->at(ii)),
sizeof(uint8_t));
306 *(thisFrag.dataBegin() + pos) = (jj)->at(ii);
311 if(dataType == DataType::JSON || dataType == DataType::String)
313 *(thisFrag.dataBegin() + pos) = 0;
316 rawOutput.write(&zero,
sizeof(
char));
323 void ots::UDPReceiver::send(CommandType command)
327 CommandPacket packet;
328 packet.type = command;
334 (
struct sockaddr*)&si_data_,
340 bool ots::UDPReceiver::isTimerExpired_()
342 auto now = std::chrono::high_resolution_clock::now();
343 auto diff = std::chrono::duration<double, std::milli>(now - lastFrag_).count();
344 return diff > fragmentWindow_;
348 void ots::UDPReceiver::stop()
350 TLOG(TLVL_DEBUG) <<
"Stopping...";
355 void ots::UDPReceiver::stopNoMutex()
361 void ots::UDPReceiver::start_()