Function application_index_execute

src/daemon/application.c:2175–2236

}

static char *application_index_execute(void *context, const char *root_path,
                                       const char *args_json) {
    cbm_daemon_application_session_t *session = context;
    if (!session || !root_path || !args_json) {
        return NULL;
    }
    char *project_key = application_index_project_key(root_path, args_json);
    if (!project_key) {
        return cbm_mcp_text_result("failed to derive index project identity", true);
    }
    application_job_subscribe_status_t subscribe_status = APPLICATION_JOB_SUBSCRIBE_UNAVAILABLE;
    cbm_daemon_application_job_t *job = NULL;
    for (;;) {
        job = application_job_subscribe(session->application, project_key, root_path, args_json,
                                        &subscribe_status);
        if (job || (subscribe_status != APPLICATION_JOB_SUBSCRIBE_BUSY &&
                    subscribe_status != APPLICATION_JOB_SUBSCRIBE_CANCELLING)) {
            break;
        }
        /* Physical job limit reached (or a same-project cancel still
         * draining): QUEUE instead of surfacing a raw busy error. The
         * request thread blocks for the whole index anyway, so waiting for
         * a slot is the same contract — and the wait stays cancellable and
         * shutdown-aware (a stopping coordinator answers UNAVAILABLE, which
         * exits this loop with the error below). */
        atomic_fetch_add_explicit(&g_application_busy_queue_waits_for_test, 1,
                                  memory_order_release);
        cbm_mutex_lock(&session->application->mutex);
        bool queued_cancelled = application_request_cancelled_locked(session);
        cbm_mutex_unlock(&session->application->mutex);
        if (queued_cancelled) {
            free(project_key);
            return cbm_mcp_text_result("index operation cancelled for this session", true);
        }
        cbm_usleep(APPLICATION_JOB_POLL_US);
    }
    free(project_key);
    if (!job) {
        const char *message = "daemon index coordinator is stopping or unavailable";
        if (subscribe_status == APPLICATION_JOB_SUBSCRIBE_OPTIONS_CONFLICT) {
            message = "another index operation for this project is active with different options";
        } else if (subscribe_status == APPLICATION_JOB_SUBSCRIBE_ALLOCATION_FAILED) {
            message = "daemon index coordinator could not allocate an index job";
        }
        return cbm_mcp_text_result(message, true);
    }
    cbm_mutex_lock(&session->application->mutex);
    if (application_request_cancelled_locked(session)) {
        application_job_unsubscribe_locked(job);
        cbm_mutex_unlock(&session->application->mutex);
        return cbm_mcp_text_result("index operation cancelled for this session", true);
    }
    if (session->active_job) {
        application_job_unsubscribe_locked(job);
        cbm_mutex_unlock(&session->application->mutex);
        return cbm_mcp_text_result("this session already has an active index operation", true);
    }
    session->active_job = job;