native_backup_restore.c

Go to the documentation of this file.

/**
 * @file
 * @brief Implements native backup and restore reporting for app state and sqlite snapshots.
 */
 
#include "native_backup_restore.h"
 
#include "native_artifact_emit.h"
#include "native_fs.h"
#include "native_json_config.h"
#include "native_support.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#ifdef _WIN32
#define native_backup_restore_strdup _strdup
#else
#define native_backup_restore_strdup strdup
#endif
 
static char *native_default_backend_local(const AppRuntime *app) {
  char *backend = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_backend") : NULL;
  if (backend == NULL || backend[0] == '\0') {
    free(backend);
    return native_backup_restore_strdup("sqlite");
  }
  return backend;
}
 
static char *native_default_sqlite_path_local(const AppRuntime *app) {
  char *db_path = app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_path") : NULL;
  char buffer[4096];
  if (db_path != NULL && db_path[0] != '\0') {
    return db_path;
  }
  free(db_path);
  snprintf(buffer, sizeof(buffer), "/var/lib/pharos/%s.sqlite3", app != NULL && app->app_id != NULL ? app->app_id : "app");
  return native_backup_restore_strdup(buffer);
}
 
static char *native_app_conf_path(const char *app_root) {
  char *app_conf = NULL;
  char *pharos_conf = NULL;
  if (app_root == NULL) {
    return NULL;
  }
  app_conf = path_join(app_root, "app.conf");
  if (app_conf != NULL && path_exists(app_conf)) {
    return app_conf;
  }
  free(app_conf);
  pharos_conf = path_join(app_root, "pharos.conf");
  if (pharos_conf != NULL && path_exists(pharos_conf)) {
    return pharos_conf;
  }
  free(pharos_conf);
  return NULL;
}
 
static char *native_app_conf_value_path(const char *app_root, const char *key) {
  char *conf_path = native_app_conf_path(app_root);
  char *raw_value = NULL;
  char *resolved = NULL;
  char *conf_dir = NULL;
  if (conf_path == NULL || key == NULL) {
    free(conf_path);
    return NULL;
  }
  raw_value = conf_lookup_value(conf_path, key);
  if (raw_value == NULL || raw_value[0] == '\0') {
    free(conf_path);
    free(raw_value);
    return NULL;
  }
  conf_dir = path_dirname(conf_path);
  if (conf_dir != NULL) {
    resolved = resolve_relative_to(conf_dir, raw_value);
  }
  free(conf_dir);
  free(conf_path);
  free(raw_value);
  return resolved;
}
 
static char *native_backup_base_dir(const AppRuntime *app) {
  char *app_value = NULL;
  char *runtime_value = NULL;
  char *fallback = NULL;
  if (app != NULL && app->app_root != NULL) {
    app_value = native_app_conf_value_path(app->app_root, "backup_dir");
    if (app_value != NULL && app_value[0] != '\0') {
      return app_value;
    }
    free(app_value);
  }
  runtime_value = app != NULL ? conf_lookup_value(app->runtime_conf_path, "backup_dir") : NULL;
  if (runtime_value != NULL && runtime_value[0] != '\0') {
    return runtime_value;
  }
  free(runtime_value);
  fallback = path_join(app != NULL ? app->app_root : NULL, "var/backups");
  return fallback;
}
 
static char *native_backup_timestamp_utc(void) {
  char buffer[32];
  time_t now = time(NULL);
  struct tm tm_now;
#ifdef _WIN32
  gmtime_s(&tm_now, &now);
#else
  gmtime_r(&now, &tm_now);
#endif
  if (strftime(buffer, sizeof(buffer), "%Y%m%dT%H%M%SZ", &tm_now) == 0) {
    return NULL;
  }
  return native_backup_restore_strdup(buffer);
}
 
static long native_json_top_level_long(const char *text, const char *key, long fallback_value) {
  char pattern[256];
  const char *cursor;
  const char *colon;
  char *endptr = NULL;
  long value;
  if (text == NULL || key == NULL) {
    return fallback_value;
  }
  snprintf(pattern, sizeof(pattern), "\"%s\"", key);
  cursor = strstr(text, pattern);
  if (cursor == NULL) {
    return fallback_value;
  }
  colon = strchr(cursor + strlen(pattern), ':');
  if (colon == NULL) {
    return fallback_value;
  }
  colon++;
  while (*colon == ' ' || *colon == '\t' || *colon == '\r' || *colon == '\n') {
    colon++;
  }
  value = strtol(colon, &endptr, 10);
  if (endptr == colon) {
    return fallback_value;
  }
  return value;
}
 
