Add bootstrap logs for lock/resolve

Author: TracSystems

src/lock.c

@@ -1,14 +1,44 @@
 #include <fs.h>
 #include <path.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <uv.h>
 
 #include "../include/appling.h"
 
+static void
+appling__bootstrap_log(const char *tag, const char *detail) {
+  const char *log_path = getenv("PEAR_BOOTSTRAP_LOG");
+  if (!log_path || !log_path[0]) return;
+
+  FILE *fp = fopen(log_path, "a");
+  if (!fp) return;
+
+  fprintf(fp, "[%llu] %s: %s\n",
+    (unsigned long long) uv_hrtime(),
+    tag ? tag : "(null)",
+    detail ? detail : ""
+  );
+
+  fclose(fp);
+}
+
 static void
 appling_lock__on_close(fs_close_t *fs_req, int status) {
   appling_lock_t *req = (appling_lock_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("lock-close", "req-null");
+    return;
+  }
+
+  {
+    char buf[128];
+    snprintf(buf, sizeof(buf), "status=%d", status);
+    appling__bootstrap_log("lock-close", buf);
+  }
+
   if (req->status < 0) status = req->status;
 
   if (status >= 0) {
@@ -22,6 +52,17 @@ static void
 appling_lock__on_lock(fs_lock_t *fs_req, int status) {
   appling_lock_t *req = (appling_lock_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("lock-lock", "req-null");
+    return;
+  }
+
+  {
+    char buf[128];
+    snprintf(buf, sizeof(buf), "status=%d", status);
+    appling__bootstrap_log("lock-lock", buf);
+  }
+
   if (status >= 0) {
     if (req->on_lock) req->on_lock(req, 0);
   } else {
@@ -35,6 +76,17 @@ static void
 appling_lock__on_open(fs_open_t *fs_req, int status, uv_file file) {
   appling_lock_t *req = (appling_lock_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("lock-open", "req-null");
+    return;
+  }
+
+  {
+    char buf[128];
+    snprintf(buf, sizeof(buf), "status=%d", status);
+    appling__bootstrap_log("lock-open", buf);
+  }
+
   if (status >= 0) {
     req->file = file;
 
@@ -48,6 +100,17 @@ static void
 appling_lock__on_mkdir(fs_mkdir_t *fs_req, int status) {
   appling_lock_t *req = (appling_lock_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("lock-mkdir", "req-null");
+    return;
+  }
+
+  {
+    char buf[256];
+    snprintf(buf, sizeof(buf), "status=%d dir=%s", status, req->dir);
+    appling__bootstrap_log("lock-mkdir", buf);
+  }
+
   appling_path_t path;
   size_t path_len = sizeof(appling_path_t);
 
@@ -110,5 +173,17 @@ appling_lock(uv_loop_t *loop, appling_lock_t *req, const char *dir, appling_lock
     );
   }
 
+  appling__bootstrap_log("lock-dir", req->dir);
+  {
+    uv_fs_t stat_req;
+    int stat_rc = uv_fs_stat(loop, &stat_req, req->dir, NULL);
+    if (stat_rc < 0) {
+      char buf[256];
+      snprintf(buf, sizeof(buf), "missing(%d) %s", stat_rc, req->dir);
+      appling__bootstrap_log("lock-dir-missing", buf);
+    }
+    uv_fs_req_cleanup(&stat_req);
+  }
+
   return fs_mkdir(req->loop, &req->mkdir, req->dir, 0777, true, appling_lock__on_mkdir);
 }

src/resolve.c

@@ -10,13 +10,41 @@
 
 #include "../include/appling.h"
 
+static void
+appling__bootstrap_log(const char *tag, const char *detail) {
+  const char *log_path = getenv("PEAR_BOOTSTRAP_LOG");
+  if (!log_path || !log_path[0]) return;
+
+  FILE *fp = fopen(log_path, "a");
+  if (!fp) return;
+
+  fprintf(fp, "[%llu] %s: %s\n",
+    (unsigned long long) uv_hrtime(),
+    tag ? tag : "(null)",
+    detail ? detail : ""
+  );
+
+  fclose(fp);
+}
+
 static void
 appling_resolve__realpath(appling_resolve_t *req);
 
 static void
 appling_resolve__on_close(fs_close_t *fs_req, int status) {
   appling_resolve_t *req = (appling_resolve_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("resolve-close", "req-null");
+    return;
+  }
+
+  {
+    char buf[128];
+    snprintf(buf, sizeof(buf), "status=%d", status);
+    appling__bootstrap_log("resolve-close", buf);
+  }
+
   if (req->status < 0) status = req->status;
 
   if (status >= 0) {
@@ -35,6 +63,11 @@ appling_resolve__on_read(fs_read_t *fs_req, int status, size_t read) {
 
   appling_resolve_t *req = (appling_resolve_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("resolve-read", "req-null");
+    return;
+  }
+
   if (status >= 0) {
     compact_state_t state = {
       0,
@@ -106,6 +139,11 @@ appling_resolve__on_read(fs_read_t *fs_req, int status, size_t read) {
 
     req->status = 0; // Reset
   } else {
+    {
+      char buf[128];
+      snprintf(buf, sizeof(buf), "status=%d", status);
+      appling__bootstrap_log("resolve-read", buf);
+    }
     req->status = status; // Propagate
   }
 
@@ -119,13 +157,23 @@ static void
 appling_resolve__on_stat(fs_stat_t *fs_req, int status, const uv_stat_t *stat) {
   appling_resolve_t *req = (appling_resolve_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("resolve-stat", "req-null");
+    return;
+  }
+
   if (status >= 0) {
     size_t len = stat->st_size;
 
     req->buf = uv_buf_init(malloc(len), len);
 
     fs_read(req->loop, &req->read, req->file, &req->buf, 1, 0, appling_resolve__on_read);
   } else {
+    {
+      char buf[128];
+      snprintf(buf, sizeof(buf), "status=%d", status);
+      appling__bootstrap_log("resolve-stat", buf);
+    }
     req->status = status; // Propagate
 
     fs_close(req->loop, &req->close, req->file, appling_resolve__on_close);
@@ -136,11 +184,29 @@ static void
 appling_resolve__on_open(fs_open_t *fs_req, int status, uv_file file) {
   appling_resolve_t *req = (appling_resolve_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("resolve-open", "req-null");
+    return;
+  }
+
   if (status >= 0) {
     req->file = file;
 
     fs_stat(req->loop, &req->stat, req->file, appling_resolve__on_stat);
   } else {
+    appling_path_t path;
+    size_t path_len = sizeof(appling_path_t);
+    path_join(
+      (const char *[]) {req->platform->path, "..", "..", "checkout", NULL},
+      path,
+      &path_len,
+      path_behavior_system
+    );
+    {
+      char buf[256];
+      snprintf(buf, sizeof(buf), "status=%d path=%s", status, path);
+      appling__bootstrap_log("resolve-open", buf);
+    }
     if (req->cb) req->cb(req, status);
   }
 }
@@ -166,11 +232,32 @@ static void
 appling_resolve__on_realpath(fs_realpath_t *fs_req, int status, const char *path) {
   appling_resolve_t *req = (appling_resolve_t *) fs_req->data;
 
+  if (!req) {
+    appling__bootstrap_log("resolve-realpath", "req-null");
+    return;
+  }
+
   if (status >= 0) {
     strcpy(req->platform->path, path);
 
     appling_resolve__open(req);
   } else {
+    {
+      appling_path_t candidate_path;
+      size_t candidate_len = sizeof(appling_path_t);
+      size_t i = req->candidate;
+      if (appling_platform_candidates[i]) {
+        path_join(
+          (const char *[]) {req->path, appling_platform_candidates[i], NULL},
+          candidate_path,
+          &candidate_len,
+          path_behavior_system
+        );
+        char buf[256];
+        snprintf(buf, sizeof(buf), "status=%d path=%s", status, candidate_path);
+        appling__bootstrap_log("resolve-realpath", buf);
+      }
+    }
     size_t i = ++req->candidate;
 
     if (appling_platform_candidates[i]) appling_resolve__realpath(req);
@@ -192,6 +279,12 @@ appling_resolve__realpath(appling_resolve_t *req) {
     path_behavior_system
   );
 
+  {
+    char buf[256];
+    snprintf(buf, sizeof(buf), "candidate=%zu path=%s", i, path);
+    appling__bootstrap_log("resolve-candidate", buf);
+  }
+
   log_debug("appling_resolve() accessing platform at %s", path);
 
   fs_realpath(req->loop, &req->realpath, path, appling_resolve__on_realpath);
@@ -245,6 +338,8 @@ appling_resolve(uv_loop_t *loop, appling_resolve_t *req, const char *dir, applin
     );
   }
 
+  appling__bootstrap_log("resolve-root", req->path);
+
   appling_resolve__realpath(req);
 
   return 0;