mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-20 08:04:57 +01:00
The writer's thread called flush() with nothing around it, so an exception leaving write() ended the process with std::terminate, with no message. One that happens: the file of a log was made a std::filesystem::path of the vehicle's name, which MSVC converts in the code page of the system and throws for bytes not of it; on a Windows with "Use Unicode UTF-8 for worldwide language support" a vehicle named in 1250, as the sceneries have them (0xB3 for ł), isn't UTF-8. - the file of a log is made of the name with MultiByteToWideChar without MB_ERR_INVALID_CHARS: the same file as before for every name of the code page, U+FFFD for the bytes not of it instead of a throw. Elsewhere the bytes are the name of the file as they were - a log whose writing throws for any other reason (memory) is kept for the next try as one whose file can't be written, and the other logs are written still - the thread, flush_for() and stop() write through flush_safely(), which lets nothing out: what was taken for a writing failing as a whole is lost and told in the log, the next writing goes on - the messages name the file by the bytes of the name, not by path::string(), which converts back Tests: a log which can't be written doesn't keep the others from theirs; a vehicle named in 1250 has its log, read back by physicslog_writer::file(). Reported in the review of #385. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
86 lines
3.8 KiB
C++
86 lines
3.8 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <filesystem>
|
|
#include <map>
|
|
#include <mutex>
|
|
#include <set>
|
|
#include <stop_token>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <thread>
|
|
|
|
// the physics logs, <folder>/<name>.dat. the lines given are kept, and written every two seconds by a thread of its
|
|
// own, each file opened only for the moment it is written to: the logs of hundreds of vehicles hold no files open, and
|
|
// the simulation doesn't wait for the disk. a crash loses the last two seconds of real time of them. lines whose file
|
|
// can't be written, held by another program say, are kept for the next try: the last 64 MB of them all at most
|
|
class physicslog_writer {
|
|
public:
|
|
explicit physicslog_writer(std::filesystem::path Folder = "physicslog", std::chrono::milliseconds Interval = std::chrono::seconds{2});
|
|
physicslog_writer(physicslog_writer const &) = delete;
|
|
physicslog_writer &operator=(physicslog_writer const &) = delete;
|
|
// stops, writing what is kept
|
|
~physicslog_writer();
|
|
|
|
// starts the log Name anew: its file is emptied and Header written into it, the next time the logs are written.
|
|
// the lines of it not written yet are dropped
|
|
void begin(std::string const &Name, std::string_view Header);
|
|
// Line at the end of the log Name. a log not begun is added to as its file stands
|
|
void append(std::string const &Name, std::string_view Line);
|
|
// writes what is kept, now
|
|
void flush();
|
|
// as flush, waited for no longer than Timeout: then false, and the writing goes on by itself, on a thread left
|
|
// behind. for the end of the process, the files held up or the disk not answering
|
|
bool flush_for(std::chrono::milliseconds Timeout);
|
|
// writes what is kept and ends the thread. what is given after is written by a flush, or at the end
|
|
void stop();
|
|
// the file of the log Name, made of its bytes as they are: those of the code page of a scenery (1250) too, on a
|
|
// Windows set to UTF-8, where the standard library throws making a path of them. there they become U+FFFD
|
|
std::filesystem::path file(std::string const &Name) const;
|
|
|
|
private:
|
|
struct pending {
|
|
bool fresh{false}; // its file is to be emptied first, and the header written into it
|
|
std::string header;
|
|
std::string text;
|
|
};
|
|
|
|
// the thread, on the first line given, unless stopped. called with m_mutex held
|
|
void start();
|
|
void run(std::stop_token const &Stop);
|
|
// as flush, letting nothing out: on the writer's thread, or at the end of the process, an exception would end the
|
|
// simulator. what was taken for a writing which failed as a whole is lost, the next one goes on with what came since
|
|
void flush_safely() noexcept;
|
|
// called with m_filemutex held
|
|
void write();
|
|
// the lines of the log Name written into its file. returns: true if they all were
|
|
bool write_log(std::string const &Name, pending const &Lines) const;
|
|
// the file of the log Name, for the log of the simulator
|
|
std::string shown(std::string const &Name) const;
|
|
|
|
std::filesystem::path const m_folder;
|
|
std::string const m_shownfolder;
|
|
std::chrono::milliseconds const m_interval;
|
|
std::mutex m_mutex; // the lines kept and the thread
|
|
std::map<std::string, pending> m_pending;
|
|
bool m_stopped{false};
|
|
std::condition_variable m_wake;
|
|
std::jthread m_thread;
|
|
std::thread::id m_writer; // of the thread, kept after it is taken to be joined: the writer knows itself by it
|
|
std::mutex m_filemutex; // the files are written one batch at a time, so the lines of a log stay in order
|
|
std::set<std::string> m_failed; // the logs whose file couldn't be written, told once
|
|
};
|
|
|
|
// the physics logs of the drivers (physicslog yes), and those the black box writes of the user's vehicles
|
|
extern physicslog_writer PhysicsLogs;
|