Solved some problem with cache management

Sebastiano Merlino · Sebastiano Merlino · commit 6d943e981f07 · 2012-12-11T03:02:01.000+01:00
diff --git a/src/httpserver/http_response.hpp b/src/httpserver/http_response.hpp
@@ -50,6 +50,15 @@ namespace details
 
 using namespace http;
 
+class bad_caching_attempt: public std::exception
+{
+    virtual const char* what() const throw()
+    {
+        return "You cannot pass ce = 0x0 without key!";
+    }
+};
+
+
 class closure_action
 {
     public:
@@ -636,6 +645,8 @@ class cache_response : public http_response
             ce(ce),
             locked_element(locked_element)
         {
+            if(ce == 0x0)
+                throw bad_caching_attempt();
         }
 
         cache_response(const http_response& b) : http_response(b) { }
diff --git a/src/httpserver/webserver.hpp b/src/httpserver/webserver.hpp
@@ -64,6 +64,7 @@ namespace details
     struct cache_manager;
     struct daemon_item;
     void unlock_cache_entry(cache_entry*);
+    void lock_cache_entry(cache_entry*);
     http_response* get_response(cache_entry*);
 }
 
@@ -335,8 +336,8 @@ class webserver
 
         std::map<details::http_endpoint, http_resource* > registered_resources;
 
-        details::cache_manager* cache_m;
         pthread_rwlock_t cache_guard;
+        std::map<std::string, cache_entry*> response_cache;
 #ifdef USE_CPP_ZEROX
         std::unordered_set<ip_representation> bans;
         std::unordered_set<ip_representation> allowances;
diff --git a/src/webserver.cpp b/src/webserver.cpp
@@ -72,15 +72,6 @@ struct daemon_item
     }
 };
 
-struct cache_manager
-{
-    std::map<std::string, cache_entry> response_cache; 
-
-    cache_manager()
-    {
-    }
-};
-
 struct http_response_ptr
 {
     public:
@@ -109,7 +100,10 @@ struct http_response_ptr
                 if((*num_references) == 0)
                 {
                     if(res && res->autodelete)
+                    {
                         delete res;
+                        res = 0x0;
+                    }
                     delete num_references;
                 }
                 else
@@ -137,7 +131,10 @@ struct http_response_ptr
                     if((*num_references) == 0)
                     {
                         if(res && res->autodelete)
+                        {
                             delete res;
+                            res = 0x0;
+                        }
                         delete num_references;
                     }
                     else
@@ -258,6 +255,11 @@ void unlock_cache_entry(cache_entry* ce)
     ce->unlock();
 }
 
+void lock_cache_entry(cache_entry* ce)
+{
+    ce->lock();
+}
+
 http_response* get_response(cache_entry* ce)
 {
     return ce->response.ptr();
@@ -425,8 +427,7 @@ webserver::webserver
     not_found_resource(not_found_resource),
     method_not_allowed_resource(method_not_allowed_resource),
     method_not_acceptable_resource(method_not_acceptable_resource),
-    internal_error_resource(internal_error_resource),
-    cache_m(new details::cache_manager())
+    internal_error_resource(internal_error_resource)
 {
     init(single_resource);
 }
@@ -466,8 +467,7 @@ webserver::webserver(const create_webserver& params):
     not_found_resource(params._not_found_resource),
     method_not_allowed_resource(params._method_not_allowed_resource),
     method_not_acceptable_resource(params._method_not_acceptable_resource),
-    internal_error_resource(params._internal_error_resource),
-    cache_m(new details::cache_manager())
+    internal_error_resource(params._internal_error_resource)
 {
     init(params._single_resource);
 }
@@ -509,7 +509,7 @@ webserver& webserver::operator=(const webserver& b)
     method_not_allowed_resource = b.method_not_allowed_resource;
     method_not_acceptable_resource = b.method_not_acceptable_resource;
     internal_error_resource = b.internal_error_resource;
-    cache_m->response_cache = b.cache_m->response_cache;
+    response_cache = b.response_cache;
     return *this;
 }
 
