Aplicaciones con Rullst I · Lección 11 / 14

Errores útiles, límites explícitos

Quien usa la aplicación necesita saber qué hacer sin recibir detalles internos.

Vamos a descubrir juntos

1
En este contrato, JSON roto recibe 400, regla inválida 422, objetivo inexistente 404 y fallo de base 503. Un tipo de contenido incorrecto puede recibir 415. No son notas del alumno: comunican resultados HTTP diferentes y ayudan al cliente.
2
DefaultBodyLimit limita el cuerpo a 4.096 bytes. Un título de 5.000 letras no llega a validación como campo pequeño: recibe 413. Límite del cuerpo y del título miden cosas distintas. Parámetros de tipo inválido pueden rechazarse antes del handler.
3
Escrituras con Origin externo reciben 403; el cliente del mismo origen usa la dirección local. Esto reduce un tipo de petición de navegador, pero no autentica personas ni bloquea programas locales sin Origin. Loopback y cabeceras no sustituyen autorización.
4
Un fallo de base devuelve storage_unavailable. El log no imprime títulos, SQL, rutas ni credenciales. El kit usa CSP y nosniff, pero no promete protección completa, límites por persona, auditoría ni disponibilidad. Las pruebas comprueban conductas concretas, no certificación de seguridad.

Tu mesa de aplicaciones

El kit incluye la aplicación completa para investigar y modificar. El fragmento explica esta etapa; el editor contiene el archivo indicado. Rullst Academy no compila ni ejecuta este servidor en el navegador.

Archivo para estudiar y modificar

src/routes.rs

400  invalid JSON syntax
422  invalid title or priority
403  external Origin on a write
404  missing mission
413  body over 4096 bytes
503  storage unavailable

Extrae el kit en una carpeta nueva y abre el terminal junto a Cargo.toml. Usa Rust 1.96+; la primera compilación puede descargar dependencias y tardar. Abre http://127.0.0.1:3010. Detén con Ctrl+C y ejecuta de nuevo tras editar.

cargo test --locked
cargo run --locked

Mis archivos y GitHub

Descarga tu borrador y sustituye el archivo indicado en tu copia extraída. El editor guarda un archivo en este navegador; tu cuenta guarda evaluaciones y XP. El ZIP excluye tus cambios. GitHub envía solo el archivo confirmado; usa Git manual para la aplicación entera, sin bases, respaldos ni secretos.

Enlaces oficiales y siguiente paso

✦

TU MISIÓN

Distinguir errores de formato, regla, origen, objetivo y almacenamiento.

Llévatelo contigo

Crea una tabla con entrada, estado esperado y siguiente acción del usuario para tres fallos. Ejecuta uno en la prueba local y comprueba que el conteo no aumentó.

A tu ritmo

Mis archivos y GitHub

Cada lección puede convertirse en un registro propio: código, notas o un plan de práctica. Guardar un archivo en GitHub es opcional y no cambia tus XP.

Manual del alumno

El editor y las descargas se abren cuando esta lección esté disponible para tu cuenta. Revisa el acceso indicado abajo o vuelve al mapa de la ruta.

Comprobando tu acceso a esta lección…

Tu camino, paso a paso

Descargar material de la actividad

Descarga el ejemplo de la lección y un cuaderno para tus notas. El ZIP incluye una guía para organizar actividades en uno o varios repositorios. Publicar es opcional; las cuentas habilitadas también pueden usar el botón de envío a GitHub.

Tu archivo de esta lección

Edita el ejemplo o registra lo aprendido. Este espacio no ejecuta código ni corrige respuestas. El borrador se guarda solo en este navegador, separado por cuenta; tú decides cuándo descargar o enviar a GitHub.

El ejemplo puede ser solo un fragmento o una guía. Cambiar la extensión no lo convierte en un programa completo. El ZIP de la actividad contiene material inicial; el botón de archivo editado descarga tu texto.

Mi código o mis notas

use crate::{
    store::Store,
    validation::{self, Completion, NewMission},
};
use rullst::{
    Router,
    response::{IntoResponse, Response},
    server::{Extension, Json, Path, StatusCode, get},
    web::axum::{
        extract::{DefaultBodyLimit, Request, rejection::JsonRejection},
        middleware::{Next, from_fn},
    },
};
use serde_json::json;

