bool recv(zmq::socket_t & socket) { clear(); while(1) { zmq::message_t message(0); try { if (!socket.recv(&message, 0)) { return false; } } catch (zmq::error_t error) { //std::cout << "E: " << error.what() << std::endl; return false; } char *data = reinterpret_cast<char*>(message.data()); if (message.size() == 17 && data[0] == 0) { push_back(encode_uuid(msg_to_string(message))); } else { push_back(msg_to_string(message)); } boost::int64_t more; size_t more_size = sizeof(more); socket.getsockopt(ZMQ_RCVMORE, &more, &more_size); if (!more) { break; } } return true; }
inline bool recv (zmq::socket_t & socket, tile_protocol & tile) { zmq::message_t msg; socket.recv(&msg); std::string buf(static_cast<char*>(msg.data()),msg.size()); return unserialise(buf, tile); }
// Receive 0MQ string from socket and convert into string static std::string s_recv (zmq::socket_t & socket) { zmq::message_t message; socket.recv(&message); return std::string(static_cast<char*>(message.data()), message.size()); }
void process_frontend(zmq::socket_t& frontend, int& available_workers) { zmq::message_t req; frontend.recv(&req); zmq::message_t reply(sizeof(available_workers)); memcpy(reply.data(), &available_workers, sizeof(available_workers)); frontend.send(reply); }
bool recursive_receive(zmq::socket_t& receiving_socket, zmq::message_t& message, const REQ& req, RES& response, bool& succeed) { bool rc = receiving_socket.recv(&message); if (rc) { auto serialized_resp = kZmqUtil->message_to_string(message); response.ParseFromString(serialized_resp); if (req.request_id() == response.response_id()) { succeed = true; return false; } else { return true; } } else { // timeout if (errno == EAGAIN) { succeed = false; } else { succeed = false; } return false; } }
// 0 for received nothing int recv_msg_async(zmq::socket_t &sock, boost::shared_array<uint8_t> &data) { zmq::message_t msgt; int nbytes; try{ nbytes = sock.recv(&msgt, ZMQ_DONTWAIT); }catch(zmq::error_t e){ return -1; } if(nbytes == 0){ if(zmq_errno() == EAGAIN) return 0; else return -1; } size_t len = msgt.size(); uint8_t *dataptr; try{ dataptr = new uint8_t[len]; }catch(std::bad_alloc e){ return -1; } memcpy(dataptr, msgt.data(), len); data.reset(dataptr); return len; }
/* * return number of bytes received, negative if error, 0 for received nothing, which should be treated as error */ int recv_msg(zmq::socket_t &sock, boost::shared_array<uint8_t> &data) { zmq::message_t msgt; int nbytes; try{ nbytes = sock.recv(&msgt); }catch(zmq::error_t e){ //LOG(NOR, stderr, "recv failed: %s\n", e.what()); return -1; } if(nbytes == 0) return 0; size_t len = msgt.size(); uint8_t *dataptr; try{ dataptr = new uint8_t[len]; }catch(std::bad_alloc e){ //LOG(DBG, stderr, "can not allocate memory!\n"); return -1; } memcpy(dataptr, msgt.data(), len); data.reset(dataptr); return len; }
void raw_sender(zmq::socket_t& s) { for (size_t i = 0; i < ITERS; ++i) { zmq::message_t msg1(ARRAY_LEN(PART1)-1); memcpy(msg1.data(), PART1, msg1.size()); s.send(msg1, ZMQ_SNDMORE); zmq::message_t msg2(ARRAY_LEN(PART2)-1); memcpy(msg2.data(), PART2, msg2.size()); s.send(msg2, ZMQ_SNDMORE); zmq::message_t msg3(ARRAY_LEN(PART3)-1); memcpy(msg3.data(), PART3, msg3.size()); s.send(msg3); zmq::message_t msg_res; s.recv(&msg_res, 0); if (i % 1000 == 0) { std::cout << "."; std::cout.flush(); } } }
/* * return number of bytes received, negative if error, 0 for received nothing, * which should be treated as error */ int32_t RecvMsg(zmq::socket_t &sock, boost::shared_array<uint8_t> &data, bool *_more){ zmq::message_t msgt; int nbytes; try{ nbytes = sock.recv(&msgt); }catch(zmq::error_t &e){ LOG(ERROR) << "RecvMsg error = " << e.what(); return -1; } if(nbytes == 0) return 0; size_t len = msgt.size(); uint8_t *dataptr; try{ dataptr = new uint8_t[len]; }catch(std::bad_alloc &e){ return -1; } memcpy(dataptr, msgt.data(), len); data.reset(dataptr); if(_more != NULL){ int more_recv; size_t s = sizeof(int); sock.getsockopt(ZMQ_RCVMORE, &more_recv, &s); *_more = (more_recv == 1) ? true : false; } return len; }
void handleOp(zmq::socket_t &socket, int opCode) { std::string s_req, trace, line; std::cout<<"Trace: "; std::getline(std::cin, trace); Request req; Id id; Person person; Request_Header_Type type; switch (opCode) { case 1: type = Request_Header_Type_LOOKUP; std::cout<<"id: "; line.clear(); std::getline(std::cin, line); id = makeId(fromString<int>(line)); req = makeRequest(type, id, person, false, trace); break; case 3: type = Request_Header_Type_REMOVE; std::cout<<"id: "; line.clear(); std::getline(std::cin, line); id = makeId(fromString<int>(line)); req = makeRequest(type, id, person, false, trace); break; case 2: { type = Request_Header_Type_INSERT; std::cout<<"id: "; line.clear(); std::getline(std::cin, line); id = makeId(fromString<int>(line)); line.clear(); std::cout<<"Name: "; std::getline(std::cin, line); std::string ph, ovr; std::cout<<"Phone: "; std::getline(std::cin, ph); std::cout<<"Overwrite: (y/n) "; std::getline(std::cin, ovr); person = makePerson(line, ph); req = makeRequest(type, id, person, ovr.compare("y") == 0, trace); break; } }; std::cout<<"Request: "<<requestToString(req); TRACE(std::cout, ""); req.SerializeToString(&s_req); zmq::message_t z_req(s_req.size()); memcpy(z_req.data(), (void *)s_req.data(), s_req.size()); socket.send(z_req); zmq::message_t z_resp; socket.recv(&z_resp); std::string s_resp((char *)z_resp.data(), z_resp.size()); Response resp; resp.ParseFromString(s_resp); std::cout<<"Response = "<<responseToString(resp); }
void receiveStr(zmq::socket_t& socket, string& s, int flags = 0) { zmq::message_t request; if (!socket.recv(&request, flags)) { std::cerr << "Reception KO" << std::endl; } s.append((char const *) request.data(), request.size()); }
void _receive(zmq::socket_t & socket, std::list<zmq::message_t*> *result) { do { zmq::message_t * msg = new zmq::message_t(); // TODO: error handling socket.recv(msg); result->push_back(msg); } while (sockopt_rcvmore(socket)); }
unsigned s_recv (zmq::socket_t & socket, std::string& buffer) { zmq::message_t message; socket.recv(&message); buffer.clear(); buffer.assign(static_cast<char*>(message.data()), message.size()); return message.size(); }
// capacity request void process_status_request(zmq::socket_t& status, int& number_of_workers) { // null request zmq::message_t incoming_msg; status.recv(&incoming_msg); // send current capacity zmq::message_t status_msg(sizeof(number_of_workers)); memcpy(status_msg.data(), &number_of_workers, sizeof(number_of_workers)); status.send(status_msg); }
static bool recv_zmq_message(zmq::socket_t& sock, zmq::message_t& msg, T& object, int flags = ZMQ_NOBLOCK) { if (!sock.recv(&msg, flags)) { return false; } memcpy(&object, msg.data(), msg.size()); return true; }
bool Server::getRequest (zmq::socket_t &socket, pb::RequestEnvelope &envelope) { long long more; size_t sz = sizeof (more); zmq::message_t request; socket.recv (&request); socket.getsockopt (ZMQ_RCVMORE, &more, &sz); bool isAnotherRequest = more != 0; envelope.ParseFromArray (request.data(), request.size()); return isAnotherRequest; }
/** Receive a string. */ inline bool recv(zmq::socket_t &s, std::string &v, int flags) { zmq::message_t msg; IB_FIRST_PART(s.recv(&msg, flags)); v.assign( static_cast<char*>(msg.data()), static_cast<char*>(msg.data()) + msg.size()); return true; }
bool ServerInterface::SendMove(enum Tetromino::Move move, int pieceId, zmq::socket_t& commandSocket) const { std::string const* moveCommandS = m_factory.CreateMoveMessage(move, pieceId); zmq::message_t moveCommand (moveCommandS->size()); memcpy(static_cast<void*>(moveCommand.data()), moveCommandS->data(), moveCommandS->size()); delete moveCommandS; commandSocket.send(moveCommand); zmq::message_t reply; commandSocket.recv(&reply); std::string replyS (static_cast<char const*>(reply.data()), reply.size()); return m_factory.ParseMoveReply(replyS); }
inline bool recv(zmq::socket_t &s, T &v, int flags) { zmq::message_t msg; IB_FIRST_PART(s.recv(&msg, flags)); in_memory_buffer mb(static_cast<char*>(msg.data()), msg.size()); std::istream is(&mb); is >> v; IB_ASSERT(!is.fail(), ib_error::ECONVERSION); return true; }
std::vector<zmq::message_t> CentralProxy::receive_multipart(zmq::socket_t& socket_fe) { std::vector<zmq::message_t> message; bool more = true; while (more) { message.push_back(zmq::message_t()); zmq::message_t& msg = message.back(); socket_fe.recv(&msg); more = msg.more(); } return message; }
bool nutils::recv_zmq_message(zmq::socket_t& sock, zmq::message_t& msg, std::string& str, int flags) { if (!sock.recv(&msg, flags)) { return false; } str.clear(); str.append(reinterpret_cast<char*>(msg.data()), msg.size()); return true; }
void recv_multipart(zmq::socket_t &socket) { int64_t more=-1; size_t more_size = sizeof (more); while(more) { zmq::message_t response; socket.recv(&response); std::string response_str((const char *)response.data(), response.size()); cout << response_str << endl; socket.getsockopt(ZMQ_RCVMORE, &more, &more_size); } }
bool safeRecv(zmq::socket_t &sock, char *buf, int buflen, bool block, size_t &response_len, int64_t timeout) { char tnam[100]; int pgn_rc = pthread_getname_np(pthread_self(),tnam, 100); assert(pgn_rc == 0); //{FileLogger fl(program_name); fl.f() << tnam << " receiving\n";} response_len = 0; int retries = 5; if (block && timeout == 0) timeout = 500; while (!MessagingInterface::aborted()) { try { zmq::pollitem_t items[] = { { (void*)sock, 0, ZMQ_POLLERR | ZMQ_POLLIN, 0 } }; int n = zmq::poll( &items[0], 1, timeout); if (!n && block) { usleep(10); continue; } if (items[0].revents & ZMQ_POLLIN) { //{FileLogger fl(program_name); fl.f() << tnam << " safeRecv() collecting data\n"; } response_len = sock.recv(buf, buflen, ZMQ_DONTWAIT); if (response_len > 0 && response_len < (unsigned int)buflen) { buf[response_len] = 0; //if (response_len>10){FileLogger fl(program_name); fl.f() << tnam << " saveRecv() collected data '" << buf << "' with length " << response_len << "\n"; } } else { //if (response_len > 10){FileLogger fl(program_name); fl.f() << tnam << " saveRecv() collected data with length " << response_len << "\n"; } } if (!response_len && block) continue; } return (response_len == 0) ? false : true; } catch (zmq::error_t e) { { FileLogger fl(program_name); fl.f() << tnam << " safeRecv error " << errno << " " << zmq_strerror(errno) << "\n"; } if (--retries == 0) { exit(EXIT_FAILURE); } if (errno == EINTR) { std::cerr << "interrupted system call, retrying\n"; if (block) continue; } usleep(10); return false; } } return false; }
// relay data from workers to frontend void process_backend(zmq::socket_t& frontend, zmq::socket_t& backend) { int64_t more; size_t moresz; moresz = sizeof(more); while(true) { zmq::message_t worker_msg; backend.recv(&worker_msg); backend.getsockopt(ZMQ_RCVMORE, &more, &moresz); frontend.send(worker_msg, more ? ZMQ_SNDMORE : 0); if(!more) { break; } } }
/** * Try to receive message part from socket. * @return false if would block */ inline bool try_recv_msg(zmq::socket_t& sock, zmq::message_t& msg, int flags = ZMQ_NOBLOCK) throw(ZmqErrorType) { bool res = false; try { res = sock.recv(&msg, flags); } catch (const zmq::error_t& e) { throw_zmq_exception(e); } return res; }
/** * Receive message part from socket */ inline void recv_msg(zmq::socket_t& sock, zmq::message_t& msg, int flags = 0) throw(ZmqErrorType) { try { if (!sock.recv(&msg, flags)) { throw zmq::error_t(); } } catch (const zmq::error_t& e) { throw_zmq_exception(e); } }
bool nutils::recv_zmq_message(zmq::socket_t& sock, zmq::message_t& msg, msgpack::object& obj, int flags) { if (!sock.recv(&msg, flags)) { return false; } msgpack::unpacked unpacked; msgpack::unpack(&unpacked, reinterpret_cast<const char*>(msg.data()), msg.size()); obj = unpacked.get(); return true; }
int relay_raw(zmq::socket_t& src, zmq::socket_t& dst, bool check_first_part) { int relayed = 0; for ( bool more = check_first_part ? has_more(src) : true; more; ++relayed) { zmq::message_t cur_part; src.recv(&cur_part); more = has_more(src); int flag = more ? ZMQ_SNDMORE : 0; send_msg(dst, cur_part, flag); } return relayed; }
std::string receiveString(zmq::socket_t & socket) { zmq::message_t message; std::string result = ""; try { socket.recv(&message); result = std::string(static_cast<char*>(message.data()), message.size()); } catch(const zmq::error_t& e) { VLOG(1) << "ZMQ receive has thrown with type " << e.what(); throw; } return result; }
/* * return number of bytes received, negative if error */ int recv_msg(zmq::socket_t &sock, commtest::cliid_t &cid, boost::shared_array<uint8_t> &data) { zmq::message_t msgt; try{ sock.recv(&msgt); }catch(zmq::error_t e){ //LOG(NOR, stderr, "recv cid failed: %s\n", e.what()); return -1; } size_t len = msgt.size(); if(len != sizeof(commtest::cliid_t)) return -1; cid = *((commtest::cliid_t *) msgt.data()); //LOG(DBG, stderr, "received id = 0x%x\n", cid); return recv_msg(sock, data); }