qml: Add node lifecycle model

Initialize and shut down the node on a worker thread. Expose lifecycle
state and block progress through NodeModel, and stop cleanly when the
window closes.

Co-authored-by: johnny9 <johnny9dev@pm.me>
Co-authored-by: João Barbosa <joao.paulo.barbosa@gmail.com>

Author: 3 people

src/init/bitcoin-qt.cpp

@@ -16,7 +16,10 @@
 
 namespace init {
 namespace {
-const char* EXE_NAME = "bitcoin-qt";
+#ifndef BITCOIN_GUI_EXECUTABLE_NAME
+#define BITCOIN_GUI_EXECUTABLE_NAME "bitcoin-qt"
+#endif
+const char* EXE_NAME = BITCOIN_GUI_EXECUTABLE_NAME;
 
 class BitcoinQtInit : public interfaces::Init
 {

src/qml/CMakeLists.txt

@@ -17,12 +17,17 @@ unset(warn_flags)
 add_library(bitcoinqml STATIC
   bitcoin.cpp
   bitcoin.h
+  initexecutor.cpp
+  initexecutor.h
+  models/nodemodel.cpp
+  models/nodemodel.h
   ${BITCOIN_QML_QRC}
 )
 
 target_compile_definitions(bitcoinqml
   PUBLIC
     QT_NO_KEYWORDS
+    QT_NO_CONTEXTLESS_CONNECT
     QT_USE_QSTRINGBUILDER
 )
 
@@ -37,19 +42,31 @@ if(ENABLE_TEST_AUTOMATION)
 endif()
 
 target_link_libraries(bitcoinqml
+  PRIVATE
+    bitcoin_node
   PUBLIC
     Qt6::Qml
     Qt6::Quick
     Qt6::QuickControls2
 )
 
-add_executable(bitcoin-qml WIN32 main.cpp)
+add_executable(bitcoin-qml WIN32
+  main.cpp
+  ../init/bitcoin-qt.cpp
+)
 add_windows_application_manifest(bitcoin-qml)
 
+target_compile_definitions(bitcoin-qml
+  PRIVATE
+    BITCOIN_GUI_EXECUTABLE_NAME="bitcoin-qml"
+)
+
 target_link_libraries(bitcoin-qml
   PRIVATE
     core_interface
     bitcoinqml
+    bitcoin_node
+    $<TARGET_NAME_IF_EXISTS:bitcoin_wallet>
 )
 
 qt6_import_qml_plugins(bitcoin-qml)

src/qml/bitcoin.cpp

@@ -4,56 +4,131 @@
 
 #include <qml/bitcoin.h>
 
+#include <clientversion.h>
+#include <common/args.h>
+#include <common/init.h>
+#include <common/system.h>
+#include <init.h>
+#include <interfaces/init.h>
+#include <interfaces/node.h>
+#include <node/interface_ui.h>
+#include <noui.h>
+#include <qml/initexecutor.h>
+#include <qml/models/nodemodel.h>
 #ifdef ENABLE_TEST_AUTOMATION
 #include <qml/test/testbridge.h>
 #endif
+#include <util/threadnames.h>
+#include <util/translation.h>
 
 #include <QGuiApplication>
 #include <QQmlApplicationEngine>
+#include <QQmlContext>
 #include <QQuickStyle>
 #include <QStringLiteral>
+#include <QTimer>
 #include <QUrl>
 
 #include <cstdlib>
+#include <iostream>
 #include <memory>
-
-#ifdef ENABLE_TEST_AUTOMATION
-namespace {
-QString TestAutomationSocketPath(int argc, char* argv[])
-{
-    const QString prefix{QStringLiteral("-test-automation=")};
-    for (int i = 1; i < argc; ++i) {
-        const QString argument{QString::fromLocal8Bit(argv[i])};
-        if (argument.startsWith(prefix)) {
-            return argument.sliced(prefix.size());
-        }
-    }
-    return {};
-}
-} // namespace
-#endif
+#include <string>
+#include <tuple>
 
 int QmlGuiMain(int argc, char* argv[])
 {
     Q_INIT_RESOURCE(bitcoin_qml);
 
+#ifdef WIN32
+    common::WinCmdLineArgs win_args;
+    std::tie(argc, argv) = win_args.get();
+#endif
+
     QQuickStyle::setStyle(QStringLiteral("Basic"));
 
     QGuiApplication app(argc, argv);
     QGuiApplication::setApplicationDisplayName(QGuiApplication::translate("bitcoin-core", "Bitcoin Core"));
+    QGuiApplication::setQuitOnLastWindowClosed(false);
+
+    SetupEnvironment();
+    util::ThreadSetInternalName("main");
+    noui_connect();
+
+    std::unique_ptr<interfaces::Init> init{interfaces::MakeGuiInit(argc, argv)};
+
+    SetupServerArgs(gArgs, init->canListenIpc());
+#ifdef ENABLE_TEST_AUTOMATION
+    gArgs.AddArg("-test-automation=<path>", "Enable test automation bridge on the given local socket path", ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
+#endif
+    std::string error;
+    if (!gArgs.ParseParameters(argc, argv, error)) {
+        InitError(Untranslated(strprintf("Error parsing command line arguments: %s", error)));
+        return EXIT_FAILURE;
+    }
+
+    if (HelpRequested(gArgs) || gArgs.GetBoolArg("-version", false)) {
+        std::cout << init->exeName() << " " << FormatFullVersion() << "\n";
+        if (!gArgs.GetBoolArg("-version", false)) {
+            std::cout << "\n" << gArgs.GetHelpMessage();
+        }
+        return EXIT_SUCCESS;
+    }
+
+    for (int i = 1; i < argc; ++i) {
+        if (!IsSwitchChar(argv[i][0])) {
+            InitError(Untranslated(strprintf("Command line contains unexpected token '%s', see bitcoin-qml -h for a list of options.", argv[i])));
+            return EXIT_FAILURE;
+        }
+    }
+
+    if (auto config_error{common::InitConfig(gArgs)}) {
+        InitError(config_error->message, config_error->details);
+        return EXIT_FAILURE;
+    }
+
+    gArgs.SoftSetBoolArg("-printtoconsole", false);
+    InitLogging(gArgs);
+    InitParameterInteraction(gArgs);
+
+    std::unique_ptr<interfaces::Node> node{init->makeNode()};
+    if (!node->baseInitialize()) {
+        return EXIT_FAILURE;
+    }
+
+    qRegisterMetaType<interfaces::BlockAndHeaderTipInfo>("interfaces::BlockAndHeaderTipInfo");
+
+    NodeModel node_model{*node};
+    QmlInitExecutor init_executor{*node};
+
+    QObject::connect(&node_model, &NodeModel::requestedInitialize, &init_executor, &QmlInitExecutor::initialize);
+    QObject::connect(&node_model, &NodeModel::requestedShutdown, &init_executor, &QmlInitExecutor::shutdown);
+    QObject::connect(&init_executor, &QmlInitExecutor::initializeResult, &node_model, &NodeModel::initializeResult);
+    QObject::connect(&init_executor, &QmlInitExecutor::shutdownResult, &node_model, &NodeModel::shutdownResult);
+    QObject::connect(&init_executor, &QmlInitExecutor::runawayException, &node_model, &NodeModel::handleRunawayException);
+    QObject::connect(&node_model, &NodeModel::shutdownComplete, &app, [&app, &node] {
+        app.exit(node->getExitStatus());
+    });
+    QObject::connect(&app, &QGuiApplication::lastWindowClosed, &node_model, &NodeModel::requestShutdown);
 
     QQmlApplicationEngine engine;
+    engine.rootContext()->setContextProperty(QStringLiteral("nodeModel"), &node_model);
     engine.load(QUrl{QStringLiteral("qrc:///qml/pages/MainWindow.qml")});
     if (engine.rootObjects().isEmpty()) {
+        node->startShutdown();
+        node->appShutdown();
         return EXIT_FAILURE;
     }
 
 #ifdef ENABLE_TEST_AUTOMATION
     std::unique_ptr<TestBridge> test_bridge;
-    if (const QString socket_path{TestAutomationSocketPath(argc, argv)}; !socket_path.isEmpty()) {
-        test_bridge = std::make_unique<TestBridge>(engine, socket_path);
+    if (gArgs.IsArgSet("-test-automation")) {
+        const QString socket_path{QString::fromStdString(gArgs.GetArg("-test-automation", ""))};
+        if (!socket_path.isEmpty()) {
+            test_bridge = std::make_unique<TestBridge>(engine, socket_path);
+        }
     }
 #endif
 
+    QTimer::singleShot(0, &node_model, &NodeModel::start);
     return app.exec();
 }

src/qml/initexecutor.cpp

@@ -0,0 +1,61 @@
+// Copyright (c) 2014-present The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <qml/initexecutor.h>
+
+#include <interfaces/node.h>
+#include <util/exception.h>
+#include <util/threadnames.h>
+
+#include <QMetaObject>
+#include <QString>
+
+QmlInitExecutor::QmlInitExecutor(interfaces::Node& node)
+    : m_node{node}
+{
+    m_context.moveToThread(&m_thread);
+    m_thread.start();
+}
+
+QmlInitExecutor::~QmlInitExecutor()
+{
+    m_thread.quit();
+    m_thread.wait();
+}
+
+void QmlInitExecutor::handleRunawayException(const std::exception* exception)
+{
+    PrintExceptionContinue(exception, "Runaway exception");
+    Q_EMIT runawayException(exception ? QString::fromUtf8(exception->what()) : tr("Unknown exception"));
+}
+
+void QmlInitExecutor::initialize()
+{
+    QMetaObject::invokeMethod(&m_context, [this] {
+        try {
+            util::ThreadRename("qml-init");
+            interfaces::BlockAndHeaderTipInfo tip_info;
+            const bool success{m_node.appInitMain(&tip_info)};
+            Q_EMIT initializeResult(success, tip_info);
+        } catch (const std::exception& exception) {
+            handleRunawayException(&exception);
+        } catch (...) {
+            handleRunawayException(nullptr);
+        }
+    });
+}
+
+void QmlInitExecutor::shutdown()
+{
+    QMetaObject::invokeMethod(&m_context, [this] {
+        try {
+            m_node.appShutdown();
+            Q_EMIT shutdownResult();
+        } catch (const std::exception& exception) {
+            handleRunawayException(&exception);
+        } catch (...) {
+            handleRunawayException(nullptr);
+        }
+    });
+}

src/qml/initexecutor.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2014-present 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_QML_INITEXECUTOR_H
+#define BITCOIN_QML_INITEXECUTOR_H
+
+#include <interfaces/node.h>
+
+#include <exception>
+
+#include <QObject>
+#include <QThread>
+
+QT_BEGIN_NAMESPACE
+class QString;
+QT_END_NAMESPACE
+
+/** Run node initialization and shutdown without blocking the GUI thread. */
+class QmlInitExecutor : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit QmlInitExecutor(interfaces::Node& node);
+    ~QmlInitExecutor() override;
+
+public Q_SLOTS:
+    void initialize();
+    void shutdown();
+
+Q_SIGNALS:
+    void initializeResult(bool success, interfaces::BlockAndHeaderTipInfo tip_info);
+    void shutdownResult();
+    void runawayException(const QString& message);
+
+private:
+    void handleRunawayException(const std::exception* exception);
+
+    interfaces::Node& m_node;
+    QObject m_context;
+    QThread m_thread;
+};
+
+#endif // BITCOIN_QML_INITEXECUTOR_H