native_app_runtime_paths.c

Go to the documentation of this file.

/**
 * @file
 * @brief Finds app roots and computes default or effective build, state, base, log, debug, and error-report paths.
 */
 
#include "native_app_runtime_paths.h"
 
#include "native_app_config.h"
#include "native_json_config.h"
#include "native_support.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#ifdef _WIN32
#define pharos_app_runtime_paths_strdup _strdup
#else
#include <dirent.h>
#define pharos_app_runtime_paths_strdup strdup
#endif
 
char *match_app_root_in_directory(const char *base_dir, const char *target_id) {
  char *manifest_path = NULL;
  char *manifest_text = NULL;
  char *manifest_id = NULL;
  char *matched = NULL;
#ifndef _WIN32
  DIR *dir = NULL;
  struct dirent *entry;
#endif
  if (base_dir == NULL || target_id == NULL || base_dir[0] == '\0') {
    return NULL;
  }
  manifest_path = path_join(base_dir, "pharos.app.json");
  if (manifest_path != NULL && path_exists(manifest_path)) {
    manifest_text = read_file_text(manifest_path);
    if (manifest_text != NULL) {
      manifest_id = json_find_string(manifest_text, "app_id");
      if (manifest_id != NULL && streq(manifest_id, target_id)) {
        matched = path_canonicalize(base_dir);
        if (matched == NULL) {
          matched = pharos_app_runtime_paths_strdup(base_dir);
        }
      }
    }
  }
  free(manifest_id);
  free(manifest_text);
  free(manifest_path);
  if (matched != NULL) {
    return matched;
  }
#ifndef _WIN32
  dir = opendir(base_dir);
  if (dir == NULL) {
    return NULL;
  }
  while ((entry = readdir(dir)) != NULL) {
    char *child_root;
    if (streq(entry->d_name, ".") || streq(entry->d_name, "..")) {
      continue;
    }
    child_root = path_join(base_dir, entry->d_name);
    if (child_root == NULL) {
      continue;
    }
    if (path_is_directory(child_root)) {
      manifest_path = path_join(child_root, "pharos.app.json");
      if (manifest_path != NULL && path_exists(manifest_path)) {
        manifest_text = read_file_text(manifest_path);
        if (manifest_text != NULL) {
          manifest_id = json_find_string(manifest_text, "app_id");
          if (manifest_id != NULL && streq(manifest_id, target_id)) {
            matched = path_canonicalize(child_root);
            if (matched == NULL) {
              matched = pharos_app_runtime_paths_strdup(child_root);
            }
          }
        }
      }
      free(manifest_id);
      manifest_id = NULL;
      free(manifest_text);
      manifest_text = NULL;
      free(manifest_path);
      manifest_path = NULL;
      if (matched != NULL) {
        free(child_root);
        break;
      }
    }
    free(child_root);
  }
  closedir(dir);
#endif
  return matched;
}
 
char *find_app_root_for_target(const char *target_id, const char *app_dir_hint, const char *repo_root, const char *binary_dir) {
  char *matched;
  if (app_dir_hint != NULL && app_dir_hint[0] != '\0') {
    matched = match_app_root_in_directory(app_dir_hint, target_id);
    if (matched != NULL) {
      return matched;
    }
  }
  if (repo_root != NULL && repo_root[0] != '\0') {
    char *apps_dir = path_join(repo_root, "apps");
    matched = match_app_root_in_directory(apps_dir, target_id);
    free(apps_dir);
    if (matched != NULL) {
      return matched;
    }
  }
  if (binary_dir != NULL && binary_dir[0] != '\0') {
    char *apps_adj = path_join(binary_dir, "apps");
    matched = match_app_root_in_directory(apps_adj, target_id);
    free(apps_adj);
    if (matched != NULL) {
      return matched;
    }
    {
      char *binary_parent = path_dirname(binary_dir);
      if (binary_parent != NULL) {
        char *apps_near = path_join(binary_parent, "apps");
        matched = match_app_root_in_directory(apps_near, target_id);
        free(apps_near);
        free(binary_parent);
        if (matched != NULL) {
          return matched;
        }
      }
    }
  }
  return NULL;
}
 
char *app_build_dir_local_native(const char *app_root) {
  AppLocalConfigNative config;
  char *value = NULL;
  char *result = NULL;
  if (load_app_local_config_native(app_root, &config) == 0) {
    if (config.build_dir != NULL && config.build_dir[0] != '\0') {
      value = pharos_app_runtime_paths_strdup(config.build_dir);
    } else if (config.manifest_build_artifact_dir != NULL && config.manifest_build_artifact_dir[0] != '\0' && !streq(config.manifest_build_artifact_dir, "null")) {
      if (streq(config.manifest_build_artifact_dir, ".")) {
        value = path_dirname(app_root);
      } else {
        char *artifact_parent = path_dirname(config.manifest_build_artifact_dir);
        if (artifact_parent != NULL) {
          value = path_dirname(artifact_parent);
        }
        free(artifact_parent);
      }
    }
    free_app_local_config_native(&config);
  }
  if (value != NULL && value[0] != '\0') {
    return value;
  }
  free(value);
  result = path_dirname(app_root);
  if (result != NULL && result[0] != '\0') {
    return result;
  }
  free(result);
  return path_join(app_root, "dist");
}
 
