ilejn

0mq reliable request reply

Sep 2nd, 2011
271
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 7.62 KB | None | 0 0
  1. #include <sys/types.h>
  2. #include <string>
  3. #include <sstream>
  4. #include <iostream>
  5.  
  6. #include <zmq.hpp>
  7.  
  8. char external_endpoint[] = "inproc://external";
  9. char internal_endpoint[] = "inproc://internal";
  10.  
  11. std::auto_ptr<zmq::context_t> ctx;
  12.  
  13. enum BrockerEndpoints
  14. {
  15.   epCLIENT,
  16.   epSERVER
  17. };
  18. const size_t NUM_OF_ENDPOINTS = epSERVER + 1;
  19.  
  20.  
  21. // avoid output mess
  22. class CriticalSectionLocker
  23. {
  24. public:
  25.   CriticalSectionLocker()
  26.   {
  27.     pthread_mutex_lock(&mutex_);
  28.   }
  29.   ~CriticalSectionLocker()
  30.   {
  31.     pthread_mutex_unlock(&mutex_);
  32.   }
  33.   operator bool()
  34.   {
  35.     return true;
  36.   }
  37. private:
  38.   static
  39.   pthread_mutex_t mutex_;
  40. };
  41.  
  42. pthread_mutex_t CriticalSectionLocker::mutex_ = PTHREAD_MUTEX_INITIALIZER;
  43.  
  44. struct timespec realtime;
  45.  
  46. #define LOG \
  47.   if(CriticalSectionLocker csl = CriticalSectionLocker()) \
  48.     ::clock_gettime(CLOCK_MONOTONIC, &realtime),           \
  49.         std::cerr << realtime.tv_sec << ":" << realtime.tv_nsec/1000 << " "
  50. ////
  51.  
  52. void*
  53. client(void*)
  54. {
  55.   std::ostringstream clid_s;
  56.   clid_s << "Client " << pthread_self() << ": ";
  57.   const std::string& clid = clid_s.str();
  58.  
  59.   try
  60.   {
  61.     zmq::socket_t cln(*ctx.get(), ZMQ_XREQ);
  62.     int zero = 0;
  63.     cln.setsockopt(ZMQ_LINGER, &zero, sizeof (zero));
  64.     cln.connect(internal_endpoint);  // to broker
  65.  
  66.     for(size_t req = 0 ;;++req)
  67.     {
  68.       zmq::message_t empty;
  69.       cln.send(empty, ZMQ_SNDMORE);
  70.  
  71.       // generate unique identifier
  72.       std::ostringstream reqid_s;
  73.       reqid_s << "request#" << pthread_self() << "#" << req;
  74.       const std::string& reqid = reqid_s.str();
  75.      
  76.       zmq::message_t request(reqid.length());
  77.       memcpy(request.data(), reqid.data(), reqid.length());
  78.       cln.send(request);
  79.       LOG << clid << "request sent" << std::endl;
  80.      
  81.       zmq_pollitem_t slot[1];
  82.       slot[0].socket = cln;
  83.       slot[0].events = ZMQ_POLLIN;
  84.  
  85.       struct timespec tp1;
  86.       ::clock_gettime(CLOCK_MONOTONIC, &tp1);
  87.    
  88.       const size_t TIMEOUT_IN_SECONDS = 1;
  89.       long poll_timeout = TIMEOUT_IN_SECONDS * 1000000;
  90.  
  91.       for(;;)
  92.       {
  93.         zmq::poll(slot, 1, poll_timeout);
  94.         if (slot[0].revents == ZMQ_POLLIN)
  95.         {
  96.           int64_t more = 0;
  97.           zmq::message_t buffer;
  98.           do
  99.           {
  100.             cln.recv(&buffer);
  101.             size_t more_size = sizeof(more);
  102.             cln.getsockopt(ZMQ_RCVMORE, &more, &more_size);
  103.           } while(more);
  104.           LOG << clid << "response recevied" << std::endl;
  105.          
  106.           std::string buffer_str((const char*)buffer.data(), buffer.size());
  107.           if (buffer_str.find(reqid) == std::string::npos)
  108.           { // mismatched - orphan response
  109.             LOG << clid << "request suffix<" << reqid <<
  110.               "> not found in response " << buffer_str <<
  111.               ". Ignore, go further." << std::endl;
  112.             struct timespec tp2;
  113.             ::clock_gettime(CLOCK_MONOTONIC, &tp2);
  114.             long elapsed_microseconds = tp2.tv_sec*1000000 + tp2.tv_nsec/1000
  115.               - tp1.tv_sec*1000000 - tp1.tv_nsec/1000;
  116.        
  117.             if (elapsed_microseconds < poll_timeout)
  118.             {
  119.               LOG << clid << "timeout not expired" << std::endl;
  120.               poll_timeout -= elapsed_microseconds;
  121.               continue;
  122.             }
  123.             else
  124.             {
  125.               LOG << clid << "message lost, go further" << std::endl;
  126.             }
  127.           }
  128.           else
  129.           {
  130.             LOG << clid << "response matched" << std::endl;
  131.           }
  132.         }
  133.         else
  134.         {
  135.           LOG << clid << "no event fired" << std::endl;
  136.           struct timespec tp2;
  137.           ::clock_gettime(CLOCK_MONOTONIC, &tp2);
  138.           long elapsed_microseconds = tp2.tv_sec*1000000 + tp2.tv_nsec/1000
  139.             - tp1.tv_sec*1000000 - tp1.tv_nsec/1000;
  140.        
  141.           if (elapsed_microseconds < poll_timeout)
  142.           {
  143.             LOG << clid << "timeout not expired" << std::endl;
  144.             poll_timeout -= elapsed_microseconds;
  145.             continue;
  146.           }
  147.           else
  148.           {
  149.             LOG << clid << "message lost, go further" << std::endl;
  150.           }
  151.         }
  152.         break;
  153.       }
  154.     }
  155.   }
  156.   catch (std::exception &e)
  157.   {
  158.     LOG << clid << e.what() << std::endl;
  159.   }
  160.   return 0;
  161. }
  162.  
  163. void*
  164. broker(void*)
  165. {
  166.   const size_t NUMBER_OF_CLIENTS = 3;
  167.   pthread_t thread[NUMBER_OF_CLIENTS];
  168.  
  169.   try
  170.   {
  171.     zmq::socket_t cln(*ctx.get(), ZMQ_XREP);
  172.     zmq::socket_t srv(*ctx.get(), ZMQ_XREQ);
  173.  
  174.     int zero = 0;
  175.     srv.setsockopt(ZMQ_LINGER, &zero, sizeof (zero));
  176.     srv.connect(external_endpoint);
  177.     cln.setsockopt(ZMQ_LINGER, &zero, sizeof (zero));
  178.     cln.bind(internal_endpoint);
  179.  
  180.     for(size_t cln = 0; cln < NUMBER_OF_CLIENTS; ++cln)
  181.     {
  182.       pthread_create(thread + cln, 0, client, 0);
  183.     }
  184.  
  185.     zmq_pollitem_t slot[NUM_OF_ENDPOINTS];
  186.  
  187.     slot[epCLIENT].socket = cln;
  188.     slot[epCLIENT].events = ZMQ_POLLIN;
  189.  
  190.     slot[epSERVER].socket = srv;
  191.     slot[epSERVER].events = ZMQ_POLLIN;
  192.  
  193.     for(;;)
  194.     {
  195.       zmq::poll(slot, NUM_OF_ENDPOINTS, -1);
  196.  
  197.       zmq::message_t buffer;
  198.  
  199.       if (slot[epCLIENT].revents)
  200.       {
  201.         int64_t more = 0;
  202.         do
  203.         {
  204.           cln.recv(&buffer);
  205.  
  206.           size_t more_size = sizeof(more);
  207.           cln.getsockopt(ZMQ_RCVMORE, &more, &more_size);
  208.  
  209.      
  210.           srv.send(buffer, more?ZMQ_SNDMORE:0);
  211.         } while(more);
  212.         // Message from client to server resent
  213.       }
  214.       if (slot[epSERVER].revents)
  215.       {
  216.         int64_t more = 0;
  217.         do
  218.         {
  219.           srv.recv(&buffer);
  220.  
  221.           size_t more_size = sizeof(more);
  222.           srv.getsockopt(ZMQ_RCVMORE, &more, &more_size);
  223.  
  224.      
  225.           cln.send(buffer, more?ZMQ_SNDMORE:0);
  226.         } while(more);
  227.         // Message from server to client resent
  228.       }
  229.     }
  230.   }
  231.   catch (std::exception &e)
  232.   {
  233.     LOG << "Broker:" << e.what() << std::endl;
  234.   }
  235.   for(size_t cln = 0; cln < NUMBER_OF_CLIENTS; ++cln)
  236.   {
  237.     pthread_join(thread[cln], 0);
  238.   }
  239.   LOG << "Broker: exiting" << std::endl;
  240.   return 0;
  241. }
  242.  
  243. int
  244. main(int, char**)
  245. {
  246.   pthread_t thread;
  247.   {
  248.     ctx.reset(new zmq::context_t(1));
  249.    
  250.     zmq::socket_t srv(*ctx.get(), ZMQ_XREP);
  251.     int zero = 0;
  252.     srv.setsockopt(ZMQ_LINGER, &zero, sizeof (zero));
  253.     srv.bind(external_endpoint);
  254.  
  255.     pthread_create(&thread, 0, broker, 0);
  256.  
  257.     const size_t NUMBER_OF_REQUESTS = 30;
  258.  
  259.     for(size_t req = 1; req <= NUMBER_OF_REQUESTS; ++req)
  260.     {
  261.       zmq::message_t ident1;
  262.       srv.recv(&ident1);
  263.    
  264.       zmq::message_t ident2;
  265.       srv.recv(&ident2);
  266.    
  267.       zmq::message_t empty;
  268.       srv.recv(&empty);
  269.       assert(!empty.size());
  270.    
  271.       zmq::message_t request;
  272.       srv.recv(&request);
  273.  
  274.       int64_t more = 0;
  275.       size_t more_size = sizeof(more);
  276.       srv.getsockopt(ZMQ_RCVMORE, &more, &more_size);
  277.       assert(!more);
  278.  
  279.       if(!(req%7))
  280.       {
  281.         LOG << "slowing down" << std::endl;
  282.         sleep(2);
  283.       }
  284.    
  285.       srv.send(ident1, ZMQ_SNDMORE);
  286.       srv.send(ident2, ZMQ_SNDMORE);
  287.       srv.send(empty, ZMQ_SNDMORE);
  288.    
  289.       std::string respstr("response ");
  290.       respstr += std::string((char*)request.data(), request.size());
  291.       zmq::message_t response(respstr.length());
  292.    
  293.       memcpy(response.data(), respstr.data(), respstr.length());
  294.       srv.send(response);
  295.       LOG << "Message from server to client sent" << std::endl;
  296.     }
  297.     LOG << "exiting" << std::endl;
  298.   }
  299.  
  300.  
  301.   ctx.reset(0);
  302.  
  303.   LOG << "after zmq_term" << std::endl;
  304.   sleep(1);
  305.   pthread_join(thread, 0);
  306.   LOG << "joined" << std::endl;
  307. }
Advertisement
Add Comment
Please, Sign In to add comment