query.c File Reference

Query tool runtime library implementation. More...

Go to the source code of this file.

Macros
#define	HEALTH_CHECK_TIMEOUT_NS   (10000LL * NS_PER_MS_INT)
#define	HEALTH_CHECK_INTERVAL_NS   (100LL * NS_PER_MS_INT)
#define	HEALTH_CHECK_CONNECT_TIMEOUT_NS   (500LL * NS_PER_MS_INT)

Functions
int	query_init (int preferred_port)
void	query_destroy (void)
bool	query_is_active (void)
int	query_get_port (void)

Detailed Description

Query tool runtime library implementation.

This provides the QUERY_INIT/QUERY_SHUTDOWN macros that applications use to auto-spawn the query controller process.

Platform support:

• Unix (macOS/Linux): Uses fork/exec to spawn controller
• Windows: Uses CreateProcess to spawn controller

Definition in file query.c.

Macro Definition Documentation

HEALTH_CHECK_CONNECT_TIMEOUT_NS

#define HEALTH_CHECK_CONNECT_TIMEOUT_NS   (500LL * NS_PER_MS_INT)

Definition at line 42 of file query.c.

HEALTH_CHECK_INTERVAL_NS

#define HEALTH_CHECK_INTERVAL_NS   (100LL * NS_PER_MS_INT)

Definition at line 41 of file query.c.

HEALTH_CHECK_TIMEOUT_NS

#define HEALTH_CHECK_TIMEOUT_NS   (10000LL * NS_PER_MS_INT)

Definition at line 40 of file query.c.

Function Documentation

query_destroy()

void query_destroy

(

void

)

Definition at line 315 of file query.c.

                         {
  if (!g_query_active && g_controller_pid <= 0) {
    return;
  }
 
  fprintf(stderr, "[query] Shutting down query server...\n");
 
#ifdef _WIN32
  if (g_controller_handle != NULL) {
    // Send termination signal
    TerminateProcess(g_controller_handle, 0);
 
    // Wait for process to exit (with timeout)
    WaitForSingleObject(g_controller_handle, 3000);
 
    CloseHandle(g_controller_handle);
    g_controller_handle = NULL;
    g_controller_pid = 0;
  }
 
  // Clean up Winsock (matches WSAStartup in query_init)
  WSACleanup();
#else
  if (g_controller_pid > 0) {
    // Send SIGTERM for graceful shutdown
    kill(g_controller_pid, SIGTERM);
 
    // Wait for process to exit (with timeout)
    int status;
    int wait_count = 0;
    while (wait_count < 30) { // 3 second timeout
      pid_t result = waitpid(g_controller_pid, &status, WNOHANG);
      if (result == g_controller_pid) {
        break;
      }
      if (result < 0) {
        break;
      }
      usleep(100 * US_PER_MS_INT); // 100ms
      wait_count++;
    }
 
    // If still running, force kill
    if (wait_count >= 30) {
      kill(g_controller_pid, SIGKILL);
      waitpid(g_controller_pid, &status, 0);
    }
 
    g_controller_pid = -1;
  }
#endif
 
  g_query_active = false;
  g_query_port = -1;
 
  fprintf(stderr, "[query] Query server stopped\n");
}

Referenced by query_init().

query_get_port()

int query_get_port

(

void

)

Definition at line 405 of file query.c.

                         {
  return g_query_port;
}

query_init()

int query_init

(

int

preferred_port

)