@@ -546,7 +546,6 @@ webserver::~webserver()
     pthread_mutex_destroy(&cleanmux);
     pthread_cond_destroy(&cleancond);
 #endif //USE_COMET
-    delete cache_m;
     for(vector<details::daemon_item*>::const_iterator it = daemons.begin(); it != daemons.end(); ++it)
         delete *it;
 }
@@ -1715,29 +1714,29 @@ 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;
+    cache_entry* ce = 0x0;
     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, cache_entry>::iterator it(cache_m->response_cache.find(key));
-    if(it != cache_m->response_cache.end())
+    map<string, cache_entry*>::iterator it(response_cache.find(key));
+    if(it != response_cache.end())
     {
         if(lock)
-            (*it).second.lock(write);
-        if((*it).second.validity != -1)
+            (*it).second->lock(write);
+        if((*it).second->validity != -1)
         {
             timeval now;
             gettimeofday(&now, NULL);
-            if( now.tv_sec - (*it).second.ts > (*it).second.validity)
+            if( now.tv_sec - (*it).second->ts > (*it).second->validity)
                 *valid = false;
         }
-        *ce = &((*it).second);
+        *ce = (*it).second;
         pthread_rwlock_unlock(&cache_guard);
-        return (*it).second.response.ptr();
+        return (*it).second->response.ptr();
     }
     else
     {
@@ -1750,14 +1749,14 @@ http_response* webserver::get_from_cache(const std::string& key, bool* valid, ca
 bool webserver::is_valid(const std::string& key)
 {
     pthread_rwlock_rdlock(&cache_guard);
-    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
-    if(it != cache_m->response_cache.end())
+    map<string, cache_entry*>::iterator it(response_cache.find(key));
+    if(it != response_cache.end())
     {
-        if((*it).second.validity != -1)
+        if((*it).second->validity != -1)
         {
             timeval now;
             gettimeofday(&now, NULL);
-            if( now.tv_sec - (*it).second.ts > (*it).second.validity)
+            if( now.tv_sec - (*it).second->ts > (*it).second->validity)
             {
                 pthread_rwlock_unlock(&cache_guard);
                 return false;
@@ -1781,44 +1780,44 @@ 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, cache_entry>::iterator it(cache_m->response_cache.find(key));
-    if(it != cache_m->response_cache.end())
-        (*it).second.lock(write);
+    map<string, cache_entry*>::iterator it(response_cache.find(key));
+    if(it != response_cache.end())
+        (*it).second->lock(write);
     pthread_rwlock_unlock(&cache_guard);
 }
 
 void webserver::unlock_cache_element(const std::string& key)
 {
     pthread_rwlock_rdlock(&cache_guard);
-    map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));
-    if(it != cache_m->response_cache.end())
-        (*it).second.unlock();
+    map<string, cache_entry*>::iterator it(response_cache.find(key));
+    if(it != response_cache.end())
+        (*it).second->unlock();
     pthread_rwlock_unlock(&cache_guard);
 }
 
 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));
+    map<string, cache_entry*>::iterator it(response_cache.find(key));
     cache_entry* to_ret;
     bool already_in = false;
-    if(it != cache_m->response_cache.end())
+    if(it != response_cache.end())
     {
-        (*it).second.lock(true);
+        (*it).second->lock(true);
         already_in = true;
     }
     if(validity == -1)
     {
         if(already_in)
         {
-            (*it).second.response = value;
-            to_ret = &(*it).second;
+            (*it).second->response = value;
+            to_ret = (*it).second;
             *new_elem = false;
         }
         else
         {
-            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);
+            pair<map<string, cache_entry*>::iterator, bool> res = response_cache.insert(pair<string, cache_entry*>(key, new cache_entry(value)));
+            to_ret = (*res.first).second;
             *new_elem = res.second;
         }
     }
