Modified webserver in order to accept comet calls

Sebastiano Merlino · Sebastiano Merlino · commit b4209eb6fb3b · 2012-09-24T15:29:28.000+02:00
Added ignored patters in gitignore
diff --git a/.gitignore b/.gitignore
@@ -5,6 +5,9 @@
 *.pm
 *.py
 *_wrap.*
+*.gcov
+*.gcno
+*.gcda
 build/*
 aclocal.m4
 autom4te.cache/
diff --git a/src/http_response.cpp b/src/http_response.cpp
@@ -29,6 +29,13 @@ using namespace std;
 namespace httpserver
 {
 
+struct data_closure
+{
+    webserver* ws;
+    string connection_id;
+    string topic;
+};
+
 const std::vector<std::pair<std::string, std::string> > http_response::get_headers()
 {
     std::vector<std::pair<std::string, std::string> > to_ret;
@@ -82,13 +89,13 @@ shoutCAST_response::shoutCAST_response
 {
 }
 
-void http_response::get_raw_response(MHD_Response** response, bool* found)
+void http_response::get_raw_response(MHD_Response** response, bool* found, webserver* ws)
 {
     size_t size = &(*content.end()) - &(*content.begin());
     *response = MHD_create_response_from_buffer(size, (void*) content.c_str(), MHD_RESPMEM_PERSISTENT);
 }
 
-void http_file_response::get_raw_response(MHD_Response** response, bool* found)
+void http_file_response::get_raw_response(MHD_Response** response, bool* found, webserver* ws)
 {
     char* page = NULL;
     size_t size = http::load_file(filename.c_str(), &page);
@@ -98,6 +105,42 @@ void http_file_response::get_raw_response(MHD_Response** response, bool* found)
         *found = false;
 }
 
+void long_polling_receive_response::get_raw_response(MHD_Response** response, bool* found, webserver* ws)
+{
+    data_closure* dc = new data_closure();
+    dc->ws = ws;
+    dc->topic = topic;
+    generate_random_uuid(dc->connection_id);
+    *response = MHD_create_response_from_callback(MHD_SIZE_UNKNOWN, 80,
+            &long_polling_receive_response::data_generator, (void*) dc, &long_polling_receive_response::free_callback);
+    ws->register_to_topic(dc->topic, dc->connection_id);
+}
+
+ssize_t long_polling_receive_response::data_generator (void* cls, uint64_t pos, char* buf, size_t max)
+{
+    data_closure* dc = static_cast<data_closure*>(cls);
+    if(dc->ws->pop_signaled(dc->connection_id))
+    {
+        string message;
+        int size = dc->ws->read_message_from_topic(dc->topic, message);
+        memcpy(buf, message.c_str(), size);
+        return size;
+    }
+    else
+        return 0;
+}
+
+void long_polling_receive_response::free_callback(void* cls)
+{
+    delete static_cast<data_closure*>(cls);
+}
+
+void long_polling_send_response::get_raw_response(MHD_Response** response, bool* found, webserver* ws)
+{
+    http_response::get_raw_response(response, found, ws);
+    ws->send_message_to_topic(topic, content);
+}
+
 void clone_response(const http_response& hr, http_response** dhrs)
 {
     switch(hr.response_type)
@@ -120,6 +163,12 @@ void clone_response(const http_response& hr, http_response** dhrs)
         case(http_response::SWITCH_PROTOCOL):
             *dhrs = new switch_protocol_response(hr);
             return;
+        case(http_response::LONG_POLLING_RECEIVE):
+            *dhrs = new long_polling_receive_response(hr);
+            return;
+        case(http_response::LONG_POLLING_SEND):
+            *dhrs = new long_polling_send_response(hr);
+            return;
     }
 }
 
diff --git a/src/http_utils.cpp b/src/http_utils.cpp
@@ -25,6 +25,7 @@
 #include <sstream>
 #include <iomanip>
 #include <fstream>
+#include <uuid/uuid.h>
 #include "string_utilities.hpp"
 #include "http_utils.hpp"
 
@@ -447,5 +448,16 @@ char* load_file (const char *filename)
     return content;
 }
 
+void generate_random_uuid(string& result)
+{
+    uuid_t out;
+    uuid_generate(out);
+    std::string ret;
+    ret.assign((const char*) out, 16);
+    char unparsed[37];
+    uuid_unparse((const unsigned char*) ret.c_str(), unparsed);
+    result.assign((const char*) unparsed, 37);
+}
+
 };
 };
diff --git a/src/httpserver/http_response.hpp b/src/httpserver/http_response.hpp
@@ -57,7 +57,9 @@ class http_response
             SHOUTCAST_CONTENT,
             DIGEST_AUTH_FAIL,
             BASIC_AUTH_FAIL,
-            SWITCH_PROTOCOL
+            SWITCH_PROTOCOL,
+            LONG_POLLING_RECEIVE,
+            LONG_POLLING_SEND
         };
 
         /**
@@ -74,7 +76,8 @@ class http_response
             const std::string& content_type = "text/plain",
             const std::string& realm = "",
             const std::string& opaque = "",
-            bool reload_nonce = false
+            bool reload_nonce = false,
+            const std::string& topic = ""
         ):
             response_type(response_type),
             content(content),
@@ -83,7 +86,8 @@ class http_response
             opaque(opaque),
             reload_nonce(reload_nonce),
             fp(-1),
-            filename(content)
+            filename(content),
+            topic(topic)
         {
             set_header(http_utils::http_header_content_type, content_type);
         }
@@ -101,7 +105,8 @@ class http_response
             fp(b.fp),
             filename(b.filename),
             headers(b.headers),
-            footers(b.footers)
+            footers(b.footers),
+            topic(b.topic)
         {
         }
         virtual ~http_response()
@@ -265,6 +270,10 @@ class http_response
         {
             return 0;
         }
+        const std::string get_topic() const
+        {
+            return this->topic;
+        }
     protected:
         response_type_T response_type;
         std::string content;
@@ -276,8 +285,9 @@ class http_response
         std::string filename;
         std::map<std::string, std::string, header_comparator> headers;
         std::map<std::string, std::string, header_comparator> footers;
+        std::string topic;
 
-        virtual void get_raw_response(MHD_Response** res, bool* found);
+        virtual void get_raw_response(MHD_Response** res, bool* found, webserver* ws = 0x0);
 
         friend class webserver;
         friend void clone_response(const http_response& hr, http_response** dhr);
@@ -310,7 +320,7 @@ class http_file_response : public http_response
 
         http_file_response(const http_response& b) : http_response(b) { }
     protected:
-        virtual void get_raw_response(MHD_Response** res, bool* found);
+        virtual void get_raw_response(MHD_Response** res, bool* found, webserver* ws = 0x0);
 };
 
 class http_basic_auth_fail_response : public http_response
@@ -372,9 +382,44 @@ class switch_protocol_response : public http_response
         { 
         }
     protected:
-        virtual void get_raw_response(MHD_Response** res, bool* found)
+        virtual void get_raw_response(MHD_Response** res, bool* found, webserver* ws = 0x0) {}
+};
+
+class long_polling_receive_response : public http_response
+{
+    public:
+        long_polling_receive_response
+        (
+            const std::string& content,
+            int response_code,
+            const std::string& content_type,
+            const std::string& topic
+        ) : http_response(http_response::LONG_POLLING_RECEIVE, content, response_code, content_type, "", "", false, topic)
+        {
+        }
+
+        long_polling_receive_response(const http_response& b) : http_response(b) { }
+    protected:
+        virtual void get_raw_response(MHD_Response** res, bool* found, webserver* ws = 0x0);
+    private:
+        static ssize_t data_generator (void* cls, uint64_t pos, char* buf, size_t max);
+        static void free_callback(void* cls);
+};
+
+class long_polling_send_response : public http_response
+{
+    public:
+        long_polling_send_response
+        (
+            const std::string& content,
+            const std::string& topic
+        ) : http_response(http_response::LONG_POLLING_SEND, content, 200, "", "", "", false, topic)
         {
         }
+
+        long_polling_send_response(const http_response& b) : http_response(b) { }
+    protected:
+        virtual void get_raw_response(MHD_Response** res, bool* found, webserver* ws = 0x0);
 };
 
 void clone_response(http_response* hr, http_response** dhr);
diff --git a/src/httpserver/http_utils.hpp b/src/httpserver/http_utils.hpp
@@ -342,6 +342,8 @@ char* load_file (const char *filename);
 
 size_t load_file (const char* filename, char** content);
 
+void generate_random_uuid(std::string& uuid);
+
 };
 };
 #endif
diff --git a/src/httpserver/webserver.hpp b/src/httpserver/webserver.hpp
@@ -52,6 +52,8 @@ class http_resource;
 class http_response;
 class http_request;
 struct modded_request;
+class long_polling_receive_response;
+class long_polling_send_response;
 
 namespace details
 {
@@ -234,6 +236,44 @@ class webserver
         void allow_ip(const std::string& ip);
         void unban_ip(const std::string& ip);
         void disallow_ip(const std::string& ip);
+
+        void send_message_to_topic(const std::string& topic, const std::string& message)
+        {
+            q_messages[topic] = message;
+            for(std::set<std::string>::const_iterator it = q_waitings[topic].begin(); it != q_waitings[topic].end(); ++it)
+                q_signal.insert((*it));
+        }
+
+        void register_to_topic(const std::string& topic, const std::string& connection_id)
+        {
+            q_waitings[topic].insert(connection_id);
+        }
+
+        size_t read_message_from_topic(const std::string& topic, std::string& message)
+        {
+            message = q_messages[topic];
+            return message.size();
+        }
+
+        size_t get_topic_consumers(const std::string& topic, std::set<std::string>& consumers)
+        {
+            for(std::set<std::string>::const_iterator it = q_waitings[topic].begin(); it != q_waitings[topic].end(); ++it)
+                consumers.insert((*it));
+            return consumers.size();
+        }
+
+        bool pop_signaled(const std::string& consumer)
+        {
+            std::set<std::string>::iterator it = q_signal.find(consumer);
+            if(it != q_signal.end())
+            {
+                q_signal.erase(it);
+                return true;
+            }
+            else
+                return false;
+        }
+
         /**
          * Method used to kill the webserver waiting for it to terminate
         **/
