int StorageHandler::SendEvent(const Event* event) {
	/*
	 * TODO: Use multimessage instead of creating a separate buffer and copying the MEP data into it
	 */
	const EVENT_HDR* data = EventSerializer::SerializeEvent(event);

	/*
	 * Send the event to the merger with a zero copy message
	 */
	zmq::message_t zmqMessage((void*) data, data->length * 4,
			(zmq::free_fn*) ZMQHandler::freeZmqMessage);

	while (ZMQHandler::IsRunning()) {
		tbb::spin_mutex::scoped_lock my_lock(sendMutex_);
		try {
			mergerSockets_[event->getBurstID() % mergerSockets_.size()]->send(zmqMessage);
			break;
		} catch (const zmq::error_t& ex) {
			if (ex.num() != EINTR) { // try again if EINTR (signal caught)
				LOG_ERROR<< ex.what() << ENDL;

				onShutDown();
				return 0;
			}
		}
	}

	return data->length * 4;
}
Esempio n. 2
0
void communication::ZeroConnection::send(const std::string& message)
{
    std::size_t length = message.size();
    zmq::message_t zmqMessage (length);

    std::memcpy(zmqMessage.data(), message.data(), length);
    
    socket_.send(zmqMessage);
}
Esempio n. 3
0
// TODO This needs to be YAMLized.
bool IEvent::Service::Publisher::publish(std::string subject, std::string message) {
	std::cerr << "DEPRECATED" << std::endl;
	int length = subject.length() + message.length() + 3;
	zmq::message_t zmqMessage(50);
	char *data = (char*) zmqMessage.data();
	sprintf_s(data, length, "%s: %s", subject.c_str(), message.c_str());
	return _publisher.send(zmqMessage);
	/*zmq::message_t zmessage(20);
	sprintf_s ((char *) message.data(), 20 ,
		"%05d %d %d", 98109, 55, 40);
	assert (_publisher);
	return _publisher.send(zmessage);*/
	return true;
}
bool ZeroMqConnection::send(const MoleQueue::PacketType &packet,
                            const MoleQueue::EndpointIdType &endpoint)
{
  zmq::message_t zmqMessage(packet.size());
  memcpy(zmqMessage.data(), packet.constData(), packet.size());
  bool rc;

  // If on the server side send the endpoint id first
  if (m_socketType == ZMQ_ROUTER) {
    zmq::message_t identity(endpoint.size());
    memcpy(identity.data(), endpoint.data(), endpoint.size());
    try {
     rc  = m_socket->send(identity, ZMQ_SNDMORE | ZMQ_NOBLOCK);
    }
    catch (zmq::error_t e) {
      qWarning("zmq exception during endpoint send: Error %d: %s",
               e.num(), e.what());
      return false;
    }

    if (!rc) {
      qWarning() << "zmq_send failed with EAGAIN";
      return false;
    }
  }

  // Send message body
  try {
    rc = m_socket->send(zmqMessage, ZMQ_NOBLOCK);
  }
  catch (zmq::error_t e) {
    qWarning("zmq exception during message send: Error %d: %s",
             e.num(), e.what());
    return false;
  }

  if (!rc) {
    qWarning() << "zmq_send failed with EAGAIN";
    return false;
  }
  return true;
}