Line data    Source code

       1             : // Copyright (c) 2023 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #ifndef BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
       6             : #define BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H
       7             : 
       8             : #include <util/translation.h>
       9             : 
      10             : #include <cstdint>
      11             : #include <string>
      12             : #include <variant>
      13             : 
      14             : class CBlockIndex;
      15             : enum class SynchronizationState;
      16             : 
      17             : namespace kernel {
      18             : 
      19             : //! Result type for use with std::variant to indicate that an operation should be interrupted.
      20             : struct Interrupted{};
      21             : 
      22             : //! Simple result type for functions that need to propagate an interrupt status and don't have other return values.
      23             : using InterruptResult = std::variant<std::monostate, Interrupted>;
      24             : 
      25             : template <typename T>
      26         201 : bool IsInterrupted(const T& result)
      27             : {
      28         201 :     return std::holds_alternative<kernel::Interrupted>(result);
      29             : }
      30             : 
      31             : /**
      32             :  * A base class defining functions for notifying about certain kernel
      33             :  * events.
      34             :  */
      35             : class Notifications
      36             : {
      37             : public:
      38           2 :     virtual ~Notifications(){};
      39             : 
      40           0 :     [[nodiscard]] virtual InterruptResult blockTip(SynchronizationState state, CBlockIndex& index) { return {}; }
      41           0 :     virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
      42           0 :     virtual void progress(const bilingual_str& title, int progress_percent, bool resume_possible) {}
      43           0 :     virtual void warning(const bilingual_str& warning) {}
      44             : 
      45             :     //! The flush error notification is sent to notify the user that an error
      46             :     //! occurred while flushing block data to disk. Kernel code may ignore flush
      47             :     //! errors that don't affect the immediate operation it is trying to
      48             :     //! perform. Applications can choose to handle the flush error notification
      49             :     //! by logging the error, or notifying the user, or triggering an early
      50             :     //! shutdown as a precaution against causing more errors.
      51           0 :     virtual void flushError(const std::string& debug_message) {}
      52             : 
      53             :     //! The fatal error notification is sent to notify the user when an error
      54             :     //! occurs in kernel code that can't be recovered from. After this
      55             :     //! notification is sent, whatever function triggered the error should also
      56             :     //! return an error code or raise an exception. Applications can choose to
      57             :     //! handle the fatal error notification by logging the error, or notifying
      58             :     //! the user, or triggering an early shutdown as a precaution against
      59             :     //! causing more errors.
      60           0 :     virtual void fatalError(const std::string& debug_message, const bilingual_str& user_message = {}) {}
      61             : };
      62             : } // namespace kernel
      63             : 
      64             : #endif // BITCOIN_KERNEL_NOTIFICATIONS_INTERFACE_H