Connection.cc

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#include "Connection.h"
 
#include "Exception.h"
 
#include <utility>
namespace ChimeraTK::Rebot {
 
  using Error = boost::system::error_code;
 
  Connection::Connection(std::string address, std::string port, uint32_t connectionTimeout_sec)
  : address_(std::move(address)), port_(std::move(port)), s_(ioContext_), disconnectTimer_(ioContext_),
    connectionTimeout_(boost::posix_time::seconds(connectionTimeout_sec)) {}
 
  void Connection::open() {
    try {
      disconnectionTimerStart();
      boost::asio::ip::tcp::resolver r(ioContext_);
      boost::asio::async_connect(
          s_, r.resolve(address_, port_), [&](const Error ec, auto) { disconnectionTimerCancel(ec); });
 
      ioContext_.restart();
      ioContext_.run();
    }
    catch(const boost::exception&) {
      throw ChimeraTK::runtime_error("RebotBackend exception: Host unreachable:");
    }
  }
 
  std::vector<uint32_t> Connection::read(uint32_t numWords) {
    std::vector<uint32_t> d(numWords);
    disconnectionTimerStart();
    boost::asio::async_read(s_, boost::asio::buffer(d), [&](Error ec, std::size_t) { disconnectionTimerCancel(ec); });
 
    ioContext_.restart();
    ioContext_.run();
    return d;
  }
 
  void Connection::write(const std::vector<uint32_t>& d) {
    disconnectionTimerStart();
    boost::asio::async_write(s_, boost::asio::buffer(d), [&](Error ec, std::size_t) { disconnectionTimerCancel(ec); });
 
    ioContext_.restart();
    ioContext_.run();
  }
 
  void Connection::close() {
    std::unique_lock lock{_closeMutex, std::defer_lock};
    if(!lock.try_lock()) {
      // Mutex already taken! Another thread is handling the close. Returning immediately.
      return;
    }
 
    if(s_.is_open()) {
      s_.cancel();
      s_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
      s_.close();
    }
  }
 
  bool Connection::isOpen() {
    return s_.is_open();
  }
 
  void Connection::disconnectionTimerStart() {
    disconnectTimer_.expires_from_now(connectionTimeout_);
    disconnectTimer_.async_wait([&](const Error& ec) {
      if(ec == boost::asio::error::operation_aborted) {
        // you have this error code when the timer was cancelled before expiry
        return;
      }
      close();
    });
  }
 
  void Connection::disconnectionTimerCancel(const Error& ec) {
    disconnectTimer_.cancel();
    if(ec) {
      close();
      throw ChimeraTK::runtime_error("Rebot connection timed out");
    }
  }
 
} // namespace ChimeraTK::Rebot