Files
breeze/tests/package_manager_host.c
waoziandClaude Opus 5.5 6f6d19f24d Rename account sync to Mesh
The codex-daochi-client-mesh-client-rename integration, committed as that
task staged it: mesh_client replaces daochi_client, account storage and
tests move to the Mesh names, and docs, locales and CI follow, with
existing accounts, encrypted records and local storage kept compatible.
The task stopped before its dependency versions were pushed; the next
commit moves Breeze to the pushed pins it needs.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-18 13:14:02 -03:00

502 lines
22 KiB
C

#include "package_manager.h"
#include "zir_string.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdatomic.h>
#include <time.h>
static const char *fixtures;
static char database[4096];
static char keys[64][128];
static char values[64][512];
static int setting_count;
static int starts;
static int transfer_failures;
static int transfer_http;
static int releases;
static bool held;
static bool deny_approval;
static const char *manifest = "diary";
static char account[65] = "fixture-account";
static EmbeddedAssetEntry publisher;
static atomic_bool block_hash;
static atomic_bool hash_started;
extern int32_t FixtureHabitsSequence(void);
extern bool FixtureRemovePayload(String digest);
static double monotonic_seconds(void) {
struct timespec now;
assert(clock_gettime(CLOCK_MONOTONIC, &now) == 0);
return (double)now.tv_sec + (double)now.tv_nsec / 1e9;
}
void __real_Sha256Hex(const unsigned char *data, int64_t size, unsigned char *digest);
void __wrap_Sha256Hex(const unsigned char *data, int64_t size, unsigned char *digest) {
if (atomic_load(&block_hash)) {
atomic_store(&hash_started, true);
while (atomic_load(&block_hash)) {
usleep(1000);
}
}
__real_Sha256Hex(data, size, digest);
}
uint8_t *__wrap_storage_user_id_buffer(void) {
return (uint8_t *)account;
}
static String load(const char *name) {
char path[4096];
snprintf(path, sizeof(path), "%s/%s", fixtures, name);
FILE *file = fopen(path, "rb");
assert(file && !fseek(file, 0, SEEK_END));
long size = ftell(file);
assert(size > 0 && !fseek(file, 0, SEEK_SET));
char *data = malloc((size_t)size);
assert(data && fread(data, 1, (size_t)size, file) == (size_t)size);
fclose(file);
return StringView(data, (size_t)size);
}
static int setting(String key) {
for (int index = 0; index < setting_count; index++) {
if (StringEqual(key, StringView(keys[index], strlen(keys[index])))) {
return index;
}
}
assert(setting_count < 64 && key.length < sizeof(keys[0]));
int index = setting_count++;
memcpy(keys[index], key.data, key.length);
return index;
}
int32_t storage_get_setting_int(String key, int32_t fallback) {
const char *value = values[setting(key)];
return *value ? atoi(value) : fallback;
}
String storage_get_setting_text(String key) {
char *value = values[setting(key)];
return StringView(value, strlen(value));
}
void storage_set_setting_int(String key, int32_t value) {
snprintf(values[setting(key)], sizeof(values[0]), "%d", value);
}
void storage_set_setting_text(String key, String value) {
if (deny_approval && key.length >= 16 && !memcmp(key.data, "package_rollback", 16)) return;
assert(value.length < sizeof(values[0]));
snprintf(values[setting(key)], sizeof(values[0]), "%.*s", (int)value.length, value.data);
}
String __wrap_storage_db_path(void) {
return StringView(database, strlen(database));
}
EmbeddedAssetEntry *asset_entry_at(size_t index) {
return index == 0 ? &publisher : NULL;
}
size_t asset_entry_total(void) {
return 1;
}
void app_web_storage_flush(void) {
}
bool AppsValidatePackage(int32_t index, String bytes) {
assert((index == 0 || index == 4) && bytes.length > 8);
return true; /* The capability decoder is covered by apps-test. */
}
int32_t AppsPreparePackage(int32_t index, String bytes) {
return AppsValidatePackage(index, bytes) ? 1 : -1;
}
void AppsDiscardPreparation(void) {
}
bool AppsPreparationIdle(void) {
return true;
}
void AppsCommitPreparation(int32_t index, int32_t revision) {
assert(index >= 0 && revision > 0);
}
/* Wraps mesh-client's SecureRandom so the device bucket is fixed. */
int32_t __wrap_SecureRandom(uint8_t *output, int64_t length) {
for (int64_t index = 0; index < length; index++) {
output[index] = (uint8_t)(index * 37 + 11);
}
return 1;
}
static char latest_query[128];
bool __wrap_file_download_FileDownloadStart(FileDownload *download, String url, String destination) {
assert(url.length > 0 && destination.length < sizeof(download->destination));
assert(download->maximum_bytes > 0);
/* Release checks name this host's interfaces and keep one device bucket. */
char target[512];
snprintf(target, sizeof(target), "%.*s", (int)destination.length, destination.data);
if (strstr(target, ".history.download.json")) {
char text[512];
snprintf(text, sizeof(text), "%.*s", (int)url.length, url.data);
assert(strstr(text, "/history?host_api=") && strstr(text, "&module_api=") && strstr(text, "&bucket=") &&
strstr(text, "&format=zx"));
assert(download->maximum_bytes == 262144);
} else if (strstr(target, ".download.json")) {
char text[512];
snprintf(text, sizeof(text), "%.*s", (int)url.length, url.data);
const char *query = strstr(text, "/latest?host_api=");
assert(query && strstr(query, "&module_api=") && strstr(query, "&bucket=") && strstr(query, "&format=zx"));
assert(!latest_query[0] || strcmp(latest_query, query) == 0);
snprintf(latest_query, sizeof(latest_query), "%s", query);
}
snprintf((char *)download->destination, sizeof(download->destination), "%.*s", (int)destination.length, destination.data);
download->status = FileDownloadStatus_Downloading;
download->handle = (uint64_t)++starts;
return true;
}
FileDownloadStatus __wrap_file_download_FileDownloadPoll(FileDownload *download) {
if (transfer_failures > 0) {
transfer_failures--;
download->http_status = transfer_http;
snprintf((char *)download->error, sizeof(download->error), "fixture interrupted transfer");
download->status = FileDownloadStatus_Error;
return download->status;
}
if (held) {
return FileDownloadStatus_Downloading;
}
const char *destination = (char *)download->destination;
const char *name = strstr(destination, ".history.download.json") ? "diary-history" :
strstr(destination, ".download.json") ? manifest :
(package_index == 0 ? "root-bytes" : "diary-bytes");
String data = load(name);
assert(data.length <= download->maximum_bytes);
FILE *output = fopen(destination, "wb");
assert(output && fwrite(data.data, 1, data.length, output) == data.length);
fclose(output);
free((void *)data.data);
download->status = FileDownloadStatus_Ready;
return download->status;
}
void __wrap_file_download_FileDownloadRelease(FileDownload *download) {
if (download->handle) {
releases++;
}
memset(download, 0, sizeof(*download));
}
static void pump(void) {
package_manager_PackagePump(8, 200000, false);
for (int attempt = 0; package_phase == 4 && attempt < 10000; attempt++) {
usleep(1000);
package_manager_PackagePump(8, 200000, false);
}
assert(package_phase != 4);
}
static void request(void) {
package_manager_PackageRequest(4);
pump();
pump();
pump();
}
int32_t RunPackageManagerFixture(void) {
pump();
assert(starts == 1 && package_index == 0 && package_check_only && !package_automatic);
assert(!package_manager_PackageAutomaticEnabled());
/* Unasked/off permits signed metadata checks, never an implicit payload. */
package_manager_PackageCancel();
package_last_check = 200000;
package_launch_checked = true;
starts = 0;
package_manager_PackageSetAutomatic(false);
pump();
assert(starts == 0); /* Availability checks remain scheduled, not every frame. */
transfer_failures = 1;
transfer_http = 503;
request();
assert(package_manager_PackageStatus(4) == 1 && starts == 1);
assert(package_recovery.attempts == 1 && package_recovery.retry_at == 200002);
for (int frame = 0; frame < 100; frame++) package_manager_PackagePump(8, 200001, false);
assert(starts == 1);
package_manager_PackagePump(8, 200002, false);
pump();
assert(starts == 2 && package_manager_PackageStatus(4) == 2);
transfer_failures = 20;
request();
const int deadlines[] = {200002, 200010, 200040};
for (int attempt = 0; attempt < 3; attempt++) {
package_manager_PackagePump(8, deadlines[attempt], false);
package_manager_PackagePump(8, deadlines[attempt], false);
}
assert(package_manager_PackageStatus(4) == 3 && package_index == -1);
int exhausted_starts = starts;
package_manager_PackagePump(8, 200100, false);
assert(starts == exhausted_starts);
assert(StringEqual(package_manager_PackageFailureDetail(4), StringLiteral("fixture interrupted transfer")));
transfer_http = 403;
request();
assert(package_manager_PackageStatus(4) == 3 && starts == exhausted_starts + 1);
transfer_failures = 0;
starts = 0;
int32_t baseline = FixtureHabitsSequence();
assert(package_manager_PackageSequence(2) == baseline);
storage_set_setting_int(StringLiteral("package_sequence_habits"), -10);
assert(package_manager_PackageSequence(2) == baseline); /* Installed baseline is the floor. */
request(); /* A manual check reuses the bundled app at the same sequence. */
assert(package_manager_PackageStatus(4) == 2 && starts == 1);
int32_t installed_sequence = package_manager_PackageSequence(4);
assert(installed_sequence > 0);
String installed = package_manager_PackageInstalledBytes(4);
assert(installed.length == 0); /* The offline bundle needs no disk cache. */
assert(package_manager_PackageAvailable(4));
manifest = "diary-new";
int before_probe = starts;
package_manager_PackageCheckForUpdate(4);
pump();
pump();
assert(starts == before_probe + 1 && package_manager_PackageUpdateAvailable(4));
assert(package_manager_PackageSequence(4) == installed_sequence);
assert(package_manager_PackageVersionCompare(package_manager_PackageAvailableVersion(4),
package_manager_PackageVersion(4)) > 0);
String version = package_manager_PackageAvailableVersion(4);
String digest = package_manager_PackageAvailableDigest(4);
assert(!package_manager_PackageRequestVersion(4, version, StringLiteral("wrong"), StringLiteral("fixture-account")));
assert(!package_manager_PackageRequestVersion(4, version, digest, StringLiteral("another-account")));
assert(package_manager_PackageRequestVersion(4, version, digest, StringLiteral("fixture-account")));
pump();
strcpy(account, "another-account");
pump(); /* An account switch cancels the approved request before payload. */
assert(package_manager_PackageStatus(4) == 3 && package_manager_PackageSequence(4) == installed_sequence);
strcpy(account, "fixture-account");
assert(package_manager_PackageRequestVersion(4, version, digest, StringLiteral("fixture-account")));
manifest = "diary";
pump();
pump(); /* The server cannot substitute another signed version. */
assert(package_manager_PackageStatus(4) == 3 && package_manager_PackageSequence(4) == installed_sequence);
manifest = "diary-new";
assert(package_manager_PackageRequestVersion(4, version, digest, StringLiteral("fixture-account")));
/* During a practice the requested install downloads its release and
payload, but checking and installing them wait for the practice. */
int before_practice = starts;
package_manager_PackagePump(8, 200000, true);
package_manager_PackagePump(8, 200000, true);
package_manager_PackagePump(8, 200000, true);
assert(starts == before_practice + 2 && package_index == 4);
assert(package_manager_PackageSequence(4) == installed_sequence);
/* Even an arbitrarily slow hash cannot block a pump or cancellation,
publish the payload, or keep a borrowed job alive after it finishes. */
atomic_store(&block_hash, true);
package_manager_PackagePump(8, 200000, false);
for (int attempt = 0; !atomic_load(&hash_started) && attempt < 5000; attempt++) {
usleep(1000);
}
assert(atomic_load(&hash_started));
double cancel_started = monotonic_seconds();
package_manager_PackagePump(8, 200000, false);
package_manager_PackageCancel();
/* The hash stays blocked, so waiting on it would never return; the bound
only allows for a slow shared CI runner. */
assert(monotonic_seconds() - cancel_started < 1.0);
assert(package_index == -1 && package_work_count > 0);
assert(package_manager_PackageSequence(4) == installed_sequence);
atomic_store(&block_hash, false);
for (int attempt = 0; package_work_count > 0 && attempt < 5000; attempt++) {
usleep(1000);
package_manager_PackagePump(8, 200000, false);
}
assert(package_work_count == 0);
assert(package_manager_PackageRequestVersion(4, version, digest, StringLiteral("fixture-account")));
pump();
pump();
pump(); /* Only the confirmed exact target may publish the payload. */
assert(package_manager_PackageSequence(4) == installed_sequence + 1);
assert(!package_manager_PackageUpdateAvailable(4));
installed = package_manager_PackageInstalledBytes(4);
assert(installed.length > 8);
assert(!package_manager_PackageInstalledIsBundled(4)); /* A newer saved release replaces the bundled app. */
free((void *)installed.data);
/* The node supplies at most three fully signed, ordered releases. A
rejected replacement cannot erase the last verified history. */
package_history_PackageHistoryRequest(4);
int before_history = starts;
pump();
assert(package_phase == 3 && starts == before_history + 1);
pump();
assert(package_history_PackageHistoryCount(4) == 2);
const char *invalid_histories[] = {"diary-history-many", "diary-history-order",
"diary-history-owner", "diary-history-forged"};
for (size_t at = 0; at < sizeof(invalid_histories) / sizeof(*invalid_histories); at++) {
String bad = load(invalid_histories[at]);
assert(!package_history_PackageHistoryAccept(4, bad));
free((void *)bad.data);
assert(package_history_PackageHistoryCount(4) == 2);
}
String older_version = package_history_PackageHistoryVersion(4, 1);
String older_digest = package_history_PackageHistoryDigest(4, 1);
assert(!package_history_PackageRollbackRequest(4, older_version, StringLiteral("wrong"), StringLiteral("fixture-account")));
assert(!package_history_PackageRollbackRequest(4, older_version, older_digest, StringLiteral("another-account")));
assert(package_history_PackageRollbackRequest(4, older_version, older_digest, StringLiteral("fixture-account")));
package_manager_PackagePump(8, 200000, false);
assert(package_phase == 2 || package_phase == 4);
strcpy(account, "another-account");
pump();
assert(package_manager_PackageStatus(4) == 3);
strcpy(account, "fixture-account");
assert(package_history_PackageRollbackRequest(4, older_version, older_digest, StringLiteral("fixture-account")));
deny_approval = true;
pump();
pump();
for (int attempt = 0; package_index >= 0 && attempt < 5000; attempt++) {
usleep(1000);
pump();
}
deny_approval = false;
assert(package_manager_PackageStatus(4) == 3 && !package_history_PackageRollbackPinned(4));
assert(FixtureRemovePayload(older_digest));
assert(package_history_PackageRollbackRequest(4, older_version, older_digest, StringLiteral("fixture-account")));
before_history = starts;
pump();
assert(package_phase == 2 && starts == before_history + 1); /* Exact retained metadata, no latest substitution. */
pump();
assert(package_manager_PackageStatus(4) == 2 && package_history_PackageRollbackPinned(4));
assert(package_manager_PackageSequence(4) == installed_sequence + 1); /* High-water never falls. */
assert(StringEqual(package_manager_PackageVersion(4), older_version));
installed = package_manager_PackageInstalledBytes(4); /* Restart accepts only the explicit signed approval. */
assert(installed.length > 8);
free((void *)installed.data);
strcpy(account, "another-account");
installed = package_manager_PackageInstalledBytes(4);
assert(installed.length == 0); /* The approval does not cross accounts. */
strcpy(account, "fixture-account");
installed = package_manager_PackageInstalledBytes(4);
assert(installed.length > 8);
free((void *)installed.data);
held = true;
package_manager_PackageSetAutomatic(true);
package_last_check = 0;
package_launch_checked = false;
pump();
assert(package_requested[4] && package_requested_check_only[4]); /* Auto checks respect the rollback pin. */
package_manager_PackageCancel();
held = false;
package_manager_PackageSetAutomatic(false);
package_last_check = 200000;
package_manager_PackageCheckForUpdate(4);
pump();
pump();
assert(package_manager_PackageUpdateAvailable(4)); /* Returning to the retained high-water release is a manual update. */
assert(package_manager_PackageRequestVersion(4, package_manager_PackageAvailableVersion(4),
package_manager_PackageAvailableDigest(4), StringLiteral("fixture-account")));
pump();
pump();
pump();
assert(!package_history_PackageRollbackPinned(4) && !package_manager_PackageUpdateAvailable(4));
manifest = "diary";
request(); /* A correctly signed older manifest must still fail. */
assert(package_manager_PackageStatus(4) == 3 && package_manager_PackageSequence(4) == installed_sequence + 1);
manifest = "diary-bad";
request();
assert(package_manager_PackageStatus(4) == 3 && package_manager_PackageSequence(4) == installed_sequence + 1);
installed = package_manager_PackageInstalledBytes(4);
assert(installed.length > 8);
free((void *)installed.data);
manifest = "diary-new";
char pointer[4096];
snprintf(pointer, sizeof(pointer), "%s/packages/diary.current.json", fixtures);
assert(unlink(pointer) == 0);
request(); /* Same signed sequence/hash repairs a missing current pointer. */
assert(package_manager_PackageStatus(4) == 2 && access(pointer, R_OK) == 0);
manifest = "root-new";
package_manager_PackageMarkRootActive(false);
package_manager_PackageRequest(0);
pump();
pump();
pump();
assert(package_manager_PackageRootPending());
installed = package_manager_PackageInstalledBytes(0);
assert(installed.length > 8);
assert(!package_manager_PackageInstalledIsBundled(0)); /* A newer saved root replaces the bundled one. */
free((void *)installed.data);
package_manager_PackageMarkRootActive(true); /* Restart activates the cached root. */
assert(!package_manager_PackageRootPending());
assert(StringEqual(package_manager_PackageVersion(2), StringLiteral("1.1.0")));
assert(StringEqual(package_manager_PackageVersion(3), StringLiteral("1.2.0")));
held = true;
package_manager_PackageSetAutomatic(true);
package_last_check = 0;
package_launch_checked = false;
pump(); /* Starts root automatic check. */
assert(package_automatic && package_index == 0);
package_manager_PackageRequest(4); /* A manual request survives disabling updates. */
int cancelled = releases;
package_manager_PackageSetAutomatic(false);
assert(package_index == -1 && releases == cancelled + 1 && package_requested[4]);
pump();
assert(package_index == 4 && !package_automatic);
package_manager_PackageSetAutomatic(false);
assert(package_index == 4); /* In-flight manual work also survives. */
package_manager_PackageCancel();
held = false;
/* A downloaded package proves itself by running; an unproven one that
three starts in a row never proved is set aside for the bundled one. */
package_trial_counted[4] = false;
String trial = package_manager_PackageInstalledBytes(4);
assert(trial.length > 8 && package_manager_PackageTrialAllows(4));
free((void *)trial.data);
package_manager_PackageTrialsProve(package_started_at + 9);
assert(package_trials_open); /* Not proven before ten seconds. */
package_manager_PackageTrialsProve(package_started_at + 10);
assert(!package_trials_open);
for (int start = 0; start < 5; start++) {
package_trial_counted[4] = false;
trial = package_manager_PackageInstalledBytes(4);
assert(trial.length > 8 && package_manager_PackageTrialAllows(4)); /* Proven stays good. */
free((void *)trial.data);
}
storage_set_setting_text(StringLiteral("package_good_diary"), StringLiteral(""));
for (int start = 0; start < 3; start++) {
package_trial_counted[4] = false;
trial = package_manager_PackageInstalledBytes(4);
assert(trial.length > 8 && package_manager_PackageTrialAllows(4));
free((void *)trial.data);
}
package_trial_counted[4] = false;
trial = package_manager_PackageInstalledBytes(4);
assert(trial.length > 8 && !package_manager_PackageTrialAllows(4));
free((void *)trial.data);
assert(!package_manager_PackageTrialAllows(4)); /* Set aside for this process too. */
int before_set_aside = starts;
manifest = "diary-new";
request(); /* The set-aside release is not downloaded again. */
assert(package_manager_PackageStatus(4) == 2 && starts == before_set_aside + 1);
/* Checks run daily, once after a start an hour after the last one, and
ten minutes after a sync reports a newer root package. */
storage_set_setting_int(StringLiteral("package_sequence_hint"), 0);
package_last_check = 200000;
package_hint_read_at = 0;
package_launch_checked = false;
assert(!package_manager_PackageCheckDue(201000));
package_launch_checked = false;
assert(package_manager_PackageCheckDue(203600));
assert(!package_manager_PackageCheckDue(203700)); /* Once per start. */
assert(package_manager_PackageCheckDue(286400));
storage_set_setting_int(StringLiteral("package_sequence_hint"), 1000000);
package_hint_read_at = 0;
assert(!package_manager_PackageCheckDue(200300));
assert(package_manager_PackageCheckDue(200700));
storage_set_setting_int(StringLiteral("package_sequence_hint"), 1);
package_hint_read_at = 0;
assert(!package_manager_PackageCheckDue(200800)); /* Not newer than the installed root. */
return 0;
}
extern int32_t CheckPackageManager(void);
int main(int argc, char **argv) {
assert(argc == 2);
fixtures = argv[1];
snprintf(database, sizeof(database), "%s/inbe.db", fixtures);
String data = load("publishers.json");
publisher = (EmbeddedAssetEntry){(uint8_t *)"apps/publishers.json", (uint8_t *)"application/json", (uint8_t *)data.data, data.length};
int result = CheckPackageManager();
free((void *)data.data);
return result;
}