HomePhorge
Diffusion Ant (mir/inline-method) Code

ant/src/watch.c
3fa05edd2fe3mir/inline-method

Last Change
Raw File

watch.c
View Options

#include "watch.h"
#include "messages.h"
#include <uv.h>
#include <stdio.h>
#include <signal.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <crprintf.h>
#ifdef _WIN32
#include <direct.h>
#endif
#ifndef SIGKILL
#define SIGKILL SIGTERM
#endif
typedef struct watch_state {
uv_loop_t loop;
uv_fs_event_t fs_event;
uv_signal_t sigint;
uv_signal_t sigterm;
uv_timer_t kill_timer;
uv_process_t *child;
char **child_argv;
char *watch_path;
bool no_clear_screen;
bool stop_requested;
bool restart_pending;
bool child_running;
bool fs_event_inited;
bool sigint_inited;
bool sigterm_inited;
bool kill_timer_inited;
bool kill_timer_running;
int final_exit_code;
} watch_state_t;
static void watch_clear_screen(void) {
fputs("\033[3J\033[2J\033[H", stdout);
fflush(stdout);
}
char *ant_watch_resolve_path(const char *path) {
#ifdef _WIN32
char *resolved = _fullpath(NULL, path, 0);
if (resolved) return resolved;
return _strdup(path);
#else
char abs_path[PATH_MAX];
const char *resolved = realpath(path, abs_path);
return strdup(resolved ? resolved : path);
#endif
}
int ant_watch_start(
uv_loop_t *loop,
uv_fs_event_t *event,
const char *path,
uv_fs_event_cb callback,
void *data,
unsigned int flags,
char **resolved_path_out
) {
char *watch_path = NULL;
int rc = 0;
if (!loop || !event || !path || !callback) return UV_EINVAL;
watch_path = ant_watch_resolve_path(path);
if (!watch_path) return UV_ENOMEM;
rc = uv_fs_event_init(loop, event);
if (rc != 0) goto cleanup;
event->data = data;
rc = uv_fs_event_start(event, callback, watch_path, flags);
if (rc != 0) goto cleanup;
if (resolved_path_out) *resolved_path_out = watch_path;
else free(watch_path);
return 0;
cleanup:
free(watch_path);
return rc;
}
void ant_watch_stop(uv_fs_event_t *event) {
if (!event) return;
uv_fs_event_stop(event);
}
static char **watch_build_child_argv(int argc, char **argv) {
char **child_argv = calloc((size_t)argc + 1, sizeof(char *));
if (!child_argv) return NULL;
int out = 0;
for (int i = 0; i < argc; i++) {
if (strcmp(argv[i], "--watch") == 0) continue;
if (strcmp(argv[i], "--no-clear-screen") == 0) continue;
child_argv[out++] = argv[i];
}
child_argv[out] = NULL;
if (out == 0) {
free(child_argv);
return NULL;
}
return child_argv;
}
static void watch_stop_kill_timer(watch_state_t *state) {
if (!state->kill_timer_inited || !state->kill_timer_running) return;
uv_timer_stop(&state->kill_timer);
state->kill_timer_running = false;
}
static void watch_on_child_closed(uv_handle_t *handle) { free(handle); }
static void watch_request_shutdown(watch_state_t *state, int exit_code);
static void watch_try_spawn_child(watch_state_t *state);
static void watch_on_kill_timer(uv_timer_t *timer) {
watch_state_t *state = (watch_state_t *)timer->data;
state->kill_timer_running = false;
if (state->child_running && state->child)
uv_process_kill(state->child, SIGKILL);
if (state->stop_requested && !uv_is_closing((uv_handle_t *)&state->kill_timer))
uv_close((uv_handle_t *)&state->kill_timer, NULL);
}
static void watch_on_child_exit(uv_process_t *proc, int64_t exit_status, int term_signal) {
watch_state_t *state = (watch_state_t *)proc->data;
state->child_running = false;
state->child = NULL;
watch_stop_kill_timer(state);
if (state->stop_requested) {
if (state->kill_timer_inited && !uv_is_closing((uv_handle_t *)&state->kill_timer))
uv_close((uv_handle_t *)&state->kill_timer, NULL);
} else if (state->restart_pending) {
watch_try_spawn_child(state);
} else if (term_signal > 0) {
state->final_exit_code = 128 + term_signal;
} else state->final_exit_code = (int)exit_status;
uv_close((uv_handle_t *)proc, watch_on_child_closed);
}
static int watch_spawn_child(watch_state_t *state) {
uv_process_t *proc = calloc(1, sizeof(*proc));
if (!proc) return UV_ENOMEM;
uv_stdio_container_t stdio[3];
stdio[0].flags = UV_INHERIT_FD; stdio[0].data.fd = 0;
stdio[1].flags = UV_INHERIT_FD; stdio[1].data.fd = 1;
stdio[2].flags = UV_INHERIT_FD; stdio[2].data.fd = 2;
uv_process_options_t options = {0};
options.file = state->child_argv[0];
options.args = state->child_argv;
options.exit_cb = watch_on_child_exit;
options.stdio_count = 3;
options.stdio = stdio;
int rc = uv_spawn(&state->loop, proc, &options);
if (rc != 0) {
free(proc);
return rc;
}
proc->data = state;
state->child = proc;
state->child_running = true;
state->restart_pending = false;
return 0;
}
static void watch_try_spawn_child(watch_state_t *state) {
if (state->stop_requested) return;
if (!state->no_clear_screen && state->restart_pending) watch_clear_screen();
int rc = watch_spawn_child(state);
if (rc != 0) {
crfprintf(stderr, msg.watch_spawn_failed, uv_strerror(rc));
watch_request_shutdown(state, EXIT_FAILURE);
}
}
static void watch_start_kill_timer(watch_state_t *state, uint64_t timeout_ms) {
if (!state->kill_timer_inited || state->kill_timer_running) return;
int rc = uv_timer_start(&state->kill_timer, watch_on_kill_timer, timeout_ms, 0);
if (rc == 0) state->kill_timer_running = true;
}
static void watch_close_signals_and_watcher(watch_state_t *state) {
if (state->fs_event_inited && !uv_is_closing((uv_handle_t *)&state->fs_event)) {
uv_fs_event_stop(&state->fs_event);
uv_close((uv_handle_t *)&state->fs_event, NULL);
}
if (state->sigint_inited && !uv_is_closing((uv_handle_t *)&state->sigint)) {
uv_signal_stop(&state->sigint);
uv_close((uv_handle_t *)&state->sigint, NULL);
}
if (state->sigterm_inited && !uv_is_closing((uv_handle_t *)&state->sigterm)) {
uv_signal_stop(&state->sigterm);
uv_close((uv_handle_t *)&state->sigterm, NULL);
}
}
static void watch_request_shutdown(watch_state_t *state, int exit_code) {
if (state->stop_requested) return;
state->stop_requested = true;
state->restart_pending = false;
state->final_exit_code = exit_code;
watch_close_signals_and_watcher(state);
if (state->child_running && state->child) {
int rc = uv_process_kill(state->child, SIGTERM);
if (rc != 0 && rc != UV_ESRCH) {
crfprintf(stderr, msg.watch_graceful_term, uv_strerror(rc));
}
watch_start_kill_timer(state, 1000);
} else if (state->kill_timer_inited && !uv_is_closing((uv_handle_t *)&state->kill_timer)) {
uv_close((uv_handle_t *)&state->kill_timer, NULL);
}
}
static void watch_request_restart(watch_state_t *state) {
if (state->stop_requested) return;
if (!state->restart_pending) {}
state->restart_pending = true;
if (state->child_running && state->child) {
int rc = uv_process_kill(state->child, SIGTERM);
if (rc != 0 && rc != UV_ESRCH) {
crfprintf(stderr, msg.watch_child_error, uv_strerror(rc));
watch_request_shutdown(state, EXIT_FAILURE);
return;
}
watch_start_kill_timer(state, 1000);
} else watch_try_spawn_child(state);
}
static void watch_on_fs_event(uv_fs_event_t *handle, const char *filename, int events, int status) {
watch_state_t *state = (watch_state_t *)handle->data;
if (status < 0) {
crfprintf(stderr, msg.watch_warn_normal, state->watch_path, uv_strerror(status));
return;
}
if ((events & (UV_CHANGE | UV_RENAME)) == 0) return;
watch_request_restart(state);
}
static void watch_on_signal(uv_signal_t *handle, int signum) {
watch_state_t *state = (watch_state_t *)handle->data;
watch_request_shutdown(state, 128 + signum);
}
int ant_watch_run(int argc, char **argv, const char *entry_file, bool no_clear_screen) {
if (!entry_file || !*entry_file) {
crfprintf(stderr, msg.watch_entrypoint_missing);
return EXIT_FAILURE;
}
watch_state_t state = {0};
state.child_argv = watch_build_child_argv(argc, argv);
state.watch_path = ant_watch_resolve_path(entry_file);
state.no_clear_screen = no_clear_screen;
state.final_exit_code = EXIT_SUCCESS;
if (!state.child_argv || !state.watch_path) {
free(state.child_argv);
free(state.watch_path);
crfprintf(stderr, msg.watch_start_fatal);
return EXIT_FAILURE;
}
int rc = uv_loop_init(&state.loop);
if (rc != 0) {
crfprintf(stderr, msg.watch_loop_fatal, uv_strerror(rc));
free(state.child_argv); free(state.watch_path);
return EXIT_FAILURE;
}
rc = ant_watch_start(
&state.loop,
&state.fs_event,
state.watch_path,
watch_on_fs_event,
&state, 0, NULL
);
if (rc == 0) state.fs_event_inited = true;
if (rc != 0) {
crfprintf(stderr, msg.watch_file_failed, state.watch_path, uv_strerror(rc));
watch_request_shutdown(&state, EXIT_FAILURE);
}
if (rc == 0) {
rc = uv_signal_init(&state.loop, &state.sigint);
if (rc == 0) state.sigint_inited = true;
if (rc == 0) {
state.sigint.data = &state;
rc = uv_signal_start(&state.sigint, watch_on_signal, SIGINT);
}
}
if (rc == 0) {
rc = uv_signal_init(&state.loop, &state.sigterm);
if (rc == 0) state.sigterm_inited = true;
if (rc == 0) {
state.sigterm.data = &state;
int sigterm_rc = uv_signal_start(&state.sigterm, watch_on_signal, SIGTERM);
if (sigterm_rc != 0 && sigterm_rc != UV_ENOSYS && sigterm_rc != UV_EINVAL) {
rc = sigterm_rc;
} else if (sigterm_rc != 0) {
uv_signal_stop(&state.sigterm);
uv_close((uv_handle_t *)&state.sigterm, NULL);
state.sigterm_inited = false;
}
}
}
if (rc == 0) {
rc = uv_timer_init(&state.loop, &state.kill_timer);
if (rc == 0) {
state.kill_timer_inited = true;
state.kill_timer.data = &state;
}
}
if (rc != 0) {
crfprintf(stderr, msg.watch_loop_handles_fatal, uv_strerror(rc));
watch_request_shutdown(&state, EXIT_FAILURE);
}
if (!state.stop_requested) watch_try_spawn_child(&state);
while (uv_run(&state.loop, UV_RUN_DEFAULT) != 0) {}
if (state.fs_event_inited && !uv_is_closing((uv_handle_t *)&state.fs_event)) {
uv_close((uv_handle_t *)&state.fs_event, NULL);
}
if (state.sigint_inited && !uv_is_closing((uv_handle_t *)&state.sigint)) {
uv_close((uv_handle_t *)&state.sigint, NULL);
}
if (state.sigterm_inited && !uv_is_closing((uv_handle_t *)&state.sigterm)) {
uv_close((uv_handle_t *)&state.sigterm, NULL);
}
if (state.kill_timer_inited && !uv_is_closing((uv_handle_t *)&state.kill_timer)) {
uv_close((uv_handle_t *)&state.kill_timer, NULL);
}
while (uv_run(&state.loop, UV_RUN_DEFAULT) != 0) {}
rc = uv_loop_close(&state.loop);
if (rc != 0) crfprintf(stderr, msg.watch_loop_cleanup, uv_strerror(rc));
free(state.child_argv);
free(state.watch_path);
return state.final_exit_code;
}

Owner Packages

  • No Owners