/* * 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; }
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; }
Message receive(zmq::socket_t& socket) { std::vector<std::string> address; std::string frame = receiveString(socket); // Do we have an address? while (frame.compare("") != 0) { address.push_back(frame); frame = receiveString(socket); } // address is a stack, so reverse it to get the right way around std::reverse(address.begin(), address.end()); // We've just read the delimiter, so now get subject auto subjectString = receiveString(socket); //the underlying representation is (explicitly) an int so fairly safe Subject subject = (Subject)detail::unserialise<std::uint32_t>(subjectString); std::vector<std::string> data; while (true) { int isMore = 0; size_t moreSize = sizeof(isMore); socket.getsockopt(ZMQ_RCVMORE, &isMore, &moreSize); if (!isMore) break; data.push_back(receiveString(socket)); } return Message(address, subject, data); }
void receiveAllStr(zmq::socket_t& socket, string& s, int flags = 0) { int64_t more = 1; size_t moreSize = sizeof(int64_t); while (more == 1) { receiveStr(socket, s, flags); socket.getsockopt(ZMQ_RCVMORE, &more, &moreSize); } }
bool has_more(zmq::socket_t& sock) { int64_t more = 0; size_t more_size = sizeof(more); sock.getsockopt(ZMQ_RCVMORE, &more, &more_size); return (more != 0); }
bool sockopt_rcvmore(zmq::socket_t & socket) { int64_t rcvmore = 0; size_t type_size = sizeof(int64_t); socket.getsockopt(ZMQ_RCVMORE, &rcvmore, &type_size); // std::cout << rcvmore << std::endl; return rcvmore ? true : false; }
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; }
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); } }
// 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; } } }
bool MultipartMessage::receiveFrom(zmq::socket_t& s, int flags) { int64_t has_more = 0 ; size_t ilen = sizeof(int64_t); parts.clear(); while (true) { Message m ; bool res = m.receiveFrom(s, flags); if (!res) { parts.clear(); return res ; } parts.push_back(m); s.getsockopt(ZMQ_RCVMORE, &has_more, &ilen); if (!has_more) break ; } return true ; }
// job allocation, relay request to workers void process_frontend(zmq::socket_t& frontend, zmq::socket_t& backend, int& number_of_workers) { int64_t more; size_t moresz; moresz = sizeof(more); // decrement available workers --number_of_workers; // process incoming using multipart aware code while(true) { zmq::message_t client_msg; frontend.recv(&client_msg); frontend.getsockopt(ZMQ_RCVMORE, &more, &moresz); backend.send(client_msg, more ? ZMQ_SNDMORE : 0); if(!more) { break; } } }
// Receives all message parts from socket, prints neatly // static void s_dump (zmq::socket_t & socket) { std::cout << "----------------------------------------" << std::endl; while (1) { // Process all parts of the message zmq::message_t message; socket.recv(&message); // Dump the message as text or binary int size = message.size(); std::string data(static_cast<char*>(message.data()), size); bool is_text = true; int char_nbr; unsigned char byte; for (char_nbr = 0; char_nbr < size; char_nbr++) { byte = data [char_nbr]; if (byte < 32 || byte > 127) is_text = false; } std::cout << "[" << std::setfill('0') << std::setw(3) << size << "]"; for (char_nbr = 0; char_nbr < size; char_nbr++) { if (is_text) std::cout << (char)data [char_nbr]; else std::cout << std::setfill('0') << std::setw(2) << std::hex << (unsigned int) data [char_nbr]; } std::cout << std::endl; int more = 0; // Multipart detection size_t more_size = sizeof (more); socket.getsockopt (ZMQ_RCVMORE, &more, &more_size); if (!more) break; // Last message part } }
// Receives all message parts from socket, prints neatly // static void s_dump (zmq::socket_t & socket) { std::cout << "----------------------------------------" << std::endl; while (1) { // Process all parts of the message zmq::message_t message; socket.recv(&message); // Dump the message as text or binary std::string data(static_cast<char*>(message.data())); int size = message.size(); bool is_text = true; int char_nbr; for (char_nbr = 0; char_nbr < size; char_nbr++) if (data [char_nbr] < 32 || data [char_nbr] > 127) is_text = 0; printf ("[%03d] ", size); for (char_nbr = 0; char_nbr < size; char_nbr++) { if (is_text) printf ("%c", data [char_nbr]); else printf ("%02X", (unsigned char) data [char_nbr]); } printf ("\n"); int64_t more; // Multipart detection size_t more_size = sizeof (more); socket.getsockopt(ZMQ_RCVMORE, &more, &more_size); if (!more) break; // Last message part } }
bool TransferMessage(::zmq::socket_t &receiver, ::zmq::socket_t &sender) { message_t msg; int32 more; size_t moresz; while (true) { if (!receiver.recv(&msg, 0)) { return false; } moresz = sizeof(more); receiver.getsockopt(ZMQ_RCVMORE, &more, &moresz); if (!sender.send(msg, more ? ZMQ_SNDMORE : 0)) { return false; } if (!more) break; } return true; }
// 0 for received nothing int32_t RecvMsgAsync(zmq::socket_t &sock, boost::shared_array<uint8_t> &data, bool *_more){ 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); 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; }
bool ReceiveMessage(::zmq::socket_t &socket, MessageContainer &container, int flags) { container.Clear(); bool in_identity = true; while (true) { message_t *msg = new message_t(); if (!socket.recv(msg, flags)) { delete msg; return false; } if (msg->size() == 0) { in_identity = false; delete msg; continue; } if (in_identity) { container.AddIdentity(msg); } else { container.AddMessage(msg); } int32 more; size_t moresz; moresz = sizeof(more); socket.getsockopt(ZMQ_RCVMORE, &more, &moresz); if (!more) break; } return true; }