node.h

// Copyright The SOLA Contributors
//
// Licensed under the MIT License.
// For details on the licensing terms, see the LICENSE file.
// SPDX-License-Identifier: MIT
 
#ifndef MINHTON_CORE_NODE_H_
#define MINHTON_CORE_NODE_H_
 
#include <chrono>
#include <future>
#include <memory>
#include <thread>
#include <vector>
 
#include "minhton/algorithms/esearch/find_query.h"
#include "minhton/core/connection_info.h"
#include "minhton/core/definitions.h"
#include "minhton/core/logic_container.h"
#include "minhton/core/node_info.h"
#include "minhton/core/routing_information.h"
#include "minhton/core/watchdog.h"
#include "minhton/logging/logging.h"
#include "minhton/message/message.h"
#include "minhton/message/types_all.h"
#include "minhton/network/network_facade.h"
#include "minhton/utils/config_node.h"
#include "minhton/utils/fsm.h"
#include "minhton/utils/procedure_info.h"
 
namespace minhton {
 
// Low level
class MinhtonNode {
public:
  explicit MinhtonNode(const ConfigNode &config_node,
                       NeighborCallbackFct fct = NeighborCallbackFct{}, bool auto_start = true);
 
  void setConfig(const minhton::ConfigNode &config);
 
  void stop();
 
  virtual ~MinhtonNode() = default;
 
  minhton::NodeInfo getNodeInfo() const;
 
  void processSignal(Signal signal);
 
  void initFSM(minhton::FSMState &init_state);
 
  FSMState getFsmState() const;
 
  std::shared_ptr<minhton::RoutingInformation> getRoutingInformation();
 
  void insert(const std::vector<Entry> &data);
  void update(const std::vector<Entry> &data);
  void remove(const std::vector<std::string> &keys);
 
  std::future<FindResult> find(const std::string &query);  // for high level api
  std::future<FindResult> find(const FindQuery &query);    // for testing
 
  // if we expose this, we dont need to expose the logic container!
  void performSearchExactTest(const minhton::NodeInfo &destination,
                              std::shared_ptr<minhton::MessageSEVariant> query);
 
  // For debugging and testing purposes
  std::shared_ptr<AccessContainer> getAccessContainer() const { return access_; };
 
private:
  void send(const MessageVariant &msg);
 
  void prepareSending(const MessageVariant &msg_variant);
 
  void triggerTimeout(const TimeoutType &timeout_type);
 
  void recv(const MessageVariant &msg);
 
  bool prepareReceiving(const MessageVariant &msg_variant);
 
  void start(const JoinInfo &info, bool auto_connect = false);
 
  std::shared_ptr<AccessContainer> access_;
 
  NetworkFacade network_facade_;
 
  std::shared_ptr<minhton::ProcedureInfo> procedure_info_;
 
  bool verbose_ = true;
 
  TimeoutLengthsContainer timeout_lengths_container_{};
 
  uint16_t getTimeoutLength(const TimeoutType &timeout_type) const;
 
  void setTimeout(TimeoutType timeout_type);
 
  minhton::core::WatchDog watchdog_;
 
  std::shared_ptr<minhton::RoutingInformation> routing_info_;
 
  minhton::FiniteStateMachine fsm_;
 
  std::unique_ptr<LogicContainer> logic_;
 
  NeighborCallbackFct neighbor_update_fct_;
 
  NodeInfo replacing_node_;
};
}  // namespace minhton
 
#endif