mirror of
https://github.com/bitcoin/bitcoin.git
synced 2026-01-19 14:53:43 +01:00
ddc7872c08
The extra `bilingual_str` argument of the fatal error notifications and `node::AbortNode()` is often unused and when used usually contains the same string as the message argument. It also seems to be confusing, since it is not consistently used for errors requiring user action. For example some assumeutxo fatal errors require the user to do something, but are not translated. So simplify the fatal error and abort node interfaces by only passing a translated string. This slightly changes the fatal errors displayed to the user. Also de-duplicate the abort error log since it is repeated in noui.cpp.
63 lines
2.5 KiB
C++
63 lines
2.5 KiB
C++
// Copyright (c) 2023 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
|
|
#define BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
|
|
|
|
#include <cstdint>
|
|
#include <variant>
|
|
|
|
class CBlockIndex;
|
|
enum class SynchronizationState;
|
|
struct bilingual_str;
|
|
|
|
namespace kernel {
|
|
|
|
//! Result type for use with std::variant to indicate that an operation should be interrupted.
|
|
struct Interrupted{};
|
|
|
|
//! Simple result type for functions that need to propagate an interrupt status and don't have other return values.
|
|
using InterruptResult = std::variant<std::monostate, Interrupted>;
|
|
|
|
template <typename T>
|
|
bool IsInterrupted(const T& result)
|
|
{
|
|
return std::holds_alternative<kernel::Interrupted>(result);
|
|
}
|
|
|
|
/**
|
|
* A base class defining functions for notifying about certain kernel
|
|
* events.
|
|
*/
|
|
class Notifications
|
|
{
|
|
public:
|
|
virtual ~Notifications(){};
|
|
|
|
[[nodiscard]] virtual InterruptResult blockTip(SynchronizationState state, CBlockIndex& index) { return {}; }
|
|
virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
|
|
virtual void progress(const bilingual_str& title, int progress_percent, bool resume_possible) {}
|
|
virtual void warning(const bilingual_str& warning) {}
|
|
|
|
//! The flush error notification is sent to notify the user that an error
|
|
//! occurred while flushing block data to disk. Kernel code may ignore flush
|
|
//! errors that don't affect the immediate operation it is trying to
|
|
//! perform. Applications can choose to handle the flush error notification
|
|
//! by logging the error, or notifying the user, or triggering an early
|
|
//! shutdown as a precaution against causing more errors.
|
|
virtual void flushError(const bilingual_str& message) {}
|
|
|
|
//! The fatal error notification is sent to notify the user when an error
|
|
//! occurs in kernel code that can't be recovered from. After this
|
|
//! notification is sent, whatever function triggered the error should also
|
|
//! return an error code or raise an exception. Applications can choose to
|
|
//! handle the fatal error notification by logging the error, or notifying
|
|
//! the user, or triggering an early shutdown as a precaution against
|
|
//! causing more errors.
|
|
virtual void fatalError(const bilingual_str& message) {}
|
|
};
|
|
} // namespace kernel
|
|
|
|
#endif // BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
|