char *effective_app_build_dir_native(const char *app_root, const char *build_dir_override) {
  if (build_dir_override != NULL && build_dir_override[0] != '\0') {
    return pharos_app_runtime_paths_strdup(build_dir_override);
  }
  return app_build_dir_local_native(app_root);
}
 
char *app_artifact_dir_from_build_dir_native(const char *build_dir, const char *app_id) {
  char *apps_root = NULL;
  char *artifact_dir = NULL;
  size_t len;
  if (build_dir == NULL || app_id == NULL) {
    return NULL;
  }
  len = strlen(build_dir);
  if ((len >= 5 && streq(build_dir + len - 5, "/apps")) || streq(build_dir, "apps")
#ifdef _WIN32
      || (len >= 5 && streq(build_dir + len - 5, "\\apps"))
#endif
  ) {
    return path_join(build_dir, app_id);
  }
  apps_root = path_join(build_dir, "apps");
  if (apps_root == NULL) {
    return NULL;
  }
  artifact_dir = path_join(apps_root, app_id);
  free(apps_root);
  return artifact_dir;
}
 
char *effective_app_artifact_dir_native(const char *app_root, const char *build_dir, const char *app_id) {
  AppLocalConfigNative config;
  char *artifact_dir = NULL;
  if (load_app_local_config_native(app_root, &config) == 0) {
    if (config.manifest_build_artifact_dir != NULL && config.manifest_build_artifact_dir[0] != '\0' && !streq(config.manifest_build_artifact_dir, "null")) {
      if (streq(config.manifest_build_artifact_dir, ".")) {
        artifact_dir = pharos_app_runtime_paths_strdup(app_root);
      } else {
#ifdef _WIN32
        if ((strlen(config.manifest_build_artifact_dir) > 2 && config.manifest_build_artifact_dir[1] == ':') || config.manifest_build_artifact_dir[0] == '\\' || config.manifest_build_artifact_dir[0] == '/') {
          artifact_dir = pharos_app_runtime_paths_strdup(config.manifest_build_artifact_dir);
        } else if (build_dir != NULL && build_dir[0] != '\0') {
          artifact_dir = path_join(build_dir, config.manifest_build_artifact_dir);
        }
#else
        if (config.manifest_build_artifact_dir[0] == '/') {
          artifact_dir = pharos_app_runtime_paths_strdup(config.manifest_build_artifact_dir);
        } else if (build_dir != NULL && build_dir[0] != '\0') {
          artifact_dir = path_join(build_dir, config.manifest_build_artifact_dir);
        }
#endif
      }
    }
    free_app_local_config_native(&config);
  }
  if (artifact_dir != NULL) {
    return artifact_dir;
  }
  return app_artifact_dir_from_build_dir_native(build_dir, app_id);
}
 
char *app_state_path_local_native(const char *app_root, const char *build_dir, const char *app_id) {
  AppLocalConfigNative config;
  char *resolved = NULL;
  if (load_app_local_config_native(app_root, &config) == 0) {
    if (config.state_path != NULL && config.state_path[0] != '\0') {
      resolved = pharos_app_runtime_paths_strdup(config.state_path);
      free_app_local_config_native(&config);
      return resolved;
    }
    if (config.state_dir != NULL && config.state_dir[0] != '\0') {
      resolved = path_join(config.state_dir, app_id);
      free_app_local_config_native(&config);
      if (resolved == NULL) {
        return NULL;
      }
      {
        char *tmp = path_join(resolved, "runtime-state.json");
        free(resolved);
        return tmp;
      }
    }
    if (config.manifest_state_path != NULL && config.manifest_state_path[0] != '\0' && !streq(config.manifest_state_path, "null")) {
      if (
#ifdef _WIN32
          (strlen(config.manifest_state_path) > 2 && config.manifest_state_path[1] == ':') ||
#endif
          config.manifest_state_path[0] == '/'
      ) {
        resolved = pharos_app_runtime_paths_strdup(config.manifest_state_path);
      } else {
        resolved = path_join(app_root, config.manifest_state_path);
      }
      free_app_local_config_native(&config);
      return resolved;
    }
    free_app_local_config_native(&config);
  }
  resolved = effective_app_artifact_dir_native(app_root, build_dir, app_id);
  if (resolved == NULL) {
    return NULL;
  }
  {
    char *tmp = path_join(resolved, "runtime-state.json");
    free(resolved);
    return tmp;
  }
}
 