static char *native_migration_fixture_path(const AppRuntime *app) {
  char *manifest_path = NULL;
  char *manifest_text = NULL;
  char *relative_path = NULL;
  char *resolved = NULL;
  if (app == NULL || app->app_root == NULL) {
    return NULL;
  }
  manifest_path = path_join(app->app_root, "pharos.app.json");
  if (manifest_path == NULL || !path_exists(manifest_path)) {
    free(manifest_path);
    return NULL;
  }
  manifest_text = read_file_text(manifest_path);
  if (manifest_text == NULL) {
    free(manifest_path);
    return NULL;
  }
  relative_path = json_find_string_in_section(manifest_text, "fixtures", "migration_fixture");
  if (relative_path != NULL && relative_path[0] != '\0') {
    resolved = resolve_relative_to(app->app_root, relative_path);
  }
  free(manifest_path);
  free(manifest_text);
  free(relative_path);
  return resolved;
}
 
static long native_migration_schema_version(const char *migration_fixture_path) {
  char *fixture_text;
  long schema_version = 0;
  if (migration_fixture_path == NULL || !path_exists(migration_fixture_path)) {
    return 0;
  }
  fixture_text = read_file_text(migration_fixture_path);
  if (fixture_text == NULL) {
    return 0;
  }
  schema_version = native_json_top_level_long(fixture_text, "schema_version", 0);
  free(fixture_text);
  return schema_version;
}
 
static int native_write_backup_state_snapshot(const AppRuntime *app, const char *output_path) {
  if (app != NULL && app->state_path != NULL && path_exists(app->state_path)) {
    return copy_file_binary(app->state_path, output_path);
  }
  return write_text_file(output_path, "{}\n");
}
 
static char *native_metadata_artifact_value(const char *metadata_path, const char *key) {
  char *metadata_text = NULL;
  char *value = NULL;
  if (metadata_path == NULL || !path_exists(metadata_path)) {
    return NULL;
  }
  metadata_text = read_file_text(metadata_path);
  if (metadata_text == NULL) {
    return NULL;
  }
  value = json_find_string_in_section(metadata_text, "artifacts", key);
  free(metadata_text);
  return value;
}
 