@@ -1828,21 +1827,21 @@ cache_entry* webserver::put_in_cache(const std::string& key, http_response* valu
         gettimeofday(&now, NULL);
         if(already_in)
         {
-            (*it).second.response = value;
-            (*it).second.ts = now.tv_sec;
-            (*it).second.validity = validity;
-            to_ret = &(*it).second;
+            (*it).second->response = value;
+            (*it).second->ts = now.tv_sec;
+            (*it).second->validity = validity;
+            to_ret = (*it).second;
             *new_elem = false;
         }
         else
         {
-            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);
+            pair<map<string, cache_entry*>::iterator, bool> res = response_cache.insert(pair<string, cache_entry*>(key, new cache_entry(value, now.tv_sec, validity)));
+            to_ret = (*res.first).second;
             *new_elem = res.second;
         }
     }
     if(already_in)
-        (*it).second.unlock();
+        (*it).second->unlock();
     if(lock)
         to_ret->lock(write);
     pthread_rwlock_unlock(&cache_guard);
@@ -1852,16 +1851,20 @@ cache_entry* webserver::put_in_cache(const std::string& key, http_response* valu
 void webserver::remove_from_cache(const std::string& key)
 {
     pthread_rwlock_wrlock(&cache_guard);
-    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);
+    map<string, cache_entry*>::iterator it(response_cache.find(key));
+    if(it != response_cache.end())
+    {
+        cache_entry* ce = (*it).second;
+        response_cache.erase(it);
+        delete ce;
+    }
     pthread_rwlock_unlock(&cache_guard);
 }
 
 void webserver::clean_cache()
 {
     pthread_rwlock_wrlock(&cache_guard);
-    cache_m->response_cache.clear();
+    response_cache.clear(); //manage this because obviously causes leaks
     pthread_rwlock_unlock(&cache_guard);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -72,15 +72,6 @@ struct daemon_item`
`72`	`72`	`}`
`73`	`73`	`};`
`74`	`74`
`75`		`-struct cache_manager`
`76`		`-{`
`77`		`- std::map<std::string, cache_entry> response_cache;`
`78`		`-`
`79`		`- cache_manager()`
`80`		`- {`
`81`		`- }`
`82`		`-};`
`83`		`-`
`84`	`75`	`struct http_response_ptr`
`85`	`76`	`{`
`86`	`77`	`public:`
`@@ -109,7 +100,10 @@ struct http_response_ptr`
`109`	`100`	`if((*num_references) == 0)`
`110`	`101`	`{`
`111`	`102`	`if(res && res->autodelete)`
	`103`	`+ {`
`112`	`104`	`delete res;`
	`105`	`+ res = 0x0;`
	`106`	`+ }`
`113`	`107`	`delete num_references;`
`114`	`108`	`}`
`115`	`109`	`else`
`@@ -137,7 +131,10 @@ struct http_response_ptr`
`137`	`131`	`if((*num_references) == 0)`
`138`	`132`	`{`
`139`	`133`	`if(res && res->autodelete)`
	`134`	`+ {`
`140`	`135`	`delete res;`
	`136`	`+ res = 0x0;`
	`137`	`+ }`
`141`	`138`	`delete num_references;`
`142`	`139`	`}`
`143`	`140`	`else`
`@@ -258,6 +255,11 @@ void unlock_cache_entry(cache_entry* ce)`
`258`	`255`	`ce->unlock();`
`259`	`256`	`}`
`260`	`257`
	`258`	`+void lock_cache_entry(cache_entry* ce)`
	`259`	`+{`
	`260`	`+ ce->lock();`
	`261`	`+}`
	`262`	`+`
`261`	`263`	`http_response* get_response(cache_entry* ce)`
`262`	`264`	`{`
`263`	`265`	`return ce->response.ptr();`
`@@ -425,8 +427,7 @@ webserver::webserver`
`425`	`427`	`not_found_resource(not_found_resource),`
`426`	`428`	`method_not_allowed_resource(method_not_allowed_resource),`
`427`	`429`	`method_not_acceptable_resource(method_not_acceptable_resource),`
`428`		`- internal_error_resource(internal_error_resource),`
`429`		`- cache_m(new details::cache_manager())`
	`430`	`+ internal_error_resource(internal_error_resource)`
`430`	`431`	`{`
`431`	`432`	`init(single_resource);`
`432`	`433`	`}`
`@@ -466,8 +467,7 @@ webserver::webserver(const create_webserver& params):`
`466`	`467`	`not_found_resource(params._not_found_resource),`
`467`	`468`	`method_not_allowed_resource(params._method_not_allowed_resource),`
`468`	`469`	`method_not_acceptable_resource(params._method_not_acceptable_resource),`
`469`		`- internal_error_resource(params._internal_error_resource),`
`470`		`- cache_m(new details::cache_manager())`
	`470`	`+ internal_error_resource(params._internal_error_resource)`
`471`	`471`	`{`
`472`	`472`	`init(params._single_resource);`
`473`	`473`	`}`
`@@ -509,7 +509,7 @@ webserver& webserver::operator=(const webserver& b)`
`509`	`509`	`method_not_allowed_resource = b.method_not_allowed_resource;`
`510`	`510`	`method_not_acceptable_resource = b.method_not_acceptable_resource;`
`511`	`511`	`internal_error_resource = b.internal_error_resource;`
`512`		`- cache_m->response_cache = b.cache_m->response_cache;`
	`512`	`+ response_cache = b.response_cache;`
`513`	`513`	`return *this;`
`514`	`514`	`}`
`515`	`515`
`@@ -546,7 +546,6 @@ webserver::~webserver()`
`546`	`546`	`pthread_mutex_destroy(&cleanmux);`
`547`	`547`	`pthread_cond_destroy(&cleancond);`
`548`	`548`	`#endif //USE_COMET`
`549`		`- delete cache_m;`
`550`	`549`	`for(vector<details::daemon_item*>::const_iterator it = daemons.begin(); it != daemons.end(); ++it)`
`551`	`550`	`delete *it;`
`552`	`551`	`}`
`@@ -1715,29 +1714,29 @@ bool webserver::pop_signaled(int consumer)`
`1715`	`1714`
`1716`	`1715`	`http_response* webserver::get_from_cache(const std::string& key, bool* valid, bool lock, bool write)`
`1717`	`1716`	`{`
`1718`		`- cache_entry* ce;`
	`1717`	`+ cache_entry* ce = 0x0;`