Definition at line 214 of file query.c.

                                   {
  // Already initialized?
  if (g_query_active) {
    return g_query_port;
  }
 
  // Find the query server executable
  char server_path[PLATFORM_MAX_PATH_LENGTH];
  if (!find_query_server_path(server_path, sizeof(server_path))) {
    fprintf(stderr, "[query] Could not find ascii-query-server executable\n");
    fprintf(stderr, "[query] Set ASCIICHAT_QUERY_SERVER environment variable or ensure "
                    "it's in .deps-cache/query-tool/\n");
    return -1;
  }
 
#ifdef _WIN32
  // Windows implementation using CreateProcess
  WSADATA wsa_data;
  if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
    fprintf(stderr, "[query] WSAStartup failed\n");
    return -1;
  }
 
  char cmdline[2048];
  safe_snprintf(cmdline, sizeof(cmdline), "\"%s\" --attach %lu --port %d", server_path,
                (unsigned long)GetCurrentProcessId(), preferred_port);
 
  STARTUPINFOA si;
  PROCESS_INFORMATION pi;
  memset(&si, 0, sizeof(si));
  si.cb = sizeof(si);
  memset(&pi, 0, sizeof(pi));
 
  // Create the controller process
  if (!CreateProcessA(NULL,               // Use command line
                      cmdline,            // Command line
                      NULL,               // Process security attributes
                      NULL,               // Thread security attributes
                      FALSE,              // Don't inherit handles
                      CREATE_NEW_CONSOLE, // Creation flags
                      NULL,               // Use parent's environment
                      NULL,               // Use parent's directory
                      &si, &pi)) {
    fprintf(stderr, "[query] Failed to start query server: error %lu\n", GetLastError());
    return -1;
  }
 
  g_controller_handle = pi.hProcess;
  g_controller_pid = pi.dwProcessId;
  CloseHandle(pi.hThread); // Don't need the thread handle
 
  fprintf(stderr, "[query] Started query server (PID %lu) on port %d\n", (unsigned long)g_controller_pid,
          preferred_port);
 
#else
  // Unix implementation using fork/exec
  pid_t self_pid = getpid();
 
  char port_str[16];
  char pid_str[16];
  safe_snprintf(port_str, sizeof(port_str), "%d", preferred_port);
  safe_snprintf(pid_str, sizeof(pid_str), "%d", self_pid);
 
  pid_t child = fork();
  if (child < 0) {
    fprintf(stderr, "[query] fork() failed: %s\n", strerror(errno));
    return -1;
  }
 
  if (child == 0) {
    // Child process: exec the controller
    // Redirect stdout/stderr to /dev/null or a log file to avoid clutter
    // (The controller has its own logging)
 
    execl(server_path, "ascii-query-server", "--attach", pid_str, "--port", port_str, (char *)NULL);
 
    // If exec fails
    fprintf(stderr, "[query] exec(%s) failed: %s\n", server_path, strerror(errno));
    exit(1);
  }
 
  // Parent process
  g_controller_pid = child;
  fprintf(stderr, "[query] Started query server (PID %d) on port %d\n", child, preferred_port);
#endif
 
  // Wait for the HTTP server to become ready
  fprintf(stderr, "[query] Waiting for HTTP server to be ready...\n");
  if (!wait_for_http_ready(preferred_port, HEALTH_CHECK_TIMEOUT_NS)) {
    fprintf(stderr, "[query] Timeout waiting for query server to start\n");
    query_destroy();
    return -1;
  }
 
  g_query_active = true;
  g_query_port = preferred_port;
 
  fprintf(stderr, "[query] Query server ready at http://localhost:%d\n", preferred_port);
  return preferred_port;
}

References HEALTH_CHECK_TIMEOUT_NS, PLATFORM_MAX_PATH_LENGTH, query_destroy(), and safe_snprintf().

query_is_active()

bool query_is_active

(

void

)

Definition at line 373 of file query.c.

                           {
  if (!g_query_active) {
    return false;
  }
 
// Verify the controller is still running
#ifdef _WIN32
  if (g_controller_handle != NULL) {
    DWORD exit_code;
    if (GetExitCodeProcess(g_controller_handle, &exit_code)) {
      if (exit_code != STILL_ACTIVE) {
        g_query_active = false;
        g_controller_handle = NULL;
        g_controller_pid = 0;
        return false;
      }
    }
  }
#else
  if (g_controller_pid > 0) {
    // Check if process is still alive
    if (kill(g_controller_pid, 0) != 0) {
      g_query_active = false;
      g_controller_pid = -1;
      return false;
    }
  }
#endif
 
  return g_query_active;
}