Conexión HTTP

Los mensajes HTTP, son los medios por los cuales se intercambian datos entre servidores y clientes. Hay dos tipos de mensajes: peticiones, enviadas por el cliente al servidor, para pedir el inicio de una acción; y respuestas, que son la respuesta del servidor.

Primero veamos cómo leemos las respuestas por medio de http. No te preocupes, no necesitas hacer un nuevo proyecto, puedes utilizar el mismo de la clase pasada, solo vamos a complementar el código. Primero, agregamos una nueva librería en el proyecto:

use std::io::prelude::*;

En este módulo tenemos el método prelude que nos ayudará a leer, escribir y releer la respuesta que recibimos en bytes.

También crearemos una nueva función llamada handle_connection en esta nueva función, leeremos los datos del flujo TCP y los imprimimos para ver los datos que se envían desde el navegador.

Ahora nuestro código debe verse de esta manera:

use std::io::prelude::*;
use std::net::{TcpListener, TcpStream};


fn main() {

	let listener = TcpListener::bind("127.0.0.1:7373").unwrap();


    	for stream in listener.incoming() {
        	let stream = stream.unwrap();

        	handle_connection(stream);
    	}
}

fn handle_connection(mut stream: TcpStream) {

}

Como puedes ver, reemplazamos el mensaje que recibíamos anteriormente para revisar que nuestra conexión funcionará, ahora solo le pasamos el "stream" a la función que acabamos de crear. Se recibe nuestro ´stream`(flujo de conexión) como un parámetro mutable, ya que no sabemos si podría leer más datos de los que solicitamos y guardarlos para después.

Dentro de nuestra función agregaremos algunas líneas extra para poder leer nuestro request y ver datos dentro de nuestro navegador, pero vamos por pasos.

Agregamos un buffer a nuestro servidor con un tamaño de 256 bytes..

let mut buffer = [0; 256];

El método stream.read, se encargará de leer todos los bytes recibidos.

stream.read(&mut buffer).unwrap();

En segundo lugar, convertimos los bytes en el buffer en una cadena y la imprimimos.

println!("Request: {}", String::from_utf8_lossy(&buffer[..]));

Si ejecutamos cargo run al entrar a nuestro navegador seguirá sin mostrarnos una página, pero al momento de acceder, en nuestra terminal nos arroja el siguiente mensaje, donde vemos la solicitud que enviamos acerca de nuestra información del navegador. Los resultados pueden variar ligeramente dependiendo el navegador que utilices.

Ya que obtenemos respuesta de nuestro navegador es hora de poder recibir respuesta con el estándar preferido de todos, nuestra querida respuesta 200. El código de status 200 nos indica que la respuesta ha sido exitosa, entonces ahora en lugar de recibir un print en nuestra terminal, vamos a poder recibir un status dentro de nuestro navegador.

Como saben, dentro de Rust podemos agregar html directo en nuestras funciones, pero esta vez queremos mantener nuestro código limpio, así que crearemos un nuevo archivo html en la carpeta raíz, crea tu propia interfaz divertida que quieres que sea, por el momento dentro del archivo HTML.

Ya que hayas creado tu interfaz, ahora es momento de agregarla a nuestro código, para esto añadiremos el módulo std::fs; que nos ayudará a leer el archivo como una cadena de caracteres desde nuestra función.

Eliminemos la línea printl de nuestro código y agreguemos las siguientes líneas:

let contents = fs::read_to_string("index.html").unwrap();

A continuación, usamos format! para agregar el contenido del archivo como el cuerpo de la respuesta de éxito.

let response = format!("HTTP/1.1 200 OK\r\n\r\n{}", contents);

stream.write(response.as_bytes()).unwrap(); //Nos ayuda a leer la cadena bytes que estamos recibiendo.

stream.flush().unwrap(); //Esperará e impedirá que el programa continúe hasta que se escriban todos los bytes en la conexión.

¡Por fin! Podemos visualizar datos en nuestro navegador.

En esta clase aprendiste más que solo leer y enviar solicitudes HTTP, deja en los comentarios cómo luce tu mensaje de bienvenida.