Ejemplos java y C/linux Twittear

Atender a varios clientes.
Sockets con select()

Normalmente a un programa servidor se le pueden conectar varios clientes simultáneamente. A un servidor de páginas web se le pueden conectar a la vez varios navegadores, al servidor del juego Quake se le pueden conectar a la vez varios jugadores, etc. Por ello un programa servidor debe estar preparado para esta circunstancia.

Hay dos opciones posibles.

• Una opción es crear un nuevo proceso o hilo por cada cliente que llegue, más el proceso o hilo principal, pendiente de aceptar nuevos clientes. En esta página no vamos a tratar esta opción.
• La otra opción sería que hubiera algo que nos avisara si algún cliente quiere conectarse o si algún cliente ya conectado quiere algo de nuestro servidor. De esta manera, nuestro programa servidor podría estar "dormido", a la espera de que sucediera alguno de estos eventos.

La primera opción, la de múltiples procesos/hilos, es adecuada cuando las peticiones de los clientes son muy numerosas y nuestro servidor no es lo bastante rápido para atenderlas consecutivamente. Si, por ejemplo, los clientes nos hacen en promedio una petición por segundo y tardamos cinco segundos en atender cada petición, es mejor opción la de un proceso por cliente.  Así, por lo menos, sólo sentirá el retraso el cliente que más pida. (En un ejemplo tan exagerado como este, posiblemente nos de igual lo que hagamos, que no seremos capaz de atender a los clientes).

La segunda es buena opción cuando recibimos peticiones de los clientes que podemos atender más rápidamente de lo que nos llegan. Si los clientes nos hacen una petición por segundo y tardamos un milisegundo en atenderla, nos bastará con un único proceso pendiente de todos.

Vamos a hacer un ejemplo de código con esta segunda opción. Un programa servidor atenderá conexiones de clientes. A cada uno le asignará un número de cliente y se lo enviará. Tendremos un programa cliente que cada segundo envía su número de cliente al servidor. Podremos lanzar hasta 10 clientes simultaneamente y todos serán atendidos. En el ejemplo básico de sockets se hicieron unos ficheros con funciones útiles. Aquí se han extraido en una librería que se necesita para el ejemplo.

Para facilitarnos el tratamiento con un solo proceso, tenemos la función select(), Si tenemos varios sockets abiertos (incluido el socket servidor que recibe a los clientes) y disponemos de sus descriptores, podemos pasarselos a la función select(). Si así lo deseamos, nuestro código se quedará dormido hasta que en alguno de los descriptores haya datos disponibles (un nuevo cliente que entra o un cliente ya existente que nos envía un mensaje).

Los parámetros de la función select() son los siguientes:

• int con el valor del descriptor más alto que queremos tratar más uno. Cada vez que abrimos un fichero, socket o similar, se nos da un descriptor de fichero que es entero. Estos descriptores suelen tener valores consecutivos. El 0 suele estar reservado para la stdin, el 1 para la stdout, el 2 para la stderr y a partir del 3 se nos irán asignando cada vez que abramos algún "fichero". Aquí debemos dar el valor más alto del descriptor que queramos pasar a la función más uno.
• fd_set * es un puntero a los descriptores de los que nos interesa saber si hay algún dato disponible para leer o que queremos que se nos avise cuando lo haya. También se nos avisará cuando haya un nuevo cliente o cuando un cliente cierre la conexión.
• fd_set * es un puntero a los descriptores de los que nos interesa saber si podemos escribir en ellos sin peligro. Si en el otro lado han cerrado la conexión e intentamos escribir, se nos enviará una señal SIGPIPE que hará que nuestro programa se caiga (salvo que tratemos la señal). Para nuestro ejemplo no nos interesa.
• fd_set * es un puntero a los descriptores de los que nos interesa saber si ha ocurrido alguna excepción. Para nuestro ejemplo no nos interesa.
• struct timeval * es el tiempo que queremos esperar como máximo. Si pasamos NULL, nos quedaremos bloqueados en la llamada a select() hasta que suceda algo en alguno de los descriptores. Se puede poner un tiempo cero si únicamente queremos saber si hay algo en algún descriptor, sin quedarnos bloqueados.

Cuando la función retorna, nos cambia los contenidos de los fd_set para indicarnos qué descriptores de fichero tiene algo. Por ello es importante inicializarlos completamente antes de volver a llamar a la función select().

Estos fd_set son unos punteros un poco raros. Para rellenarlos y ver su contenido tenemos una serie de macros:

• FD_ZERO (fd_set *) nos vacía el puntero, de forma que estamos indicando que no nos interesa ningún descriptor de fichero.
• FD_SET (int, fd_set *) mete el descriptor que le pasamos en int al puntero fd_set. De esta forma estamos indicando que tenemos interes en ese descriptor.
  Llamando primero a FD_ZERO() para inicializar el contenido del puntero y luego a FD_SET() tantas veces como descriptores tengamos, ya tenemos la variable dipuesta para llamar a select().
