consensus.h

Go to the documentation of this file.

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
 
#include <ascii-chat/network/acip/acds_sizes.h>
#include <ascii-chat/crypto/sizes.h>
#include <ascii-chat/common.h>
 
#pragma once
 
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/network/consensus/metrics.h>
#include <stdint.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct session_consensus session_consensus_t;

typedef asciichat_error_t (*session_consensus_send_packet_fn)(void *context,
                                                              const uint8_t next_participant_id[SESSION_ID_SIZE],
                                                              const uint8_t *packet, size_t packet_size);

typedef asciichat_error_t (*session_consensus_on_election_fn)(void *context, const uint8_t host_id[SESSION_ID_SIZE],
                                                              const char host_address[ACIP_ADDRESS_SIZE],
                                                              uint16_t host_port,
                                                              const uint8_t backup_id[SESSION_ID_SIZE],
                                                              const char backup_address[ACIP_ADDRESS_SIZE],
                                                              uint16_t backup_port);

typedef asciichat_error_t (*session_consensus_get_metrics_fn)(void *context, const uint8_t my_id[SESSION_ID_SIZE],
                                                              participant_metrics_t *out_metrics);

typedef asciichat_error_t (*session_consensus_election_fn)(void *context, const participant_metrics_t *metrics,
                                                           int num_metrics, int *out_best_index, int *out_backup_index);

typedef struct {
  session_consensus_send_packet_fn send_packet; 
  session_consensus_on_election_fn on_election; 
  session_consensus_get_metrics_fn get_metrics; 
  session_consensus_election_fn election;       
  void *context;                                
} session_consensus_callbacks_t;

asciichat_error_t session_consensus_create(const uint8_t my_id[SESSION_ID_SIZE], bool is_leader,
                                           const uint8_t participant_ids[MAX_SESSION_PARTICIPANTS][SESSION_ID_SIZE],
                                           int num_participants, const session_consensus_callbacks_t *callbacks,
                                           session_consensus_t **out_consensus);

void session_consensus_destroy(session_consensus_t *consensus);

asciichat_error_t session_consensus_process(session_consensus_t *consensus, uint32_t timeout_ms);

asciichat_error_t
session_consensus_set_topology(session_consensus_t *consensus,
                               const uint8_t participant_ids[MAX_SESSION_PARTICIPANTS][SESSION_ID_SIZE],
                               int num_participants);

asciichat_error_t session_consensus_on_collection_start(session_consensus_t *consensus, uint32_t round_id,
                                                        uint64_t deadline_ns);

asciichat_error_t session_consensus_on_stats_update(session_consensus_t *consensus,
                                                    const uint8_t sender_id[SESSION_ID_SIZE],
                                                    const participant_metrics_t *metrics, uint8_t num_metrics);

asciichat_error_t session_consensus_on_election_result(session_consensus_t *consensus,
                                                       const uint8_t host_id[SESSION_ID_SIZE],
                                                       const char host_address[ACIP_ADDRESS_SIZE], uint16_t host_port,
                                                       const uint8_t backup_id[SESSION_ID_SIZE],
                                                       const char backup_address[ACIP_ADDRESS_SIZE],
                                                       uint16_t backup_port);

asciichat_error_t session_consensus_get_elected_host(session_consensus_t *consensus,
                                                     uint8_t out_host_id[SESSION_ID_SIZE],
                                                     char out_host_address[ACIP_ADDRESS_SIZE], uint16_t *out_host_port,
                                                     uint8_t out_backup_id[SESSION_ID_SIZE],
                                                     char out_backup_address[ACIP_ADDRESS_SIZE],
                                                     uint16_t *out_backup_port);

bool session_consensus_is_ready(session_consensus_t *consensus);

int session_consensus_get_state(session_consensus_t *consensus);

uint64_t session_consensus_time_until_next_round(session_consensus_t *consensus);

int session_consensus_get_metrics_count(session_consensus_t *consensus);
 
#ifdef __cplusplus
}
#endif