@@ -282,9 +322,15 @@ class webserver
 #ifdef USE_CPP_ZEROX
         std::unordered_set<ip_representation> bans;
         std::unordered_set<ip_representation> allowances;
+        std::unordered_map<std::string, std::string> q_messages;
+        std::unordered_map<std::string, std::unordered_set<std::string> > q_waitings;
+        std::unordered_set<std::string> q_signal;
 #else
         std::set<ip_representation> bans;
         std::set<ip_representation> allowances;
+        std::map<std::string, std::string> q_messages;
+        std::map<std::string, std::set<std::string> > q_waitings;
+        std::set<std::string> q_signal;
 #endif
         struct MHD_Daemon *daemon;
 
diff --git a/src/webserver.cpp b/src/webserver.cpp
@@ -815,7 +815,7 @@ int webserver::finalize_answer(MHD_Connection* connection, struct modded_request
     }
 #endif
     mr->dhrs = dhrs;
-    dhrs->get_raw_response(&response, &found);
+    dhrs->get_raw_response(&response, &found, this);
     vector<pair<string,string> > response_headers;
     dhrs->get_headers(response_headers);
     vector<pair<string,string> > response_footers;
diff --git a/test/Test.cpp b/test/Test.cpp
@@ -1,13 +1,21 @@
 #include "Test.hpp"