`1719`	`1718`	`return get_from_cache(key, valid, &ce, lock, write);`
`1720`	`1719`	`}`
`1721`	`1720`
`1722`	`1721`	`http_response* webserver::get_from_cache(const std::string& key, bool* valid, cache_entry** ce, bool lock, bool write)`
`1723`	`1722`	`{`
`1724`	`1723`	`pthread_rwlock_rdlock(&cache_guard);`
`1725`	`1724`	`*valid = true;`
`1726`		`- map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));`
`1727`		`- if(it != cache_m->response_cache.end())`
	`1725`	`+ map<string, cache_entry*>::iterator it(response_cache.find(key));`
	`1726`	`+ if(it != response_cache.end())`
`1728`	`1727`	`{`
`1729`	`1728`	`if(lock)`
`1730`		`- (*it).second.lock(write);`
`1731`		`- if((*it).second.validity != -1)`
	`1729`	`+ (*it).second->lock(write);`
	`1730`	`+ if((*it).second->validity != -1)`
`1732`	`1731`	`{`
`1733`	`1732`	`timeval now;`
`1734`	`1733`	`gettimeofday(&now, NULL);`
`1735`		`- if( now.tv_sec - (it).second.ts > (it).second.validity)`
	`1734`	`+ if( now.tv_sec - (it).second->ts > (it).second->validity)`
`1736`	`1735`	`*valid = false;`
`1737`	`1736`	`}`
`1738`		`- ce = &((it).second);`
	`1737`	`+ ce = (it).second;`
`1739`	`1738`	`pthread_rwlock_unlock(&cache_guard);`
`1740`		`- return (*it).second.response.ptr();`
	`1739`	`+ return (*it).second->response.ptr();`
