leave_algorithm_general.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_ALGORITHMS_LEAVE_ALGORITHM_GENERAL_H_
#define MINHTON_ALGORITHMS_LEAVE_ALGORITHM_GENERAL_H_
 
#include <memory>
#include <optional>
 
#include "minhton/algorithms/leave/interface_leave_algorithm.h"
#include "minhton/message/find_replacement.h"
#include "minhton/message/lock_neighbor_request.h"
#include "minhton/message/lock_neighbor_response.h"
#include "minhton/message/message.h"
#include "minhton/message/remove_neighbor.h"
#include "minhton/message/remove_neighbor_ack.h"
#include "minhton/message/replacement_ack.h"
#include "minhton/message/replacement_nack.h"
#include "minhton/message/replacement_offer.h"
#include "minhton/message/replacement_update.h"
#include "minhton/message/signoff_parent_answer.h"
#include "minhton/message/signoff_parent_request.h"
#include "minhton/message/unlock_neighbor.h"
#include "minhton/message/update_neighbors.h"
 
namespace minhton {
 
class LeaveAlgorithmGeneral : public LeaveAlgorithmInterface {
public:
  explicit LeaveAlgorithmGeneral(std::shared_ptr<AccessContainer> access)
      : LeaveAlgorithmInterface(access){};
 
  ~LeaveAlgorithmGeneral() override = default;
 
  void process(const MessageVariant &msg) override;
 
  void initiateSelfDeparture() override = 0;
 
protected:
  virtual void processFindReplacement(const minhton::MessageFindReplacement &message) = 0;
 
  void processReplacementOffer(const minhton::MessageReplacementOffer &message);
 
  void processSignOffParentRequest(const minhton::MessageSignoffParentRequest &message);
 
  void processSignOffParentAnswer(const minhton::MessageSignoffParentAnswer &message);
 
  void processReplacementAck(const minhton::MessageReplacementAck &message);
 
  void processLockNeighborRequest(const minhton::MessageLockNeighborRequest &message);
 
  void processLockNeighborResponse(const minhton::MessageLockNeighborResponse &message);
 
  void processRemoveNeighborAck();
 
  void processReplacementUpdate(const minhton::MessageReplacementUpdate &message);
 
  void performLeaveWithoutReplacement();
 
  void performLeaveWithReplacement(minhton::NodeInfo leaving_node,
                                   std::vector<minhton::NodeInfo> neighbors_of_leaving_node,
                                   bool leaving_node_was_locked, bool leaving_node_locked_right,
                                   bool leaving_node_locked_left);
 
  void prepareLeavingAsSuccessor(const minhton::NodeInfo &node_to_replace);
 
  void signOffFromParent();
 
  uint32_t signOffFromNeighborsAndAdjacents();
 
  void processUpdateForwardAck();
 
  void sendReplacementOffer();
 
  void sendNackToReplacement(uint64_t ref_event_id);
 
  void replaceMyself(const minhton::NodeInfo &node_to_replace,
                     std::vector<minhton::NodeInfo> neighbors_of_node_to_replace) override;
 
  void processReceiveSignoffNeighborAdjacentsAck();
 
  void processReceiveReplacementUpdateAck();
 
  void processUnlockNeighbor(const MessageUnlockNeighbor &msg);
 
  // TODO Temporary
  minhton::NodeInfo replacing_node_;
  uint64_t leaving_event_id_ = 0;
  bool in_leave_progress_ = false;
  bool locked_right_neighbor_ = false;
  bool locked_left_neighbor_ = false;
  uint32_t remaining_lock_neighbor_response_ = 0;
  std::shared_ptr<minhton::MessageSignoffParentRequest> current_signoff_request_ = nullptr;
 
  std::shared_ptr<minhton::MessageReplacementUpdate> last_replacement_update_ = nullptr;
  NodeInfo old_parent_;
 
  static minhton::NodeInfo getAdjacentLeftFromVector(const minhton::NodeInfo &considered_node,
                                                     std::vector<minhton::NodeInfo> neighbors);
 
  static minhton::NodeInfo getAdjacentRightFromVector(const minhton::NodeInfo &considered_node,
                                                      std::vector<minhton::NodeInfo> neighbors);
};
 
}  // namespace minhton
 
#endif