1 #include "artdaq-ots/Generators/UDPReceiver.hh"
3 #include "artdaq-core/Utilities/SimpleLookupPolicy.hh"
4 #include "artdaq-ots/Overlays/FragmentType.hh"
5 #include "artdaq-ots/Overlays/UDPFragmentWriter.hh"
6 #include "artdaq/Application/GeneratorMacros.hh"
7 #include "canvas/Utilities/Exception.h"
8 #include "fhiclcpp/ParameterSet.h"
9 #include "otsdaq-core/Macros/CoutMacros.h"
19 ots::UDPReceiver::UDPReceiver(fhicl::ParameterSet
const& ps)
20 : CommandableFragmentGenerator(ps)
21 , rawOutput_(ps.get<bool>(
"raw_output_enabled", false))
22 , rawPath_(ps.get<std::string>(
"raw_output_path",
"/tmp"))
23 , dataport_(ps.get<int>(
"port", 6343))
24 , ip_(ps.get<std::string>(
"ip",
"127.0.0.1"))
25 , rcvbuf_(ps.get<int>(
"rcvbuf", 0x1000000))
26 , expectedPacketNumber_(0)
27 , sendCommands_(ps.get<bool>(
"send_OtsUDP_commands", false))
28 , fragmentWindow_(ps.get<double>(
"fragment_time_window_ms", 1000))
29 , lastFrag_(std::chrono::high_resolution_clock::now())
31 __COUT__ <<
"Constructor." << __E__;
33 datasocket_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
36 throw art::Exception(art::errors::Configuration)
37 <<
"UDPReceiver: Error creating socket!";
41 struct sockaddr_in si_me_data;
42 si_me_data.sin_family = AF_INET;
43 si_me_data.sin_port = htons(dataport_);
44 si_me_data.sin_addr.s_addr = htonl(INADDR_ANY);
45 if(bind(datasocket_, (
struct sockaddr*)&si_me_data,
sizeof(si_me_data)) == -1)
47 throw art::Exception(art::errors::Configuration)
48 <<
"UDPReceiver: Cannot bind data socket to port " << dataport_;
58 setsockopt(datasocket_, SOL_SOCKET, SO_RCVBUF, &rcvbuf_,
sizeof(rcvbuf_)))
60 throw art::Exception(art::errors::Configuration)
61 <<
"UDPReceiver: Could not set receive buffer size: " << rcvbuf_;
65 si_data_.sin_family = AF_INET;
66 si_data_.sin_port = htons(dataport_);
67 if(inet_aton(ip_.c_str(), &si_data_.sin_addr) == 0)
69 throw art::Exception(art::errors::Configuration)
70 <<
"UDPReceiver: Could not translate provided IP Address: " << ip_;
73 TLOG_INFO(
"UDPReceiver") <<
"UDP Receiver Construction Complete!" << TLOG_ENDL;
75 __COUT__ <<
"Constructed." << __E__;
79 ots::UDPReceiver::~UDPReceiver()
81 __COUT__ <<
"Destructor." << __E__;
84 if(receiverThread_.joinable())
85 receiverThread_.join();
93 __COUT__ <<
"Destructed." << __E__;
97 void ots::UDPReceiver::start()
99 __COUT__ <<
"Starting..." << __E__;
101 TLOG_INFO(
"UDPReceiver") <<
"Starting..." << TLOG_ENDL;
103 receiverThread_ = std::thread(&UDPReceiver::receiveLoop_,
this);
106 __COUT__ <<
"Started." << __E__;
110 void ots::UDPReceiver::receiveLoop_()
112 while(!should_stop())
114 struct pollfd ufds[1];
115 ufds[0].fd = datasocket_;
116 ufds[0].events = POLLIN | POLLPRI;
118 int rv = poll(ufds, 1, 1000);
121 TLOG_TRACE(
"UDPReceiver") <<
"revents: " << ufds[0].revents <<
", "
123 if(ufds[0].revents == POLLIN || ufds[0].revents == POLLPRI)
128 uint8_t peekBuffer[4];
129 socklen_t dataSz =
sizeof(si_data_);
130 recvfrom(datasocket_,
134 (
struct sockaddr*)&si_data_,
137 TLOG_TRACE(
"UDPReceiver")
138 <<
"Received UDP Datagram with sequence number " << std::hex <<
"0x"
139 <<
static_cast<int>(peekBuffer[1]) <<
"!" << std::dec << TLOG_ENDL;
140 TLOG_TRACE(
"UDPReceiver")
141 <<
"peekBuffer[1] == expectedPacketNumber_: " << std::hex
142 <<
static_cast<int>(peekBuffer[1])
143 <<
" =?= " << (
int)expectedPacketNumber_ << TLOG_ENDL;
144 TLOG_TRACE("UDPReceiver")
145 << "peekBuffer: 0: " << std::hex << static_cast<
int>(peekBuffer[0])
146 << ", 1: " << std::hex << static_cast<
int>(peekBuffer[1])
147 << ", 2: " << std::hex << static_cast<
int>(peekBuffer[2])
148 << ", 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_;
159 TLOG_WARNING(
"UDPReceiver")
161 <<
"Sequence Number different than expected! (delta: "
162 << delta <<
")" << TLOG_ENDL;
163 expectedPacketNumber_ = seqNum;
166 packetBuffer_t receiveBuffer;
167 receiveBuffer.resize(1500);
168 int sts = recvfrom(datasocket_,
170 receiveBuffer.size(),
172 (
struct sockaddr*)&si_data_,
176 TLOG_WARNING(
"UDPReceiver")
177 <<
"Error on socket: " << strerror(errno) << TLOG_ENDL;
181 TLOG_TRACE(
"UDPReceiver")
182 <<
"Received " << sts <<
" bytes." << TLOG_ENDL;
185 std::unique_lock<std::mutex> lock(receiveBufferLock_);
186 TLOG_TRACE(
"UDPReceiver")
187 <<
"Now placing UDP datagram with sequence number " << std::hex
188 << (int)seqNum <<
" into buffer." << std::dec << TLOG_ENDL;
189 receiveBuffers_.push_back(receiveBuffer);
191 ++expectedPacketNumber_;
196 TLOG_WARNING(
"UDPReceiver")
197 <<
"Received out-of-order datagram: " << seqNum
198 <<
" != " << expectedPacketNumber_ <<
" (expected)" << TLOG_ENDL;
199 packetBuffer_t receiveBuffer;
200 receiveBuffer.resize(1500);
201 int sts = recvfrom(datasocket_,
203 receiveBuffer.size(),
205 (
struct sockaddr*)&si_data_,
211 TLOG_INFO(
"UDPReceiver") <<
"receive Loop exiting..." << TLOG_ENDL;
215 bool ots::UDPReceiver::getNext_(artdaq::FragmentPtrs& output)
223 std::unique_lock<std::mutex> lock(receiveBufferLock_);
224 std::move(receiveBuffers_.begin(),
225 receiveBuffers_.end(),
226 std::inserter(packetBuffers_, packetBuffers_.end()));
227 receiveBuffers_.clear();
230 if(packetBuffers_.size() > 0)
232 size_t packetBufferSize = 0;
233 for(
auto& buf : packetBuffers_)
235 packetBufferSize += buf.size();
237 TLOG_TRACE(
"UDPReceiver")
238 <<
"Calling ProcessData, packetBuffers_.size() == "
239 << std::to_string(packetBuffers_.size())
240 <<
", sz = " << std::to_string(packetBufferSize) << TLOG_ENDL;
241 ProcessData_(output);
243 packetBuffers_.clear();
244 TLOG_TRACE(
"UDPReceiver")
245 <<
"Returning output of size " << output.size() << TLOG_ENDL;
256 void ots::UDPReceiver::ProcessData_(artdaq::FragmentPtrs& output)
259 metadata.port = dataport_;
260 metadata.address = si_data_.sin_addr.s_addr;
262 std::size_t initial_payload_size = 0;
264 output.emplace_back(artdaq::Fragment::FragmentBytes(initial_payload_size,
267 ots::detail::FragmentType::UDP,
272 TLOG_TRACE(
"UDPReceiver")
273 <<
"Received data, now placing data with UDP sequence number " << std::hex
274 <<
static_cast<int>((packetBuffers_.front()).at(1)) <<
" into UDPFragment"
276 thisFrag.resize(64050 * packetBuffers_.size() + 1);
277 std::ofstream rawOutput;
280 std::string outputPath =
281 rawPath_ +
"/UDPReceiver-" + ip_ +
":" + std::to_string(dataport_) +
".bin";
282 rawOutput.open(outputPath, std::ios::out | std::ios::app | std::ios::binary);
285 DataType dataType = getDataType((packetBuffers_.front()).at(0));
286 thisFrag.set_hdr_type((
int)dataType);
288 for(
auto jj = packetBuffers_.begin(); jj != packetBuffers_.end(); ++jj)
290 for(
int ii = 0; ii < 64050; ++ii)
293 if((jj)->at(ii) == 0 &&
294 (dataType == DataType::JSON || dataType == DataType::String))
300 rawOutput.write((
char*)&((jj)->at(ii)),
sizeof(uint8_t));
301 *(thisFrag.dataBegin() + pos) = (jj)->at(ii);
306 if(dataType == DataType::JSON || dataType == DataType::String)
308 *(thisFrag.dataBegin() + pos) = 0;
311 rawOutput.write(&zero,
sizeof(
char));
318 void ots::UDPReceiver::send(CommandType command)
322 CommandPacket packet;
323 packet.type = command;
329 (
struct sockaddr*)&si_data_,
335 bool ots::UDPReceiver::isTimerExpired_()
337 auto now = std::chrono::high_resolution_clock::now();
338 auto diff = std::chrono::duration<double, std::milli>(now - lastFrag_).count();
339 return diff > fragmentWindow_;
343 void ots::UDPReceiver::stop()
345 __COUT__ <<
"Stopping..." << __E__;
350 void ots::UDPReceiver::stopNoMutex()
356 void ots::UDPReceiver::start_()