dsn_handler.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 ALGORITHMS_ESEARCH_DSN_HANDLER_H_
#define ALGORITHMS_ESEARCH_DSN_HANDLER_H_
 
#include <memory>
#include <queue>
#include <unordered_map>
#include <vector>
 
#include "minhton/algorithms/esearch/distributed_data.h"
#include "minhton/algorithms/esearch/find_query.h"
#include "minhton/core/routing_information.h"
 
namespace minhton {
 
class DSNHandler {
public:
  DSNHandler(std::shared_ptr<RoutingInformation> routing_info,
             std::function<void(const NodeInfo &node)> request_attribute_inquiry_callback);
 
  bool isActive();
 
  std::vector<std::tuple<NodeInfo, std::vector<NodeData::Key>>> getUndecidedNodesAndMissingKeys(
      FindQuery &query, bool all_information_present, const uint64_t &timestamp_now);
 
  std::vector<NodeInfo> getTrueNodes(FindQuery &query, const uint64_t &timestamp_now);
 
  void onNeighborChangeNotification(const minhton::NodeInfo &neighbor,
                                    NeighborRelationship relationship);
 
  void onNodeInfoChangeNotification(const minhton::NodeInfo &previous_node_info,
                                    const minhton::NodeInfo &new_node_info);
 
  void requestAttributeInformation(LogicalNodeInfo peer, const DistributedData &distr_data);
 
  void updateInquiredOrSubscribedAttributeValues(
      const NodeInfo &inquired_or_updated_node,
      std::unordered_map<NodeData::Key, NodeData::ValueAndType> attribute_values_and_types,
      uint64_t update_timestamp);
 
  // TODO unit tests
  void updateRemovedAttributes(const NodeInfo &inquired_node,
                               std::vector<NodeData::Key> removed_keys);
 
  std::unordered_map<LogicalNodeInfo, DistributedData, LogicalNodeInfoHasher> getCoverData() const;
 
  // TODO unit tests
  void notifyAboutQueryRequest(const FindQuery &query, uint64_t request_timestamp);
 
  // LATER unit tests
  std::unordered_map<NodeInfo, std::vector<NodeData::Key>, NodeInfoHasher>
  getNodesAndKeysToSubscribe(uint64_t const &timestamp_now);
 
  // LATER unit tests
  std::unordered_map<NodeInfo, std::vector<NodeData::Key>, NodeInfoHasher>
  getNodesAndKeysToUnsubscribe(uint64_t const &timestamp_now);
 
  // TODO unit tests
  void setPlacedSubscriptionOrders(
      std::unordered_map<NodeInfo, std::vector<NodeData::Key>, NodeInfoHasher>
          subscription_orders_map);
 
  // TODO unit tests
  void setPlacedUnsubscriptionOrders(
      std::unordered_map<NodeInfo, std::vector<NodeData::Key>, NodeInfoHasher>
          unsubscription_orders_map);
 
  NodeData::Attributes getNodeAttributes(const NodeInfo &node);
 
private:
  void checkPosition();
 
  void buildCoverArea();
 
  void buildExtendedCoverArea();
 
  void buildTempCoverArea();
 
  bool is_active_;
 
  bool was_previously_active_ = false;
 
  NodeInfo previous_node_info_;
 
  std::shared_ptr<RoutingInformation> routing_info_;
 
  std::unordered_map<LogicalNodeInfo, DistributedData, LogicalNodeInfoHasher> cover_data_;
 
  std::vector<std::tuple<uint32_t, uint32_t>> cover_area_positions_;
 
  std::vector<std::tuple<uint32_t, uint32_t>> extended_cover_area_positions_;
  std::unordered_map<LogicalNodeInfo, DistributedData, LogicalNodeInfoHasher> extended_cover_data_;
 
  std::unordered_map<NodeData::Key, std::queue<uint64_t>> request_timestamps_;
 
  uint8_t timestamp_storage_limit_ = 5;
 
  std::function<void(const NodeInfo &)> request_attribute_inquiry_callback_;
 
  static double calculateFrequency(std::queue<uint64_t> timestamps, uint64_t const &timestamp_now);
};
 
}  // namespace minhton
 
#endif