Function invoke_handler

packages/dashboard/src-tauri/src/serve/mod.rs:196–237

(
    State(state): State<ServeState>,
    payload: Result<Json<InvokeRequest>, JsonRejection>,
)

}

async fn invoke_handler(
    State(state): State<ServeState>,
    payload: Result<Json<InvokeRequest>, JsonRejection>,
) -> Response {
    let Json(payload) = match payload {
        Ok(payload) => payload,
        Err(err) => {
            let status = if err.status() == StatusCode::PAYLOAD_TOO_LARGE {
                StatusCode::PAYLOAD_TOO_LARGE
            } else {
                StatusCode::BAD_REQUEST
            };
            return json_error(status, format!("Invalid JSON request: {err}"));
        }
    };

    let _permit = if dispatch::uses_subprocess_or_network_probe(&payload.cmd) {
        match state.subprocess_limit.acquire().await {
            Ok(permit) => Some(permit),
            Err(_) => {
                return json_error(StatusCode::SERVICE_UNAVAILABLE, "Server is shutting down")
            }
        }
    } else {
        None
    };

    match dispatch::dispatch(&state.app_state, &payload.cmd, payload.args).await {
        Ok(value) => Json(value).into_response(),
        Err(dispatch::DispatchError::UnknownCommand) => {
            json_error(StatusCode::NOT_FOUND, "Unknown command")
        }
        Err(dispatch::DispatchError::BadArgs(err)) => {
            json_error(StatusCode::BAD_REQUEST, format!("Invalid arguments: {err}"))
        }
        Err(dispatch::DispatchError::Command(err)) => json_error(StatusCode::BAD_REQUEST, err),
        Err(dispatch::DispatchError::Serialize(err)) => json_error(
            StatusCode::BAD_REQUEST,
            format!("Failed to encode response: {err}"),
        ),
    }
}

async fn api_not_found() -> Response {
    json_error(StatusCode::NOT_FOUND, "Unknown API route")