Do-it-yourself instant messaging service

We all are accustomed to using ICQ, many of them implement this functionality in their projects, someone uses a database, or a queue server, for example, memcacheq. There are ready-made solutions, such as eJabber.

If you are interested in how you can do it yourself, then wellcom under castes, where the server part of the Instant Messaging Service will be reviewed. From the client, I hope, figure it out for yourself ...

The essence of “Short message service is basically a queue server running HTTP, which should be easily integrated with any JS framework. All results are displayed in JSON. The exchange with the server is carried out from the browser via AJAX.
')
using the POST method, we write data by the key, which is the url (or part of it). Using the GET method, we retrieve from the queue (by the key, which is the url) what was recorded. So we have: one Heshtablitsu, the key in which are uri, and the data - the queue. The queue represents a message string. If you wish, you can add time. Although there are many ideas for development.

So closer to the topic:

1. #include <sys / types.h>
2. #include <sys / time.h>
3. #include <sys / queue.h>
4. #include <stdlib.h>
5. #include <err.h>
6. #include <event.h>
7. #include <evhttp.h>
9. #include <map>
10. #include <string>
11. #include <queue>
13. using namespace std ;
15. std :: map < string, queue < string >> ht ;
17. void generic_handler ( struct evhttp_request * req, void * arg )
18. {
19. struct evbuffer * buf ;
20. buf = evbuffer_new ( ) ;
21. if ( buf == NULL )
22. err ( 1 , "failed to create response response" ) ;
23. string key = evhttp_request_uri ( req ) ;
24. string out ;
26. if ( req - > type == EVHTTP_REQ_POST ) {
28. const char * str_len = evhttp_find_header ( req - > input_headers, "Content-Length" ) ;
29. int len = atoi ( str_len ) ;
30. out. assign ( ( const char * ) EVBUFFER_DATA ( req - > input_buffer ) , len ) ;
31. if ( ht. find ( key ) == ht. end ( ) ) {
32. queue < string > q ;
33. q. push ( out ) ;
34. ht. insert ( pair < string, queue < string >> ( key, q ) ) ;
35. } else
36. ht [ key ] . push ( out ) ;
37. evbuffer_add_printf ( buf, "{ \" result \ " : \" Ok \ " } \ r \ n " ) ;
38. } else {
39. if ( ht. find ( key ) == ht. end ( ) ) {
40. evbuffer_add_printf ( buf, "{ \" result \ " : null} \ r \ n " ) ;
41. } else {
42. queue < string > q = ht [ key ] ;
43. if ( q. size ( ) ) {
44. out = q. front ( ) ;
45. q. pop ( ) ;
46. ht [ key ] = q ;
47. evbuffer_add_printf ( buf, "{ \" result \ " : \" % s \ " }" , out. c_str ( ) ) ;
48. } else {
49. evbuffer_add_printf ( buf, "{ \" result \ " : null}" )
50. }
51. }
52. }
53. evhttp_send_reply ( req, HTTP_OK, "OK" , buf ) ;
54. }
56. int main ( int argc, char ** argv )
57. {
58. struct evhttp * httpd ;
59. event_init ( ) ;
60. httpd = evhttp_start ( "0.0.0.0" , 8080 ) ;
61. evhttp_set_gencb ( httpd, generic_handler, NULL ) ;
62. event_dispatch ( ) ;
63. evhttp_free ( httpd ) ;
64. return 0 ;
65. }

a few explanations on the code:
lines 58-63 WEB server initialization. The basis for taking WEB server based on libevent. He has excellent performance. On my 2.3GHz laptop, it gives a performance of 2k qps. Any URL is processed.
pp 20-22 - initialize buffer
page 23 we get REQUEST_IRI and use for the key. There are many suggestions for optimization.
p 26 we check for POST. Sure, you can still check on HEAD (other methods evhttp does not support). We will not complicate life yet.
pp 28-30 we form variable in which the data is stored. Since garbage accumulates in the buffer, we write as many bytes as indicated in the Content-Length header.
pp. 30-35 If the key does not exist, then we start a new queue and insert a data item into the queue
page 36 otherwise just insert the data item into the queue
p 38 - fulfills the GET method
page 39 checks if the key exists
page 40 - no - display a message about the empty result
p 42 - get data by key
page 43 - check whether the queue is empty,
pages 44-47 - no, select a message from the queue and output it, the queue is reduced by one message
It is possible to slightly flame, that it is necessary to make an escaping. Yes, be sure to add it.
p 49 yes, the queue is empty, we report about it.
page 53 finalize the request, send the response code 200 OK

It should be noted that the model is single-threaded, so there is no need to make any locks on the record. Although this question will also be worked out by me.

Ab results
Concurrency Level: 3
Time taken for tests: 0.415 seconds
Complete requests: 1000
Failed requests: 0
Write errors: 0
Total transferred: 83000 bytes
HTML transferred: 19000 bytes
Requests per second: 2409.31 [#/sec] (mean)
Time per request: 1.245 [ms] (mean)
Time per request: 0.415 [ms] (mean, across all concurrent requests)
Transfer rate: 195.29 [Kbytes/sec] received

The amount of memory consumed per 10,000 messages - just over 600K

In fact, it is planned to deliver for nginx, let it be responsible for security (ngx_http_accesskey_module)
config file:
location /test {
proxy_pass 127.0.0.1:8080;
## ngx_http_accesskey_module
}
but through nginx performance reaches 800 rps

There are many ideas - how and where to go next. For example, display of activity status, antispam.
Any other ideas are welcome. While I am sitting without work, there is no project on which I can test it. According to my calculations, at the same time about 10 thousand clients will calmly pull if inquiries with a frequency of 1 -1.5 minutes (130-200 rps) are made.