+#include <signal.h>
 #include <string>
 #include <vector>
 #include <unistd.h>
-#include <boost/thread.hpp>
 #include <iostream>
 #include <fstream>
 #include <stdio.h>
 using namespace std;
 
+webserver* ws_ptr;
+
+void signal_callback_handler(int signum)
+{
+    cout << "bye!" << endl;
+    ws_ptr->stop();
+}
+
 Test::Test() : http_resource() 
 {
 }
@@ -24,8 +32,13 @@ http_response Test::render_GET(const http_request& r)
 	cout << "PROVA: " << r.get_arg("prova") << endl;
 	cout << "ALTRO: " << r.get_arg("altro") << endl;
     cout << "THUMB: " << r.get_arg("thumbId") << endl;
+    cout << "COOKIE: " << r.get_cookie("auth") << endl;
+    std::map<std::string, std::string, header_comparator> head;
+    r.get_headers(head);
+    for(std::map<std::string, std::string, header_comparator>::const_iterator it = head.begin(); it != head.end(); ++it)
+        cout << (*it).first <<  "-> " << (*it).second << endl;
 	string pp = r.get_arg("prova");
-	return http_file_response("/home/etr/progs/libhttpserver/test/readme", 200);
+	return http_file_response("/home/etr/progs/libhttpserver/test/noimg.png", 200, "image/png");
 }
 
 http_response Test::render_POST(const http_request& r)
@@ -56,12 +69,15 @@ http_response Test::render_PUT(const http_request& r)
 
 int main()
 {
-	webserver ws = create_webserver(9898);
+    signal(SIGINT, &signal_callback_handler);
+	webserver ws = create_webserver(8080);
+    ws_ptr = &ws;
 	Test dt = Test();
 	Test2 dt2 = Test2();
     ws.register_resource(string("base/{var1}/{var2}/drop_test/{var3}/tail"), &dt2, true);
     ws.register_resource(string("other/side/{thumbId|[0-9]*}"), &dt, true);
-	boost::thread* t1 = new boost::thread(boost::bind(&webserver::start, ws, true));
-	t1->join();
+    ws.register_resource(string("another/{thumbId|[0-9]*}"), &dt, true);
+    ws.register_resource(string("edge/thumbnail"), &dt, true);
+    ws.start(true);
 	return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -815,7 +815,7 @@ int webserver::finalize_answer(MHD_Connection* connection, struct modded_request`
`815`	`815`	`}`
`816`	`816`	`#endif`
`817`	`817`	`mr->dhrs = dhrs;`
`818`		`- dhrs->get_raw_response(&response, &found);`
	`818`	`+ dhrs->get_raw_response(&response, &found, this);`
`819`	`819`	`vector<pair<string,string> > response_headers;`
`820`	`820`	`dhrs->get_headers(response_headers);`
`821`	`821`	`vector<pair<string,string> > response_footers;`