Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file MsgHandler.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Michael Behrisch
17 : /// @author Mirko Barthauer
18 : /// @date Tue, 17 Jun 2003
19 : ///
20 : // Retrieves messages about the process and gives them further to output
21 : /****************************************************************************/
22 : #include <config.h>
23 :
24 : #include <string>
25 : #include <cassert>
26 : #include <vector>
27 : #include <algorithm>
28 : #include <iostream>
29 : #ifdef WIN32
30 : #define NOMINMAX
31 : #include <windows.h>
32 : #undef NOMINMAX
33 : #else
34 : #include <unistd.h>
35 : #endif
36 : #include <utils/options/OptionsCont.h>
37 : #include <utils/iodevices/OutputDevice.h>
38 : #include <utils/common/UtilExceptions.h>
39 : #include "MsgHandler.h"
40 :
41 :
42 : // ===========================================================================
43 : // static member variables
44 : // ===========================================================================
45 : MsgHandler::Factory MsgHandler::myFactory = nullptr;
46 : MsgHandler* MsgHandler::myErrorInstance = nullptr;
47 : MsgHandler* MsgHandler::myWarningInstance = nullptr;
48 : MsgHandler* MsgHandler::myMessageInstance = nullptr;
49 : bool MsgHandler::myAmProcessingProcess = false;
50 : bool MsgHandler::myWriteDebugMessages = false;
51 : bool MsgHandler::myWriteDebugGLMessages = false;
52 : bool MsgHandler::myWriteTimestamps = false;
53 : bool MsgHandler::myWriteProcessId = false;
54 : std::string MsgHandler::myErrorPrefix = "Error: ";
55 : std::string MsgHandler::myWarningPrefix = "Warning: ";
56 :
57 :
58 : // ===========================================================================
59 : // method definitions
60 : // ===========================================================================
61 :
62 : MsgHandler*
63 1124877 : MsgHandler::getMessageInstance() {
64 1124877 : if (myMessageInstance == nullptr) {
65 87139 : if (myFactory == nullptr) {
66 37770 : myMessageInstance = new MsgHandler(MsgType::MT_MESSAGE);
67 : } else {
68 49369 : myMessageInstance = myFactory(MsgType::MT_MESSAGE);
69 : }
70 : }
71 1124877 : return myMessageInstance;
72 : }
73 :
74 :
75 : MsgHandler*
76 3275830 : MsgHandler::getWarningInstance() {
77 3275830 : if (myWarningInstance == nullptr) {
78 138058 : if (myFactory == nullptr) {
79 75319 : myWarningInstance = new MsgHandler(MsgType::MT_WARNING);
80 : } else {
81 62739 : myWarningInstance = myFactory(MsgType::MT_WARNING);
82 : }
83 : }
84 3275830 : return myWarningInstance;
85 : }
86 :
87 :
88 : MsgHandler*
89 5548546 : MsgHandler::getErrorInstance() {
90 5548546 : if (myErrorInstance == nullptr) {
91 133466 : myErrorInstance = new MsgHandler(MsgType::MT_ERROR);
92 : }
93 5548546 : return myErrorInstance;
94 : }
95 :
96 :
97 : void
98 0 : MsgHandler::enableDebugMessages(bool enable) {
99 0 : myWriteDebugMessages = enable;
100 0 : }
101 :
102 : void
103 0 : MsgHandler::enableDebugGLMessages(bool enable) {
104 0 : myWriteDebugGLMessages = enable;
105 0 : }
106 :
107 :
108 : std::string
109 0 : MsgHandler::insertLineBreaks(std::string msg, int lineWidth) {
110 : // TODO: check what FXFont::getTextWidth can do
111 : //int textWidth = getApp()->getNormalFont()->getTextWidth
112 0 : if ((int)msg.size() <= lineWidth) {
113 0 : return msg;
114 : }
115 : size_t pos = 0;
116 0 : size_t nextLineBreak = msg.find('\n');
117 0 : size_t spaceAfterLine = msg.find(' ', lineWidth);
118 0 : while (spaceAfterLine != std::string::npos) {
119 0 : if (nextLineBreak == std::string::npos || nextLineBreak > spaceAfterLine) {
120 : msg = msg.replace(spaceAfterLine, 1, "\n");
121 0 : pos = spaceAfterLine + 1;
122 : } else {
123 0 : pos = nextLineBreak + 1;
124 : }
125 0 : spaceAfterLine = msg.find(' ', pos + lineWidth);
126 0 : nextLineBreak = msg.find('\n', pos);
127 : }
128 0 : return msg;
129 : }
130 :
131 :
132 : void
133 6603850 : MsgHandler::inform(std::string msg, bool addType) {
134 6603850 : if (addType && !myInitialMessages.empty() && myInitialMessages.size() < 5) {
135 229 : myInitialMessages.push_back(msg);
136 : }
137 : // beautify progress output
138 6603850 : if (myAmProcessingProcess) {
139 840 : myAmProcessingProcess = false;
140 1680 : MsgHandler::getMessageInstance()->inform("");
141 : }
142 13207700 : msg = build(msg, addType);
143 : // inform all receivers
144 12614550 : for (auto i : myRetrievers) {
145 6010700 : i->inform(msg);
146 : }
147 : // set the information that something occurred
148 6603850 : myWasInformed = true;
149 6603850 : }
150 :
151 :
152 : void
153 149934 : MsgHandler::beginProcessMsg(std::string msg, bool addType) {
154 299868 : msg = build(msg, addType);
155 : // inform all other receivers
156 184218 : for (auto i : myRetrievers) {
157 34284 : i->inform(msg, true);
158 34284 : myAmProcessingProcess = true;
159 : }
160 : // set the information that something occurred
161 149934 : myWasInformed = true;
162 149934 : }
163 :
164 :
165 : void
166 148796 : MsgHandler::endProcessMsg2(bool success, long duration) {
167 148796 : if (success) {
168 148068 : if (duration > -1) {
169 272354 : endProcessMsg(TLF(" done (%ms).", toString(duration)));
170 : } else {
171 23782 : endProcessMsg(TL(" done."));
172 : }
173 : } else {
174 1456 : endProcessMsg(TL(" failed."));
175 : }
176 148796 : }
177 :
178 :
179 : void
180 149491 : MsgHandler::endProcessMsg(std::string msg) {
181 : // inform all other receivers
182 183593 : for (auto i : myRetrievers) {
183 34102 : i->inform(msg);
184 : }
185 : // set the information that something occurred
186 149491 : myWasInformed = true;
187 149491 : myAmProcessingProcess = false;
188 149491 : }
189 :
190 :
191 : void
192 418709 : MsgHandler::clear(bool resetInformed) {
193 418709 : if (myAggregationThreshold >= 0) {
194 44239 : for (const auto& i : myAggregationCount) {
195 5429 : if (i.second > myAggregationThreshold) {
196 11685 : inform(toString(i.second) + " total messages of type: " + i.first);
197 : }
198 : }
199 : }
200 : myAggregationCount.clear();
201 418709 : if (!resetInformed && myInitialMessages.size() > 1) {
202 3 : const bool wasInformed = myWasInformed;
203 15 : for (const std::string& msg : myInitialMessages) {
204 24 : inform(msg, false);
205 : }
206 : myInitialMessages.clear();
207 3 : myWasInformed = wasInformed;
208 : }
209 418709 : if (resetInformed) {
210 415880 : myWasInformed = false;
211 : }
212 418709 : }
213 :
214 :
215 : void
216 447098 : MsgHandler::addRetriever(OutputDevice* retriever) {
217 447098 : if (!isRetriever(retriever)) {
218 447098 : myRetrievers.push_back(retriever);
219 : }
220 447098 : }
221 :
222 :
223 : void
224 1117550 : MsgHandler::removeRetriever(OutputDevice* retriever) {
225 1117550 : std::vector<OutputDevice*>::iterator i = find(myRetrievers.begin(), myRetrievers.end(), retriever);
226 1117550 : if (i != myRetrievers.end()) {
227 433343 : myRetrievers.erase(i);
228 : }
229 1117550 : }
230 :
231 :
232 : bool
233 790665 : MsgHandler::isRetriever(OutputDevice* retriever) const {
234 790665 : return std::find(myRetrievers.begin(), myRetrievers.end(), retriever) != myRetrievers.end();
235 : }
236 :
237 :
238 : void
239 310723 : MsgHandler::removeRetrieverFromAllInstances(OutputDevice* out) {
240 310723 : if (myErrorInstance != nullptr) {
241 310723 : myErrorInstance->removeRetriever(out);
242 : }
243 310723 : if (myWarningInstance != nullptr) {
244 310723 : myWarningInstance->removeRetriever(out);
245 : }
246 310723 : if (myMessageInstance != nullptr) {
247 264367 : myMessageInstance->removeRetriever(out);
248 : }
249 310723 : }
250 :
251 :
252 : void
253 56227 : MsgHandler::setupI18n(const std::string& locale) {
254 : #ifdef HAVE_INTL
255 56227 : if (locale != "") {
256 : #ifdef WIN32
257 : _putenv_s("LANGUAGE", locale.data());
258 : #else
259 56227 : setenv("LANGUAGE", locale.data(), true);
260 : #endif
261 : }
262 56227 : if (!setlocale(LC_MESSAGES, "")) {
263 0 : WRITE_WARNINGF(TL("Could not set locale to '%'."), locale);
264 : }
265 56227 : const char* sumoPath = getenv("SUMO_HOME");
266 56227 : if (sumoPath == nullptr) {
267 16 : if (!bindtextdomain("sumo", nullptr)) {
268 0 : WRITE_WARNING(TL("Environment variable SUMO_HOME is not set, could not find localized messages."));
269 0 : return;
270 : }
271 : } else {
272 112422 : const std::string path = sumoPath + std::string("/data/locale/");
273 56211 : if (!bindtextdomain("sumo", path.data())) {
274 0 : WRITE_WARNING(TL("Could not find localized messages."));
275 : return;
276 : }
277 : }
278 56227 : bind_textdomain_codeset("sumo", "UTF-8");
279 56227 : textdomain("sumo");
280 : #ifdef WIN32
281 : SetConsoleOutputCP(CP_UTF8);
282 : #endif
283 : #else
284 : UNUSED_PARAMETER(locale);
285 : #endif
286 56227 : myWarningPrefix = TL("Warning: ");
287 56227 : myErrorPrefix = TL("Error: ");
288 56227 : gLocaleInitialized = true;
289 : }
290 :
291 :
292 : void
293 51393 : MsgHandler::initOutputOptions() {
294 : // initialize console properly
295 51393 : OutputDevice::getDevice("stdout");
296 51393 : OutputDevice::getDevice("stderr");
297 51393 : OptionsCont& oc = OptionsCont::getOptions();
298 51393 : getWarningInstance()->setAggregationThreshold(oc.getInt("aggregate-warnings"));
299 51393 : getErrorInstance()->setAggregationThreshold(oc.getInt("aggregate-warnings"));
300 102786 : if (oc.getBool("no-warnings")) {
301 406 : getWarningInstance()->removeRetriever(&OutputDevice::getDevice("stderr"));
302 : }
303 : // build the logger if possible
304 102786 : if (oc.isSet("log", false)) {
305 392 : OutputDevice* logFile = &OutputDevice::getDevice(oc.getString("log"));
306 392 : getErrorInstance()->addRetriever(logFile);
307 784 : if (!oc.getBool("no-warnings")) {
308 392 : getWarningInstance()->addRetriever(logFile);
309 : }
310 392 : getMessageInstance()->addRetriever(logFile);
311 784 : if (oc.getBool("log.timestamps")) {
312 1 : myWriteTimestamps = true;
313 : }
314 784 : if (oc.getBool("log.processid")) {
315 1 : myWriteProcessId = true;
316 : }
317 : }
318 102786 : if (oc.isSet("message-log", false)) {
319 8335 : OutputDevice* logFile = &OutputDevice::getDevice(oc.getString("message-log"));
320 8335 : getMessageInstance()->addRetriever(logFile);
321 : }
322 102786 : if (oc.isSet("error-log", false)) {
323 8367 : OutputDevice* logFile = &OutputDevice::getDevice(oc.getString("error-log"));
324 8367 : getErrorInstance()->addRetriever(logFile);
325 8367 : getWarningInstance()->addRetriever(logFile);
326 : }
327 102786 : if (oc.getBool("verbose")) {
328 11510 : getErrorInstance()->myInitialMessages.push_back("Repeating initial error messages:");
329 : } else {
330 91276 : getMessageInstance()->removeRetriever(&OutputDevice::getDevice("stdout"));
331 : }
332 51393 : }
333 :
334 :
335 : void
336 147342 : MsgHandler::cleanupOnEnd() {
337 147342 : delete myMessageInstance;
338 147342 : myMessageInstance = nullptr;
339 147342 : delete myWarningInstance;
340 147342 : myWarningInstance = nullptr;
341 147342 : delete myErrorInstance;
342 147342 : myErrorInstance = nullptr;
343 147342 : }
344 :
345 :
346 : std::string
347 6 : MsgHandler::buildProcessIdPrefix() const {
348 6 : std::stringstream prefix;
349 6 : prefix << "[PID: ";
350 : #ifdef WIN32
351 : prefix << GetCurrentProcessId();
352 : #else
353 6 : prefix << getpid();
354 : #endif
355 6 : prefix << "] ";
356 6 : return prefix.str();
357 6 : }
358 :
359 :
360 358663 : MsgHandler::MsgHandler(MsgType type) :
361 358663 : myType(type), myWasInformed(false), myAggregationThreshold(-1) {
362 358663 : if (type == MsgType::MT_MESSAGE) {
363 174278 : addRetriever(&OutputDevice::getDevice("stdout"));
364 : } else {
365 543048 : addRetriever(&OutputDevice::getDevice("stderr"));
366 : }
367 358663 : }
368 :
369 :
370 605102 : MsgHandler::~MsgHandler() {
371 605102 : }
372 :
373 :
374 : bool
375 490297 : MsgHandler::wasInformed() const {
376 490297 : return myWasInformed;
377 : }
378 :
379 :
380 : /****************************************************************************/
|