Esta práctica consiste en el diseño e implementación de un intérprete de órdenes al estilo de los shells de UNIX, utilizando una arquitectura cliente/servidor. El intérprete de órdenes será un proceso servidor que se ejecutará en segundo plano. Tal servidor atenderá las peticiones de otros procesos clientes, según un protocolo de comunicaciones conocido por ambas clases de procesos.
Por tanto, en esta práctica hay que escribir el código de un proceso servidor y de un proceso cliente.
El programa servidor tendrá la siguiente sintaxis:
servidor
Al invocar al servidor, quedará automáticamente en segundo plano (background), en espera de atender las futuras peticiones de los procesos clientes hasta que reciba una orden especial de finalización.
El servidor ejecutará las órdenes secuencialmente, una detrás de otra. Esto es, el servidor no puede lanzar varias órdenes concurrentes, y siempre tendrá que esperar a que una orden finalice para tramitar la siguiente.
Los clientes que envíen peticiones mientras el servidor está ejecutando una orden tendrán que esperar. Cuando una orden termine de ejecutarse, el servidor deberá notificar el resultado de la ejecución al proceso cliente que la demandó (el cual estará esperando por la notificación).
Mientras no haya órdenes que atender, el servidor permanecerá bloqueado.
El programa cliente admitirá dos opciones de trabajo:
cliente arg1 arg2 ... argN
cliente finaliza
El cliente admitirá uno o más argumentos, que constituyen la orden que se transmite al servidor. El cliente quedará bloqueado hasta que la orden haya sido ejecutada por completo, momento en el que el servidor le enviará una notificación.
El primer argumento (arg1) es el nombre del programa que se
quiere ejecutar. Es obligatorio al menos un argumento. En el caso especial de
que el primer argumento sea la cadena finaliza, se
enviará al servidor una petición de que finalice.
Las órdenes enviadas no contendrán asteriscos, redirecciones ni tuberías (complicarían en exceso la implementación de la práctica).
La salida de datos de la orden ejecutada se mostrará en la misma terminal del cliente.
En caso de que el servidor finalice o aborte durante la ejecución de la orden, el cliente deberá desbloquearse y terminar imprimiendo un mensaje alusivo.
Toda orden que se le envía al servidor para que la ejecute
deberá ser pasada como parámetro de ejecución del programa
cliente, es decir, si por ejemplo queremos que se ejecute un cliente que
demande la ejecución del orden del sistema date
(mostrar fecha y hora actual), entonces se deberá teclear desde el
símbolo del sistema lo siguiente:
$ cliente date
Otro ejemplo: para solicitarle al servidor que muestre el contenido de un
supuesto directorio cuya ruta es /mi_dir, entonces
habría que teclear desde el símbolo del sistema la
línea:
$ cliente ls /mi_dir
Las órdenes con caracteres comodín, como
ls *.txt, no les van a funcionar correctamente, así
que no las empleen.
Los clientes y el servidor han de transferirse información (las peticiones y las respuestas). Además, los procesos del sistema tendrán que sincronizarse en ciertos momentos (ej. cuando un cliente espera a que se complete una petición).
El sistema operativo UNIX ofrece múltiples mecanismos para realizar comunicaciones entre procesos: utilizar un fichero normal, un fichero FIFO o pipe, zonas de memoria compartida o colas de mensajes. Los ficheros FIFO y las colas de mensajes facilitan además la sincronización.
El UNIX tiene semáforos como herramienta especialmente destinada a la sincronización entre procesos.
Para esta práctica, ustedes tendrán que optar entre uno de estos dos conjuntos de herramientas:
* Memoria compartida y semáforos
* Colas de mensajes