|
|
|
|
@ -1,7 +1,9 @@
|
|
|
|
|
// test_media_delivery_full.c — полный сценарий: создание, передача, сборка, репликация
|
|
|
|
|
//
|
|
|
|
|
// 4 узла: n1 (автор), n2 (получатель), s1 (суперузел), s2 (суперузел)
|
|
|
|
|
// Топология: цепь 0→1 1→2 2→3
|
|
|
|
|
// Фазы:
|
|
|
|
|
// P1: CHAT-группа (topo_groups_create_group + member_sync_put)
|
|
|
|
|
// A1: SUPER_HELLO, HAVE_BLOCK, репликация
|
|
|
|
|
// A2: admission control (OVERLOADED)
|
|
|
|
|
// B1: n1 создаёт файл → n2 инициирует загрузку → стриминг → сборка → проверка
|
|
|
|
|
@ -10,6 +12,8 @@
|
|
|
|
|
#include "media_delivery_proto.h" |
|
|
|
|
#include "media_download.h" |
|
|
|
|
#include "media_index.h" |
|
|
|
|
#include "member_sync.h" |
|
|
|
|
#include "../routing_layer/topo_node_sqlite.h" |
|
|
|
|
#include "../utun_instance.h" |
|
|
|
|
#include "../transport_layer/etcp.h" |
|
|
|
|
#include "../config_parser.h" |
|
|
|
|
@ -34,10 +38,12 @@ static int G_PASSED = 0, G_FAILED = 0, G_TOTAL = 0;
|
|
|
|
|
#define TIMEOUT_TB 300000 |
|
|
|
|
#define POLL_MS 5 |
|
|
|
|
#define N_NODES 4 /* n1=0, n2=1, s1=2, s2=3 */ |
|
|
|
|
#define CH_ID "31415926535" |
|
|
|
|
|
|
|
|
|
static struct UASYNC* g_ua = NULL; |
|
|
|
|
static struct UTUN_INSTANCE* g_inst[N_NODES]; |
|
|
|
|
static uint64_t g_nid[N_NODES]; |
|
|
|
|
static uint64_t g_group_id = 0; |
|
|
|
|
static uint8_t g_test_mid[16], g_test_bid0[16], g_test_bid1[16]; |
|
|
|
|
static char g_tdir[256] = "/tmp/utun_mdf_XXXXXX"; |
|
|
|
|
static char g_cfg[N_NODES][256]; |
|
|
|
|
@ -92,11 +98,66 @@ static int msend(struct UTUN_INSTANCE* inst, uint64_t dst, const uint8_t* data,
|
|
|
|
|
return rc; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* ── Phase P1: create CHAT group + members on all nodes ── */ |
|
|
|
|
|
|
|
|
|
static void setup_chat_group(void) { |
|
|
|
|
uint8_t x25519_pub[32] = {0}, ed_pub[32] = {0}, ch_sig[64] = {0}; |
|
|
|
|
int i; |
|
|
|
|
|
|
|
|
|
TEST("generate channel keys"); { |
|
|
|
|
EVP_PKEY* xpkey = NULL, *epkey = NULL; |
|
|
|
|
EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_X25519, NULL); |
|
|
|
|
if (ctx) { EVP_PKEY_keygen_init(ctx); EVP_PKEY_generate(ctx, &xpkey); EVP_PKEY_CTX_free(ctx); } |
|
|
|
|
if (xpkey) { size_t l = 32; EVP_PKEY_get_raw_public_key(xpkey, x25519_pub, &l); EVP_PKEY_free(xpkey); } |
|
|
|
|
ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_ED25519, NULL); |
|
|
|
|
if (ctx) { EVP_PKEY_keygen_init(ctx); EVP_PKEY_generate(ctx, &epkey); EVP_PKEY_CTX_free(ctx); } |
|
|
|
|
if (epkey) { size_t l = 32; EVP_PKEY_get_raw_public_key(epkey, ed_pub, &l); |
|
|
|
|
/* sign channel */ |
|
|
|
|
EVP_MD_CTX* mctx = EVP_MD_CTX_new(); |
|
|
|
|
if (mctx) { EVP_DigestSignInit(mctx, NULL, NULL, NULL, epkey); |
|
|
|
|
size_t sl = 64; EVP_DigestSign(mctx, ch_sig, &sl, (const uint8_t*)CH_ID, strlen(CH_ID)); EVP_MD_CTX_free(mctx); } |
|
|
|
|
EVP_PKEY_free(epkey); |
|
|
|
|
} |
|
|
|
|
if (x25519_pub[0] || ed_pub[0]) OK(); else FAIL(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
TEST("create CHAT groups + peers tables"); { |
|
|
|
|
for (i = 0; i < N_NODES; i++) { |
|
|
|
|
sqlite3* db = g_inst[i]->topo_sqlite_db; |
|
|
|
|
struct TOPO_GROUPS* tg = g_inst[i]->topo_groups; |
|
|
|
|
if (!db || !tg) continue; |
|
|
|
|
topo_node_sqlite_channel_put(db, CH_ID, "test", g_nid[0], x25519_pub, NULL, ed_pub, NULL, ch_sig); |
|
|
|
|
if (topo_groups_find(tg, g_group_id)) continue; |
|
|
|
|
topo_groups_create_group(tg, g_group_id, TOPO_GROUP_TYPE_CHAT, CH_ID); |
|
|
|
|
} |
|
|
|
|
OK(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
TEST("add all 4 members (n1, n2, s1 supernode, s2 supernode)"); { |
|
|
|
|
const char* adm[4] = { NULL, NULL, "supernode=yes", "supernode=yes" }; |
|
|
|
|
for (i = 0; i < N_NODES; i++) { |
|
|
|
|
sqlite3* db = g_inst[i]->topo_sqlite_db; |
|
|
|
|
if (!db) continue; |
|
|
|
|
for (int m = 0; m < N_NODES; m++) { |
|
|
|
|
member_sync_put(g_inst[i], CH_ID, g_nid[m], |
|
|
|
|
g_inst[m]->my_keys.public_key, g_inst[m]->my_ed25519_pubkey, |
|
|
|
|
NULL, 0, NULL, 0, "{\"name\":\"node\"}", |
|
|
|
|
NULL, 0, adm[m], NULL, 0); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
int ok = 1; |
|
|
|
|
for (i = 0; i < N_NODES; i++) if (member_sync_count(g_inst[i], CH_ID) < N_NODES) ok = 0; |
|
|
|
|
if (ok) OK(); else FAIL(); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* ── Phase A1: SUPER_HELLO ── */ |
|
|
|
|
static void phase_a1_super_hello(void) { |
|
|
|
|
TEST("s1,s2 are supernodes"); { |
|
|
|
|
media_delivery_set_supernode(g_inst[2], 1); |
|
|
|
|
media_delivery_set_supernode(g_inst[3], 1); |
|
|
|
|
topo_node_sqlite_nodeinfo_updated(g_inst[2]->topo_sqlite_db, g_nid[2]); |
|
|
|
|
topo_node_sqlite_nodeinfo_updated(g_inst[3]->topo_sqlite_db, g_nid[3]); |
|
|
|
|
if (g_inst[2]->md.is_supernode && g_inst[3]->md.is_supernode) OK(); else FAIL(); |
|
|
|
|
} |
|
|
|
|
TEST("SUPER_HELLO s1↔s2"); { |
|
|
|
|
@ -115,7 +176,7 @@ static void phase_a2_have_block_replication(void) {
|
|
|
|
|
uint8_t uuid[16]; memset(uuid, 0xAB, 16); |
|
|
|
|
TEST("HAVE_BLOCK n2→s1"); { |
|
|
|
|
struct media_pkt_have_block hb; memset(&hb, 0, sizeof(hb)); |
|
|
|
|
hb.subcmd = MEDIA_SUBCMD_HAVE_BLOCK; hb.group_id = 0; |
|
|
|
|
hb.subcmd = MEDIA_SUBCMD_HAVE_BLOCK; hb.group_id = g_group_id; |
|
|
|
|
memcpy(hb.block_id, uuid, 16); memcpy(hb.media_id, uuid, 16); |
|
|
|
|
hb.chunk = 0; hb.timestamp = (int64_t)time(NULL); |
|
|
|
|
msend(g_inst[1], g_nid[2], (const uint8_t*)&hb, sizeof(hb)); |
|
|
|
|
@ -141,7 +202,8 @@ static void phase_a3_admission(void) {
|
|
|
|
|
TEST("1st BLOCK_REQ → stream"); { |
|
|
|
|
uint8_t mid[16], bid[16]; memset(mid, 0xCD, 16); memset(bid, 0xCE, 16); |
|
|
|
|
struct media_pkt_block_req req; memset(&req, 0, sizeof(req)); |
|
|
|
|
req.subcmd = MEDIA_SUBCMD_BLOCK_REQ; memcpy(req.media_id, mid, 16); memcpy(req.block_id, bid, 16); |
|
|
|
|
req.subcmd = MEDIA_SUBCMD_BLOCK_REQ; req.group_id = g_group_id; |
|
|
|
|
memcpy(req.media_id, mid, 16); memcpy(req.block_id, bid, 16); |
|
|
|
|
msend(g_inst[1], g_nid[0], (const uint8_t*)&req, sizeof(req)); |
|
|
|
|
int a = 0; while (a < 200) { uasync_poll(g_ua, POLL_MS); a++; } |
|
|
|
|
if (g_inst[0]->md.active_streams >= 1) OK(); else FAIL("active=%d", g_inst[0]->md.active_streams); |
|
|
|
|
@ -150,25 +212,21 @@ static void phase_a3_admission(void) {
|
|
|
|
|
for (int i = 0; i < 3; i++) { |
|
|
|
|
uint8_t mid[16], bid[16]; memset(mid, i+10, 16); memset(bid, i+20, 16); |
|
|
|
|
struct media_pkt_block_req req; memset(&req, 0, sizeof(req)); |
|
|
|
|
req.subcmd = MEDIA_SUBCMD_BLOCK_REQ; req.chunk = (uint32_t)i; |
|
|
|
|
req.subcmd = MEDIA_SUBCMD_BLOCK_REQ; req.group_id = g_group_id; req.chunk = (uint32_t)i; |
|
|
|
|
memcpy(req.media_id, mid, 16); memcpy(req.block_id, bid, 16); |
|
|
|
|
msend(g_inst[1], g_nid[0], (const uint8_t*)&req, sizeof(req)); |
|
|
|
|
} |
|
|
|
|
int a = 0; while (a < 200) { uasync_poll(g_ua, POLL_MS); a++; } |
|
|
|
|
if (g_inst[0]->md.active_streams == 3) OK(); else FAIL("active=%d", g_inst[0]->md.active_streams); |
|
|
|
|
} |
|
|
|
|
g_inst[0]->md.active_streams = 0; /* reset for next phase */ |
|
|
|
|
g_inst[0]->md.active_streams = 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* ══════════════════════════════════════════════════════════
|
|
|
|
|
Phase B1: create file → register → stream → assemble → verify |
|
|
|
|
══════════════════════════════════════════════════════════ */ |
|
|
|
|
|
|
|
|
|
static int g_dl_done = 0, g_dl_err = 0; |
|
|
|
|
static void dl_done_cb(void* arg, int err) { (void)arg; g_dl_done = 1; g_dl_err = err; } |
|
|
|
|
|
|
|
|
|
static void phase_b1_file_transfer(void) { |
|
|
|
|
/* create source file in /tmp */ |
|
|
|
|
char src_tmp[512]; snprintf(src_tmp, sizeof(src_tmp), "/tmp/mdl_test_%d.bin", getpid()); |
|
|
|
|
char media_dir[512]; snprintf(media_dir, sizeof(media_dir), "%s/media", g_db_dir[0]); |
|
|
|
|
utun_mkdir(media_dir, 0755); |
|
|
|
|
@ -180,14 +238,9 @@ static void phase_b1_file_transfer(void) {
|
|
|
|
|
FILE* f = fopen(src_tmp, "wb"); |
|
|
|
|
if (f) { fwrite(file_data, 1, 2048, f); fclose(f); } |
|
|
|
|
|
|
|
|
|
/* copy to media dir (simulates what media_index_register_async does with copy=1) */ |
|
|
|
|
{ |
|
|
|
|
FILE* fin = fopen(src_tmp, "rb"); |
|
|
|
|
FILE* fout = fopen(dst_path, "wb"); |
|
|
|
|
if (fin && fout) { uint8_t buf[4096]; size_t rd; while ((rd = fread(buf, 1, sizeof(buf), fin)) > 0) fwrite(buf, 1, rd, fout); } |
|
|
|
|
if (fin) fclose(fin); |
|
|
|
|
if (fout) fclose(fout); |
|
|
|
|
} |
|
|
|
|
{ FILE* fin = fopen(src_tmp, "rb"), *fout = fopen(dst_path, "wb"); |
|
|
|
|
if (fin && fout) { uint8_t buf[4096]; size_t rd; while ((rd = fread(buf, 1, sizeof(buf), fin)) > 0) fwrite(buf, 1, rd, fout); } |
|
|
|
|
if (fin) fclose(fin); if (fout) fclose(fout); } |
|
|
|
|
|
|
|
|
|
TEST("media_index_commit + ui_state"); { |
|
|
|
|
uint8_t hash[32]; |
|
|
|
|
@ -198,24 +251,16 @@ static void phase_b1_file_transfer(void) {
|
|
|
|
|
EVP_MD_CTX_free(ctx); |
|
|
|
|
|
|
|
|
|
media_index_init(g_inst[0]->topo_sqlite_db); |
|
|
|
|
/* ui_state: streaming handler reads media_base */ |
|
|
|
|
sqlite3_exec(g_inst[0]->topo_sqlite_db, "CREATE TABLE IF NOT EXISTS ui_state(key TEXT PRIMARY KEY, value TEXT)", NULL, NULL, NULL); |
|
|
|
|
{ |
|
|
|
|
sqlite3_stmt* us = NULL; |
|
|
|
|
sqlite3_prepare_v2(g_inst[0]->topo_sqlite_db, "INSERT OR REPLACE INTO ui_state(key,value) VALUES('media_base',?)", -1, &us, NULL); |
|
|
|
|
sqlite3_bind_text(us, 1, media_base, -1, SQLITE_STATIC); |
|
|
|
|
sqlite3_step(us); sqlite3_finalize(us); |
|
|
|
|
} |
|
|
|
|
{ sqlite3_stmt* us = NULL; |
|
|
|
|
sqlite3_prepare_v2(g_inst[0]->topo_sqlite_db, "INSERT OR REPLACE INTO ui_state(key,value) VALUES('media_base',?)", -1, &us, NULL); |
|
|
|
|
sqlite3_bind_text(us, 1, media_base, -1, SQLITE_STATIC); sqlite3_step(us); sqlite3_finalize(us); } |
|
|
|
|
|
|
|
|
|
struct media_index_result result; |
|
|
|
|
memset(&result, 0, sizeof(result)); |
|
|
|
|
struct media_index_result result; memset(&result, 0, sizeof(result)); |
|
|
|
|
media_index_generate_uuid(result.media_id); |
|
|
|
|
memcpy(result.content_hash, hash, 32); |
|
|
|
|
result.file_size = 2048; |
|
|
|
|
result.block_size = 1024; |
|
|
|
|
result.num_blocks = 2; |
|
|
|
|
result.block_ids = u_malloc(32); |
|
|
|
|
result.block_sigs = u_malloc(128); |
|
|
|
|
result.file_size = 2048; result.block_size = 1024; result.num_blocks = 2; |
|
|
|
|
result.block_ids = u_malloc(32); result.block_sigs = u_malloc(128); |
|
|
|
|
for (int i = 0; i < 2; i++) { |
|
|
|
|
media_index_generate_uuid(result.block_ids + i * 16); |
|
|
|
|
uint8_t smsg[2048]; size_t soff = 0; |
|
|
|
|
@ -229,7 +274,6 @@ static void phase_b1_file_transfer(void) {
|
|
|
|
|
memcpy(g_test_mid, result.media_id, 16); |
|
|
|
|
memcpy(g_test_bid0, result.block_ids, 16); |
|
|
|
|
memcpy(g_test_bid1, result.block_ids + 16, 16); |
|
|
|
|
|
|
|
|
|
int ndb = db_count(g_inst[0]->topo_sqlite_db, "media_files", NULL, 0); |
|
|
|
|
media_index_result_free(&result); |
|
|
|
|
if (ndb == 2) OK(); else FAIL("media_files has %d rows (expected 2)", ndb); |
|
|
|
|
@ -237,7 +281,7 @@ static void phase_b1_file_transfer(void) {
|
|
|
|
|
|
|
|
|
|
TEST("n2→n1 BLOCK_REQ streams data"); { |
|
|
|
|
struct media_pkt_block_req req; memset(&req, 0, sizeof(req)); |
|
|
|
|
req.subcmd = MEDIA_SUBCMD_BLOCK_REQ; |
|
|
|
|
req.subcmd = MEDIA_SUBCMD_BLOCK_REQ; req.group_id = g_group_id; |
|
|
|
|
memcpy(req.media_id, g_test_mid, 16); memcpy(req.block_id, g_test_bid0, 16); |
|
|
|
|
req.chunk = 0; |
|
|
|
|
g_inst[0]->md.stream_completed = 0; |
|
|
|
|
@ -264,23 +308,31 @@ int main(void) {
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
g_ua = uasync_create(); |
|
|
|
|
for (int i = 0; i < N_NODES; i++) { |
|
|
|
|
for (int i = 0; i < N_NODES; i++) |
|
|
|
|
wf(g_cfg[i], "[global]\ntun_ip=10.99.%d.1/24\ntun_ifname=tun%d0\ndb_path=%s\n" |
|
|
|
|
"[server: s1]\naddr=127.0.0.1:%d\ntype=public\n[allowed_keys]\nallow_all=1\n", |
|
|
|
|
i, i, g_db_dir[i], g_port[i]); |
|
|
|
|
for (int i = 0; i < N_NODES; i++) { |
|
|
|
|
config_ensure_keys_and_node_id(g_cfg[i]); |
|
|
|
|
struct utun_config* c = parse_config(g_cfg[i]); g_nid[i] = c->global.my_node_id; free_config(c); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for (int i = 0; i < N_NODES; i++) { |
|
|
|
|
char *pr = gv(g_cfg[i], "priv"), *pu = gv(g_cfg[i], "pub"); |
|
|
|
|
int next = (i + 1) % N_NODES; char *n_pu = gv(g_cfg[next], "pub"); |
|
|
|
|
char link[256]; snprintf(link, sizeof(link), |
|
|
|
|
"[client: to_n%d]\nkeepalive=1\npeer_public_key=%s\nlink=s1:127.0.0.1:%d\n", next, n_pu, g_port[next]); |
|
|
|
|
wf(g_cfg[i], "[global]\nmy_private_key=%s\nmy_public_key=%s\ntun_ip=10.99.%d.1/24\ntun_ifname=tun%d0\n" |
|
|
|
|
"db_path=%s\n[server: s1]\naddr=127.0.0.1:%d\ntype=public\n%s[allowed_keys]\nallow_all=1\n", |
|
|
|
|
pr, pu, i, i, g_db_dir[i], g_port[i], link); |
|
|
|
|
u_free(pr); u_free(pu); u_free(n_pu); |
|
|
|
|
if (i == 0) { |
|
|
|
|
wf(g_cfg[i], "[global]\nmy_private_key=%s\nmy_public_key=%s\ntun_ip=10.99.%d.1/24\ntun_ifname=tun%d0\n" |
|
|
|
|
"db_path=%s\n[server: s1]\naddr=127.0.0.1:%d\ntype=public\n[allowed_keys]\nallow_all=1\n", |
|
|
|
|
pr, pu, i, i, g_db_dir[i], g_port[i]); |
|
|
|
|
} else { |
|
|
|
|
int prev = i - 1; char *pv_pu = gv(g_cfg[prev], "pub"); |
|
|
|
|
char link[256]; snprintf(link, sizeof(link), |
|
|
|
|
"[client: to_n%d]\nkeepalive=1\npeer_public_key=%s\nlink=s1:127.0.0.1:%d\n", prev, pv_pu, g_port[prev]); |
|
|
|
|
wf(g_cfg[i], "[global]\nmy_private_key=%s\nmy_public_key=%s\ntun_ip=10.99.%d.1/24\ntun_ifname=tun%d0\n" |
|
|
|
|
"db_path=%s\n[server: s1]\naddr=127.0.0.1:%d\ntype=public\n%s[allowed_keys]\nallow_all=1\n", |
|
|
|
|
pr, pu, i, i, g_db_dir[i], g_port[i], link); |
|
|
|
|
u_free(pv_pu); |
|
|
|
|
} |
|
|
|
|
u_free(pr); u_free(pu); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for (int i = 0; i < N_NODES; i++) { |
|
|
|
|
@ -295,6 +347,10 @@ int main(void) {
|
|
|
|
|
if (!g_connected) { printf("FAIL: connection timeout\n"); goto done; } } |
|
|
|
|
printf(" connected\n"); |
|
|
|
|
|
|
|
|
|
g_group_id = strtoull(CH_ID, NULL, 10); |
|
|
|
|
/* ══ Phase P1: create CHAT groups + members ══ */ |
|
|
|
|
setup_chat_group(); |
|
|
|
|
|
|
|
|
|
phase_a1_super_hello(); |
|
|
|
|
phase_a2_have_block_replication(); |
|
|
|
|
phase_a3_admission(); |
|
|
|
|
|
evgeny
2 months ago