app_configuration_impl.hpp

Go to the documentation of this file.

#ifndef KAGOME_APP_CONFIGURATION_IMPL_HPP
#define KAGOME_APP_CONFIGURATION_IMPL_HPP

#include "application/app_configuration.hpp"

#define RAPIDJSON_NO_SIZETYPEDEFINE
namespace rapidjson {
  using SizeType = ::std::size_t;
}
#include <rapidjson/document.h>
#undef RAPIDJSON_NO_SIZETYPEDEFINE

#include <array>
#include <cstdio>
#include <memory>

#include "log/logger.hpp"

#ifdef DECLARE_PROPERTY
#error DECLARE_PROPERTY already defined!
#endif  // DECLARE_PROPERTY
#define DECLARE_PROPERTY(T, N)                                                 \
 private:                                                                      \
  T N##_;                                                                      \
                                                                               \
 public:                                                                       \
  std::conditional<std::is_trivial<T>::value && (sizeof(T) <= sizeof(size_t)), \
                   T,                                                          \
                   const T &>::type                                            \
  N() const override {                                                         \
    return N##_;                                                               \
  }

namespace kagome::application {

  // clang-format off
  // clang-format on

  class AppConfigurationImpl final : public AppConfiguration {
    using FilePtr = std::unique_ptr<std::FILE, decltype(&std::fclose)>;

   public:
    explicit AppConfigurationImpl(log::Logger logger);
    ~AppConfigurationImpl() override = default;

    AppConfigurationImpl(const AppConfigurationImpl &) = delete;
    AppConfigurationImpl &operator=(const AppConfigurationImpl &) = delete;

    AppConfigurationImpl(AppConfigurationImpl &&) = default;
    AppConfigurationImpl &operator=(AppConfigurationImpl &&) = default;

    [[nodiscard]] bool initializeFromArgs(int argc, const char **argv);

    network::Roles roles() const override {
      return roles_;
    }
    boost::filesystem::path chainSpecPath() const override;
    boost::filesystem::path runtimeCacheDirPath() const override;
    boost::filesystem::path runtimeCachePath(
        std::string runtime_hash) const override;
    boost::filesystem::path chainPath(std::string chain_id) const override;
    boost::filesystem::path databasePath(std::string chain_id) const override;
    boost::filesystem::path keystorePath(std::string chain_id) const override;

    const std::optional<crypto::Ed25519PrivateKey> &nodeKey() const override {
      return node_key_;
    }

    const std::optional<std::string> &nodeKeyFile() const override {
      return node_key_file_;
    }

    bool shouldSaveNodeKey() const override {
      return save_node_key_;
    }

    const std::vector<libp2p::multi::Multiaddress> &listenAddresses()
        const override {
      return listen_addresses_;
    }

    const std::vector<libp2p::multi::Multiaddress> &publicAddresses()
        const override {
      return public_addresses_;
    }

    const std::vector<libp2p::multi::Multiaddress> &bootNodes() const override {
      return boot_nodes_;
    }

    uint16_t p2pPort() const override {
      return p2p_port_;
    }
    uint32_t outPeers() const override {
      return out_peers_;
    }
    uint32_t inPeers() const override {
      return in_peers_;
    }
    uint32_t inPeersLight() const override {
      return in_peers_light_;
    }
    int32_t luckyPeers() const override {
      return lucky_peers_;
    }
    const boost::asio::ip::tcp::endpoint &rpcHttpEndpoint() const override {
      return rpc_http_endpoint_;
    }
    const boost::asio::ip::tcp::endpoint &rpcWsEndpoint() const override {
      return rpc_ws_endpoint_;
    }
    const boost::asio::ip::tcp::endpoint &openmetricsHttpEndpoint()
        const override {
      return openmetrics_http_endpoint_;
    }
    uint32_t maxWsConnections() const override {
      return max_ws_connections_;
    }
    std::chrono::seconds getRandomWalkInterval() const override {
      return std::chrono::seconds(random_walk_interval_);
    }
    const std::vector<std::string> &log() const override {
      return logger_tuning_config_;
    }
    uint32_t maxBlocksInResponse() const override {
      return max_blocks_in_response_;
    }
    const network::PeeringConfig &peeringConfig() const override {
      return peering_config_;
    }
    bool isRunInDevMode() const override {
      return dev_mode_;
    }
    const std::string &nodeName() const override {
      return node_name_;
    }
    const std::string &nodeVersion() const override {
      return node_version_;
    }
    bool isTelemetryEnabled() const override {
      return is_telemetry_enabled_;
    }
    const std::vector<telemetry::TelemetryEndpoint> &telemetryEndpoints()
        const override {
      return telemetry_endpoints_;
    }
    SyncMethod syncMethod() const override {
      return sync_method_;
    }
    RuntimeExecutionMethod runtimeExecMethod() const override {
      return runtime_exec_method_;
    }
    bool useWavmCache() const override {
      return use_wavm_cache_;
    }
    bool purgeWavmCache() const override {
      return purge_wavm_cache_;
    }
    OffchainWorkerMode offchainWorkerMode() const override {
      return offchain_worker_mode_;
    }
    bool isOffchainIndexingEnabled() const override {
      return enable_offchain_indexing_;
    }
    bool subcommandChainInfo() const override {
      return subcommand_chain_info_;
    }
    std::optional<primitives::BlockId> recoverState() const override {
      return recovery_state_;
    }
    StorageBackend storageBackend() const override {
      return storage_backend_;
    }
    std::optional<std::string_view> devMnemonicPhrase() const override {
      if (dev_mnemonic_phrase_) {
        return *dev_mnemonic_phrase_;
      }
      return std::nullopt;
    }