`1741`	`1740`	`}`
`1742`	`1741`	`else`
`1743`	`1742`	`{`
`@@ -1750,14 +1749,14 @@ http_response* webserver::get_from_cache(const std::string& key, bool* valid, ca`
`1750`	`1749`	`bool webserver::is_valid(const std::string& key)`
`1751`	`1750`	`{`
`1752`	`1751`	`pthread_rwlock_rdlock(&cache_guard);`
`1753`		`- map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));`
`1754`		`- if(it != cache_m->response_cache.end())`
	`1752`	`+ map<string, cache_entry*>::iterator it(response_cache.find(key));`
	`1753`	`+ if(it != response_cache.end())`
`1755`	`1754`	`{`
`1756`		`- if((*it).second.validity != -1)`
	`1755`	`+ if((*it).second->validity != -1)`
`1757`	`1756`	`{`
`1758`	`1757`	`timeval now;`
`1759`	`1758`	`gettimeofday(&now, NULL);`
`1760`		`- if( now.tv_sec - (it).second.ts > (it).second.validity)`
	`1759`	`+ if( now.tv_sec - (it).second->ts > (it).second->validity)`
`1761`	`1760`	`{`
`1762`	`1761`	`pthread_rwlock_unlock(&cache_guard);`
`1763`	`1762`	`return false;`
`@@ -1781,44 +1780,44 @@ bool webserver::is_valid(const std::string& key)`
`1781`	`1780`	`void webserver::lock_cache_element(const std::string& key, bool write)`
`1782`	`1781`	`{`
`1783`	`1782`	`pthread_rwlock_rdlock(&cache_guard);`
`1784`		`- map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));`
`1785`		`- if(it != cache_m->response_cache.end())`
`1786`		`- (*it).second.lock(write);`
	`1783`	`+ map<string, cache_entry*>::iterator it(response_cache.find(key));`
	`1784`	`+ if(it != response_cache.end())`
	`1785`	`+ (*it).second->lock(write);`
`1787`	`1786`	`pthread_rwlock_unlock(&cache_guard);`
`1788`	`1787`	`}`
`1789`	`1788`
`1790`	`1789`	`void webserver::unlock_cache_element(const std::string& key)`
`1791`	`1790`	`{`
`1792`	`1791`	`pthread_rwlock_rdlock(&cache_guard);`
`1793`		`- map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));`
`1794`		`- if(it != cache_m->response_cache.end())`
`1795`		`- (*it).second.unlock();`
	`1792`	`+ map<string, cache_entry*>::iterator it(response_cache.find(key));`
	`1793`	`+ if(it != response_cache.end())`
	`1794`	`+ (*it).second->unlock();`
`1796`	`1795`	`pthread_rwlock_unlock(&cache_guard);`
`1797`	`1796`	`}`
`1798`	`1797`
`1799`	`1798`	`cache_entry* webserver::put_in_cache(const std::string& key, http_response* value, bool* new_elem, bool lock, bool write, int validity)`
`1800`	`1799`	`{`
`1801`	`1800`	`pthread_rwlock_wrlock(&cache_guard);`
`1802`		`- map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));`
	`1801`	`+ map<string, cache_entry*>::iterator it(response_cache.find(key));`
`1803`	`1802`	`cache_entry* to_ret;`
`1804`	`1803`	`bool already_in = false;`
`1805`		`- if(it != cache_m->response_cache.end())`
	`1804`	`+ if(it != response_cache.end())`
`1806`	`1805`	`{`
`1807`		`- (*it).second.lock(true);`
	`1806`	`+ (*it).second->lock(true);`
`1808`	`1807`	`already_in = true;`
`1809`	`1808`	`}`
`1810`	`1809`	`if(validity == -1)`
`1811`	`1810`	`{`
`1812`	`1811`	`if(already_in)`
`1813`	`1812`	`{`
`1814`		`- (*it).second.response = value;`
`1815`		`- to_ret = &(*it).second;`
	`1813`	`+ (*it).second->response = value;`
	`1814`	`+ to_ret = (*it).second;`
