void
av::NetNodeServer::cast(av::Msg& av_msg)
{
zmq::message_t zmq_message(av_msg.getSize());
memcpy(zmq_message.data(), av_msg.getBuffer(), av_msg.getSize());
mSocket.send(zmq_message);
}
int main(int argc, char* argv[])
{
setup_signal(SIGTERM, signal_exit);
setup_signal(SIGINT, signal_exit);
/* google log */
google::InitGoogleLogging(argv[0]);
google::InstallFailureSignalHandler();
google::LogToStderr();
const char* id = "simple-node";
if (argc > 1)
id = argv[1];
try
{
terra::message msg;
msg.set_id(id);
msg.set_type(terra::message::HEARTBEAT);
zmq::context_t ctx(1);
zmq::socket_t socket(ctx, ZMQ_PUB);
socket.connect("tcp://localhost:60300");
msg.set_heartbeat(0);
while (run)
{
msg.set_timestamp(terra::timestamp::now());
zmq::message_t zmq_message(msg.ByteSize());
msg.SerializeToArray(zmq_message.data(), zmq_message.size());
LOG(INFO) << "sending message { size = " << zmq_message.size() << " }";
socket.send(zmq_message);
msg.set_heartbeat(msg.heartbeat() + 1);
sleep(2);
}
socket.close();
}
catch (const std::exception& e)
{
LOG(ERROR) << "ERROR: " << e.what();
}
return EXIT_SUCCESS;
}
bool OTSocket_ZMQ_4::Send(const OTASCIIArmor & ascEnvelope)
{
if (!m_bInitialized) { OT_FAIL; }
if (0 >= ascEnvelope.GetLength()) { OTLog::vError("%s: Error: %s is zero length!\n", __FUNCTION__, "ascEnvelope"); OT_FAIL; }
m_ascLastMsgSent.Set(ascEnvelope); // In case we need to re-send.
if (!m_HasContext) { OT_FAIL; }
if (NULL == m_pzmq->context_zmq) { OTLog::vError("%s: Error: %s must exist to Send!\n", __FUNCTION__, "m_pzmq->context_zmq"); OT_FAIL; }
if (!m_bConnected && !m_bListening) return false;
if (m_bConnected && m_bListening) return false;
if (NULL == m_pzmq->socket_zmq) { OTLog::vError("%s: Error: %s must exist to Send!\n", __FUNCTION__, "m_pzmq->socket_zmq"); OT_FAIL; }
// -----------------------------------
const int64_t lLatencySendMilliSec = m_lLatencySendMs;
zmq::message_t zmq_message(ascEnvelope.GetLength());
memcpy((void*)zmq_message.data(), ascEnvelope.Get(), ascEnvelope.GetLength());
bool bSuccessSending = false;
if (m_bIsBlocking)
{
try {
bSuccessSending = m_pzmq->socket_zmq->send(zmq_message); // Blocking.
}
catch (std::exception& e) {
OTLog::vError("%s: Exception Caught: %s \n", __FUNCTION__, e.what());
OT_FAIL;
}
}
else // not blocking
{
int32_t nSendTries = m_nLatencySendNoTries;
int64_t lDoubling = lLatencySendMilliSec;
bool bKeepTrying = true;
while (bKeepTrying && (nSendTries > 0))
{
zmq::pollitem_t items[] = {
{ (*m_pzmq->socket_zmq), 0, ZMQ_POLLOUT, 0 }
};
int nPoll = 0;
try {
nPoll = zmq::poll(&items[0], 1, static_cast<long>(lDoubling)); // ZMQ_POLLOUT, 1 item, timeout (milliseconds)
}
catch (std::exception& e) {
OTLog::vError("%s: Exception Caught: %s \n", __FUNCTION__, e.what());
OT_FAIL;
}
lDoubling *= 2;
if (items[0].revents & ZMQ_POLLOUT)
{
try {
bSuccessSending = m_pzmq->socket_zmq->send(zmq_message, ZMQ_NOBLOCK); // <=========== SEND ===============
}
catch (std::exception& e) {
OTLog::vError("%s: Exception Caught: %s \n", __FUNCTION__, e.what());
OT_FAIL;
}
OTLog::SleepMilliseconds(1);
if (!bSuccessSending)
{
if (false == HandleSendingError())
bKeepTrying = false;
}
else
break; // (Success -- we're done in this loop.)
}
else if ((-1) == nPoll) // error.
{
if (false == HandlePollingError())
bKeepTrying = false;
}
--nSendTries;
}
}
/*
Normally, we try to send...
If the send fails, we wait X ms and then try again (Y times).
BUT -- what if the failure was an errno==EAGAIN ?
In that case, it's not a REAL failure, but rather, a "failure right now, try again in a sec."
*/
// ***********************************
if (bSuccessSending)
OTLog::SleepMilliseconds(m_lLatencyDelayAfter > 0 ? m_lLatencyDelayAfter : 1);
return bSuccessSending;
}
/* Plugin: Multithreaded loop. */
void InputPlugin::operator()()
{
try
{
/* ZMQ: Create framework subscription socket on this thread. */
zmq::socket_t zmq_framework_subscriber (*this->zmq_context.get(), ZMQ_SUB);
/* ZMQ: Connect. */
zmq_framework_subscriber.connect("inproc://Framework");
/* ZMQ: Suscribe to all messages. */
zmq_framework_subscriber.setsockopt(ZMQ_SUBSCRIBE, "", 0);
std::this_thread::sleep_for(std::chrono::milliseconds( 10 ));
/* OIS: Initialization.*/
OIS::ParamList pl;
std::ostringstream wnd;
wnd << this->base_window.get()->native_window();
pl.insert(std::make_pair(std::string("WINDOW"), wnd.str()));
pl.insert(std::make_pair(std::string("x11_mouse_grab"), std::string("false")));
pl.insert(std::make_pair(std::string("x11_mouse_hide"), std::string("false")));
pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
auto ois_manager = OIS::InputManager::createInputSystem(pl);
/* OIS: Print debugging information. */
auto ois_info = std::string("-----OIS-----\n") +
"Version: " + ois_manager->getVersionName() + "\n" +
"Manager: " + ois_manager->inputSystemName() + "\n" +
"Total keyboards: " + std::to_string(ois_manager->getNumberOfDevices(OIS::OISKeyboard)) + "\n" +
"Total mice: " + std::to_string(ois_manager->getNumberOfDevices(OIS::OISMouse)) + "\n" +
"Total gamepads: " + "-" + "\n" +
"Total joysticks: " + std::to_string(ois_manager->getNumberOfDevices(OIS::OISJoyStick));
std::cout << ois_info << std::endl;
/* OIS: Keyboard initialization. */
auto ois_keyboard = static_cast<OIS::Keyboard*>(ois_manager->createInputObject( OIS::OISKeyboard, false));
/* ZMQ: Send ready message. */
{
zeug::string_hash message("Ready");
zmq::message_t zmq_message_send(message.Size());
memcpy(zmq_message_send.data(), message.Get(), message.Size());
this->zmq_input_publisher->send(zmq_message_send);
}
/* ZMQ: Listen for start message. */
for(;;)
{
zmq::message_t zmq_message;
if (zmq_framework_subscriber.recv(&zmq_message, ZMQ_NOBLOCK))
{
if (zeug::string_hash("Start") == zeug::string_hash(zmq_message.data()))
{
break;
}
}
}
/* Plugin: Loop. */
for(;;)
{
/* ZMQ: Listen for stop message. */
{
zmq::message_t zmq_message;
if (zmq_framework_subscriber.recv(&zmq_message, ZMQ_NOBLOCK))
{
if (zeug::string_hash("Stop") == zeug::string_hash(zmq_message.data()))
{
break;
}
}
}
if (this->base_window->poll())
{
/* OIS: Handle input */
ois_keyboard->capture();
if( ois_keyboard->isKeyDown( OIS::KC_ESCAPE ))
{
/* Topic */
{
zeug::string_hash message("Keyboard");
zmq::message_t zmq_message(message.Size());
memcpy(zmq_message.data(), message.Get(), message.Size());
zmq_input_publisher->send(zmq_message, ZMQ_SNDMORE);
}
/* Message */
{
zeug::string_hash message("Esc");
zmq::message_t zmq_message(message.Size());
memcpy(zmq_message.data(), message.Get(), message.Size());
zmq_input_publisher->send(zmq_message, ZMQ_SNDMORE);
}
/* End of message. */
{
zeug::string_hash message("Finish");
zmq::message_t zmq_message(message.Size());
memcpy(zmq_message.data(), message.Get(), message.Size());
zmq_input_publisher->send(zmq_message);
}
}
else if( ois_keyboard->isKeyDown( OIS::KC_RETURN ))
{
/* Topic */
{
zeug::string_hash message("Keyboard");
zmq::message_t zmq_message(message.Size());
memcpy(zmq_message.data(), message.Get(), message.Size());
zmq_input_publisher->send(zmq_message, ZMQ_SNDMORE);
}
/* Message */
{
zeug::string_hash message("Enter");
zmq::message_t zmq_message(message.Size());
memcpy(zmq_message.data(), message.Get(), message.Size());
zmq_input_publisher->send(zmq_message, ZMQ_SNDMORE);
}
/* End of message. */
{
zeug::string_hash message("Finish");
zmq::message_t zmq_message(message.Size());
memcpy(zmq_message.data(), message.Get(), message.Size());
zmq_input_publisher->send(zmq_message);
}
}
}
}
}
/* Plugin: Catch plugin specific exceptions and rethrow them as runtime error*/
catch(const OIS::Exception& ois_exception )
{
/* ZMQ: Send stop message. */
zeug::string_hash message("Stop");
zmq::message_t zmq_message_send(message.Size());
memcpy(zmq_message_send.data(), message.Get(), message.Size());
this->zmq_input_publisher->send(zmq_message_send);
throw std::runtime_error(std::string(" OIS - ") + ois_exception.eText);
return;
}
}