char *effective_app_state_path_native(const char *app_root, const char *build_dir, const char *app_id, const char *state_path_override, const char *state_dir_override) {
  char *resolved = NULL;
  if (state_path_override != NULL && state_path_override[0] != '\0') {
    return pharos_app_runtime_paths_strdup(state_path_override);
  }
  if (state_dir_override != NULL && state_dir_override[0] != '\0') {
    resolved = path_join(state_dir_override, app_id);
    if (resolved == NULL) {
      return NULL;
    }
    {
      char *tmp = path_join(resolved, "runtime-state.json");
      free(resolved);
      return tmp;
    }
  }
  return app_state_path_local_native(app_root, build_dir, app_id);
}
 
char *app_base_path_local_native(const char *app_root) {
  AppLocalConfigNative config;
  char *value = NULL;
  char *normalized;
  if (load_app_local_config_native(app_root, &config) == 0) {
    if (config.base_path != NULL && config.base_path[0] != '\0') {
      value = pharos_app_runtime_paths_strdup(config.base_path);
    } else if (config.manifest_base_path != NULL) {
      value = pharos_app_runtime_paths_strdup(config.manifest_base_path);
    }
    free_app_local_config_native(&config);
  }
  if (value == NULL) {
    value = pharos_app_runtime_paths_strdup("");
  }
  normalized = normalize_base_path_native(value);
  free(value);
  return normalized;
}
 
char *effective_app_base_path_native(const char *app_root, const char *base_path_override) {
  if (base_path_override != NULL && base_path_override[0] != '\0') {
    return normalize_base_path_native(base_path_override);
  }
  return app_base_path_local_native(app_root);
}
 
char *app_log_path_local_native(const char *app_root, const char *app_id) {
  AppLocalConfigNative config;
  char *value = NULL;
  if (load_app_local_config_native(app_root, &config) == 0) {
    if (config.log_path != NULL && config.log_path[0] != '\0') {
      value = pharos_app_runtime_paths_strdup(config.log_path);
    }
    free_app_local_config_native(&config);
  }
  if (value != NULL && value[0] != '\0') {
    return value;
  }
  free(value);
  {
    size_t needed = strlen("/var/log/pharos/.log") + strlen(app_id) + 1;
    char *log_path = (char *)malloc(needed);
    if (log_path != NULL) {
      snprintf(log_path, needed, "/var/log/pharos/%s.log", app_id);
    }
    return log_path;
  }
}
 
char *effective_app_log_path_native(const char *app_root, const char *app_id, const char *log_path_override) {
  if (log_path_override != NULL && log_path_override[0] != '\0') {
    return pharos_app_runtime_paths_strdup(log_path_override);
  }
  return app_log_path_local_native(app_root, app_id);
}
 
char *app_log_format_local_native(const char *app_root) {
  (void)app_root;
  return pharos_app_runtime_paths_strdup("service");
}
 
char *effective_app_log_format_native(const char *app_root) {
  return app_log_format_local_native(app_root);
}
 
char *app_error_report_path_local_native(const char *app_root) {
  AppLocalConfigNative config;
  char *value = NULL;
  if (load_app_local_config_native(app_root, &config) == 0) {
    if (config.error_report_path != NULL && config.error_report_path[0] != '\0') {
      value = pharos_app_runtime_paths_strdup(config.error_report_path);
    }
    free_app_local_config_native(&config);
  }
  if (value != NULL && value[0] != '\0') {
    return value;
  }
  free(value);
  return pharos_app_runtime_paths_strdup("");
}
 
char *effective_app_error_report_path_native(const char *app_root, const char *app_id) {
  char *value = app_error_report_path_local_native(app_root);
  if (value != NULL && value[0] != '\0') {
    return value;
  }
  free(value);
  {
    size_t needed = strlen("/var/log/pharos/.error.jsonl") + strlen(app_id != NULL ? app_id : "app") + 1;
    char *path = (char *)malloc(needed);
    if (path != NULL) {
      snprintf(path, needed, "/var/log/pharos/%s.error.jsonl", app_id != NULL && app_id[0] != '\0' ? app_id : "app");
    }
    return path;
  }
}
 
char *app_debug_local_native(const char *app_root) {
  AppLocalConfigNative config;
  char *value = NULL;
  if (load_app_local_config_native(app_root, &config) == 0) {
    if (config.debug != NULL && config.debug[0] != '\0') {
      value = pharos_app_runtime_paths_strdup(config.debug);
    }
    free_app_local_config_native(&config);
  }
  if (value != NULL && value[0] != '\0') {
    return value;
  }
  free(value);
  return pharos_app_runtime_paths_strdup("false");
}
 
char *effective_app_debug_native(const char *app_root, const char *debug_override) {
  if (debug_override != NULL && debug_override[0] != '\0') {
    return pharos_app_runtime_paths_strdup(debug_override);
  }
  return app_debug_local_native(app_root);
}