   private:
    void parse_general_segment(const rapidjson::Value &val);
    void parse_blockchain_segment(const rapidjson::Value &val);
    void parse_storage_segment(const rapidjson::Value &val);
    void parse_network_segment(const rapidjson::Value &val);
    void parse_additional_segment(const rapidjson::Value &val);

    struct SegmentHandler {
      using Handler = std::function<void(rapidjson::Value &)>;
      char const *segment_name;
      Handler handler;
    };

    // clang-format off
    std::vector<SegmentHandler> handlers_ = {
        SegmentHandler{"general",    std::bind(&AppConfigurationImpl::parse_general_segment, this, std::placeholders::_1)},
        SegmentHandler{"blockchain", std::bind(&AppConfigurationImpl::parse_blockchain_segment, this, std::placeholders::_1)},
        SegmentHandler{"storage",    std::bind(&AppConfigurationImpl::parse_storage_segment, this, std::placeholders::_1)},
        SegmentHandler{"network",    std::bind(&AppConfigurationImpl::parse_network_segment, this, std::placeholders::_1)},
        SegmentHandler{"additional", std::bind(&AppConfigurationImpl::parse_additional_segment, this, std::placeholders::_1)},
    };
    // clang-format on

    bool validate_config();

    void read_config_from_file(const std::string &filepath);

    bool load_ms(const rapidjson::Value &val,
                 char const *name,
                 std::vector<std::string> &target);

    bool load_ma(const rapidjson::Value &val,
                 char const *name,
                 std::vector<libp2p::multi::Multiaddress> &target);
    bool load_telemetry_uris(const rapidjson::Value &val,
                             char const *name,
                             std::vector<telemetry::TelemetryEndpoint> &target);
    bool load_str(const rapidjson::Value &val,
                  char const *name,
                  std::string &target);
    bool load_u16(const rapidjson::Value &val,
                  char const *name,
                  uint16_t &target);
    bool load_u32(const rapidjson::Value &val,
                  char const *name,
                  uint32_t &target);
    bool load_i32(const rapidjson::Value &val,
                  char const *name,
                  int32_t &target);
    bool load_bool(const rapidjson::Value &val, char const *name, bool &target);

    boost::asio::ip::tcp::endpoint getEndpointFrom(const std::string &host,
                                                   uint16_t port) const;

    outcome::result<boost::asio::ip::tcp::endpoint> getEndpointFrom(
        const libp2p::multi::Multiaddress &multiaddress) const;

    bool testListenAddresses() const;

    std::optional<telemetry::TelemetryEndpoint> parseTelemetryEndpoint(
        const std::string &record) const;

    FilePtr open_file(const std::string &filepath);

    log::Logger logger_;

    network::Roles roles_;
    std::optional<crypto::Ed25519PrivateKey> node_key_;
    std::optional<std::string> node_key_file_;
    bool save_node_key_;
    std::vector<libp2p::multi::Multiaddress> listen_addresses_;
    std::vector<libp2p::multi::Multiaddress> public_addresses_;
    std::vector<libp2p::multi::Multiaddress> boot_nodes_;
    std::vector<telemetry::TelemetryEndpoint> telemetry_endpoints_;
    bool is_telemetry_enabled_;
    uint16_t p2p_port_;
    boost::asio::ip::tcp::endpoint rpc_http_endpoint_;
    boost::asio::ip::tcp::endpoint rpc_ws_endpoint_;
    boost::asio::ip::tcp::endpoint openmetrics_http_endpoint_;
    std::vector<std::string> logger_tuning_config_;
    uint32_t max_blocks_in_response_;
    std::string rpc_http_host_;
    std::string rpc_ws_host_;
    std::string openmetrics_http_host_;
    boost::filesystem::path chain_spec_path_;
    boost::filesystem::path base_path_;
    std::optional<boost::filesystem::path> keystore_path_;
    uint16_t rpc_http_port_;
    uint16_t rpc_ws_port_;
    uint16_t openmetrics_http_port_;
    uint32_t out_peers_;
    uint32_t in_peers_;
    uint32_t in_peers_light_;
    int32_t lucky_peers_;
    network::PeeringConfig peering_config_;
    bool dev_mode_;
    std::string node_name_;
    std::string node_version_;
    uint32_t max_ws_connections_;
    uint32_t random_walk_interval_;
    SyncMethod sync_method_;
    RuntimeExecutionMethod runtime_exec_method_;
    bool use_wavm_cache_;
    bool purge_wavm_cache_;
    OffchainWorkerMode offchain_worker_mode_;
    bool enable_offchain_indexing_;
    bool subcommand_chain_info_;
    std::optional<primitives::BlockId> recovery_state_;
    StorageBackend storage_backend_ = StorageBackend::RocksDB;
    std::optional<std::string> dev_mnemonic_phrase_;
  };

}  // namespace kagome::application

#undef DECLARE_PROPERTY

#endif  // KAGOME_APP_CONFIGURATION_IMPL_HPP