Debian Codegraph @

Source/Logger/CLogger.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20 #include "CLogger.h"
21
22
23 QString logTr(const char *sourceText, const char *comment, int n) {
24 return QObject::tr(sourceText,comment,n);
25 }
26
27
28 namespace Konclude {
29
30 namespace Logger {
31
32 CLogger *CLogger::mInstance=0;
33
34 QMutex *CLogger::mInstanceCreationMutex = new QMutex();
35
36
37 CLogger::CLogger()
38 : CIntervalThread("Logger") {
39
40 unsavedMessagesCount = 0;
41 savedMessageCount = 0;
42 totalMessageCount = 0;
43 lastInMemoryMessage = 0;
44
45 nextMessageID = 0;
46
47 mMaxLogMessageCount = -1;
48 mMinLoggingLevel = 0;
49 mCurrentLogMessageCount = 0;
50
51 startThread();
52 }
53
54
55 CLogger::~CLogger() {
56 stopThread();
57 }
58
59
60
61 void CLogger::shutdownLogger() {
62 mInstance->waitSynchronization();
63 mInstanceCreationMutex->lock();
64 mInstance->stopThread();
65 // wait until the thread is stopped
66 mInstance->wait();
67 delete mInstance;
68 mInstance = 0;
69 mInstanceCreationMutex->unlock();
70 }
71
72
73
74 CCallbackRequestLogMessagesContext *CLogger::getLogMessages(qint64 messageIDBegin, qint64 messageIDEnd, double levelBegin, double levelEnd, QStringList domains, QLinkedList<void *> objects) {
75 CBlockingCallbackData *blockingCallback = new CBlockingCallbackData();
76 getLogMessages(blockingCallback,messageIDBegin,messageIDEnd,levelBegin,levelEnd,domains,objects);
77 blockingCallback->waitForCallback();
78 CCallbackRequestLogMessagesContext *context = (CCallbackRequestLogMessagesContext *)blockingCallback->takeCallbackDataContext();
79 delete blockingCallback;
80 return context;
81 }
82
83
84 void CLogger::getLogMessages(CCallbackData *callback, qint64 messageIDBegin, qint64 messageIDEnd, double levelBegin, double levelEnd, QStringList domains, QLinkedList<void *> objects) {
85 postEvent(new CRequestLogMessagesEvent(callback,messageIDBegin,messageIDEnd,levelBegin,levelEnd,domains,objects));
86 }
87
88
89 void CLogger::releaseLogMessages(QLinkedList<CLogMessage *> &logMessages) {
90 postEvent(new CReleaseLogMessagesEvent(logMessages));
91 }
92
93
94 double CLogger::getMinLoggingLevel() {
95 return mMinLoggingLevel;
96 }
97
98
99 bool CLogger::hasMinLoggingLevel(double level) {
100 return level >= mMinLoggingLevel;
101 }
102
103
104 void CLogger::configureLogger(qint64 maxLogMessages, double minLoggingLevel) {
105 postEvent(new CConfigureLoggerEvent(maxLogMessages,minLoggingLevel));
106 }
107
108
109 void CLogger::addLogMessage(QString message, double level, QString domain, void *object) {
110 postEvent(new CLoggingEvent(new CLogMessage(domain,message,level,object)));
111 }
112
113 void CLogger::addLogObserver(CAbstractLogObserver *observer, double level, QStringList domains) {
114 if (domains.count() <= 0) {
115 domains<<"::";
116 }
117 observerSyncMutex.lock();
118 CLogObserverData *obsData = new CLogObserverData(observer,level,domains);
119 addObserverToDomains(obsData,domains);
120 observerHash.insertMulti(observer,obsData);
121 observerSyncMutex.unlock();
122 CThread::waitSynchronization();
123 }
124
125
126 void CLogger::removeObserverFromAllDomains(CAbstractLogObserver *observer) {
127 observerSyncMutex.lock();
128 if (observerHash.contains(observer)) {
129 QList<CLogObserverData *> obsDataList(observerHash.values(observer));
130 foreach (CLogObserverData *obsData, obsDataList) {
131 if (observerDomainHash.contains(obsData)) {
132 QList<CLogDomain *> domainList(observerDomainHash.values(obsData));
133 foreach (CLogDomain *domain, domainList) {
134 domain->removeLogObserver(obsData);
135 }
136 }
137 delete obsData;
138 }
139 observerHash.remove(observer);
140 }
141 observerSyncMutex.unlock();
142 }
143
144 void CLogger::removeObserverFromDomains(CAbstractLogObserver *observer, QStringList remDomains) {
145 observerSyncMutex.lock();
146 QSet<QString> removeDomainsSet;
147
148 if (observerHash.contains(observer)) {
149 QList<CLogObserverData *> obsDataList(observerHash.values(observer));
150 foreach (QString domain,remDomains) {
151 removeDomainsSet.insert(domain);
152 }
153 foreach (CLogObserverData *obsData, obsDataList) {
154 QStringList domainList(obsData->getLogDomains());
155 foreach (QString domain, domainList) {
156 if (removeDomainsSet.contains(domain)) {
157 if (domainHash.contains(domain)) {
158 CLogDomain *logDomain = domainHash.value(domain);
159 logDomain->removeLogObserver(obsData);
160 }
161 obsData->removeLogDomain(domain);
162 }
163 }
164 }
165 }
166 observerSyncMutex.unlock();
167 }
168
169
170
171 void CLogger::addObserverToDomains(CLogObserverData *obsData, QStringList domains) {
172 foreach (QString domainString, domains) {
173 CLogDomain *domain = 0;
174 if (domainHash.contains(domainString)) {
175 domain = domainHash.value(domainString);
176 } else {
177 domain = new CLogDomain(domainString);
178 domainHash.insert(domainString,domain);
179 }
180 if (domain) {
181 obsData->addLogDomain(domainString);
182 domain->addLogObserver(obsData);
183 observerDomainHash.insert(obsData,domain);
184 }
185 }
186 }
187
188
189
190 void CLogger::threadStarted() {
191 CIntervalThread::threadStarted();
192 startTimerWithInterval(SAVETOFILETIMERID,1000);
193 }
194
195 void CLogger::threadStopped() {
196 CIntervalThread::threadStopped();
197 qDeleteAll(loglist);
198 }
199
200
201
202 bool CLogger::deleteOldLogMessages() {
203 bool messagesDeleted = false;
204 if (mCurrentLogMessageCount > mMaxLogMessageCount && mMaxLogMessageCount >= 0) {
205 while (mCurrentLogMessageCount > mMaxLogMessageCount && !loglist.isEmpty()) {
206 CLogMessage* deleteLM = loglist.takeLast();
207 idMessageHash.remove(deleteLM->getLogID());
208 delete deleteLM;
209 messagesDeleted = true;
210 --mCurrentLogMessageCount;
211 }
212 }
213 return messagesDeleted;
214 }
215
216
217
218 bool CLogger::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
219 if (CIntervalThread::processCustomsEvents(type,event)) {
220 return true;
221 } else if (type == Konclude::Logger::EVENTLOGMESSAGE) {
222 SETTASKDESCRIPTION("Process Log Message");
223 CLoggingEvent *le = (CLoggingEvent *)event;
224 CLogMessage *lm = le->getLogMessage();
225
226 QString domain = lm->getDomain();
227 QStringList domainList(domain.split("::",QString::SkipEmptyParts));
228
229 loglist.append(lm);
230 unsavedMessagesCount++;
231 totalMessageCount++;
232
233 observerSyncMutex.lock();
234
235 lm->setLogID(nextMessageID);
236 idMessageHash.insert(nextMessageID,lm);
237 ++nextMessageID;
238 ++mCurrentLogMessageCount;
239
240 propagateLogMessageToDomain("::",lm);
241
242 QString accDomain;
243
244 foreach (QString endDomain, domainList) {
245 accDomain.append("::");
246 accDomain.append(endDomain);
247 propagateLogMessageToDomain(accDomain,lm);
248 propagateLogMessageToDomain(endDomain,lm);
249 }
250 observerSyncMutex.unlock();
251
252 deleteOldLogMessages();
253
254 return true;
255
256 } else if (type == Konclude::Logger::EVENTCONFIGURELOGGER) {
257 SETTASKDESCRIPTION("Configure Logger");
258 CConfigureLoggerEvent* cle = (CConfigureLoggerEvent *)event;
259
260 mMaxLogMessageCount = cle->getMaxLogMessageCount();
261 mMinLoggingLevel = cle->getMinLoggingLevel();
262
263 deleteOldLogMessages();
264
265 return true;
266
267 } else if (type == Konclude::Logger::EVENTRELEASELOGMESSAGES) {
268 SETTASKDESCRIPTION("Release Log Message");
269 CReleaseLogMessagesEvent *rlm = (CReleaseLogMessagesEvent *)event;
270
271 QLinkedList<CLogMessage *> releaseLogMessageList(rlm->getLogMessages());
272
273 foreach (CLogMessage *logMessage, releaseLogMessageList) {
274 logMessage->decLockCount();
275 }
276
277 return true;
278
279 } else if (type == Konclude::Logger::EVENTREQUESTLOGMESSAGES) {
280 SETTASKDESCRIPTION("Create Log Message Collection Response");
281 CRequestLogMessagesEvent *rlm = (CRequestLogMessagesEvent *)event;
282
283 CCallbackRequestLogMessagesContext *logMessageContext = new CCallbackRequestLogMessagesContext();
284
285 double beginLevel = rlm->getBeginLevel();
286 double endLevel = rlm->getEndLevel();
287
288 qint64 beginID = rlm->getMessageBeginID();
289 qint64 endID = rlm->getMessageEndID();
290 if (endID == -1) {
291 endID = nextMessageID;
292 }
293 endID = qMax(endID,beginID);
294
295 QStringList domainGetList = rlm->getDomains();
296 CCallbackData *callback = rlm->getCallback();
297
298 QSet<QString> domainGetSet;
299 foreach (QString domain, domainGetList) {
300 domainGetSet.insert(domain);
301 }
302
303 QLinkedList<void *> objectList = rlm->getObjects();
304
305 for (qint64 startID = qMax(beginID,lastInMemoryMessage); startID != endID; ++startID) {
306
307 if (idMessageHash.contains(startID)) {
308 CLogMessage *message = idMessageHash.value(startID);
309
310 double logLevel = message->getLogLevel();
311 if (logLevel >= beginLevel && logLevel <= endLevel) {
312
313 bool messageRequested = false;
314 if (domainGetList.isEmpty()) {
315 messageRequested = true;
316 } else {
317 if (domainGetSet.contains("::")) {
318 messageRequested = true;
319 } else {
320 QStringList domainList(message->getDomain().split("::",QString::SkipEmptyParts));
321 QString accDomain;
322 foreach (const QString& endDomain, domainList) {
323 accDomain.append("::");
324 accDomain.append(endDomain);
325 if (domainGetSet.contains(accDomain) || domainGetSet.contains(endDomain)) {
326 messageRequested = true;
327 break;
328 }
329 }
330
331 }
332 }
333
334
335 if (messageRequested) {
336 logMessageContext->addLogMessage(message);
337 message->incLockCount();
338 }
339
340 }
341
342
343 }
344
345 }
346
347 callback->setCallbackDataContext(logMessageContext);
348
349 callback->doCallback();
350 return true;
351
352 }
353 return false;
354 }
355
356
357 void CLogger::propagateLogMessageToDomain(QString domain, CLogMessage *message) {
358 CLogDomain *logDomain = domainHash.value(domain);
359 if (logDomain) {
360 logDomain->postLogMessage(message);
361 }
362 }
363
364
365
366 bool CLogger::processTimer(qint64 timerID) {
367 if (timerID == SAVETOFILETIMERID) {
368 return true;
369 }
370 return false;
371 }
372
373
374 // returns the Instance of the CLogger and creates it when necessary
375 CLogger *CLogger::getInstance() {
376 if (mInstance == nullptr) {
377 mInstanceCreationMutex->lock();
378 if (mInstance == 0) {
379 mInstance = new CLogger();
380 }
381 mInstanceCreationMutex->unlock();
382 }
383 return mInstance;
384 }
385
386
387
388 }; // end namespace Logger
389
390 }; // end namespace Konclude