-/*
- * Copyright 2001-2007 Internet2
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * MemoryStorageService.cpp
- *
- * In-memory "persistent" storage, suitable for simple applications.
- */
-
-#include "internal.h"
-#include "util/NDC.h"
-#include "util/StorageService.h"
-#include "util/Threads.h"
-#include "util/XMLHelper.h"
-
-#include <log4cpp/Category.hh>
-#include <xercesc/util/XMLUniDefs.hpp>
-
-using namespace xmltooling;
-using namespace log4cpp;
-using namespace std;
-
-namespace xmltooling {
- class XMLTOOL_DLLLOCAL MemoryStorageService : public StorageService
- {
- public:
- MemoryStorageService(const DOMElement* e);
- virtual ~MemoryStorageService();
-
- void createString(const char* context, const char* key, const char* value, time_t expiration);
- int readString(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0);
- int updateString(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0);
- bool deleteString(const char* context, const char* key);
-
- void createText(const char* context, const char* key, const char* value, time_t expiration) {
- return createString(context, key, value, expiration);
- }
- int readText(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0) {
- return readString(context, key, pvalue, pexpiration, version);
- }
- int updateText(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0) {
- return updateString(context, key, value, expiration, version);
- }
- bool deleteText(const char* context, const char* key) {
- return deleteString(context, key);
- }
-
- void reap(const char* context);
- void updateContext(const char* context, time_t expiration);
- void deleteContext(const char* context) {
- Lock wrapper(contextLock);
- m_contextMap.erase(context);
- }
-
- private:
- void cleanup();
-
- struct XMLTOOL_DLLLOCAL Record {
- Record() : expiration(0), version(1) {}
- Record(const string& s, time_t t) : data(s), expiration(t), version(1) {}
- string data;
- time_t expiration;
- int version;
- };
-
- struct XMLTOOL_DLLLOCAL Context {
- Context() : m_lock(RWLock::create()) {}
- Context(const Context& src) {
- m_dataMap = src.m_dataMap;
- m_lock = RWLock::create();
- }
- ~Context() { delete m_lock; }
- map<string,Record> m_dataMap;
- RWLock* m_lock;
- unsigned long reap(time_t exp);
- };
-
- Context& getContext(const char* context) {
- Lock wrapper(contextLock);
- return m_contextMap[context];
- }
-
- map<string,Context> m_contextMap;
- Mutex* contextLock;
- CondWait* shutdown_wait;
- Thread* cleanup_thread;
- static void* cleanup_fn(void*);
- bool shutdown;
- int m_cleanupInterval;
- Category& m_log;
-
- friend class _expcheck;
- };
-
- StorageService* XMLTOOL_DLLLOCAL MemoryStorageServiceFactory(const DOMElement* const & e)
- {
- return new MemoryStorageService(e);
- }
-};
-
-static const XMLCh cleanupInterval[] = UNICODE_LITERAL_15(c,l,e,a,n,u,p,I,n,t,e,r,v,a,l);
-
-MemoryStorageService::MemoryStorageService(const DOMElement* e)
- : contextLock(NULL), shutdown_wait(NULL), cleanup_thread(NULL), shutdown(false), m_cleanupInterval(0),
- m_log(Category::getInstance(XMLTOOLING_LOGCAT".StorageService"))
-{
- const XMLCh* tag=e ? e->getAttributeNS(NULL,cleanupInterval) : NULL;
- if (tag && *tag) {
- m_cleanupInterval = XMLString::parseInt(tag);
- }
- if (!m_cleanupInterval)
- m_cleanupInterval=900;
-
- contextLock = Mutex::create();
- shutdown_wait = CondWait::create();
- cleanup_thread = Thread::create(&cleanup_fn, (void*)this);
-}
-
-MemoryStorageService::~MemoryStorageService()
-{
- // Shut down the cleanup thread and let it know...
- shutdown = true;
- shutdown_wait->signal();
- cleanup_thread->join(NULL);
-
- delete shutdown_wait;
- delete contextLock;
-}
-
-void* MemoryStorageService::cleanup_fn(void* cache_p)
-{
- MemoryStorageService* cache = reinterpret_cast<MemoryStorageService*>(cache_p);
-
-#ifndef WIN32
- // First, let's block all signals
- Thread::mask_all_signals();
-#endif
-
- // Now run the cleanup process.
- cache->cleanup();
- return NULL;
-}
-
-void MemoryStorageService::cleanup()
-{
-#ifdef _DEBUG
- NDC ndc("cleanup");
-#endif
-
- auto_ptr<Mutex> mutex(Mutex::create());
- mutex->lock();
-
- m_log.info("cleanup thread started...running every %d seconds", m_cleanupInterval);
-
- while (!shutdown) {
- shutdown_wait->timedwait(mutex.get(), m_cleanupInterval);
- if (shutdown)
- break;
-
- unsigned long count=0;
- time_t now = time(NULL);
- Lock wrapper(contextLock);
- for (map<string,Context>::iterator i=m_contextMap.begin(); i!=m_contextMap.end(); ++i)
- count += i->second.reap(now);
-
- if (count)
- m_log.info("purged %d expired record(s) from storage", count);
- }
-
- m_log.info("cleanup thread finished");
-
- mutex->unlock();
- Thread::exit(NULL);
-}
-
-void MemoryStorageService::reap(const char* context)
-{
- getContext(context).reap(time(NULL));
-}
-
-unsigned long MemoryStorageService::Context::reap(time_t exp)
-{
- // Lock the "database".
- m_lock->wrlock();
- SharedLock wrapper(m_lock, false);
-
- // Garbage collect any expired entries.
- unsigned long count=0;
- map<string,Record>::iterator cur = m_dataMap.begin();
- map<string,Record>::iterator stop = m_dataMap.end();
- while (cur != stop) {
- if (cur->second.expiration <= exp) {
- map<string,Record>::iterator tmp = cur++;
- m_dataMap.erase(tmp);
- ++count;
- }
- else {
- cur++;
- }
- }
- return count;
-}
-
-void MemoryStorageService::createString(const char* context, const char* key, const char* value, time_t expiration)
-{
- Context& ctx = getContext(context);
-
- // Lock the maps.
- ctx.m_lock->wrlock();
- SharedLock wrapper(ctx.m_lock, false);
-
- // Check for a duplicate.
- map<string,Record>::iterator i=ctx.m_dataMap.find(key);
- if (i!=ctx.m_dataMap.end()) {
- // Not yet expired?
- if (time(NULL) < i->second.expiration)
- throw IOException("attempted to insert a record with duplicate key ($1)", params(1,key));
- // It's dead, so we can just remove it now and create the new record.
- ctx.m_dataMap.erase(i);
- }
-
- ctx.m_dataMap[key]=Record(value,expiration);
-
- m_log.debug("inserted record (%s) in context (%s)", key, context);
-}
-
-int MemoryStorageService::readString(const char* context, const char* key, string* pvalue, time_t* pexpiration, int version)
-{
- Context& ctx = getContext(context);
-
- SharedLock wrapper(ctx.m_lock);
- map<string,Record>::iterator i=ctx.m_dataMap.find(key);
- if (i==ctx.m_dataMap.end())
- return 0;
- else if (time(NULL) >= i->second.expiration)
- return 0;
- if (pexpiration)
- *pexpiration = i->second.expiration;
- if (i->second.version == version)
- return version; // nothing's changed, so just echo back the version
- if (pvalue)
- *pvalue = i->second.data;
- return i->second.version;
-}
-
-int MemoryStorageService::updateString(const char* context, const char* key, const char* value, time_t expiration, int version)
-{
- Context& ctx = getContext(context);
-
- // Lock the map.
- ctx.m_lock->wrlock();
- SharedLock wrapper(ctx.m_lock, false);
-
- map<string,Record>::iterator i=ctx.m_dataMap.find(key);
- if (i==ctx.m_dataMap.end())
- return 0;
- else if (time(NULL) >= i->second.expiration)
- return 0;
-
- if (version > 0 && version != i->second.version)
- return -1; // caller's out of sync
-
- if (value) {
- i->second.data = value;
- ++(i->second.version);
- }
-
- if (expiration && expiration != i->second.expiration)
- i->second.expiration = expiration;
-
- m_log.debug("updated record (%s) in context (%s)", key, context);
- return i->second.version;
-}
-
-bool MemoryStorageService::deleteString(const char* context, const char* key)
-{
- Context& ctx = getContext(context);
-
- // Lock the map.
- ctx.m_lock->wrlock();
- SharedLock wrapper(ctx.m_lock, false);
-
- // Find the record.
- map<string,Record>::iterator i=ctx.m_dataMap.find(key);
- if (i!=ctx.m_dataMap.end()) {
- ctx.m_dataMap.erase(i);
- m_log.debug("deleted record (%s) in context (%s)", key, context);
- return true;
- }
-
- m_log.debug("deleting record (%s) in context (%s)....not found", key, context);
- return false;
-}
-
-void MemoryStorageService::updateContext(const char* context, time_t expiration)
-{
- Context& ctx = getContext(context);
-
- // Lock the map.
- ctx.m_lock->wrlock();
- SharedLock wrapper(ctx.m_lock, false);
-
- time_t now = time(NULL);
- map<string,Record>::iterator stop=ctx.m_dataMap.end();
- for (map<string,Record>::iterator i = ctx.m_dataMap.begin(); i!=stop; ++i) {
- if (now >= i->second.expiration)
- i->second.expiration = expiration;
- }
-
- m_log.debug("updated expiration of valid records in context (%s)", context);
-}
+/*\r
+ * Copyright 2001-2007 Internet2\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+/**\r
+ * MemoryStorageService.cpp\r
+ *\r
+ * In-memory "persistent" storage, suitable for simple applications.\r
+ */\r
+\r
+#include "internal.h"\r
+#include "logging.h"\r
+#include "util/NDC.h"\r
+#include "util/StorageService.h"\r
+#include "util/Threads.h"\r
+#include "util/XMLHelper.h"\r
+\r
+#include <memory>\r
+#include <xercesc/util/XMLUniDefs.hpp>\r
+\r
+using namespace xmltooling::logging;\r
+using namespace xmltooling;\r
+using namespace std;\r
+\r
+using xercesc::DOMElement;\r
+\r
+namespace xmltooling {\r
+ class XMLTOOL_DLLLOCAL MemoryStorageService : public StorageService\r
+ {\r
+ public:\r
+ MemoryStorageService(const DOMElement* e);\r
+ virtual ~MemoryStorageService();\r
+\r
+ bool createString(const char* context, const char* key, const char* value, time_t expiration);\r
+ int readString(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0);\r
+ int updateString(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0);\r
+ bool deleteString(const char* context, const char* key);\r
+\r
+ bool createText(const char* context, const char* key, const char* value, time_t expiration) {\r
+ return createString(context, key, value, expiration);\r
+ }\r
+ int readText(const char* context, const char* key, string* pvalue=NULL, time_t* pexpiration=NULL, int version=0) {\r
+ return readString(context, key, pvalue, pexpiration, version);\r
+ }\r
+ int updateText(const char* context, const char* key, const char* value=NULL, time_t expiration=0, int version=0) {\r
+ return updateString(context, key, value, expiration, version);\r
+ }\r
+ bool deleteText(const char* context, const char* key) {\r
+ return deleteString(context, key);\r
+ }\r
+\r
+ void reap(const char* context);\r
+ void updateContext(const char* context, time_t expiration);\r
+ void deleteContext(const char* context) {\r
+ m_lock->wrlock();\r
+ m_contextMap.erase(context);\r
+ m_lock->unlock();\r
+ }\r
+\r
+ private:\r
+ void cleanup();\r
+\r
+ struct XMLTOOL_DLLLOCAL Record {\r
+ Record() : expiration(0), version(1) {}\r
+ Record(const string& s, time_t t) : data(s), expiration(t), version(1) {}\r
+ string data;\r
+ time_t expiration;\r
+ int version;\r
+ };\r
+\r
+ struct XMLTOOL_DLLLOCAL Context {\r
+ Context() {}\r
+ Context(const Context& src) {\r
+ m_dataMap = src.m_dataMap;\r
+ }\r
+ map<string,Record> m_dataMap;\r
+ unsigned long reap(time_t exp);\r
+ };\r
+\r
+ Context& readContext(const char* context) {\r
+ m_lock->rdlock();\r
+ map<string,Context>::iterator i = m_contextMap.find(context);\r
+ if (i != m_contextMap.end())\r
+ return i->second;\r
+ m_lock->unlock();\r
+ m_lock->wrlock();\r
+ return m_contextMap[context];\r
+ }\r
+\r
+ Context& writeContext(const char* context) {\r
+ m_lock->wrlock();\r
+ return m_contextMap[context];\r
+ }\r
+\r
+ map<string,Context> m_contextMap;\r
+ RWLock* m_lock;\r
+ CondWait* shutdown_wait;\r
+ Thread* cleanup_thread;\r
+ static void* cleanup_fn(void*);\r
+ bool shutdown;\r
+ int m_cleanupInterval;\r
+ Category& m_log;\r
+ };\r
+\r
+ StorageService* XMLTOOL_DLLLOCAL MemoryStorageServiceFactory(const DOMElement* const & e)\r
+ {\r
+ return new MemoryStorageService(e);\r
+ }\r
+};\r
+\r
+static const XMLCh cleanupInterval[] = UNICODE_LITERAL_15(c,l,e,a,n,u,p,I,n,t,e,r,v,a,l);\r
+\r
+MemoryStorageService::MemoryStorageService(const DOMElement* e)\r
+ : m_lock(NULL), shutdown_wait(NULL), cleanup_thread(NULL), shutdown(false), m_cleanupInterval(0),\r
+ m_log(Category::getInstance(XMLTOOLING_LOGCAT".StorageService"))\r
+{\r
+ const XMLCh* tag=e ? e->getAttributeNS(NULL,cleanupInterval) : NULL;\r
+ if (tag && *tag) {\r
+ m_cleanupInterval = XMLString::parseInt(tag);\r
+ }\r
+ if (!m_cleanupInterval)\r
+ m_cleanupInterval=900;\r
+\r
+ m_lock = RWLock::create();\r
+ shutdown_wait = CondWait::create();\r
+ cleanup_thread = Thread::create(&cleanup_fn, (void*)this);\r
+}\r
+\r
+MemoryStorageService::~MemoryStorageService()\r
+{\r
+ // Shut down the cleanup thread and let it know...\r
+ shutdown = true;\r
+ shutdown_wait->signal();\r
+ cleanup_thread->join(NULL);\r
+\r
+ delete cleanup_thread;\r
+ delete shutdown_wait;\r
+ delete m_lock;\r
+}\r
+\r
+void* MemoryStorageService::cleanup_fn(void* cache_p)\r
+{\r
+ MemoryStorageService* cache = reinterpret_cast<MemoryStorageService*>(cache_p);\r
+\r
+#ifndef WIN32\r
+ // First, let's block all signals\r
+ Thread::mask_all_signals();\r
+#endif\r
+\r
+ // Now run the cleanup process.\r
+ cache->cleanup();\r
+ return NULL;\r
+}\r
+\r
+void MemoryStorageService::cleanup()\r
+{\r
+#ifdef _DEBUG\r
+ NDC ndc("cleanup");\r
+#endif\r
+\r
+ auto_ptr<Mutex> mutex(Mutex::create());\r
+ mutex->lock();\r
+\r
+ m_log.info("cleanup thread started...running every %d seconds", m_cleanupInterval);\r
+\r
+ while (!shutdown) {\r
+ shutdown_wait->timedwait(mutex.get(), m_cleanupInterval);\r
+ if (shutdown)\r
+ break;\r
+\r
+ unsigned long count=0;\r
+ time_t now = time(NULL);\r
+ m_lock->wrlock();\r
+ SharedLock locker(m_lock, false);\r
+ for (map<string,Context>::iterator i=m_contextMap.begin(); i!=m_contextMap.end(); ++i)\r
+ count += i->second.reap(now);\r
+\r
+ if (count)\r
+ m_log.info("purged %d expired record(s) from storage", count);\r
+ }\r
+\r
+ m_log.info("cleanup thread finished");\r
+\r
+ mutex->unlock();\r
+ Thread::exit(NULL);\r
+}\r
+\r
+void MemoryStorageService::reap(const char* context)\r
+{\r
+ Context& ctx = writeContext(context);\r
+ SharedLock locker(m_lock, false);\r
+ ctx.reap(time(NULL));\r
+}\r
+\r
+unsigned long MemoryStorageService::Context::reap(time_t exp)\r
+{\r
+ // Garbage collect any expired entries.\r
+ unsigned long count=0;\r
+ map<string,Record>::iterator cur = m_dataMap.begin();\r
+ map<string,Record>::iterator stop = m_dataMap.end();\r
+ while (cur != stop) {\r
+ if (cur->second.expiration <= exp) {\r
+ map<string,Record>::iterator tmp = cur++;\r
+ m_dataMap.erase(tmp);\r
+ ++count;\r
+ }\r
+ else {\r
+ cur++;\r
+ }\r
+ }\r
+ return count;\r
+}\r
+\r
+bool MemoryStorageService::createString(const char* context, const char* key, const char* value, time_t expiration)\r
+{\r
+ Context& ctx = writeContext(context);\r
+ SharedLock locker(m_lock, false);\r
+\r
+ // Check for a duplicate.\r
+ map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+ if (i!=ctx.m_dataMap.end()) {\r
+ // Not yet expired?\r
+ if (time(NULL) < i->second.expiration)\r
+ return false;\r
+ // It's dead, so we can just remove it now and create the new record.\r
+ ctx.m_dataMap.erase(i);\r
+ }\r
+\r
+ ctx.m_dataMap[key]=Record(value,expiration);\r
+\r
+ m_log.debug("inserted record (%s) in context (%s)", key, context);\r
+ return true;\r
+}\r
+\r
+int MemoryStorageService::readString(const char* context, const char* key, string* pvalue, time_t* pexpiration, int version)\r
+{\r
+ Context& ctx = readContext(context);\r
+ SharedLock locker(m_lock, false);\r
+\r
+ map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+ if (i==ctx.m_dataMap.end())\r
+ return 0;\r
+ else if (time(NULL) >= i->second.expiration)\r
+ return 0;\r
+ if (pexpiration)\r
+ *pexpiration = i->second.expiration;\r
+ if (i->second.version == version)\r
+ return version; // nothing's changed, so just echo back the version\r
+ if (pvalue)\r
+ *pvalue = i->second.data;\r
+ return i->second.version;\r
+}\r
+\r
+int MemoryStorageService::updateString(const char* context, const char* key, const char* value, time_t expiration, int version)\r
+{\r
+ Context& ctx = writeContext(context);\r
+ SharedLock locker(m_lock, false);\r
+\r
+ map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+ if (i==ctx.m_dataMap.end())\r
+ return 0;\r
+ else if (time(NULL) >= i->second.expiration)\r
+ return 0;\r
+\r
+ if (version > 0 && version != i->second.version)\r
+ return -1; // caller's out of sync\r
+\r
+ if (value) {\r
+ i->second.data = value;\r
+ ++(i->second.version);\r
+ }\r
+\r
+ if (expiration && expiration != i->second.expiration)\r
+ i->second.expiration = expiration;\r
+\r
+ m_log.debug("updated record (%s) in context (%s)", key, context);\r
+ return i->second.version;\r
+}\r
+\r
+bool MemoryStorageService::deleteString(const char* context, const char* key)\r
+{\r
+ Context& ctx = writeContext(context);\r
+ SharedLock locker(m_lock, false);\r
+\r
+ // Find the record.\r
+ map<string,Record>::iterator i=ctx.m_dataMap.find(key);\r
+ if (i!=ctx.m_dataMap.end()) {\r
+ ctx.m_dataMap.erase(i);\r
+ m_log.debug("deleted record (%s) in context (%s)", key, context);\r
+ return true;\r
+ }\r
+\r
+ m_log.debug("deleting record (%s) in context (%s)....not found", key, context);\r
+ return false;\r
+}\r
+\r
+void MemoryStorageService::updateContext(const char* context, time_t expiration)\r
+{\r
+ Context& ctx = writeContext(context);\r
+ SharedLock locker(m_lock, false);\r
+\r
+ time_t now = time(NULL);\r
+ map<string,Record>::iterator stop=ctx.m_dataMap.end();\r
+ for (map<string,Record>::iterator i = ctx.m_dataMap.begin(); i!=stop; ++i) {\r
+ if (now < i->second.expiration)\r
+ i->second.expiration = expiration;\r
+ }\r
+\r
+ m_log.debug("updated expiration of valid records in context (%s)", context);\r
+}\r
projects / shibboleth / cpp-xmltooling.git / blobdiff