Después de preparar la presentación de Una introdución a Perl 6 me llamó mucho la atención las funcionalidades que ofrece Perl6 sobre programación reactiva y gestión de eventos, así que después de mostrar cómo funciona un servidor HTTP con Perl5 me propuse hacerlo también con Perl6.
Con Perl6 es un poco distinto en cuanto a sintaxis y soporte multihilo pero la forma de gestionar HTTP es la misma. En cuanto al soporte multihilo existe la clase IO::Socket::Async.listen que proporciona la creación y puesta a la escucha de sockets asíncronos con soporte multihilo, de forma que por cada conexión crea un hilo alojado en un pool que Perl6 gestiona internamente.
La prueba de concepto la puedes encontrar aquí.
Este mini servidor web funciona en Windows y GNU/Linux con Rakudo Perl6 instalado y un par de módulos de Perl6 (URI y URI::Escape) que interpretan de forma adecuada las URIs que llegan al servidor.
La parte CGI se realiza mediante módulos de Perl6 y con el resto tenemos un servidor web funcional pero muy básico (solo contempla los códigos HTTP 200 y 404).
El frontal se compone de HTML, CSS y Javascript con JQuery para gestionar la conexión asíncrona con el script CGI de Perl6 que hace de servicio web.
Mostrando entradas con la etiqueta http. Mostrar todas las entradas
Mostrando entradas con la etiqueta http. Mostrar todas las entradas
jueves, 28 de julio de 2016
domingo, 21 de febrero de 2016
Funcionamiento de un Servidor Web
En éste documento muestro el funcionamiento de un servidor web utilizando Perl; desde cómo crear un socket y ponerlo a la escucha, cómo hablar HTTP de forma básica y cómo utilizar las capacidades multihilo para lograr la máxima rapidez y eficiencia.
sábado, 1 de marzo de 2014
miniServidor Web en Windows
Mirando un poco cómo hacer una pequeña aplicación en lenguaje C para probar Sockets y comunicar programas a través de TCP/IP, encontré que el compilador LCC-Win trae una biblioteca llamada netutils.h dejando el asunto fácil y muy interesante.
Adaptando un poco el ejemplo de la aplicación servidor que trae la documentación, decidí dar un repaso al protocolo HTTP y crear un pequeño servidor Web.
El funcionamiento de este miniServidor Web sería muy sencillo y no cumpliría mucho con el estándar, pero para ver cómo funciona por dentro está bien. Lo que hace es lo siguiente:
El código fuente sería el siguiente (servidor.c):
Una vez creado servidor.c, en la misma carpeta creamos el archivo HTML que queremos publicar en nuestro miniServidorWeb (holamundo.html), cuyo código sería el siguiente:
Asumiendo que LCC-Win está instalado en c:\lcc y que tenemos la ruta de los binarios del compilador (c:\lcc\bin) incluida en la variable PATH del sistema, ya podemos compilar y enlazar:
lcc servidor.c
lcclnk servidor.obj c:\lcc\lib\netutils.lib
Con esto tendremos el ejecutable servidor.exe creado, que es nuestro miniServidor Web. Lo ejecutamos dándole como parámetro el nombre del archivo HTML a publicar:
servidor.exe holamundo.html
Y el miniServidor Web quedará a la escucha en el puerto 10000 de la IP 127.0.0.1, datos proporcionados en el código fuente. Ahora le toca al cliente, vamos al navegador Web y tecleamos la URL:
http://127.0.0.1:10000
Con esto el navegador Web conecta con la IP indicada en el puerto 10000 y recupera nuestro HTML.
Mientras, en la ventana donde ejecutamos el miniServidor Web aparecerán los datos recibidos y los enviados en cada sesión HTTP.
Y ahí lo tienes, el servidor Web más pequeño del mundo.
Adaptando un poco el ejemplo de la aplicación servidor que trae la documentación, decidí dar un repaso al protocolo HTTP y crear un pequeño servidor Web.
El funcionamiento de este miniServidor Web sería muy sencillo y no cumpliría mucho con el estándar, pero para ver cómo funciona por dentro está bien. Lo que hace es lo siguiente:
- Leer un archivo HTML dado como parámetro.
- Iniciar una sesión de conexión a un Socket en la IP 127.0.01 en el puerto 10000.
- Esperar una conexión de un navegador web.
- Cuando reciba una conexión, visualiza la información recibida (las cabeceras HTTP del navegador).
- Preparar las cabeceras HTTP de respuesta.
- Leer el archivo HTML dado y agregarlo a las cabeceras anteriores.
- Enviar la respuesta al navegador (cabeceras HTTP y el HTML).
- Visualizar los datos enviados.
El código fuente sería el siguiente (servidor.c):
#include <stdio .h>
#include "netutils.h"
int main(int argc,char *argv[])
{
while (1)
{
FILE* pf;
if ((pf = fopen(argv[1],"rt")) == NULL)
{
puts("Error abriendo html.");
return 1;
}
Session session;
char buf[8192];
memset (&session,0,sizeof(session));
session.port = 10000;
session.Host = "127.0.0.1";
if (ServerConnect(&session)){ return 0; }
printf("Conectado...\n");
memset(buf,0,sizeof(buf));
if (Receive(&session,sizeof(buf)-1,buf)) { return 0; }
printf("Datos recibidos:\n\n %s\n",buf);
char texto[1000000] = "HTTP/1.1 200 OK\nContent-Type: text/html\n\n";
int c, i = strlen(texto);
while ( (c=getc(pf) ) != EOF){ texto[i] = c; i++; }
texto[i] = '\0';
fclose(pf);
if (Send(&session,strlen(texto),texto)){ return 0; }
printf("Datos enviados:\n\n %s\n", texto);
CloseSession(&session);
printf("\nConexion cerrada.\n");
}
}
printf("Datos recibidos:\n\n %s\n",buf);
char texto[1000000] = "HTTP/1.1 200 OK\nContent-Type: text/html\n\n";
int c, i = strlen(texto);
while ( (c=getc(pf) ) != EOF){ texto[i] = c; i++; }
texto[i] = '\0';
fclose(pf);
if (Send(&session,strlen(texto),texto)){ return 0; }
printf("Datos enviados:\n\n %s\n", texto);
CloseSession(&session);
printf("\nConexion cerrada.\n");
}
}
Una vez creado servidor.c, en la misma carpeta creamos el archivo HTML que queremos publicar en nuestro miniServidorWeb (holamundo.html), cuyo código sería el siguiente:
<html>
<head>
<title>Titulo>/title>
</head>
<body>
<p><h1>Hola Mundo</h1></p>
</body>
</html>
<head>
<title>Titulo>/title>
</head>
<body>
<p><h1>Hola Mundo</h1></p>
</body>
</html>
Asumiendo que LCC-Win está instalado en c:\lcc y que tenemos la ruta de los binarios del compilador (c:\lcc\bin) incluida en la variable PATH del sistema, ya podemos compilar y enlazar:
lcc servidor.c
lcclnk servidor.obj c:\lcc\lib\netutils.lib
Con esto tendremos el ejecutable servidor.exe creado, que es nuestro miniServidor Web. Lo ejecutamos dándole como parámetro el nombre del archivo HTML a publicar:
servidor.exe holamundo.html
Y el miniServidor Web quedará a la escucha en el puerto 10000 de la IP 127.0.0.1, datos proporcionados en el código fuente. Ahora le toca al cliente, vamos al navegador Web y tecleamos la URL:
http://127.0.0.1:10000
Con esto el navegador Web conecta con la IP indicada en el puerto 10000 y recupera nuestro HTML.
Mientras, en la ventana donde ejecutamos el miniServidor Web aparecerán los datos recibidos y los enviados en cada sesión HTTP.
Y ahí lo tienes, el servidor Web más pequeño del mundo.
sábado, 16 de junio de 2012
¿Qué servidor hay detrás de una web?
Detrás de cualquier sitio web hay un servidor web, como Apache, IIS, etc. Una forma de saber esto es mirar el campo Server de la cabecera HTTP en la respuesta del sitio web en cuestión.
Por ejemplo, hagamos una lista de sitios web en un archivo de texto ( webs.txt ):
www.microsoft.com
www.google.com
www.apple.com
www.wikipedia.org
www.yahoo.com
www.facebook.com
www.twitter.com
Y ahora utilicemos el siguiente script de Powershell ( webserver.ps1 ) en la misma carpeta que el archivo webs.txt:
El resultado es el siguiente:
www.microsoft.com -> Microsoft-IIS/8.0
www.google.com -> gws
www.apple.com -> Apache/2.2.3 (Oracle)
www.wikipedia.org -> Apache
www.yahoo.com -> YTS/1.20.10
www.facebook.com -> no especificado
www.twitter.com -> tfe
Y las conclusiones son interesantes:
Por ejemplo, hagamos una lista de sitios web en un archivo de texto ( webs.txt ):
www.microsoft.com
www.google.com
www.apple.com
www.wikipedia.org
www.yahoo.com
www.facebook.com
www.twitter.com
Y ahora utilicemos el siguiente script de Powershell ( webserver.ps1 ) en la misma carpeta que el archivo webs.txt:
# webserver.ps1 - servidores web desde urls
function servidor_web($url)
{
if ( $url -ne "" )
{
$solicitud=[system.Net.HttpWebRequest]::Create("http://"+$url)
$cabecera = $solicitud.getresponse()
$cabecera.Close()
if ( $cabecera.Server ) { write-host $url "->" $cabecera.Server }
else { write-host $url "-> no especificado" }
}
}
$urls = get-content ./webs.txt
foreach ( $url in $urls) { servidor_web($url) }
function servidor_web($url)
{
if ( $url -ne "" )
{
$solicitud=[system.Net.HttpWebRequest]::Create("http://"+$url)
$cabecera = $solicitud.getresponse()
$cabecera.Close()
if ( $cabecera.Server ) { write-host $url "->" $cabecera.Server }
else { write-host $url "-> no especificado" }
}
}
$urls = get-content ./webs.txt
foreach ( $url in $urls) { servidor_web($url) }
El resultado es el siguiente:
www.microsoft.com -> Microsoft-IIS/8.0
www.google.com -> gws
www.apple.com -> Apache/2.2.3 (Oracle)
www.wikipedia.org -> Apache
www.yahoo.com -> YTS/1.20.10
www.facebook.com -> no especificado
www.twitter.com -> tfe
Y las conclusiones son interesantes:
- Los servidores web de Google, Yahoo y Twitter son de desarrollo propio ( gws es Google Web Server, YTS es Yahoo Traffic Server y tfe sólo lo sabrán los ingenieros de Twitter ).
- Facebook no da a conocer el campo Server en su cabecera (no especificado).
- Apple y Wikipedia apuestan por Apache.
Suscribirse a:
Comentarios (Atom)