Rust
Marco web de hierro

Introducción

Sencillo servidor 'Hello'

Este ejemplo envía una respuesta codificada al usuario cuando envía una solicitud de servidor.

extern crate iron;

use iron::prelude::*;
use iron::status;

// You can pass the handler as a function or a closure. In this
// case, we've chosen a function for clarity.
// Since we don't care about the request, we bind it to _.
fn handler(_: &mut Request) -> IronResult<Response> {
    Ok(Response::with((status::Ok, "Hello, Stack Overflow")))
}

fn main() {
    Iron::new(handler).http("localhost:1337").expect("Server failed!")
}

Al crear un nuevo servidor Iron en este ejemplo, expect detectar cualquier error con un mensaje de error más descriptivo. En las aplicaciones de producción, maneje el error producido (consulte la documentación de http() ).

Instalación de hierro

Agregue esta dependencia al archivo Cargo.toml :

[dependencies]
iron = "0.4.0"

Run cargo build y Cargo descargará e instalará la versión especificada de Iron.

Enrutamiento simple con hierro

Este ejemplo proporcionará enrutamiento web básico utilizando Iron.

Para empezar, deberá agregar la dependencia de Iron a su archivo Cargo.toml .

[dependencies]
iron = "0.4.*"

Usaremos la propia librería Router de Iron. Para simplificar, el proyecto Iron proporciona esta biblioteca como parte de la biblioteca de Iron Core, eliminando cualquier necesidad de agregarla como una dependencia separada. A continuación, hacemos referencia tanto a la biblioteca Iron como a la biblioteca Router.

extern crate iron;
extern crate router;

Luego importamos los objetos requeridos para permitirnos administrar el enrutamiento y devolver una respuesta al usuario.

use iron::{Iron, Request, Response, IronResult};
use iron::status;
use router::{Router};

En este ejemplo, lo mantendremos simple escribiendo la lógica de enrutamiento dentro de nuestra función main() . Por supuesto, a medida que su aplicación crezca, querrá separar el enrutamiento, el registro, los problemas de seguridad y otras áreas de su aplicación web. Por ahora, este es un buen punto de partida.

fn main() {
    let mut router = Router::new();
    router.get("/", handler, "handler");
    router.get("/:query", query_handler, "query_handler");

Repasemos lo que hemos logrado hasta ahora. Actualmente, nuestro programa crea una instancia de un nuevo objeto de Iron Router y adjunta dos "controladores" a dos tipos de solicitud de URL: el primero ( "/" ) es la raíz de nuestro dominio, y el segundo ( "/:query" ) es cualquier ruta debajo de la raiz

Al usar un punto y coma antes de la palabra "consulta", le estamos diciendo a Iron que tome esta parte de la ruta de la URL como una variable y la pase a nuestro controlador.

La siguiente línea de código es cómo creamos una instancia de Iron, designando nuestro propio objeto router para administrar nuestras solicitudes de URL. El dominio y el puerto están codificados en este ejemplo para simplificar.

    Iron::new(router).http("localhost:3000").unwrap();

A continuación, declaramos dos funciones en línea que son nuestros manejadores, handler y query_handler . Ambos se utilizan para demostrar URL fijas y URL variables.

En la segunda función tomamos la variable "query" de la URL que contiene el objeto de solicitud, y la enviamos de vuelta al usuario como respuesta.

    fn handler(_: &mut Request) -> IronResult<Response> {
        Ok(Response::with((status::Ok, "OK")))
    }

    fn query_handler(req: &mut Request) -> IronResult<Response> {
        let ref query = req.extensions.get::<Router>()
            .unwrap().find("query").unwrap_or("/");
        Ok(Response::with((status::Ok, *query)))
    }
}

Si ejecutamos este ejemplo, podremos ver el resultado en el navegador web en localhost:3000 . La raíz del dominio debe responder con "OK" , y cualquier cosa debajo de la raíz debe repetir la ruta de regreso.

El siguiente paso de este ejemplo podría ser la separación del enrutamiento y el servicio de páginas estáticas.