Transport.cpp

Go to the documentation of this file.

 
#include "rogue/Directives.h"
 
#include "rogue/protocols/packetizer/Transport.h"
 
#include <memory>
 
#include "rogue/GeneralError.h"
#include "rogue/GilRelease.h"
#include "rogue/Logging.h"
#include "rogue/interfaces/stream/Buffer.h"
#include "rogue/interfaces/stream/Frame.h"
#include "rogue/protocols/packetizer/Controller.h"
 
namespace rpp = rogue::protocols::packetizer;
namespace ris = rogue::interfaces::stream;
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
namespace bp = boost::python;
#endif
 
rpp::TransportPtr rpp::Transport::create() {
    rpp::TransportPtr r = std::make_shared<rpp::Transport>();
    return (r);
}
 
void rpp::Transport::setup_python() {
#ifndef NO_PYTHON
 
    bp::class_<rpp::Transport, rpp::TransportPtr, bp::bases<ris::Master, ris::Slave>, boost::noncopyable>("Transport",
                                                                                                          bp::init<>());
 
    bp::implicitly_convertible<rpp::TransportPtr, ris::MasterPtr>();
    bp::implicitly_convertible<rpp::TransportPtr, ris::SlavePtr>();
#endif
}
 
rpp::Transport::Transport() {}
 
rpp::Transport::~Transport() {
    // No-op if setController() never ran.
    if (thread_) {
        threadEn_ = false;
        // Release the GIL: worker may be mid-sendFrame to a Python slave.
        rogue::GilRelease noGil;
        cntl_->stopQueue();
        thread_->join();
    }
}
 
void rpp::Transport::setController(rpp::ControllerPtr cntl) {
    // One-shot: re-assigning a joinable std::thread triggers std::terminate.
    if (thread_) return;
 
    // threadEn_ must precede thread ctor; rollback both on spawn failure.
    rpp::ControllerPtr prevCntl = cntl_;
    cntl_ = cntl;
    threadEn_ = true;
    try {
        thread_ = std::make_unique<std::thread>(&rpp::Transport::runThread, this);
    } catch (...) {
        threadEn_ = false;
        cntl_ = prevCntl;
        throw;
    }
 
    // Set a thread name
#ifndef __MACH__
    pthread_setname_np(thread_->native_handle(), "PackTrans");
#endif
}
 
void rpp::Transport::acceptFrame(ris::FramePtr frame) {
    cntl_->transportRx(frame);
}
 
void rpp::Transport::runThread() {
    ris::FramePtr frame;
    Logging log("packetizer.Transport");
    log.logThreadId();
 
    while (threadEn_) {
        if ((frame = cntl_->transportTx()) != NULL) sendFrame(frame);
    }
}