char *build_native_backup_report_local_json(const ServeConfig *config, const AppRuntime *app, const char *backend_override, const char *output_dir_override, char **error_out) {
  char *backend = NULL;
  char *base_dir = NULL;
  char *timestamp = NULL;
  char *target_dir = NULL;
  char *backup_dir_path = NULL;
  char *state_backup_path = NULL;
  char *metadata_path = NULL;
  char *sqlite_db_path = NULL;
  char *sqlite_snapshot_path = NULL;
  char *migration_fixture = NULL;
  char *migration_fixture_json = NULL;
  char *target_id_json = NULL;
  char *backend_json = NULL;
  char *backup_dir_json = NULL;
  char *metadata_path_json = NULL;
  char *state_path_json = NULL;
  char *sqlite_snapshot_path_json = NULL;
  char *schema_json = NULL;
  char *metadata_json = NULL;
  char *result = NULL;
  long schema_version = 0;
  size_t metadata_needed;
  size_t needed;
 
  if (error_out != NULL) {
    *error_out = NULL;
  }
  if (config == NULL || app == NULL || config->target_id == NULL) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup requires a resolved app runtime");
    }
    return NULL;
  }
 
  backend = (backend_override != NULL && backend_override[0] != '\0') ? native_backup_restore_strdup(backend_override) : native_default_backend_local(app);
  if (backend == NULL || !streq(backend, "sqlite")) {
    free(backend);
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup currently supports sqlite-backed apps only");
    }
    return NULL;
  }
 
  base_dir = (output_dir_override != NULL && output_dir_override[0] != '\0') ? native_backup_restore_strdup(output_dir_override) : native_backup_base_dir(app);
  timestamp = native_backup_timestamp_utc();
  target_dir = path_join(base_dir, config->target_id);
  backup_dir_path = path_join(target_dir, timestamp);
  state_backup_path = path_join(backup_dir_path, "state.json");
  metadata_path = path_join(backup_dir_path, "metadata.json");
  sqlite_db_path = native_default_sqlite_path_local(app);
  sqlite_snapshot_path = path_join(backup_dir_path, "database.sqlite3");
  migration_fixture = native_migration_fixture_path(app);
  schema_version = native_migration_schema_version(migration_fixture);
 
  if (base_dir == NULL || timestamp == NULL || target_dir == NULL || backup_dir_path == NULL || state_backup_path == NULL || metadata_path == NULL || sqlite_db_path == NULL || sqlite_snapshot_path == NULL) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup could not resolve required paths");
    }
    goto cleanup;
  }
  if (!path_exists(sqlite_db_path)) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("sqlite backup requires an existing database file");
    }
    goto cleanup;
  }
  if (ensure_directory(backup_dir_path) != 0) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup could not create the backup directory");
    }
    goto cleanup;
  }
  if (copy_file_binary(sqlite_db_path, sqlite_snapshot_path) != 0) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup could not copy the sqlite snapshot");
    }
    goto cleanup;
  }
  if (native_write_backup_state_snapshot(app, state_backup_path) != 0) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup could not write the state scratch snapshot");
    }
    goto cleanup;
  }
 
  migration_fixture_json = migration_fixture != NULL ? json_string_dup_native(migration_fixture) : native_backup_restore_strdup("null");
  schema_json = native_backup_restore_strdup("pharos.backup.bundle.v1");
  target_id_json = json_string_dup_native(config->target_id);
  backend_json = json_string_dup_native(backend);
  backup_dir_json = json_string_dup_native(backup_dir_path);
  metadata_path_json = json_string_dup_native(metadata_path);
  state_path_json = json_string_dup_native(state_backup_path);
  sqlite_snapshot_path_json = json_string_dup_native(sqlite_snapshot_path);
  if (migration_fixture_json == NULL || schema_json == NULL || target_id_json == NULL || backend_json == NULL || backup_dir_json == NULL || metadata_path_json == NULL || state_path_json == NULL || sqlite_snapshot_path_json == NULL) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup could not allocate report fields");
    }
    goto cleanup;
  }
 
  metadata_needed = strlen(schema_json) + strlen(target_id_json) + strlen(backend_json) + strlen(timestamp) + strlen(state_path_json) + strlen(sqlite_snapshot_path_json) + strlen(migration_fixture_json) + 256;
  metadata_json = (char *)malloc(metadata_needed);
  if (metadata_json == NULL) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup could not allocate metadata output");
    }
    goto cleanup;
  }
  snprintf(metadata_json, metadata_needed, "{\"schema\":\"pharos.backup.bundle.v1\",\"target_kind\":\"app\",\"target_id\":%s,\"backend\":%s,\"environment\":\"development\",\"created_at\":\"%s\",\"schema_version\":%ld,\"migration_fixture\":%s,\"artifacts\":{\"state_json\":%s,\"sqlite_snapshot\":%s}}", target_id_json, backend_json, timestamp, schema_version, migration_fixture_json, state_path_json, sqlite_snapshot_path_json);
  if (write_text_file(metadata_path, metadata_json) != 0) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native backup could not write metadata.json");
    }
    goto cleanup;
  }
 
  needed = strlen(target_id_json) + strlen(backend_json) + strlen(backup_dir_json) + strlen(metadata_path_json) + strlen(state_path_json) + strlen(sqlite_snapshot_path_json) + 192;
  result = (char *)malloc(needed);
  if (result != NULL) {
    snprintf(result, needed, "{\"report_id\":\"pharos-backup-v1\",\"target_kind\":\"app\",\"target_id\":%s,\"backend\":%s,\"status\":\"backed_up\",\"backup_dir\":%s,\"metadata_path\":%s,\"state_path\":%s,\"sqlite_snapshot\":%s}", target_id_json, backend_json, backup_dir_json, metadata_path_json, state_path_json, sqlite_snapshot_path_json);
  }
  if (result == NULL && error_out != NULL) {
    *error_out = native_backup_restore_strdup("native backup could not allocate the backup report");
  }
 
cleanup:
  free(backend);
  free(base_dir);
  free(timestamp);
  free(target_dir);
  free(backup_dir_path);
  free(state_backup_path);
  free(metadata_path);
  free(sqlite_db_path);
  free(sqlite_snapshot_path);
  free(migration_fixture);
  free(migration_fixture_json);
  free(target_id_json);
  free(backend_json);
  free(backup_dir_json);
  free(metadata_path_json);
  free(state_path_json);
  free(sqlite_snapshot_path_json);
  free(schema_json);
  free(metadata_json);
  return result;
}
 
