config.hpp

Go to the documentation of this file.

// (C) Copyright 2025, SECO Mind Srl
//
// SPDX-License-Identifier: Apache-2.0
 
#ifndef ASTARTE_MQTT_CONFIG_H
#define ASTARTE_MQTT_CONFIG_H

 
#include <ada.h>
#include <spdlog/spdlog.h>
 
#include <chrono>
#include <filesystem>
#include <fstream>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
 
#include "astarte_device_sdk/mqtt/errors.hpp"
#include "astarte_device_sdk/mqtt/pairing.hpp"
 
namespace astarte::device::mqtt {

using namespace std::chrono_literals;
 
// Forward declaration, needed to make Credential private.
class Credential;

constexpr uint32_t DEFAULT_KEEP_ALIVE = 30;

constexpr uint32_t DEFAULT_CONNECTION_TIMEOUT = 5;

constexpr auto DEFAULT_DISCONNECTION_TIMEOUT = 1s;

class Config {
 public:
  Config(Config&& other) noexcept;

  auto operator=(Config&& other) noexcept -> Config&;

  Config(const Config&) = delete;

  auto operator=(const Config&) -> Config& = delete;

  ~Config();

  [[nodiscard]] static auto with_credential_secret(std::string_view realm,
                                                   std::string_view device_id,
                                                   std::string_view credential,
                                                   std::string_view pairing_url,
                                                   std::string_view store_dir) -> Config;

  [[nodiscard]] auto realm() -> std::string_view { return realm_; }

  [[nodiscard]] auto device_id() -> std::string_view { return device_id_; }

  [[nodiscard]] auto pairing_url() -> std::string_view { return pairing_url_; }

  [[nodiscard]] auto cred_is_credential_secret() -> bool;

  [[nodiscard]] auto credential_secret() -> std::optional<std::string>;

  [[nodiscard]] auto store_dir() -> std::string_view { return store_dir_; }

  auto keepalive(uint32_t duration) -> Config& {
    this->keepalive_ = duration;
    return *this;
  }

  auto ignore_ssl_errors() -> Config& {
    this->ignore_ssl_ = true;
    return *this;
  }

  auto connection_timeout(uint32_t duration) -> Config& {
    this->conn_timeout_ = duration;
    return *this;
  }

  auto disconnection_timeout(std::chrono::milliseconds duration) -> Config& {
    this->disconn_timeout_ = duration;
    return *this;
  }

  [[nodiscard]] auto keepalive() const -> uint32_t { return keepalive_; }

  [[nodiscard]] auto connection_timeout() const -> uint32_t { return conn_timeout_; }

  [[nodiscard]] auto disconnection_timeout() const -> std::chrono::milliseconds {
    return disconn_timeout_;
  }
 
 private:
  Config(std::string_view realm, std::string_view device_id, std::unique_ptr<Credential> credential,
         std::string_view pairing_url, std::string_view store_dir);
 
  std::string realm_;
  std::string device_id_;
  std::string pairing_url_;
  std::unique_ptr<Credential> credential_;
  std::string store_dir_;
  bool ignore_ssl_{false};
  uint32_t keepalive_;
  uint32_t conn_timeout_;
  std::chrono::milliseconds disconn_timeout_;
};
 
}  // namespace astarte::device::mqtt
 
#endif  // ASTARTE_MQTT_CONFIG_H