Aplicações com Rullst I · Lição 11 / 14

Erros úteis, limites explícitos

Quem usa a aplicação precisa saber o que fazer sem receber detalhes internos.

Vamos descobrir juntos

1
Neste contrato, JSON quebrado recebe 400, regra inválida 422, alvo inexistente 404 e falha do banco 503. Tipo de conteúdo errado pode receber 415. Esses códigos não são notas do aluno: comunicam resultados HTTP diferentes e ajudam o cliente a reagir.
2
DefaultBodyLimit limita o corpo a 4.096 bytes. Um título de 5.000 letras não chega à validação como se fosse um campo pequeno: o pedido recebe 413. Limite de corpo e limite de título medem coisas diferentes. Parâmetros com tipos inválidos também podem ser rejeitados antes do handler.
3
Chamadas de escrita com Origin externo recebem 403; o cliente da mesma origem usa o endereço local. Isso reduz um tipo de chamada de navegador, mas não autentica pessoas nem bloqueia programas locais que omitam Origin. Loopback e cabeçalhos não substituem autorização.
4
Uma falha do banco devolve storage_unavailable. O log não imprime títulos, SQL, caminhos nem credenciais. O kit usa CSP e nosniff, mas não promete proteção completa, limites por pessoa, auditoria ou disponibilidade. Testes de laboratório verificam comportamentos específicos, não uma certificação de segurança.

Sua bancada de aplicações

O kit inclui o aplicativo completo para investigar e modificar. O trecho abaixo explica esta etapa; o editor contém o arquivo indicado. A Rullst Academy não compila nem executa esse servidor no navegador.

Arquivo para estudar e 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

Extraia o kit numa pasta nova e abra o terminal junto a Cargo.toml. Use Rust 1.96+; o primeiro build pode baixar dependências e demorar. Depois abra http://127.0.0.1:3010. Pare com Ctrl+C e execute novamente após editar.

cargo test --locked
cargo run --locked

Meus arquivos e GitHub

Baixe seu rascunho e substitua o arquivo indicado na sua cópia extraída. O editor guarda um arquivo neste navegador; a conta guarda avaliações e XP. O ZIP não contém suas alterações. GitHub envia só o arquivo confirmado; para o aplicativo completo use Git manual, sem bancos, backups ou segredos.

Links oficiais e próximo passo

✦

SUA MISSÃO

Diferenciar erros de formato, regra, origem, alvo e armazenamento.

Leve com você

Monte uma tabela com entrada, status esperado e próximo passo do usuário para três falhas. Execute uma no teste local e confira que a contagem de missões não aumentou.

No seu ritmo

Meus arquivos e GitHub

Toda lição pode virar um registro seu: código, anotações ou um plano de prática. Guardar um arquivo no GitHub é opcional e não altera seu XP.

Manual do aluno

O editor e os downloads abrem quando esta lição estiver liberada para sua conta. Confira o acesso abaixo ou volte ao mapa da trilha.

Conferindo seu acesso à lição…

Seu caminho, passo a passo

Baixar material da atividade

Baixe o exemplo da lição e um caderno para suas anotações. O ZIP inclui um guia para organizar atividades em um ou mais repositórios. Publicar é opcional; contas elegíveis também podem usar o botão de envio ao GitHub.

Seu arquivo desta lição

Edite o exemplo ou registre o que aprendeu. Este espaço não executa código nem corrige respostas. O rascunho é salvo apenas neste navegador, separado por conta; baixar e enviar ao GitHub são ações suas.

O exemplo pode ser apenas um trecho ou roteiro. Mudar a extensão não o transforma em programa completo. O ZIP da atividade contém material inicial; o botão de arquivo editado baixa o seu texto.

Meu código ou minhas anotações

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 do arquivo

Seu texto será guardado neste navegador ao editar. Em computador compartilhado, limpe os rascunhos ao terminar.

O envio direto aceita até 8 KiB de texto em um arquivo. Use o download e o guia manual para projetos com vários arquivos.

Erros úteis, limites explícitos

Vamos descobrir juntos

Sua bancada de aplicações

Arquivo para estudar e modificar

Links oficiais e próximo passo

Agora é a sua vez

Decida antes de executar

Leve com você

Meus arquivos e GitHub

Seu arquivo desta lição

Guardar no meu GitHub

Rullstpetbot