Evgeny
5 months ago
3 changed files with 720 additions and 245 deletions
@ -0,0 +1,344 @@
|
||||
Архитектура P2P Direct Connection (установка оптимального подключения между узлами) |
||||
|
||||
Цель: в большой сети узлов каждый узел умеет находить быстрые подключения |
||||
к любому другому узлу — либо прямое (direct), либо через минимальное число |
||||
промежуточных узлов с минимальным суммарным RTT. Оба узла пробуют доступные |
||||
варианты пингом и выбирают лучший. |
||||
|
||||
|
||||
=== Что уже есть в коде (используем, не дублируем) === |
||||
|
||||
1. NODEINFO уже содержит поле tranzit_nodes + структуру NODEINFO_TRANZIT_NODE |
||||
(node_id, rtt, link_q) — "лучшие транзитные узлы, выбирается/обновляется узлом", |
||||
но пока не заполняется и не используется. |
||||
|
||||
2. Пинг-инфраструктура: route_ping_send_req_addr (запрос удалённого пинга через |
||||
третий узел), route_ping_handle_resp (приём результата). Также есть |
||||
etcp_send_ping_to_socket — прямой пинг с конкретного сокета на конкретный адрес |
||||
с pubkey для шифрования. |
||||
|
||||
3. NAT-детекция уже работает: проверка типа NAT через третий узел, обмен NAT_INFO. |
||||
|
||||
4. Path system: NODEINFO_PATH с hop_count, routes → ROUTE_ENTRY → NODEINFO_Q → paths — |
||||
уже выбирается путь для маршрутизации пакетов. |
||||
|
||||
5. Константа ROUTE_SUBCMD_CONN_REQ (0x0B) зарезервирована в route_bgp.h, но не реализована. |
||||
|
||||
6. NODEINFO_Q уже имеет best_socket, last_ping_time, last_rtt. |
||||
|
||||
|
||||
=== Общий алгоритм (на примере узлов A и B) === |
||||
|
||||
A ──(ETCP через релейные узлы)──> B [текущий путь, hop_count > 1] |
||||
|
||||
1. A замечает большой объём трафика к B → запускает CONN_REQ |
||||
2. A шлёт B через существующий ETCP-путь: свои адреса-кандидаты + лучших транзитных соседей |
||||
3. B получает CONN_REQ, сразу начинает пинговать адреса A, собирает свои данные |
||||
4. B шлёт CONN_RESP: свои адреса + транзитных соседей + результаты пробных пингов |
||||
5. A получает CONN_RESP, пингует все адреса B |
||||
6. Оба вычисляют лучший вариант (прямой или релейный с минимальным RTT) |
||||
7. Оба шлют друг другу CONN_RESULT с выбором |
||||
8. Оба пытаются создать ETCP link к выбранному адресу (если прямой) |
||||
9. Лишние/худшие линки закрываются позже — все линки в рамках одного ETCP_CONN |
||||
|
||||
|
||||
=== Фаза 1: Обмен кандидатами (CONN_REQ → CONN_RESP) === |
||||
|
||||
Узел-инициатор A собирает и отправляет: |
||||
- Свои адреса-кандидаты: из своих ETCP_SOCKET (interface_addr + nat_addr). |
||||
Включаются только сокеты с NAT_VERIFIED_* / EIM / PUBLIC (type >= NAT_VERIFIED_UNKNOWN). |
||||
Для каждого: ip, port, type, socket_id. |
||||
- Лучших транзитных соседей: top-N directly-connected узлов (hop_count == 1) |
||||
отсортированных по NODEINFO_Q.last_rtt (лучший RTT первым). |
||||
|
||||
Узел B при получении CONN_REQ: |
||||
- Сохраняет кандидатов A |
||||
- Сразу запускает пробные пинги ко всем адресам A (etcp_send_ping_to_socket с pubkey) |
||||
- Собирает свои адреса-кандидаты |
||||
- Собирает своих транзитных соседей |
||||
- Шлёт CONN_RESP со своими данными + уже готовыми результатами проб |
||||
|
||||
|
||||
=== Фаза 2: Пробы (CONN_RESP → Пинги) === |
||||
|
||||
Узел A при получении CONN_RESP: |
||||
- Запускает пинги ко всем адресам B: |
||||
каждый адрес B пингуется с каждого своего сокета (N×M проб) |
||||
- Использует etcp_send_ping_to_socket с pubkey узла B (из NODEINFO) |
||||
- Пинг идёт напрямую по UDP (не через ETCP) — проверяет реальную достижимость |
||||
включая NAT traversal |
||||
- Ждёт все результаты либо таймаут |
||||
|
||||
Параллельно B тоже завершает свои пробы (запущенные на шаге 3). |
||||
|
||||
|
||||
=== Фаза 3: Выбор лучшего пути (→ CONN_RESULT) === |
||||
|
||||
Каждая сторона независимо вычисляет: |
||||
|
||||
best = {mode: none, rtt: 65535} |
||||
|
||||
Прямые варианты: |
||||
for each (мой_сокет, peer_addr) где probe.ok: |
||||
if probe.rtt < best.rtt: |
||||
best = {direct, my_sock_idx, peer_addr_idx, probe.rtt} |
||||
|
||||
Релейные варианты: |
||||
for each общий_транзитный_узел R (доступен и A и B): |
||||
// RTT(A↔R) берём из своих замеров (A знает RTT до своих соседей) |
||||
// RTT(R↔B) берём из транзитных соседей B (присланы в CONN_RESP) |
||||
total_rtt = A→R_rtt + R→B_rtt |
||||
if total_rtt < best.rtt: |
||||
best = {relay, R, total_rtt} |
||||
|
||||
Обе стороны приходят к одинаковому выводу (информация симметрична). |
||||
|
||||
Шлют CONN_RESULT с выбором. |
||||
Если прямой вариант — оба пытаются создать ETCP link к адресу пира. |
||||
Если релейный — используют существующий путь (уже работает). |
||||
|
||||
|
||||
=== Триггер запуска negotiation === |
||||
|
||||
В route_pkt (routing.c) при отправке пакета узлу с hop_count > 1: |
||||
- Накапливаем счётчик байт к этому узлу (per-node counter в bgp) |
||||
- При превышении порога (например 64KB) и если negotiation ещё не запущен — стартуем |
||||
- Cooldown: не чаще чем раз в 30 секунд для одной пары узлов |
||||
- Если negotiation уже в процессе для этой пары — не дублируем |
||||
|
||||
|
||||
=== Tranzit nodes — автоматическое заполнение === |
||||
|
||||
В route_bgp_update_my_nodeinfo (route_node.c) при каждом обновлении NODEINFO: |
||||
- Сканируем directly-connected соседей (из bgp->nodes, где hop_count == 1) |
||||
- Сортируем по NODEINFO_Q.last_rtt (лучший RTT первым) |
||||
- Берём top-N (до 4) и упаковываем в NODEINFO.tranzit_nodes как массив |
||||
NODEINFO_TRANZIT_NODE (node_id, rtt, link_q) |
||||
|
||||
Плюс периодический refill (раз в ~10 сек) для свежести RTT замеров. |
||||
|
||||
|
||||
=== Структуры данных (новые, route_p2pconn.h) === |
||||
|
||||
#define P2P_MAX_ADDRS 8 |
||||
#define P2P_MAX_RELAYS 8 |
||||
#define P2P_MAX_PROBES (P2P_MAX_ADDRS * P2P_MAX_ADDRS) // до 64 |
||||
|
||||
#define P2P_PHASE_WAIT_RESP 0 // ждём CONN_RESP от пира |
||||
#define P2P_PHASE_PROBING 1 // пингуем адреса пира |
||||
#define P2P_PHASE_SELECTING 2 // выбор лучшего, отправка CONN_RESULT |
||||
#define P2P_PHASE_DONE 3 // завершено |
||||
|
||||
// Один адрес-кандидат |
||||
struct P2P_ADDR { |
||||
uint32_t ip; // network byte order |
||||
uint16_t port; |
||||
uint8_t type; // NAT_VERIFIED_* |
||||
uint8_t socket_id; |
||||
}; |
||||
|
||||
// Один транзитный узел |
||||
struct P2P_RELAY { |
||||
uint64_t node_id; |
||||
uint16_t rtt; // x0.1ms |
||||
uint16_t link_q; |
||||
}; |
||||
|
||||
// Результат одного пробного пинга |
||||
struct P2P_PROBE_RESULT { |
||||
uint8_t my_sock_idx; // индекс в my_addrs[] |
||||
uint8_t peer_addr_idx; // индекс в peer_addrs[] |
||||
uint16_t rtt; // x0.1ms, 0 = fail |
||||
}; |
||||
|
||||
// Состояние одних переговоров (хранится в хеш-таблице bgp->p2p_negotiations) |
||||
struct P2P_NEGOTIATION { |
||||
struct ll_entry ll; |
||||
uint32_t request_id; |
||||
uint64_t peer_node_id; |
||||
uint8_t phase; |
||||
|
||||
// Мои данные |
||||
struct P2P_ADDR my_addrs[P2P_MAX_ADDRS]; |
||||
uint8_t my_addr_count; |
||||
struct P2P_RELAY my_relays[P2P_MAX_RELAYS]; |
||||
uint8_t my_relay_count; |
||||
|
||||
// Данные пира (заполняются из CONN_RESP) |
||||
struct P2P_ADDR peer_addrs[P2P_MAX_ADDRS]; |
||||
uint8_t peer_addr_count; |
||||
struct P2P_RELAY peer_relays[P2P_MAX_RELAYS]; |
||||
uint8_t peer_relay_count; |
||||
|
||||
// Результаты проб |
||||
struct P2P_PROBE_RESULT probes[P2P_MAX_PROBES]; |
||||
uint8_t probe_total; // сколько всего запланировано |
||||
uint8_t probe_done; // сколько завершилось (ok + fail) |
||||
|
||||
// Лучший выбор |
||||
uint8_t best_mode; // 1=direct, 2=relay |
||||
uint64_t best_relay; // node_id релея (если mode=relay) |
||||
uint16_t best_rtt; // x0.1ms |
||||
uint8_t best_my_sock_idx; // индекс в my_addrs (если direct) |
||||
uint8_t best_peer_addr_idx;// индекс в peer_addrs (если direct) |
||||
|
||||
void* timeout_timer; // общий таймаут на всю negotiation |
||||
}; |
||||
|
||||
// Счётчик трафика per-node (для триггера, хранится в bgp) |
||||
struct P2P_TRAFFIC_COUNTER { |
||||
uint64_t node_id; |
||||
uint64_t bytes_sent; // накоплено байт |
||||
uint64_t last_negotiation_time; // время последней попытки (0 = не было) |
||||
}; |
||||
|
||||
|
||||
=== Протокольные пакеты (добавляются в route_bgp.h) === |
||||
|
||||
ROUTE_SUBCMD_CONN_REQ 0x0B // запрос прямого подключения (уже зарезервирован) |
||||
ROUTE_SUBCMD_CONN_RESP 0x0C // ответ с адресами + результаты проб |
||||
ROUTE_SUBCMD_CONN_RESULT 0x0E // финальный выбор |
||||
|
||||
// Пакет CONN_REQ (A → B) |
||||
struct BGP_CONN_REQ { |
||||
uint8_t cmd; // ETCP_ID_ROUTE_ENTRY |
||||
uint8_t subcmd; // ROUTE_SUBCMD_CONN_REQ |
||||
uint32_t request_id; // для корреляции |
||||
uint8_t addr_count; // число адресов-кандидатов |
||||
uint8_t relay_count; // число транзитных узлов |
||||
uint8_t reserved[2]; |
||||
// далее динамически (размер = addr_count*8 + relay_count*12): |
||||
// [addr_count × {ip[4] port[2] type[1] socket_id[1]}] |
||||
// [relay_count × {node_id[8] rtt[2] link_q[2]}] |
||||
}; |
||||
|
||||
// Пакет CONN_RESP (B → A) |
||||
struct BGP_CONN_RESP { |
||||
uint8_t cmd; // ETCP_ID_ROUTE_ENTRY |
||||
uint8_t subcmd; // ROUTE_SUBCMD_CONN_RESP |
||||
uint32_t request_id; |
||||
uint8_t addr_count; // адреса B |
||||
uint8_t relay_count; // транзитные узлы B |
||||
uint8_t probe_count; // готовые результаты проб B→A |
||||
uint8_t reserved; |
||||
// [addr_count × {ip[4] port[2] type[1] socket_id[1]}] |
||||
// [relay_count × {node_id[8] rtt[2] link_q[2]}] |
||||
// [probe_count × {peer_addr_idx[1] my_sock_idx[1] rtt[2] ok[1]}] |
||||
}; |
||||
|
||||
// Пакет CONN_RESULT (A ↔ B, финальный) |
||||
struct BGP_CONN_RESULT { |
||||
uint8_t cmd; |
||||
uint8_t subcmd; // ROUTE_SUBCMD_CONN_RESULT |
||||
uint32_t request_id; |
||||
uint8_t chosen_mode; // 1=direct, 2=relay |
||||
uint8_t reserved; |
||||
uint16_t chosen_rtt; // x0.1ms |
||||
// Если direct: |
||||
uint32_t peer_ip; // IP пира к которому подключаемся |
||||
uint16_t peer_port; |
||||
uint8_t my_socket_id; // свой сокет для подключения |
||||
uint8_t peer_socket_id; // сокет пира |
||||
// Если relay (оверлей тех же байт): |
||||
// uint64_t relay_node_id; |
||||
}; |
||||
|
||||
|
||||
=== API модуля route_p2pconn === |
||||
|
||||
// Запуск negotiation к узлу peer_node_id. |
||||
// Вызывается из route_pkt при превышении порога трафика. |
||||
int p2p_start_negotiation(struct ROUTE_BGP* bgp, uint64_t peer_node_id); |
||||
|
||||
// Проверка: запущена ли уже negotiation для этой пары |
||||
int p2p_is_negotiating(struct ROUTE_BGP* bgp, uint64_t peer_node_id); |
||||
|
||||
// Сбор своих адресов-кандидатов (из etcp_sockets) |
||||
int p2p_collect_my_addrs(struct ROUTE_BGP* bgp, struct P2P_ADDR* out, uint8_t max); |
||||
|
||||
// Сбор лучших транзитных соседей (из directly-connected nodes) |
||||
int p2p_collect_my_relays(struct ROUTE_BGP* bgp, struct P2P_RELAY* out, uint8_t max); |
||||
|
||||
// Обработчики входящих пакетов (вызываются из route_bgp_receive_cbk): |
||||
void p2p_handle_conn_req(struct ROUTE_BGP* bgp, struct ETCP_CONN* from, |
||||
const uint8_t* data, size_t len); |
||||
void p2p_handle_conn_resp(struct ROUTE_BGP* bgp, struct ETCP_CONN* from, |
||||
const uint8_t* data, size_t len); |
||||
void p2p_handle_conn_result(struct ROUTE_BGP* bgp, struct ETCP_CONN* from, |
||||
const uint8_t* data, size_t len); |
||||
|
||||
// Отмена negotiation при удалении conn |
||||
void p2p_cancel_for_conn(struct ROUTE_BGP* bgp, struct ETCP_CONN* conn); |
||||
|
||||
// Очистка всех negotiation (при destroy bgp) |
||||
void p2p_destroy_all(struct ROUTE_BGP* bgp); |
||||
|
||||
|
||||
=== Схема состояний negotiation === |
||||
|
||||
IDLE ──(трафик > порог)──→ WAIT_RESP ──(CONN_RESP получен)──→ PROBING |
||||
↑ ↑ │ |
||||
│ (таймаут) (все пробы готовы) |
||||
│ ↓ │ |
||||
└──────────────────────────── DONE ←──(CONN_RESULT отправлен)── SELECTING |
||||
|
||||
|
||||
=== Интеграция (какие файлы меняются) === |
||||
|
||||
Новые файлы: |
||||
src/route_p2pconn.h — структуры, константы, прототипы |
||||
src/route_p2pconn.c — вся логика negotiation |
||||
|
||||
Изменения в существующих: |
||||
src/route_bgp.h — добавить ROUTE_SUBCMD_CONN_RESP 0x0C, |
||||
ROUTE_SUBCMD_CONN_RESULT 0x0E, |
||||
структуры пакетов BGP_CONN_REQ/RESP/RESULT |
||||
src/route_bgp.c — в route_bgp_receive_cbk добавить обработку |
||||
новых subcmd. В struct ROUTE_BGP добавить |
||||
поле p2p_negotiations (очередь/хеш negotiation) |
||||
и p2p_traffic_counters (per-node counters) |
||||
src/route_node.c — в route_bgp_update_my_nodeinfo заполнять |
||||
tranzit_nodes из RTT directly-connected соседей |
||||
src/routing.c — в route_pkt добавить накопление счётчика трафика |
||||
и вызов p2p_start_negotiation при превышении порога |
||||
src/Makefile.am — добавить route_p2pconn.c в сборку |
||||
|
||||
|
||||
=== Внутренняя логика route_p2pconn.c === |
||||
|
||||
p2p_start_negotiation(bgp, peer_node_id): |
||||
1. Проверить что нет активной negotiation для этой пары |
||||
2. Проверить cooldown (30 сек) |
||||
3. Создать struct P2P_NEGOTIATION, заполнить my_addrs, my_relays |
||||
4. Сформировать BGP_CONN_REQ и отправить через существующий путь к пиру |
||||
5. Поставить таймаут на всю negotiation (например 5 сек) |
||||
|
||||
p2p_handle_conn_req(bgp, from_conn, data, len): |
||||
1. Распарсить BGP_CONN_REQ |
||||
2. Сохранить адреса и релеи инициатора в P2P_NEGOTIATION |
||||
3. Собрать свои my_addrs, my_relays |
||||
4. Запустить пробные пинги к адресам инициатора (p2p_start_probes) |
||||
5. Когда пробы готовы — отправить CONN_RESP с результатами |
||||
|
||||
p2p_start_probes(neg): |
||||
1. Для каждой пары (мой_сокет, peer_addr) запланировать пинг |
||||
2. Вызвать etcp_send_ping_to_socket с pubkey пира |
||||
3. В коллбэке сохранить результат в probes[], инкрементировать probe_done |
||||
4. Когда probe_done == probe_total → вызвать p2p_select_best |
||||
|
||||
p2p_select_best(neg): |
||||
1. Прямые: найти пару (my_sock, peer_addr) с минимальным rtt > 0 |
||||
2. Релейные: для каждого общего транзитного узла посчитать суммарный rtt, |
||||
найти минимум |
||||
3. Сравнить прямой vs релейный лучший rtt |
||||
4. Записать выбор в neg->best_* |
||||
5. Отправить CONN_RESULT пиру |
||||
6. Вызвать p2p_establish_link(neg) |
||||
|
||||
p2p_establish_link(neg): |
||||
1. Если best_mode == direct: |
||||
- Найти/создать ETCP_CONN к пиру (по node_id) |
||||
- Вызвать etcp_link_new с chosen address |
||||
2. Если best_mode == relay: |
||||
- Ничего не делаем, существующий путь уже работает |
||||
3. Пометить negotiation как DONE |
||||
Loading…
Reference in new issue