http_renderer_process.c File Reference

Go to the source code of this file.

Data Structures
struct	render_worker_t

Macros
#define	MCP_RENDER_ENV_CAPACITY   16

Functions
void	http_renderer_process (http_renderer_process_request_t *r, atomic_t *cancelled, http_renderer_process_result_t *result)
void	http_renderer_process_result_destroy (http_renderer_process_result_t *result)

Macro Definition Documentation

MCP_RENDER_ENV_CAPACITY

#define MCP_RENDER_ENV_CAPACITY   16

Definition at line 3 of file http_renderer_process.c.

Referenced by http_renderer_process().

Function Documentation

http_renderer_process()

void http_renderer_process	(	http_renderer_process_request_t *	r,
		atomic_t *	cancelled,
		http_renderer_process_result_t *	result )

Definition at line 112 of file http_renderer_process.c.

                                                                   {
  memset(result, 0, sizeof(*result));
  if (r->output_type != HTTP_RENDER_OUTPUT_TEXT && r->output_type != HTTP_RENDER_OUTPUT_FILE) {
    SAFE_STRNCPY(result->error, "Renderer output must select text or files", sizeof(result->error));
    return;
  }
  render_worker_t w = {.cancelled = cancelled, .result = result, .started = time_get_ns(), .timeout = r->timeout_ms};
  result->text = SAFE_CALLOC(HTTP_RENDERER_MAX_OUTPUT + 1, 1, char *);
  if (uv_loop_init(&w.loop)) {
    SAFE_STRNCPY(result->error, "Cannot initialize renderer event loop", sizeof(result->error));
    return;
  }
  uv_pipe_init(&w.loop, &w.output, 0);
  uv_pipe_init(&w.loop, &w.errors, 0);
  uv_timer_init(&w.loop, &w.timer);
  w.output.data = w.errors.data = w.timer.data = w.process.data = &w;
  uv_stdio_container_t streams[3] = {0};
  streams[0].flags = UV_IGNORE;
  streams[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
  streams[1].data.stream = (uv_stream_t *)&w.output;
  streams[2].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
  streams[2].data.stream = (uv_stream_t *)&w.errors;
  // Only runtime essentials are inherited; user config, ASCII_CHAT_* and credentials are excluded.
  const char *keys[] = {
      "PATH", "SystemRoot", "WINDIR", "TEMP", "TMP", "TMPDIR", "LD_LIBRARY_PATH", "DYLD_LIBRARY_PATH", "TESTING", NULL};
  char *env[MCP_RENDER_ENV_CAPACITY] = {0};
  size_t ne = 0;
  for (size_t i = 0; keys[i]; ++i) {
    const char *v = platform_getenv(keys[i]);
    if (v) {
      size_t n = strlen(keys[i]) + strlen(v) + 2;
      env[ne] = SAFE_MALLOC(n, char *);
      SAFE_SNPRINTF(env[ne], n, "%s=%s", keys[i], v);
      ++ne;
    }
  }
  // The private staging directory provides an isolated home for media libraries.
  if (r->stage_dir[0]) {
    size_t n = strlen(r->stage_dir) + sizeof("HOME=");
    env[ne] = SAFE_MALLOC(n, char *);
    SAFE_SNPRINTF(env[ne], n, "HOME=%s", r->stage_dir);
    ++ne;
  }
  env[ne++] = platform_strdup("ASCII_CHAT_MCP_WORKER=1");
  env[ne++] = platform_strdup("ASCII_CHAT_OTEL_ENABLED_TELEMETRY=none");
  if (r->capture_webcam)
    env[ne++] = platform_strdup("ASCII_CHAT_MCP_WEBCAM=1");
  uv_process_options_t opts = {
      .exit_cb = exited, .file = r->argv[0], .args = r->argv, .env = env, .stdio_count = 3, .stdio = streams};
  int rc = uv_spawn(&w.loop, &w.process, &opts);
  for (size_t i = 0; i < ne; ++i)
    SAFE_FREE(env[i]);
  if (rc) {
    SAFE_SNPRINTF(result->error, sizeof(result->error), "Cannot start renderer: %s", uv_strerror(rc));
    uv_close((uv_handle_t *)&w.output, NULL);
    uv_close((uv_handle_t *)&w.errors, NULL);
    uv_close((uv_handle_t *)&w.timer, NULL);
  } else {
    uv_read_start((uv_stream_t *)&w.output, allocate, read_output);
    uv_read_start((uv_stream_t *)&w.errors, allocate, read_output);
    uv_timer_start(&w.timer, tick, 20, 20);
  }
  uv_run(&w.loop, UV_RUN_DEFAULT);
  uv_loop_close(&w.loop);
  result->elapsed_ms = (time_get_ns() - w.started) / 1000000;
  if (rc || w.failed)
    return;
  result->error[0] = '\0';
  if (!result->length && !r->stage_file[0]) {
    SAFE_STRNCPY(result->error, "Renderer returned no ASCII art", sizeof(result->error));
    return;
  }
  if (r->stage_file[0]) {
    uv_fs_t fs;
    int e = uv_fs_stat(NULL, &fs, r->stage_file, NULL);
    bool valid = e == 0 && fs.statbuf.st_size > 0;
    uv_fs_req_cleanup(&fs);
    if (!valid) {
      SAFE_STRNCPY(result->error, "Renderer did not create an output file", sizeof(result->error));
      return;
    }
    // Hard-link publication is atomic and fails if any file/symlink already owns the destination.
    // Staging beside the destination keeps this on the same filesystem.
    e = uv_fs_link(NULL, &fs, r->stage_file, r->output_path, NULL);
    uv_fs_req_cleanup(&fs);
    if (e) {
      SAFE_SNPRINTF(result->error, sizeof(result->error), "Cannot save without replacing an existing file: %s",
                    uv_strerror(e));
      return;
    }
    SAFE_STRNCPY(result->output_path, r->output_path, sizeof(result->output_path));
  }
  http_render_result_t frames = {0};
  if (result->text && result->length)
    (void)http_render_result_add_text_frame(&frames, result->text, result->length, 0);
  if (result->output_path[0])
    (void)http_render_result_add_file_frame(&frames, result->output_path, 0);
  result->frames = frames.frames;
  result->frame_count = frames.frame_count;
}

References http_renderer_process_request_t::argv, http_renderer_process_request_t::capture_webcam, http_renderer_process_result_t::elapsed_ms, http_renderer_process_result_t::error, render_worker_t::errors, render_worker_t::failed, http_render_result_t::frame_count, http_renderer_process_result_t::frame_count, http_render_result_t::frames, http_renderer_process_result_t::frames, HTTP_RENDER_OUTPUT_FILE, HTTP_RENDER_OUTPUT_TEXT, http_render_result_add_file_frame(), http_render_result_add_text_frame(), HTTP_RENDERER_MAX_OUTPUT, http_renderer_process_result_t::length, render_worker_t::loop, MCP_RENDER_ENV_CAPACITY, render_worker_t::output, http_renderer_process_request_t::output_path, http_renderer_process_result_t::output_path, http_renderer_process_request_t::output_type, platform_getenv(), render_worker_t::process, SAFE_CALLOC, SAFE_FREE, SAFE_MALLOC, SAFE_SNPRINTF, SAFE_STRNCPY, http_renderer_process_request_t::stage_dir, http_renderer_process_request_t::stage_file, render_worker_t::started, http_renderer_process_result_t::text, http_renderer_process_request_t::timeout_ms, render_worker_t::timer, and valid.

http_renderer_process_result_destroy()

void http_renderer_process_result_destroy

(

http_renderer_process_result_t *

result

)

Definition at line 214 of file http_renderer_process.c.

                                                                                  {
  if (!result)
    return;
  for (size_t i = 0; i < result->frame_count; ++i)
    SAFE_FREE(result->frames[i].text);
  SAFE_FREE(result->frames);
  SAFE_FREE(result->text);
  memset(result, 0, sizeof(*result));
}

References http_renderer_process_result_t::frame_count, http_renderer_process_result_t::frames, SAFE_FREE, http_render_frame_t::text, and http_renderer_process_result_t::text.