taraxa_peer.hpp

Go to the documentation of this file.

#pragma once
 
#include <libp2p/Common.h>
 
#include <atomic>
#include <boost/noncopyable.hpp>
 
#include "common/types.hpp"
#include "common/util.hpp"
#include "network/tarcap/stats/packets_stats.hpp"
 
namespace taraxa::network::tarcap {
 
class TaraxaPeer : public boost::noncopyable {
 public:
  TaraxaPeer();
  TaraxaPeer(const dev::p2p::NodeID& id, size_t transaction_pool_size, std::string address);
 
  bool markDagBlockAsKnown(const blk_hash_t& hash);
  bool isDagBlockKnown(const blk_hash_t& hash) const;
 
  bool markTransactionAsKnown(const trx_hash_t& hash);
  bool isTransactionKnown(const trx_hash_t& hash) const;
 
  bool markPbftVoteAsKnown(const vote_hash_t& hash);
  bool isPbftVoteKnown(const vote_hash_t& hash) const;
 
  bool markPbftBlockAsKnown(const blk_hash_t& hash);
  bool isPbftBlockKnown(const blk_hash_t& hash) const;
 
  bool markPillarVoteAsKnown(const vote_hash_t& hash);
  bool isPillarVoteKnown(const vote_hash_t& hash) const;
 
  const dev::p2p::NodeID& getId() const;
 
  bool reportSuspiciousPacket();
 
  bool dagSyncingAllowed() const;
 
  bool requestDagSyncingAllowed() const;
 
  void addSentPacket(const std::string& packet_type, const PacketStats& packet);
 
  std::pair<std::chrono::system_clock::time_point, PacketStats> getAllPacketsStatsCopy() const;
 
  void resetPacketsStats();
 
  void resetKnownCaches();
 
 public:
  std::atomic<bool> syncing_ = false;
  std::atomic<uint64_t> dag_level_ = 0;
  std::atomic<PbftPeriod> pbft_chain_size_ = 0;
  std::atomic<PbftPeriod> pbft_period_ = pbft_chain_size_ = 1;
  std::atomic<PbftRound> pbft_round_ = 1;
  std::atomic<PbftPeriod> last_status_pbft_chain_size_ = 0;
  std::atomic_bool peer_dag_synced_ = false;
  std::atomic_uint64_t peer_dag_synced_time_ = 0;
  std::atomic_bool peer_dag_syncing_ = false;
  std::atomic_bool peer_requested_dag_syncing_ = false;
  std::atomic_uint64_t peer_requested_dag_syncing_time_ = 0;
  std::atomic_bool peer_light_node = false;
  std::atomic<PbftPeriod> peer_light_node_history = 0;
  std::string address_;
 
  // Mutex used to prevent race condition between dag syncing and gossiping
  mutable boost::shared_mutex mutex_for_sending_dag_blocks_;
 
 private:
  dev::p2p::NodeID id_;
 
  ExpirationBlockNumberCache<blk_hash_t> known_dag_blocks_;
  ExpirationBlockNumberCache<trx_hash_t> known_transactions_;
  // PBFT
  ExpirationBlockNumberCache<blk_hash_t> known_pbft_blocks_;
  ExpirationBlockNumberCache<vote_hash_t> known_votes_;  // both pbft & pillar votes
 
  std::atomic<uint64_t> timestamp_suspicious_packet_ = 0;
  std::atomic<uint64_t> suspicious_packet_count_ = 0;
  const uint64_t kMaxSuspiciousPacketPerMinute = 50000;
 
  // Performance extensive dag syncing is only allowed to be requested once each kDagSyncingLimit seconds
  const uint64_t kDagSyncingLimit = 60;
 
  // Packets stats for packets sent by *this TaraxaPeer
  PacketsStats sent_packets_stats_;
};
 
}  // namespace taraxa::network::tarcap