Changed cache interface in order to simplify management

Sebastiano Merlino · Sebastiano Merlino · commit e9b765958368 · 2012-11-08T15:07:46.000+01:00
diff --git a/src/http_response.cpp b/src/http_response.cpp
@@ -29,10 +29,15 @@ using namespace std;
 namespace httpserver
 {
 
+void unlock_on_close::do_action()
+{
+    details::unlock_cache_entry(elem);
+}
+
 cache_response::~cache_response()
 {
-    if(locked_element)
-        ws->unlock_cache_element(content);
+    if(ce != 0x0 && locked_element)
+        details::unlock_cache_entry(ce);
 }
 
 const std::vector<std::pair<std::string, std::string> > http_response::get_headers()
@@ -134,10 +139,13 @@ void http_file_response::get_raw_response(MHD_Response** response, webserver* ws
 
 void cache_response::get_raw_response(MHD_Response** response, webserver* ws)
 {
-    this->ws = ws;
     this->locked_element = true;
     bool valid;
-    http_response* r = ws->get_from_cache(content, &valid, true);
+    http_response* r;
+    if(ce == 0x0)
+        r = ws->get_from_cache(content, &valid, &ce, true, false);
+    else
+        r = details::get_response(ce);
     r->get_raw_response(response, ws);
     r->decorate_response(*response); //It is done here to avoid to search two times for the same element
     
diff --git a/src/httpserver/http_response.hpp b/src/httpserver/http_response.hpp
@@ -34,6 +34,8 @@ namespace httpserver
 {
 
 class webserver;
+class http_response;
+struct cache_entry;
 
 namespace http
 {
@@ -48,6 +50,46 @@ namespace details
 
 using namespace http;
 
+class closure_action
+{
+    public:
+        closure_action(bool deletable = true):
+            deletable(deletable)
+        {
+        }
+        closure_action(const closure_action& b):
+            deletable(b.deletable)
+        {
+        }
+        virtual void do_action() = 0;
+        bool deletable;
+    private:
+        friend class http_response;
+};
+
+class empty_closure : public closure_action
+{
+    public:
+        void do_action()
+        {
+        }
+};
+
+class unlock_on_close : public closure_action
+{
+    public:
+        unlock_on_close(cache_entry* elem, bool deletable = true) : closure_action(deletable), elem(elem) { }
+        unlock_on_close(const unlock_on_close& b) : closure_action(elem), elem(b.elem) { }
+        unlock_on_close& operator = (const unlock_on_close& b)
+        {
+            elem = b.elem;
+            return *this;
+        }
+        virtual void do_action();
+    private:
+        cache_entry* elem;
+};
+
 /**
  * Class representing an abstraction for an Http Response. It is used from classes using these apis to send information through http protocol.
 **/
@@ -103,7 +145,8 @@ class http_response
             topics(topics),
             keepalive_secs(keepalive_secs),
             keepalive_msg(keepalive_msg),
-            send_topic(send_topic)
+            send_topic(send_topic),
+            ca(new empty_closure())
         {
             set_header(http_utils::http_header_content_type, content_type);
         }
@@ -128,9 +171,36 @@ class http_response
             keepalive_msg(b.keepalive_msg),
             send_topic(b.send_topic)
         {
+            if(ca != 0x0 && ca->deletable)
+                delete ca;
+            ca = b.ca;
+        }
+        http_response& operator=(const http_response& b)
+        {
+            response_type = b.response_type;
+            content = b.content;
+            response_code = b.response_code;
+            autodelete = b.autodelete;
+            realm = b.realm;
+            opaque = b.opaque;
+            reload_nonce = b.reload_nonce;
+            fp = b.fp;
+            filename = b.filename;
+            headers = b.headers;
+            footers = b.footers;
+            topics = b.topics;
+            keepalive_secs = b.keepalive_secs;
+            keepalive_msg = b.keepalive_msg;
+            send_topic = b.send_topic;
+            if(ca != 0x0 && ca->deletable)
+                delete ca;
+            ca = b.ca;
+            return *this;
         }
         virtual ~http_response()
         {
+            if(ca != 0x0 && ca->deletable)
+                delete ca;
         }
         /**
          * Method used to get the content from the response.
@@ -304,6 +374,10 @@ class http_response
                 topics.push_back(*it);
             return topics.size();
         }
+        void set_closure_action(closure_action* ca)
+        {
+            this->ca = ca;
+        }
     protected:
         response_type_T response_type;
         std::string content;
@@ -321,6 +395,7 @@ class http_response
         std::string keepalive_msg;
         std::string send_topic;
         struct MHD_Connection* underlying_connection;
+        closure_action* ca;
 
         virtual void get_raw_response(MHD_Response** res, webserver* ws = 0x0);
         virtual void decorate_response(MHD_Response* res);
@@ -510,10 +585,20 @@ class cache_response : public http_response
     public:
         cache_response
         (
-            const std::string& key
+            const std::string& key,
+            bool locked_element = false
         ) : http_response(http_response::CACHED_CONTENT, key),
-            ws(0x0),
-            locked_element(false)
+            ce(0x0),
+            locked_element(locked_element)
+        {
+        }
+        cache_response
+        (
+            cache_entry* ce,
+            bool locked_element = false
+        ) : http_response(http_response::CACHED_CONTENT, ""),
+            ce(ce),
+            locked_element(locked_element)
         {
         }
 
@@ -525,7 +610,7 @@ class cache_response : public http_response
         virtual void get_raw_response(MHD_Response** res, webserver* ws = 0x0);
         virtual void decorate_response(MHD_Response* res);
     private:
-        webserver* ws;
+        cache_entry* ce;
         bool locked_element;
         friend class webserver;
 };
diff --git a/src/httpserver/webserver.hpp b/src/httpserver/webserver.hpp
@@ -55,13 +55,15 @@ class cache_response;
 class http_request;
 class long_polling_receive_response;
 class long_polling_send_response;
+struct cache_entry;
 
 namespace details
 {
     class http_endpoint;
-    struct cache_entry;
     struct modded_request;
     struct cache_manager;
+    void unlock_cache_entry(cache_entry*);
+    http_response* get_response(cache_entry*);
 }
 
 using namespace http;
@@ -263,9 +265,10 @@ class webserver
         bool pop_signaled(int consumer);
 
         http_response* get_from_cache(const std::string& key, bool* valid, bool lock = false, bool write = false);
+        http_response* get_from_cache(const std::string& key, bool* valid, cache_entry** ce, bool lock = false, bool write = false);
         void lock_cache_element(const std::string& key, bool write = false);
         void unlock_cache_element(const std::string& key);
-        void put_in_cache(const std::string& key, http_response* value, int validity = -1);
+        cache_entry* put_in_cache(const std::string& key, http_response* value, bool* new_elem, bool lock = false, bool write = false, int validity = -1);
         void remove_from_cache(const std::string& key);
         bool is_valid(const std::string& key);
         void clean_cache();
diff --git a/src/webserver.cpp b/src/webserver.cpp
@@ -58,7 +58,7 @@ namespace details
 
 struct cache_manager
 {
-    std::map<std::string, details::cache_entry> response_cache; 
+    std::map<std::string, cache_entry> response_cache; 
 
     cache_manager()
     {
@@ -148,11 +148,13 @@ struct modded_request
     bool second;
 };
 
+}
+
 struct cache_entry
 {
     long ts;
     int validity;
-    http_response_ptr response;
+    details::http_response_ptr response;
     pthread_rwlock_t elem_guard;
 
     cache_entry():
@@ -184,7 +186,7 @@ struct cache_entry
         elem_guard = b.elem_guard;
     }
 
-    cache_entry(http_response_ptr response, long ts = -1, int validity = -1):
+    cache_entry(details::http_response_ptr response, long ts = -1, int validity = -1):
         ts(ts),
         validity(validity),
         response(response)
@@ -193,8 +195,21 @@ struct cache_entry
     }
 };
 
+namespace details
+{
+
+void unlock_cache_entry(cache_entry* ce)
+{
+    pthread_rwlock_unlock(&ce->elem_guard);
 }
 
+http_response* get_response(cache_entry* ce)
+{
+    return ce->response.ptr();
+}
+
+};
+
 using namespace http;
 
 int policy_callback (void *, const struct sockaddr*, socklen_t);
@@ -487,6 +502,8 @@ void webserver::sweet_kill()
 void webserver::request_completed (void *cls, struct MHD_Connection *connection, void **con_cls, enum MHD_RequestTerminationCode toe) 
 {
     details::modded_request* mr = (struct details::modded_request*) *con_cls;
+    if(mr->dhrs->ca != 0x0)
+        mr->dhrs->ca->do_action();
     if (NULL == mr) 
     {
         return;
@@ -1488,10 +1505,16 @@ bool webserver::pop_signaled(int consumer)
 }
 
 http_response* webserver::get_from_cache(const std::string& key, bool* valid, bool lock, bool write)
+{
+    cache_entry* ce;
+    return get_from_cache(key, valid, &ce, lock, write);
+}
+
+http_response* webserver::get_from_cache(const std::string& key, bool* valid, cache_entry** ce, bool lock, bool write)
 {
     pthread_rwlock_rdlock(&cache_guard);
     *valid = true;
-    map<string, details::cache_entry>::iterator it(cache_m->response_cache.find(key));
+    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
     if(it != cache_m->response_cache.end())
     {
         if(lock)
@@ -1508,6 +1531,7 @@ http_response* webserver::get_from_cache(const std::string& key, bool* valid, bo
             if( now.tv_sec - (*it).second.ts > (*it).second.validity)
                 *valid = false;
         }
+        *ce = &((*it).second);
         pthread_rwlock_unlock(&cache_guard);
         return (*it).second.response.ptr();
     }
@@ -1522,7 +1546,7 @@ http_response* webserver::get_from_cache(const std::string& key, bool* valid, bo
 bool webserver::is_valid(const std::string& key)
 {
     pthread_rwlock_rdlock(&cache_guard);
-    map<string, details::cache_entry>::iterator it(cache_m->response_cache.find(key));
+    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
     if(it != cache_m->response_cache.end())
     {
         if((*it).second.validity != -1)
@@ -1548,7 +1572,7 @@ bool webserver::is_valid(const std::string& key)
 void webserver::lock_cache_element(const std::string& key, bool write)
 {
     pthread_rwlock_rdlock(&cache_guard);
-    map<string, details::cache_entry>::iterator it(cache_m->response_cache.find(key));
+    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
     if(it != cache_m->response_cache.end())
     {
         if(write)
@@ -1562,33 +1586,61 @@ void webserver::lock_cache_element(const std::string& key, bool write)
 void webserver::unlock_cache_element(const std::string& key)
 {
     pthread_rwlock_rdlock(&cache_guard);
-    map<string, details::cache_entry>::iterator it(cache_m->response_cache.find(key));
+    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
     if(it != cache_m->response_cache.end())
         pthread_rwlock_unlock(&((*it).second.elem_guard));
     pthread_rwlock_unlock(&cache_guard);
 }
 
-void webserver::put_in_cache(const std::string& key, http_response* value, int validity)
+cache_entry* webserver::put_in_cache(const std::string& key, http_response* value, bool* new_elem, bool lock, bool write, int validity)
 {
+    pthread_rwlock_wrlock(&cache_guard);
+    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
+    bool unlock = false;
+    cache_entry* to_ret;
+    if(it != cache_m->response_cache.end())
+    {
+        pthread_rwlock_wrlock(&((*it).second.elem_guard));
+        unlock = true;
+    }
     if(validity == -1)
     {
-        pthread_rwlock_wrlock(&cache_guard);
-        cache_m->response_cache.insert(pair<string, details::cache_entry>(key, details::cache_entry(value)));
+        pair<map<string, cache_entry>::iterator, bool> res = cache_m->response_cache.insert(pair<string, cache_entry>(key, cache_entry(value)));
+        to_ret = &((*res.first).second);
+        if(lock)
+        {
+            if(write)
+                pthread_rwlock_wrlock(&to_ret->elem_guard);
+            else
+                pthread_rwlock_rdlock(&to_ret->elem_guard);
+        }
+        *new_elem = res.second;
     }
     else
     {
-        pthread_rwlock_wrlock(&cache_guard);
         timeval now;
         gettimeofday(&now, NULL);
-        cache_m->response_cache.insert(pair<string, details::cache_entry>(key, details::cache_entry(value, now.tv_sec, validity)));
+        pair<map<string, cache_entry>::iterator, bool> res = cache_m->response_cache.insert(pair<string, cache_entry>(key, cache_entry(value, now.tv_sec, validity)));
+        to_ret = &((*res.first).second);
+        if(lock)
+        {
+            if(write)
+                pthread_rwlock_wrlock(&to_ret->elem_guard);
+            else
+                pthread_rwlock_rdlock(&to_ret->elem_guard);
+        }
+        *new_elem = res.second;
     }
+    if(unlock)
+        pthread_rwlock_unlock(&((*it).second.elem_guard));
     pthread_rwlock_unlock(&cache_guard);
+    return to_ret;
 }
 
 void webserver::remove_from_cache(const std::string& key)
 {
     pthread_rwlock_wrlock(&cache_guard);
-    map<string, details::cache_entry>::iterator it(cache_m->response_cache.find(key));
+    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
     if(it != cache_m->response_cache.end())
         cache_m->response_cache.erase(it);
     pthread_rwlock_unlock(&cache_guard);
