mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-05-23 02:10:51 +02:00
31eca93a9e
This change drops the last kernel dependency on shutdown.cpp. It also adds new hooks for libbitcoinkernel applications to be able to interrupt kernel operations when the chain tip changes. This is a refactoring that does not affect behavior. (Looking at the code it can appear like the new break statement in the ActivateBestChain function is a change in behavior, but actually the previous StartShutdown call was indirectly triggering a break before, because it was causing m_chainman.m_interrupt to be true. The new code just makes the break more obvious.)
65 lines
2.5 KiB
C++
65 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 <util/translation.h>
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <variant>
|
|
|
|
class CBlockIndex;
|
|
enum class SynchronizationState;
|
|
|
|
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 std::string& debug_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 std::string& debug_message, const bilingual_str& user_message = {}) {}
|
|
};
|
|
} // namespace kernel
|
|
|
|
#endif // BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
|