• FD_ISSET (int, fd_set *) nos indica si ha habido algo en el descriptor int dentro de fd_set. Cuando select() sale, debemos ir interrogando a todos los descriptores uno por uno con esta macro.
• FD_CLEAR (int, fd_set *) elimina el descriptor dentro del fd_set.

En nuestro programa de ejemplo del servidor tendremos un descriptor del socket servidor y un array con 10 descriptores para clientes. Inicializaremos fd_set con un FD_ZERO(), luego le añadiremos el socket servidor y finalmente, con un bucle, los sockets clientes. Después llamaremos a la función select(). El código sería más o menos

fd_set descriptoresLectura;
int socketServidor;
int socketCliente[10];
int numeroClientes;
...
FD_ZERO (&descriptoresLectura);
FD_SET (socketServidor, &descriptoresLectura);
for (i=0; i<numeroClientes; i++)
    FD_SET (socketCliente[i], &descriptoresLectura);
...
select (maximo+1, &descriptoresLectura, NULL, NULL, NULL);

Como no tenemos interes en condiciones de escritura ni excepciones, pasamos NULL en el segundo y tercer parámetro. El último lo ponemos también a NULL puesto que no tenemos otra tarea que hacer hasta que alguien se conecte o nos envíe algo.

Cuando se salga del select() es porque: 1) se ha intentado conectar un nuevo cliente, 2) uno de los clientes ya conectados nos ha enviado un mensaje o bien 3) uno de los clientes ya conectados ha cerrado la conexión. En cualquiera de estas circunstancias, tenemos que hacer el tratamiento adecuado. La función select() sólo nos avisa de que algo ha pasado, pero no acepta automáticamente al nuevo cliente, no lee su mensaje ni cierra su socket.

Por ello, detrás del select(), debemos verificar socketServidor para ver si hay un nuevo cliente y todos los socketCliente[], para ver si nos han enviado algo o cerrado el socket. El código, después del select(), sería:

/* Se tratan los clientes */
for (i=0; i<numeroClientes; i++)
{
    if (FD_ISSET (socketCliente[i], &descriptoresLectura))
    {
        if ((Lee_Socket (socketCliente[i], (char *)&buffer, sizeof(int)) > 0))
        {
            /* Se ha leido un dato del cliente correctamente. Hacer aquí el tratamiento para ese mensaje. En el ejemplo, se lee y se escribe en pantalla. */
        }
        else
        {
            /* Hay un error en la lectura. Posiblemente el cliente ha cerrado la conexión. Hacer aquí el tratamiento. En el ejemplo, se cierra el socket y se elimina del array de socketCliente[] */
        }
    }
}

/* Se trata el socket servidor */
if (FD_ISSET (socketServidor, &descriptoresLectura))
{
    /* Un nuevo cliente solicita conexión. Aceptarla aquí. En el ejemplo, se acepta la conexión, se mete el descriptor en socketCliente[] y se envía al cliente su posición en el array como número de cliente. */
}

La función Lee_Socket() forma parte de la librería que se comentó anteriormente. Devuelve lo mismo que la función read(), es decir, el número de bytes leidos, 0 si se ha cerrado el socket o -1 si ha habido error.

En cuanto al código de ejemplo del cliente, poco tiene que decir. Abre la conexión, recibe un número de cliente del servidor y se lo reenvia una vez por segundo.

En primer lugar, pera ejecutar el ejemplo, necesitas una mini librería de socket que he hecho para no tener que repetir el mismo código en todos los ejemplos.

Una vez que tengas la librería, tienes los códigos de ejemplo en servselect.c y clientselect.c, que se compilan con Makefile. Descárgalos en un directorio distinto al de la librería (ya que el fichero Makefile, aunque con el mismo nombre, es distinto del de la librería), quita la extensión .txt. Edita el Makefile del ejemplo y en la línea que pone

LIBCHSOCKET = ../LIBRERIA

cambia ../LIBRERIA por el path donde hayas descargado y compilado la librería. Compila el ejemplo con el comando make.

Con permisos de root, en el fichero /etc/services debes añadir una línea que ponga

cpp_java    15557/tcp

El número puede ser el que tú quieras entre 1024 y 65535 siempre y cuando no exista ya en el fichero. El nombre cpp_java aparece tal cual en el código del ejemplo. Si quieres puedes poner otro nombre en el /etc/services, pero debes cambiarlo también en los fuentes del ejemplo.

Una vez compilado todo, ejecuta el servidor con ./servselect. Luego puedes ejecutar en varias ventanas tantos clientes ./clientselect como desees. Verás como todos son atendidos, hasta un máximo de 10 simultáneamente.

Estadísticas y comentarios

Numero de visitas desde el 4 Feb 2007:

• Esta pagina este mes: 83
• Total de esta pagina: 99514
• Total del sitio: 42395153