fn error(status: StatusCode, code: &str) -> Response {
    (status, Json(json!({"error": code}))).into_response()
}
fn unavailable() -> Response {
    // No submitted text, SQL, paths or credentials in browser errors or logs.
    eprintln!("mission-board: database operation failed");
    error(StatusCode::SERVICE_UNAVAILABLE, "storage_unavailable")
}

async fn list(Extension(store): Extension<Store>) -> Response {
    match store.list().await {
        Ok(items) => Json(items).into_response(),
        Err(_) => unavailable(),
    }
}
async fn create(
    Extension(store): Extension<Store>,
    input: Result<Json<NewMission>, JsonRejection>,
) -> Response {
    let Json(input) = match input {
        Ok(value) => value,
        Err(e) => return error(e.status(), "invalid_json"),
    };
    let input = match validation::validate(input) {
        Ok(value) => value,
        Err(code) => return error(StatusCode::UNPROCESSABLE_ENTITY, code),
    };
    match store.create(input).await {
        Ok(item) => (StatusCode::CREATED, Json(item)).into_response(),
        Err(_) => unavailable(),
    }
}
async fn complete(
    Extension(store): Extension<Store>,
    Path(id): Path<i64>,
    input: Result<Json<Completion>, JsonRejection>,
) -> Response {
    let Json(input) = match input {
        Ok(value) => value,
        Err(e) => return error(e.status(), "invalid_json"),
    };
    match store.complete(id, input.done).await {
        Ok(true) => StatusCode::NO_CONTENT.into_response(),
        Ok(false) => error(StatusCode::NOT_FOUND, "not_found"),
        Err(_) => unavailable(),
    }
}
#[derive(Clone)]
struct Origins(Vec<String>);

async fn boundary(
    Extension(origins): Extension<Origins>,
    request: Request,
    next: Next,
) -> Response {
    // A loopback exercise, not an authentication/authorization system.
    if request.method() != "GET" && request.method() != "HEAD" {
        if let Some(origin) = request.headers().get("origin") {
            if !origin
                .to_str()
                .is_ok_and(|value| origins.0.iter().any(|allowed| allowed == value))
            {
                return error(StatusCode::FORBIDDEN, "invalid_origin");
            }
        }
    }
    let mut response = next.run(request).await;
    response
        .headers_mut()
        .insert("cache-control", "no-store".parse().unwrap());
    response
        .headers_mut()
        .insert("x-content-type-options", "nosniff".parse().unwrap());
    response.headers_mut().insert("content-security-policy", "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'".parse().unwrap());
    response
}

pub fn app(store: Store) -> Router {
    app_with_origins(store, &["http://127.0.0.1:3010", "http://localhost:3010"])
}

pub fn app_with_origins(store: Store, origins: &[&str]) -> Router {
    Router::new()
        .route(
            "/",
            get(|| async { rullst::response::Html(include_str!("../web/index.html")) }),
        )
        .route(
            "/app.js",
            get(|| async {
                (
                    [("content-type", "text/javascript; charset=utf-8")],
                    include_str!("../web/app.js"),
                )
            }),
        )
        .route(
            "/style.css",
            get(|| async {
                (
                    [("content-type", "text/css; charset=utf-8")],
                    include_str!("../web/style.css"),
                )
            }),
        )
        .route("/healthz", get(|| async { Json(json!({"status":"ok"})) }))
        .route("/api/missions", get(list).post(create))
        .route(
            "/api/missions/{id}/completion",
            rullst::web::axum::routing::put(complete),
        )
        .fallback(|| async { error(StatusCode::NOT_FOUND, "not_found") })
        .layer(DefaultBodyLimit::max(4096))
        .layer(from_fn(boundary))
        .layer(Extension(Origins(
            origins.iter().map(|v| (*v).into()).collect(),
        )))
        .layer(Extension(store))
}

Formato del archivo

Tu texto se guardará en este navegador al editarlo. En un equipo compartido, borra los borradores al terminar.

El envío directo acepta hasta 8 KiB de texto en un archivo. Usa las descargas y la guía manual para proyectos con varios archivos.

Errores útiles, límites explícitos

Vamos a descubrir juntos

Tu mesa de aplicaciones

Archivo para estudiar y modificar

Enlaces oficiales y siguiente paso

Ahora te toca

Decide antes de ejecutar

Llévatelo contigo

Mis archivos y GitHub

Tu archivo de esta lección

Guardar en mi GitHub

Rullstpetbot