diagnostic_client.cpp

Go to the documentation of this file.

/* Diagnostic Client library
 * Copyright (C) 2024  Avijit Dey
 * 
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#include "include/diagnostic_client.h"
 
#include <pthread.h>
 
#include <memory>
#include <string>
#include <thread>
 
#include "core/include/result.h"
#include "parser/json_parser.h"
#include "src/common/diagnostic_manager.h"
#include "src/common/logger.h"
#include "src/dcm/dcm_client.h"
#include "src/dcm/error_domain/dm_error_domain.h"
 
namespace diag {
namespace client {
 
class DiagClient::DiagClientImpl final {
 public:
  explicit DiagClientImpl(std::string_view diag_client_config_path) noexcept
      : dcm_instance_{},
        dcm_thread_{},
        diag_client_config_path_{diag_client_config_path} {}
 
  DiagClientImpl(const DiagClientImpl &other) noexcept = delete;
  DiagClientImpl &operator=(const DiagClientImpl &other) noexcept = delete;
 
  DiagClientImpl(DiagClientImpl &&other) noexcept = delete;
  DiagClientImpl &operator=(DiagClientImpl &&other) noexcept = delete;
 
  ~DiagClientImpl() noexcept = default;
 
  Result<void> Initialize() noexcept {
    logger::DiagClientLogger::GetDiagClientLogger().GetLogger().LogInfo(
        __FILE__, __LINE__, __func__, [](std::stringstream &msg) { msg << "DiagClient Initialization started"; });
 
    // read configuration
    boost_support::parser::boost_tree config{};
    return boost_support::parser::Read(diag_client_config_path_, config)
        .MapError([](boost_support::parser::ParsingErrorCode const &) noexcept {
          logger::DiagClientLogger::GetDiagClientLogger().GetLogger().LogError(
              __FILE__, __LINE__, "", [](std::stringstream &msg) { msg << "DiagClient Initialization failed"; });
          return error_domain::MakeErrorCode(error_domain::DmErrorErrc::kInitializationFailed);
        })
        .AndThen([this, &config]() {
          // create single dcm instance and pass the configuration
          dcm_instance_ = std::make_unique<diag::client::dcm::DCMClient>(config_parser::ReadDcmClientConfig(config));
          // start dcm client thread
          dcm_thread_ = std::thread([this]() noexcept { this->dcm_instance_->Main(); });
          pthread_setname_np(dcm_thread_.native_handle(), "dcm_client");
          logger::DiagClientLogger::GetDiagClientLogger().GetLogger().LogInfo(
              __FILE__, __LINE__, "", [](std::stringstream &msg) { msg << "DiagClient Initialization completed"; });
        });
  }
 
  Result<void> DeInitialize() noexcept {
    logger::DiagClientLogger::GetDiagClientLogger().GetLogger().LogInfo(
        __FILE__, __LINE__, __func__, [](std::stringstream &msg) { msg << "DiagClient De-Initialization started"; });
    // shutdown DCM module here
    return dcm_instance_->SignalShutdown()
        .AndThen([this]() {
          if (dcm_thread_.joinable()) { dcm_thread_.join(); }
          logger::DiagClientLogger::GetDiagClientLogger().GetLogger().LogInfo(
              __FILE__, __LINE__, "", [](std::stringstream &msg) { msg << "DiagClient De-Initialization completed"; });
        })
        .OrElse([](core_type::ErrorCode const &) {
          return error_domain::MakeErrorCode(error_domain::DmErrorErrc::kDeInitializationFailed);
        });
  }
 
  conversation::DiagClientConversation GetDiagnosticClientConversation(std::string_view conversation_name) noexcept {
    if (!dcm_instance_) {
      logger::DiagClientLogger::GetDiagClientLogger().GetLogger().LogFatal(
          __FILE__, __LINE__, "", [](std::stringstream &msg) { msg << "DiagClient is not Initialized"; });
    }
    return dcm_instance_->GetDiagnosticClientConversation(conversation_name);
  }
 
  Result<vehicle_info::VehicleInfoMessageResponseUniquePtr, DiagClient::VehicleInfoResponseError>
  SendVehicleIdentificationRequest(
      diag::client::vehicle_info::VehicleInfoListRequestType vehicle_info_request) noexcept {
    if (!dcm_instance_) {
      logger::DiagClientLogger::GetDiagClientLogger().GetLogger().LogFatal(
          __FILE__, __LINE__, "", [](std::stringstream &msg) { msg << "DiagClient is not Initialized"; });
    }
    return dcm_instance_->SendVehicleIdentificationRequest(std::move(vehicle_info_request));
  }
 
 private:
  std::unique_ptr<diag::client::common::DiagnosticManager> dcm_instance_;
 
  std::thread dcm_thread_;
 
  std::string diag_client_config_path_;
};
 
DiagClient::DiagClient(std::string_view diag_client_config_path) noexcept
    : diag_client_impl_{std::make_unique<DiagClientImpl>(diag_client_config_path)} {}
 
DiagClient::~DiagClient() noexcept = default;
 
Result<void> DiagClient::Initialize() noexcept { return diag_client_impl_->Initialize(); }
 
Result<void> DiagClient::DeInitialize() noexcept { return diag_client_impl_->DeInitialize(); }
 
Result<vehicle_info::VehicleInfoMessageResponseUniquePtr, DiagClient::VehicleInfoResponseError>
DiagClient::SendVehicleIdentificationRequest(
    diag::client::vehicle_info::VehicleInfoListRequestType vehicle_info_request) noexcept {
  return diag_client_impl_->SendVehicleIdentificationRequest(std::move(vehicle_info_request));
}
 
conversation::DiagClientConversation DiagClient::GetDiagnosticClientConversation(
    std::string_view conversation_name) noexcept {
  return diag_client_impl_->GetDiagnosticClientConversation(conversation_name);
}
 
std::unique_ptr<DiagClient> CreateDiagnosticClient(std::string_view diag_client_config_path) {
  return (std::make_unique<DiagClient>(diag_client_config_path));
}
 
}  // namespace client
}  // namespace diag