include/sen/kernel/transport.h

Go to the documentation of this file.

// === transport.h =====================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_KERNEL_TRANSPORT_H
#define SEN_KERNEL_TRANSPORT_H
 
// sen
#include "sen/core/base/class_helpers.h"
#include "sen/core/base/compiler_macros.h"
#include "sen/core/base/memory_block.h"
#include "sen/core/base/move_only_function.h"
#include "sen/core/base/numbers.h"
#include "sen/core/base/span.h"
#include "sen/core/base/strong_type.h"
#include "sen/core/io/output_stream.h"
#include "sen/core/obj/object_provider.h"
#include "sen/kernel/tracer.h"
 
// generated code
#include "stl/sen/kernel/basic_types.stl.h"
 
// std
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>

SEN_STRONG_TYPE(TimerId, uint64_t)
SEN_STRONG_TYPE_HASHABLE(TimerId)
 
namespace sen::kernel
{
 
SEN_STRONG_TYPE(ProcessId, uint32_t)
 
struct BusId: public StrongType<uint32_t, BusId>
{
  using Base = StrongType<uint32_t, BusId>;
  using Base::Base;
  using Base::ValueType;
 
  void* userData = nullptr;  
};

struct ParticipantAddr
{
  ProcessId proc;
  ObjectOwnerId id;
 
  void* userData = nullptr;  
};
 
[[nodiscard]] bool operator==(const ParticipantAddr& lhs, const ParticipantAddr& rhs) noexcept;
[[nodiscard]] bool operator!=(const ParticipantAddr& lhs, const ParticipantAddr& rhs) noexcept;

constexpr std::size_t maxBestEffortMessageSize = 65527U;

using BestEffortBlockPtr = std::shared_ptr<FixedMemoryBlock>;

using ReliableBlockPtr = std::shared_ptr<ResizableHeapBlock>;

using BestEffortBufferList = std::vector<BestEffortBlockPtr>;

[[nodiscard]] uint32_t getKernelProtocolVersion() noexcept;
 
class UniqueByteBufferManagerImpl;
 
class UniqueByteBufferManager final
{
  SEN_MOVE_ONLY(UniqueByteBufferManager)
  using BufferType = std::vector<uint8_t>;
 
public:
  using ByteBufferHandle = std::unique_ptr<BufferType, sen::std_util::move_only_function<void(BufferType*)>>;
 
  UniqueByteBufferManager();
  ~UniqueByteBufferManager();

  ByteBufferHandle getBuffer(size_t size);
 
private:
  std::unique_ptr<UniqueByteBufferManagerImpl> pImpl_;
};

class TransportListener
{
  SEN_NOCOPY_NOMOVE(TransportListener)
 
public:  // special members
  TransportListener() = default;
  virtual ~TransportListener() = default;
 
public:
  using ByteBufferManager = UniqueByteBufferManager;
  using ByteBufferHandle = ByteBufferManager::ByteBufferHandle;

  virtual ByteBufferManager& getBufferManager() = 0;
 
public:
  virtual void remoteProcessLost(ProcessId who) = 0;

  virtual void remoteParticipantJoinedBus(ParticipantAddr addr,
                                          const ProcessInfo& processInfo,
                                          BusId bus,
                                          std::string busName) = 0;

  virtual void remoteParticipantLeftBus(ParticipantAddr addr, BusId bus, std::string busName) = 0;

  virtual void remoteBroadcastMessageReceived(BusId busId, Span<const uint8_t> msg, ByteBufferHandle buffer) = 0;

  virtual void remoteMessageReceived(ObjectOwnerId to,
                                     BusId busId,
                                     Span<const uint8_t> msg,
                                     ByteBufferHandle buffer,
                                     bool ensureNotDropped) = 0;
};

struct TransportStats
{
  std::size_t udpSentBytes = 0;
  std::size_t udpReceivedBytes = 0;
  std::size_t tcpSentBytes = 0;
  std::size_t tcpReceivedBytes = 0;
};

class Transport
{
  SEN_NOCOPY_NOMOVE(Transport)
 
public:
  explicit Transport(std::string_view sessionName);
  virtual ~Transport() = default;
 
public:
  virtual void start(TransportListener* listener) = 0;

  virtual void sendTo(ParticipantAddr& to, BusId& busId, TransportMode mode, MemBlockPtr data) = 0;

  virtual void sendTo(ParticipantAddr& to, BusId& busId, TransportMode mode, MemBlockPtr data1, MemBlockPtr data2) = 0;

  virtual void localParticipantJoinedBus(ObjectOwnerId participant, BusId bus, const std::string& busName) = 0;

  virtual void localParticipantLeftBus(ObjectOwnerId participant, BusId bus, const std::string& busName) = 0;

  [[nodiscard]] virtual const ProcessInfo& getOwnInfo() const noexcept = 0;

  virtual void stop() noexcept = 0;
 
  virtual void stopIO() noexcept {}

  [[nodiscard]] virtual TransportStats fetchStats() const = 0;
 
public:  // timers
  virtual TimerId startTimer(std::chrono::steady_clock::duration timeout, std::function<void()>&& timeoutCallback) = 0;

  virtual bool cancelTimer(TimerId id) = 0;
 
private:
  std::string name_;
};

using TransportFactory = std::function<std::unique_ptr<Transport>(const std::string&, std::unique_ptr<Tracer> tracer)>;

}  // namespace sen::kernel
 
namespace sen
{
template <>
struct ShouldBePassedByValue<kernel::ProcessId>: std::true_type
{
};
 
template <>
struct ShouldBePassedByValue<kernel::BusId>: std::true_type
{
};
}  // namespace sen
 
SEN_STRONG_TYPE_HASHABLE(sen::kernel::BusId)
 
SEN_STRONG_TYPE_HASHABLE(sen::kernel::ProcessId)
 
//----------------------------------------------------------------------------------------------------------------------
// Inline implementation
//----------------------------------------------------------------------------------------------------------------------
 
template <>
struct std::hash<sen::kernel::ParticipantAddr>
{
  template <class T>
  void hashCombine(std::size_t& seed, const T& v) const noexcept
  {
    std::hash<T> hasher;
    seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);  // NOLINT
  }
 
  std::size_t operator()(const sen::kernel::ParticipantAddr& val) const noexcept
  {
    std::size_t seed = 150783;  // NOLINT(readability-magic-numbers)
    hashCombine(seed, val.proc);
    hashCombine(seed, val.id);
    return seed;
  }
};
 
#endif  // SEN_KERNEL_TRANSPORT_H