app_configuration.hpp

Go to the documentation of this file.

#ifndef KAGOME_APP_CONFIGURATION_HPP
#define KAGOME_APP_CONFIGURATION_HPP

#include <memory>
#include <optional>
#include <string>

#include <boost/asio/ip/tcp.hpp>
#include <boost/filesystem.hpp>
#include <libp2p/multi/multiaddress.hpp>

#include "crypto/ed25519_types.hpp"
#include "log/logger.hpp"
#include "network/peering_config.hpp"
#include "network/types/roles.hpp"
#include "primitives/block_id.hpp"
#include "telemetry/endpoint.hpp"

namespace kagome::application {

  class AppConfiguration {
   public:
    static constexpr uint32_t kAbsolutMinBlocksInResponse = 1;
    static constexpr uint32_t kAbsolutMaxBlocksInResponse = 128;
    static constexpr uint32_t kNodeNameMaxLength = 64;

    static_assert(kAbsolutMinBlocksInResponse <= kAbsolutMaxBlocksInResponse,
                  "Check max and min page bounding values!");

    virtual ~AppConfiguration() = default;

    virtual network::Roles roles() const = 0;

    virtual boost::filesystem::path chainSpecPath() const = 0;

    virtual boost::filesystem::path runtimeCacheDirPath() const = 0;

    virtual boost::filesystem::path runtimeCachePath(
        std::string runtime_hash) const = 0;

    virtual boost::filesystem::path chainPath(std::string chain_id) const = 0;

    virtual boost::filesystem::path databasePath(
        std::string chain_id) const = 0;

    virtual boost::filesystem::path keystorePath(
        std::string chain_id) const = 0;

    virtual const std::optional<crypto::Ed25519PrivateKey> &nodeKey() const = 0;

    virtual const std::optional<std::string> &nodeKeyFile() const = 0;

    virtual bool shouldSaveNodeKey() const = 0;

    virtual uint16_t p2pPort() const = 0;

    virtual uint32_t outPeers() const = 0;

    virtual uint32_t inPeers() const = 0;

    virtual uint32_t inPeersLight() const = 0;

    virtual int32_t luckyPeers() const = 0;

    virtual const std::vector<libp2p::multi::Multiaddress> &bootNodes()
        const = 0;

    virtual const std::vector<libp2p::multi::Multiaddress> &listenAddresses()
        const = 0;

    virtual const std::vector<libp2p::multi::Multiaddress> &publicAddresses()
        const = 0;

    virtual const boost::asio::ip::tcp::endpoint &rpcHttpEndpoint() const = 0;

    virtual const boost::asio::ip::tcp::endpoint &rpcWsEndpoint() const = 0;

    virtual const boost::asio::ip::tcp::endpoint &openmetricsHttpEndpoint()
        const = 0;

    virtual uint32_t maxWsConnections() const = 0;

    virtual std::chrono::seconds getRandomWalkInterval() const = 0;

    virtual const std::vector<std::string> &log() const = 0;

    virtual uint32_t maxBlocksInResponse() const = 0;

    virtual const network::PeeringConfig &peeringConfig() const = 0;

    virtual bool isRunInDevMode() const = 0;

    virtual const std::string &nodeName() const = 0;

    virtual const std::string &nodeVersion() const = 0;

    virtual bool isTelemetryEnabled() const = 0;

    virtual const std::vector<telemetry::TelemetryEndpoint>
        &telemetryEndpoints() const = 0;

    enum class SyncMethod { Full, Fast };
    virtual SyncMethod syncMethod() const = 0;

    enum class RuntimeExecutionMethod { Compile, Interpret };
    virtual RuntimeExecutionMethod runtimeExecMethod() const = 0;

    virtual bool useWavmCache() const = 0;

    virtual bool purgeWavmCache() const = 0;

    enum class OffchainWorkerMode { WhenValidating, Always, Never };
    virtual OffchainWorkerMode offchainWorkerMode() const = 0;

    virtual bool isOffchainIndexingEnabled() const = 0;

    virtual bool subcommandChainInfo() const = 0;

    virtual std::optional<primitives::BlockId> recoverState() const = 0;

    enum class StorageBackend { RocksDB };

    virtual StorageBackend storageBackend() const = 0;

    virtual std::optional<std::string_view> devMnemonicPhrase() const = 0;
  };

}  // namespace kagome::application

#endif  // KAGOME_APP_CONFIGURATION_HPP