char *build_native_restore_report_local_json(const ServeConfig *config, const AppRuntime *app, const char *backend_override, const char *input_dir, char **error_out) {
  char *backend = NULL;
  char *metadata_path = NULL;
  char *state_path = NULL;
  char *sqlite_snapshot_path = NULL;
  char *metadata_snapshot_value = NULL;
  char *metadata_state_value = NULL;
  char *sqlite_db_path = NULL;
  char *db_parent = NULL;
  char *tmp_db_path = NULL;
  char *target_id_json = NULL;
  char *backend_json = NULL;
  char *input_dir_json = NULL;
  char *result = NULL;
  size_t needed;
 
  if (error_out != NULL) {
    *error_out = NULL;
  }
  if (config == NULL || app == NULL || config->target_id == NULL) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native restore requires a resolved app runtime");
    }
    return NULL;
  }
  if (input_dir == NULL || input_dir[0] == '\0') {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("restore requires --input-dir");
    }
    return NULL;
  }
 
  backend = (backend_override != NULL && backend_override[0] != '\0') ? native_backup_restore_strdup(backend_override) : native_default_backend_local(app);
  if (backend == NULL || !streq(backend, "sqlite")) {
    free(backend);
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native restore currently supports sqlite-backed apps only");
    }
    return NULL;
  }
 
  metadata_path = path_join(input_dir, "metadata.json");
  state_path = path_join(input_dir, "state.json");
  metadata_snapshot_value = native_metadata_artifact_value(metadata_path, "sqlite_snapshot");
  metadata_state_value = native_metadata_artifact_value(metadata_path, "state_json");
  sqlite_snapshot_path = metadata_snapshot_value != NULL && metadata_snapshot_value[0] != '\0' ? metadata_snapshot_value : path_join(input_dir, "database.sqlite3");
  metadata_snapshot_value = NULL;
  sqlite_db_path = native_default_sqlite_path_local(app);
  db_parent = path_dirname(sqlite_db_path);
  tmp_db_path = sqlite_db_path != NULL ? (char *)malloc(strlen(sqlite_db_path) + 16) : NULL;
 
  if (metadata_path == NULL || sqlite_db_path == NULL || db_parent == NULL || tmp_db_path == NULL) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native restore could not resolve required paths");
    }
    goto cleanup;
  }
  snprintf(tmp_db_path, strlen(sqlite_db_path) + 16, "%s.restore.tmp", sqlite_db_path);
  if (!path_exists(metadata_path)) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("missing restore metadata");
    }
    goto cleanup;
  }
  if (sqlite_snapshot_path == NULL || !path_exists(sqlite_snapshot_path)) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("sqlite restore requires a database snapshot and will not rebuild database truth from JSON");
    }
    goto cleanup;
  }
  if (ensure_directory(db_parent) != 0) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native restore could not create the sqlite parent directory");
    }
    goto cleanup;
  }
  if (copy_file_binary(sqlite_snapshot_path, tmp_db_path) != 0) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native restore could not copy the sqlite snapshot");
    }
    goto cleanup;
  }
  if (rename(tmp_db_path, sqlite_db_path) != 0) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native restore could not replace the sqlite database");
    }
    goto cleanup;
  }
  if (app->state_path != NULL) {
    const char *state_source = metadata_state_value != NULL && metadata_state_value[0] != '\0' ? metadata_state_value : state_path;
    if (state_source != NULL && path_exists(state_source)) {
      copy_file_binary(state_source, app->state_path);
    }
  }
 
  target_id_json = json_string_dup_native(config->target_id);
  backend_json = json_string_dup_native(backend);
  input_dir_json = json_string_dup_native(input_dir);
  if (target_id_json == NULL || backend_json == NULL || input_dir_json == NULL) {
    if (error_out != NULL) {
      *error_out = native_backup_restore_strdup("native restore could not allocate report fields");
    }
    goto cleanup;
  }
  needed = strlen(target_id_json) + strlen(backend_json) + strlen(input_dir_json) + 128;
  result = (char *)malloc(needed);
  if (result != NULL) {
    snprintf(result, needed, "{\"report_id\":\"pharos-restore-v1\",\"target_kind\":\"app\",\"target_id\":%s,\"backend\":%s,\"input_dir\":%s,\"status\":\"restored\"}", target_id_json, backend_json, input_dir_json);
  }
  if (result == NULL && error_out != NULL) {
    *error_out = native_backup_restore_strdup("native restore could not allocate the restore report");
  }
 
cleanup:
  free(backend);
  free(metadata_path);
  free(state_path);
  free(sqlite_snapshot_path);
  free(metadata_snapshot_value);
  free(metadata_state_value);
  free(sqlite_db_path);
  free(db_parent);
  free(tmp_db_path);
  free(target_id_json);
  free(backend_json);
  free(input_dir_json);
  return result;
}