`1816`	`1815`	`*new_elem = false;`
`1817`	`1816`	`}`
`1818`	`1817`	`else`
`1819`	`1818`	`{`
`1820`		`- pair<map<string, cache_entry>::iterator, bool> res = cache_m->response_cache.insert(pair<string, cache_entry>(key, cache_entry(value)));`
`1821`		`- to_ret = &((*res.first).second);`
	`1819`	`+ pair<map<string, cache_entry>::iterator, bool> res = response_cache.insert(pair<string, cache_entry>(key, new cache_entry(value)));`
	`1820`	`+ to_ret = (*res.first).second;`
`1822`	`1821`	`*new_elem = res.second;`
`1823`	`1822`	`}`
`1824`	`1823`	`}`
`@@ -1828,21 +1827,21 @@ cache_entry* webserver::put_in_cache(const std::string& key, http_response* valu`
`1828`	`1827`	`gettimeofday(&now, NULL);`
`1829`	`1828`	`if(already_in)`
`1830`	`1829`	`{`
`1831`		`- (*it).second.response = value;`
`1832`		`- (*it).second.ts = now.tv_sec;`
`1833`		`- (*it).second.validity = validity;`
`1834`		`- to_ret = &(*it).second;`
	`1830`	`+ (*it).second->response = value;`
	`1831`	`+ (*it).second->ts = now.tv_sec;`
	`1832`	`+ (*it).second->validity = validity;`
	`1833`	`+ to_ret = (*it).second;`
`1835`	`1834`	`*new_elem = false;`
`1836`	`1835`	`}`
`1837`	`1836`	`else`
`1838`	`1837`	`{`
`1839`		`- 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)));`
`1840`		`- to_ret = &((*res.first).second);`
	`1838`	`+ pair<map<string, cache_entry>::iterator, bool> res = response_cache.insert(pair<string, cache_entry>(key, new cache_entry(value, now.tv_sec, validity)));`
	`1839`	`+ to_ret = (*res.first).second;`
`1841`	`1840`	`*new_elem = res.second;`
`1842`	`1841`	`}`
`1843`	`1842`	`}`
`1844`	`1843`	`if(already_in)`
`1845`		`- (*it).second.unlock();`
	`1844`	`+ (*it).second->unlock();`
`1846`	`1845`	`if(lock)`
`1847`	`1846`	`to_ret->lock(write);`
`1848`	`1847`	`pthread_rwlock_unlock(&cache_guard);`
`@@ -1852,16 +1851,20 @@ cache_entry* webserver::put_in_cache(const std::string& key, http_response* valu`
`1852`	`1851`	`void webserver::remove_from_cache(const std::string& key)`
`1853`	`1852`	`{`
`1854`	`1853`	`pthread_rwlock_wrlock(&cache_guard);`
`1855`		`- map<string, cache_entry>::iterator it(cache_m->response_cache.find(key));`
`1856`		`- if(it != cache_m->response_cache.end())`
`1857`		`- cache_m->response_cache.erase(it);`
	`1854`	`+ map<string, cache_entry*>::iterator it(response_cache.find(key));`
	`1855`	`+ if(it != response_cache.end())`
	`1856`	`+ {`
	`1857`	`+ cache_entry* ce = (*it).second;`
	`1858`	`+ response_cache.erase(it);`
	`1859`	`+ delete ce;`
	`1860`	`+ }`
`1858`	`1861`	`pthread_rwlock_unlock(&cache_guard);`
`1859`	`1862`	`}`
`1860`	`1863`
`1861`	`1864`	`void webserver::clean_cache()`
`1862`	`1865`	`{`
`1863`	`1866`	`pthread_rwlock_wrlock(&cache_guard);`
`1864`		`- cache_m->response_cache.clear();`
	`1867`	`+ response_cache.clear(); //manage this because obviously causes leaks`
`1865`	`1868`	`pthread_rwlock_unlock(&cache_guard);`
`1866`	`1869`	`}`
`1867`	`1870`