tcp_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 "boost-support/client/tcp/tcp_client.h"
 
#include <variant>
 
#include "boost-support/common/logger.h"
#include "boost-support/connection/tcp/tcp_connection.h"
#include "boost-support/error_domain/boost_support_error_domain.h"
#include "boost-support/socket/io_context.h"
#include "boost-support/socket/tcp/tcp_socket.h"
#include "boost-support/socket/tls/tls_socket.h"
#include "core/include/variant_helper.h"
 
namespace boost_support {
namespace client {
namespace tcp {
namespace {
std::string AppendIpAddressAndPort(std::string_view client_name, std::string_view ip_address,
                                   std::uint16_t port_num) {
  std::string connection_name{client_name};
  connection_name.append("_");
  connection_name.append(ip_address);
  connection_name.append("_");
  connection_name.append(std::to_string(port_num));
  return connection_name;
}
}  // namespace
 
class TcpClient::TcpClientImpl final {
 private:
  using TcpConnection = connection::tcp::TcpConnection<connection::tcp::ConnectionType::kClient,
                                                       socket::tcp::TcpSocket>;
 
  enum class State : std::uint8_t {
    kConnected = 0U,   
    kDisconnected = 1U 
  };
 
  using IoContext = boost_support::socket::IoContext;
 
 public:
  TcpClientImpl(std::string_view client_name, std::string_view local_ip_address,
                std::uint16_t local_port_num) noexcept
      : io_context_{},
        connection_state_{State::kDisconnected},
        client_name_{AppendIpAddressAndPort(client_name, local_ip_address, local_port_num)},
        tcp_connection_{client_name,
                        socket::tcp::TcpSocket{local_ip_address, local_port_num, io_context_}} {}
 
  TcpClientImpl(const TcpClientImpl &other) noexcept = delete;
  TcpClientImpl &operator=(const TcpClientImpl &other) noexcept = delete;
 
  TcpClientImpl(TcpClientImpl &&other) noexcept = delete;
  TcpClientImpl &operator=(TcpClientImpl &&other) noexcept = delete;
 
  ~TcpClientImpl() noexcept = default;
 
  void Initialize() noexcept { tcp_connection_.Initialize(); }
 
  void DeInitialize() noexcept { tcp_connection_.DeInitialize(); }
 
  void SetReadHandler(HandlerRead read_handler) noexcept {
    tcp_connection_.SetReadHandler(std::move(read_handler));
  }
 
  core_type::Result<void> ConnectToHost(std::string_view host_ip_address,
                                        std::uint16_t host_port_num) {
    core_type::Result<void> result{
        error_domain::MakeErrorCode(error_domain::BoostSupportErrorErrc::kSocketError)};
    if (connection_state_.load(std::memory_order_seq_cst) != State::kConnected) {
      if (tcp_connection_.ConnectToHost(host_ip_address, host_port_num)) {
        connection_state_.store(State::kConnected, std::memory_order_seq_cst);
        result.EmplaceValue();
      }  // else, connect failed
    } else {
      // already connected
      result.EmplaceValue();
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogVerbose(
          FILE_NAME, __LINE__, __func__,
          [](std::stringstream &msg) { msg << "Tcp client is already connected"; });
    }
    return result;
  }
 
  core_type::Result<void> DisconnectFromHost() {
    core_type::Result<void> result{
        error_domain::MakeErrorCode(error_domain::BoostSupportErrorErrc::kSocketError)};
    if (connection_state_.load(std::memory_order_seq_cst) == State::kConnected) {
      tcp_connection_.DisconnectFromHost();
      connection_state_.store(State::kDisconnected, std::memory_order_seq_cst);
      result.EmplaceValue();
    } else {
      // Not connected
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogDebug(
          FILE_NAME, __LINE__, __func__,
          [](std::stringstream &msg) { msg << "Tcp client is in disconnected state"; });
    }
    return result;
  }
 
  auto IsConnectedToHost() const noexcept -> bool {
    return (connection_state_.load(std::memory_order_seq_cst) == State::kConnected);
  }
 
  core_type::Result<void> Transmit(MessageConstPtr tcp_message) {
    core_type::Result<void> result{
        error_domain::MakeErrorCode(error_domain::BoostSupportErrorErrc::kGenericError)};
    if (connection_state_.load(std::memory_order_seq_cst) == State::kConnected) {
      if (tcp_connection_.Transmit(std::move(tcp_message))) { result.EmplaceValue(); }
    } else {
      // not connected
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogError(
          FILE_NAME, __LINE__, __func__, [](std::stringstream &msg) {
            msg << "Tcp client is Offline, please connect to server first";
          });
    }
    return result;
  }
 
 private:
  IoContext io_context_;
 
  std::atomic<State> connection_state_;
 
  std::string client_name_;
 
  TcpConnection tcp_connection_;
};
 
TcpClient::TcpClient(std::string_view client_name, std::string_view local_ip_address,
                     std::uint16_t local_port_num) noexcept
    : tcp_client_impl_{
          std::make_unique<TcpClientImpl>(client_name, local_ip_address, local_port_num)} {}
 
TcpClient::TcpClient(TcpClient &&other) noexcept = default;
 
TcpClient &TcpClient::operator=(TcpClient &&other) noexcept = default;
 
TcpClient::~TcpClient() noexcept = default;
 
void TcpClient::Initialize() noexcept { tcp_client_impl_->Initialize(); }
 
void TcpClient::DeInitialize() noexcept { tcp_client_impl_->DeInitialize(); }
 
void TcpClient::SetReadHandler(TcpClient::HandlerRead read_handler) noexcept {
  tcp_client_impl_->SetReadHandler(std::move(read_handler));
}
 
core_type::Result<void> TcpClient::ConnectToHost(std::string_view host_ip_address,
                                                 std::uint16_t host_port_num) {
  return tcp_client_impl_->ConnectToHost(host_ip_address, host_port_num);
}
 
core_type::Result<void> TcpClient::DisconnectFromHost() {
  return tcp_client_impl_->DisconnectFromHost();
}
 
auto TcpClient::IsConnectedToHost() const noexcept -> bool {
  return tcp_client_impl_->IsConnectedToHost();
}
 
core_type::Result<void> TcpClient::Transmit(MessageConstPtr tcp_message) {
  return tcp_client_impl_->Transmit(std::move(tcp_message));
}
 
}  // namespace tcp
}  // namespace client
}  // namespace boost_support