46 #include <boost/python.hpp>
47namespace bp = boost::python;
57rpu::Server::Server(uint16_t port,
bool jumbo) :
rpu::
Core(jumbo) {
65 std::shared_ptr<int> scopePtr = std::make_shared<int>(0);
68 if ((
fd_ = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
72 memset(&locAddr_, 0,
sizeof(
struct sockaddr_in));
73 locAddr_.sin_family = AF_INET;
74 locAddr_.sin_addr.s_addr = htonl(INADDR_ANY);
75 locAddr_.sin_port = htons(port_);
77 memset(&
remAddr_, 0,
sizeof(
struct sockaddr_in));
83 if (bind(
fd_, (
struct sockaddr*)&locAddr_,
sizeof(locAddr_)) < 0) {
87 "Failed to bind to local port %" PRIu16
". Another process may be using it",
93 len =
sizeof(locAddr_);
94 if (getsockname(
fd_, (
struct sockaddr*)&locAddr_, &len) < 0) {
99 port_ = ntohs(locAddr_.sin_port);
106 udpLog_->debug(
"UDP server ready. localPort=%" PRIu16
", maxPayload=%" PRIu32, port_,
maxPayload());
110 thread_ =
new std::thread(&rpu::Server::runThread,
this, std::weak_ptr<int>(scopePtr));
120 pthread_setname_np(
thread_->native_handle(),
"UdpServer");
125rpu::Server::~Server() {
129void rpu::Server::stop() {
141 udpLog_->debug(
"Stopping UDP server on local port %" PRIu16, port_);
146uint32_t rpu::Server::getPort() {
152 ris::Frame::BufferIterator it;
158 struct iovec msg_iov[1];
162 std::lock_guard<std::mutex> lock(udpMtx_);
165 if (frame->getError()) {
166 udpLog_->warning(
"Dropping errored outbound frame on local port %" PRIu16
", error=0x%" PRIx8,
173 msg.msg_name = &remAddr_;
174 msg.msg_namelen =
sizeof(
struct sockaddr_in);
175 msg.msg_iov = msg_iov;
177 msg.msg_control = NULL;
178 msg.msg_controllen = 0;
182 for (it = frame->beginBuffer(); it != frame->endBuffer(); ++it) {
183 if ((*it)->getPayload() == 0)
break;
186 msg_iov[0].iov_base = (*it)->begin();
187 msg_iov[0].iov_len = (*it)->getPayload();
199 if (select(fd_ + 1, NULL, &fds, NULL, &tout) <= 0) {
200 udpLog_->critical(
"Server::acceptFrame: Timeout waiting for outbound transmit after %" PRIuLEAST32
201 ".%" PRIuLEAST32
" seconds! May be caused by outbound backpressure.",
205 }
else if ((res = sendmsg(fd_, &msg, 0)) < 0) {
206 udpLog_->warning(
"UDP write call failed on server port %" PRIu16
": %s",
208 std::strerror(errno));
215void rpu::Server::runThread(std::weak_ptr<int> lockPtr) {
221 struct sockaddr_in tmpAddr;
226 while (!lockPtr.expired())
continue;
228 udpLog_->logThreadId();
235 ris::Pool::shared_from_this();
237 }
catch (
const std::bad_weak_ptr&) {
238 std::this_thread::sleep_for(std::chrono::milliseconds(1));
241 if (!threadEn_)
return;
244 frame = reqLocalFrame(maxPayload(),
false);
248 buff = *(frame->beginBuffer());
249 avail = buff->getAvailable();
250 tmpLen =
sizeof(
struct sockaddr_in);
251 res = recvfrom(fd_, buff->begin(), avail, MSG_TRUNC | MSG_DONTWAIT, (
struct sockaddr*)&tmpAddr, &tmpLen);
257 if (memcmp(&remAddr_, &tmpAddr,
sizeof(remAddr_)) != 0) {
258 std::lock_guard<std::mutex> lock(udpMtx_);
259 char tmpIp[INET_ADDRSTRLEN];
260 if (inet_ntop(AF_INET, &(tmpAddr.sin_addr), tmpIp,
sizeof(tmpIp)) != NULL) {
261 udpLog_->debug(
"UDP server peer updated on local port %" PRIu16
" to %s:%" PRIu16,
264 ntohs(tmpAddr.sin_port));
266 udpLog_->debug(
"UDP server peer updated on local port %" PRIu16, port_);
273 udpLog_->warning(
"Receive data was too large on local port %" PRIu16
". rx=%i, avail=%" PRIu32
279 buff->setPayload(res);
284 frame = reqLocalFrame(maxPayload(),
false);
292 tout.tv_usec = 100000;
294 select(fd_ + 1, &fds, NULL, NULL, &tout);
299void rpu::Server::setup_python() {
302 bp::class_<rpu::Server, rpu::ServerPtr, bp::bases<rpu::Core, ris::Master, ris::Slave>, boost::noncopyable>(
304 bp::init<uint16_t, bool>())
305 .def(
"getPort", &rpu::Server::getPort);
307 bp::implicitly_convertible<rpu::ServerPtr, rpu::CorePtr>();
308 bp::implicitly_convertible<rpu::ServerPtr, ris::MasterPtr>();
309 bp::implicitly_convertible<rpu::ServerPtr, ris::SlavePtr>();
static GeneralError create(std::string src, const char *fmt,...)
Creates a formatted error instance.
RAII helper that releases the Python GIL for a scope.
static std::shared_ptr< rogue::Logging > create(const std::string &name, bool quiet=false)
Creates a logger instance.
void setFixedSize(uint32_t size)
Sets fixed-size mode.
void setPoolSize(uint32_t size)
Sets buffer pool size.
Shared UDP transport base for stream client/server endpoints.
std::atomic< bool > threadEn_
std::shared_ptr< rogue::Logging > udpLog_
struct sockaddr_in remAddr_
uint32_t maxPayload()
Returns maximum UDP payload size in bytes.
std::shared_ptr< rogue::interfaces::stream::Buffer > BufferPtr
Shared pointer alias for Buffer.
std::shared_ptr< rogue::interfaces::stream::Frame > FramePtr
Shared pointer alias for Frame.
std::shared_ptr< rogue::interfaces::stream::FrameLock > FrameLockPtr
Shared pointer alias for FrameLock.
std::shared_ptr< rogue::protocols::udp::Server > ServerPtr