int main(int argc, char **argv)
{
char buffer[255];
if (argc != 2) {
strcpy (buffer, "Error: Cantidad de parametros invalida\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int cantProcesos = 0;
sscanf(argv[1] , "%d", &cantProcesos);
// Obteniendo semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
semControl.destroy();
// Obteniendo semaforos de control de los procesos
Semaphore semProductores = Semaphore();
semProductores.getSemaphore((char *)DIRECTORY, ID_SEMPRODUCTORES, cantProcesos);
semProductores.destroy();
// Obteniendo la memoria compartida
CountingSharedMemory shMem = CountingSharedMemory();
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
shMem.destroy();
return 0;
}
int main(int argc, char **argv)
{
Semaphore semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
semControl.destroy();
// Obteniendo memoria compartida
TicketsInfoSharedMemory shMem = TicketsInfoSharedMemory();
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
shMem.destroy();
// Obteniendo colas de mensajes
GetVendedorMessageQueue getVendedorQueue1 = GetVendedorMessageQueue();
getVendedorQueue1.getMessageQueue((char*)DIRECTORY, ID_GET_VENDEDOR_1);
getVendedorQueue1.destroy();
ComprarMessageQueue comprarQueue1 = ComprarMessageQueue();
comprarQueue1.getMessageQueue((char*)DIRECTORY, ID_COMPRAR_1);
comprarQueue1.destroy();
VenderMessageQueue venderQueue1 = VenderMessageQueue();
venderQueue1.getMessageQueue((char*)DIRECTORY, ID_VENDER_1);
venderQueue1.destroy();
GetVendedorMessageQueue getVendedorQueue2 = GetVendedorMessageQueue();
getVendedorQueue2.getMessageQueue((char*)DIRECTORY, ID_GET_VENDEDOR_2);
getVendedorQueue2.destroy();
ComprarMessageQueue comprarQueue2 = ComprarMessageQueue();
comprarQueue2.getMessageQueue((char*)DIRECTORY, ID_COMPRAR_2);
comprarQueue2.destroy();
VenderMessageQueue venderQueue2 = VenderMessageQueue();
venderQueue2.getMessageQueue((char*)DIRECTORY, ID_VENDER_2);
venderQueue2.destroy();
// Obteniendo memoria compartida de numerador
NumeradorSharedMemory shMemNum = NumeradorSharedMemory();
shMemNum.getSharedMemory((char *)DIRECTORY_NUM, ID_SHMEM_NUMERADOR);
shMemNum.destroy();
Semaphore semControlNum = Semaphore();
semControlNum.getSemaphore((char *)DIRECTORY_NUM, ID_SEMCONTROL_NUMERADOR, 1);
semControlNum.destroy();
return 0;
}
void iniciarIPC(ComunicacionRobot5MessageQueue &colaComunicacionRobot5,
PedidosAgvMessageQueue &colaPedidos,
BufferCanastoSharedMemory *bufferCanasto,
Semaphore &semaforoAccesoBufferAgv,
Semaphore &semaforoBloqueoAgv) {
/* Obtengo la cola de comunicacion con el robot 5 */
colaComunicacionRobot5.getMessageQueue(DIRECTORY,ID_COLA_API_ROBOT_5);
/* Obtengo la cola de pedidos */
colaPedidos.getMessageQueue(DIRECTORY,ID_COLA_PEDIDOS_AGV_5);
/* Obtengo el buffer para depositar los canastos */
bufferCanasto[0].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_0);
bufferCanasto[1].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_1);
bufferCanasto[2].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_2);
/* Obtengo los semaforos de acceso a los buffer */
semaforoAccesoBufferAgv.getSemaphore(DIRECTORY, ID_SEM_ACCESO_BUFFER_AGV, 3);
/* Obtengo los semaforos de bloqueo de los Agv */
semaforoBloqueoAgv.getSemaphore(DIRECTORY, ID_SEM_BLOQUEO_AGV, 3);
}
int main(int argc, char **argv)
{
// Obtengo los semaforos que controlan el avance de productores y analizadores
Semaphore semProductores = Semaphore();
semProductores.getSemaphore((char *)DIRECTORY,ID_SEMPRODUCTORES, CANT_PRODUCTORES);
semProductores.destroy();
Semaphore semAnalizadores = Semaphore();
semAnalizadores.getSemaphore((char *)DIRECTORY,ID_SEMANALIZADORES, CANT_ANALIZADORES);
semAnalizadores.destroy();
// Obtengo el semaforo que controla el acceso a la memoria compartida
Semaphore semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
semControl.destroy();
// Obtengo la memoria compartida
SamplesTableSharedMemory table = SamplesTableSharedMemory();
table.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
table.destroy();
return 0;
}
int main(int argc, char** argv) {
char buffer[TAM_BUFFER];
try {
/* Obtengo la cola de comunicacion con el robot 5 con los dos procesos del controlador */
ComunicacionRobot5MessageQueue colaComunicacionRobot5 = ComunicacionRobot5MessageQueue();
colaComunicacionRobot5.getMessageQueue(DIRECTORY,ID_COLA_API_ROBOT_5);
colaComunicacionRobot5.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo la cola de pedidos del robot 5 */
PedidosProduccionMessageQueue colaPedidos = PedidosProduccionMessageQueue();
colaPedidos.getMessageQueue(DIRECTORY,ID_COLA_PEDIDOS_PRODUCCION);
colaPedidos.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
/*
* ROBOT 5 - AGV
*/
try {
/* Obtengo los buffer para depositar los canastos */
BufferCanastoSharedMemory bufferCanasto[3];
bufferCanasto[0].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_0);
bufferCanasto[0].destroy();
bufferCanasto[1].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_1);
bufferCanasto[1].destroy();
bufferCanasto[2].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_2);
bufferCanasto[2].destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo los semaforos de acceso a los buffer de los canastos */
Semaphore semaforoAccesoBufferAgv;
semaforoAccesoBufferAgv.getSemaphore(DIRECTORY, ID_SEM_ACCESO_BUFFER_AGV, 3);
semaforoAccesoBufferAgv.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo los semaforos de bloqueo de los Agv */
Semaphore semaforoBloqueoAgv;
semaforoBloqueoAgv.getSemaphore(DIRECTORY, ID_SEM_BLOQUEO_AGV, 3);
semaforoBloqueoAgv.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo la cola de pedidos de los AGV */
PedidosAgvMessageQueue colaPedidosAgv;
colaPedidosAgv.getMessageQueue(DIRECTORY,ID_COLA_PEDIDOS_AGV_5);
colaPedidosAgv.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
/*
* Robot 5 - Cinta
*/
try {
/* Obtengo las memorias compartidas y los semaforos de las cintas transportadoras */
Semaphore semCinta0 = Semaphore();
semCinta0.getSemaphore(DIRECTORY, ID_CINTA_6_0, 1);
semCinta0.destroy();
CintaTransportadoraSharedMemory memCinta0 = CintaTransportadoraSharedMemory();
memCinta0.getSharedMemory(DIRECTORY, ID_CINTA_6_0);
memCinta0.destroy();
Semaphore semCinta1 = Semaphore();
semCinta1.getSemaphore(DIRECTORY, ID_CINTA_6_1, 1);
semCinta1.destroy();
CintaTransportadoraSharedMemory memCinta1 = CintaTransportadoraSharedMemory();
memCinta1.getSharedMemory(DIRECTORY, ID_CINTA_6_1);
memCinta1.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo el semaforo de bloqueo del robot 5 */
Semaphore semBloqueo5 = Semaphore();
semBloqueo5.getSemaphore(DIRECTORY, ID_SEM_BLOQUEO_ROBOT_5, 1);
semBloqueo5.destroy();
/* Obtengo la memoria de estado del robot 5 y el semaforo de acceso */
EstadoRobot5SharedMemory estadoRobot5 = EstadoRobot5SharedMemory();
estadoRobot5.getSharedMemory(DIRECTORY, ID_MEM_ESTADO_ROBOT_5);
estadoRobot5.destroy();
Semaphore semaforoAccesoEstadoRobot5 = Semaphore();
semaforoAccesoEstadoRobot5.getSemaphore(DIRECTORY, ID_SEM_ACCESO_ESTADO_ROBOT_5, 1);
semaforoAccesoEstadoRobot5.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo la memoria de estado de los robot 11 y los semaforos de acceso */
EstadoRobot11SharedMemory estadoRobot11[2];
estadoRobot11[0].getSharedMemory(DIRECTORY, ID_MEM_ESTADO_ROBOT_11_0);
estadoRobot11[0].destroy();
estadoRobot11[1].getSharedMemory(DIRECTORY, ID_MEM_ESTADO_ROBOT_11_1);
estadoRobot11[1].destroy();
Semaphore semaforoAccesoEstadoRobot11 = Semaphore();
semaforoAccesoEstadoRobot11.getSemaphore(DIRECTORY, ID_SEM_ACCESO_ESTADO_ROBOT_11, 2);
semaforoAccesoEstadoRobot11.destroy();
/* Obtengo los semaforos de bloqueo del robot 11 */
Semaphore semaforoBloqueoRobot11 = Semaphore();
semaforoBloqueoRobot11.getSemaphore(DIRECTORY, ID_SEM_BLOQUEO_ROBOT_11, 2);
semaforoBloqueoRobot11.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 2) {
strcpy (buffer, "Error Puerta Entrada: Cantidad de parametros invalida\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
srand (time(NULL));
int totalPuerta = 0;
int nroPuerta = 0;
sscanf(argv[1] , "%d", &nroPuerta);
sprintf(buffer, "Puerta Entrada: %d Iniciando\n", nroPuerta);
write(fileno(stdout), buffer, strlen(buffer));
// Creando semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
if (semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener el semaforo de control\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo memoria compartida
InfoMuseoSharedMemory shMem = InfoMuseoSharedMemory();
if (shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la memoria\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = true;
while (deboSeguir) {
int dormir = rand() % 5 + 1;
sprintf (buffer, "Puerta Entrada: %d Durmiendo por %d segundos\n", nroPuerta, dormir);
write (fileno(stdout),buffer, strlen(buffer));
usleep(dormir*1000*1000);
totalPuerta++;
sprintf (buffer, "Puerta Entrada: %d Llego la persona %d\n", nroPuerta, totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
int semaphoreOperation = semControl.wait(0);
if (semaphoreOperation == -1) exit(-1);
{
InfoMuseo *info = shMem.readInfo();
if (! (*info).abierto) {
sprintf (buffer, "Puerta Entrada: %d El museo esta CERRADO, la persona %d debe irse\n", nroPuerta,totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
}
else {
if ((*info).cantidad == (*info).cantidadMaxima) {
sprintf (buffer, "Puerta Entrada: %d El museo esta LLENO, la persona %d debe irse\n", nroPuerta,totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
}
else {
sprintf (buffer, "Puerta Entrada: %d La persona %d ingresa al museo\n", nroPuerta,totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
(*info).cantidad++;
(*info).total++;
shMem.writeInfo(info);
}
}
}
semControl.signal(0);
if (semaphoreOperation == -1) exit(-1);
}
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 2) {
strcpy (buffer, "Productor: Error: Cantidad de parametros invalida\n Uso:\n ./productor [NRO PRODUCTOR]\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
int nroProductor = 0;
sscanf(argv[1] , "%d", &nroProductor);
sprintf(buffer, "Productor %d: Iniciando\n", nroProductor);
write(fileno(stdout), buffer, strlen(buffer));
Semaphore semControl = Semaphore();
Semaphore semProductores = Semaphore();
Semaphore semAnalizadores = Semaphore();
MuestrasSharedMemory shMem = MuestrasSharedMemory();
try {
// Obteniendo semaforo de control de acceso a la memoria compartida
semControl.getSemaphore((char *)DIRECTORY, ID_SEM_CONTROL, 1);
// Obteniendo semaforo de bloqueo de los procesos
semProductores.getSemaphore((char *)DIRECTORY, ID_SEM_PRODUCTORES, CANT_MUESTRAS);
// Obteniendo semaforo de bloqueo de los procesos
semAnalizadores.getSemaphore((char *)DIRECTORY, ID_SEM_ANALIZADORES, CANT_ANALIZADORES);
// Obteniendo memoria compartida
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM_MUESTRAS);
}
catch (IPCException &ex) {
sprintf (buffer, "Productor %d: Error Init: %s\n", nroProductor, ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = true;
while (deboSeguir) {
try {
semControl.wait();
Muestras *estado = shMem.readInfo();
// Verifico si la muestra ya fue analizada por todos los analizadores
bool cambiar = puedoCambiar(estado, nroProductor);
while (! cambiar) {
sprintf(buffer, "Productor %d: La muestra todavia no fue analizada por completo.\n",nroProductor);
write(fileno(stdout), buffer, strlen(buffer));
// La muestra no fue analizada por completo, me bloqueo esperando que todos los analizadores terminen
(*estado).productorBloqueado[nroProductor] = true;
shMem.writeInfo(estado);
// Libero la memoria compartida
semControl.signal();
// Me bloqueo en mi semaforo
semProductores.wait(nroProductor);
// Obtengo la memoria compartida y vuelvo a verificar si debo producir
semControl.wait();
estado = shMem.readInfo();
cambiar = puedoCambiar(estado, nroProductor);
}
// Todos los analizadores analizaron la muestra, puedo colocar una nueva muestra
sprintf(buffer, "Productor %d: La muestra ya fue analizada por completo, procedo a cambiarla.\n",nroProductor);
write(fileno(stdout), buffer, strlen(buffer));
// Libero la memoria compartida mientras busco una nueva muestra
semControl.signal();
// Busco una nueva muestra
srand(time(NULL));
int delay = (rand() % 3) + 1;
sprintf(buffer, "Productor %d: Buscando una nueva muestra durante %d\n", nroProductor, delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
// Una vez depositada la nueva muestra, desbloqueo a los analizadores necesarios
semControl.wait();
estado = shMem.readInfo();
// Indico que hay una nueva muestra para analizar y
// verifico si hay algun analizador bloqueado en mi muestra y lo libero
for (int j = 0; j < CANT_ANALIZADORES; ++j) {
(*estado).estadoMuestras[j][nroProductor] = false;
if ((*estado).analizadorBloqueado[j] == nroProductor) {
sprintf(buffer, "Productor %d: Libero al analizador %d\n", nroProductor, j);
write(fileno(stdout), buffer, strlen(buffer));
// Libero al analizador que esta esperando la muestra
(*estado).analizadorBloqueado[j] = CANT_MUESTRAS;
semAnalizadores.signal(j);
}
}
shMem.writeInfo(estado);
semControl.signal();
}
catch (IPCException &ex) {
sprintf (buffer, "Productor %d: Error: %s\n", nroProductor, ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
}
sprintf(buffer, "Productor %d: Terminado \n",nroProductor);
write(fileno(stdout), buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
try {
// Obteniendo semaforo de control de acceso a la memoria compartida Sala
Semaphore semControlSala = Semaphore();
semControlSala.getSemaphore((char *)DIRECTORY, ID_SEM_CONTROL_SALA, 1);
semControlSala.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo semaforo de bloqueo de la puerta
Semaphore semPuerta = Semaphore();
semPuerta.getSemaphore((char *)DIRECTORY, ID_SEM_PUERTA, 1);
semPuerta.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo semaforo de bloqueo de buses
Semaphore semBuses = Semaphore();
semBuses.getSemaphore((char *)DIRECTORY, ID_SEM_BUSES, 1);
semBuses.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo la cola de mensajes de intercambio
IntercambioMessageQueue intercambioMessageQueue = IntercambioMessageQueue();
intercambioMessageQueue.getMessageQueue((char*)DIRECTORY, ID_COLA_PERSONAS);
intercambioMessageQueue.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo memoria compartida Sala
InfoSalaSharedMemory shMemSala = InfoSalaSharedMemory();
shMemSala.getSharedMemory((char *)DIRECTORY, ID_SHMEM_SALA);
shMemSala.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 3) {
strcpy (buffer, "Error Puerta Entrada: Cantidad de parametros invalida\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int nroPuerta = 0;
sscanf(argv[1] , "%d", &nroPuerta);
int totalPuertas = 0;
sscanf(argv[2] , "%d", &totalPuertas);
sprintf(buffer, "Puerta Entrada: %d Iniciando\n", nroPuerta);
write(fileno(stdout), buffer, strlen(buffer));
// Obteniendo semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
if (semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener el semafoto de control\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo semaforo de control de acceso a las puertas
Semaphore semPuertas = Semaphore();
if (semPuertas.getSemaphore((char *)DIRECTORY, ID_SEMPUERTAS, totalPuertas) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener el semafoto de las puertas\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo memoria compartida
InfoMuseoSharedMemory shMem = InfoMuseoSharedMemory();
if (shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la memoria\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo la cola de mensajes de entrada
EntradaMessageQueue entradaMessageQueue = EntradaMessageQueue();
if (entradaMessageQueue.getMessageQueue((char*)DIRECTORY, ID_COLA_ENTRADA) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la cola de entrada\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo la cola de mensajes de respuesta
RespuestaMessageQueue respuestaMessageQueue = RespuestaMessageQueue();
if (respuestaMessageQueue.getMessageQueue((char*)DIRECTORY, ID_COLA_RESPUESTA) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la cola de respuesta\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = true;
while (deboSeguir) {
MensajeEntrada entrada;
entradaMessageQueue.recibirMensajeEntrada(nroPuerta, &entrada);
sprintf (buffer, "Puerta Entrada: %d Recibio a la persona %d\n", nroPuerta, entrada.idPersona);
write (fileno(stdout),buffer, strlen(buffer));
int semaphoreOperation = semControl.wait(0);
if (semaphoreOperation == -1) exit(-1);
{
InfoMuseo *info = shMem.readInfo();
if (! (*info).abierto) {
sprintf (buffer, "Puerta Entrada: %d Museo cerrado, la persona %d debe irse\n", nroPuerta, entrada.idPersona);
write (fileno(stdout),buffer, strlen(buffer));
MensajeRespuesta respuesta;
respuesta.mtype = entrada.idPersona;
respuesta.resultado = false;
respuestaMessageQueue.enviarMensajeRespuesta(respuesta);
deboSeguir = false;
}
else {
sprintf (buffer, "Puerta Entrada: %d Museo abierto, la persona %d puede entrar\n", nroPuerta, entrada.idPersona);
write (fileno(stdout),buffer, strlen(buffer));
bool capacidadDisponible = !((*info).cantidad == (*info).cantidadMaxima);
while ( !capacidadDisponible ) {
(*info).puertasBloqueadas[nroPuerta - 1] = true;
shMem.writeInfo(info);
semaphoreOperation = semControl.signal(0);
if (semaphoreOperation == -1) exit(-1);
semaphoreOperation = semPuertas.wait(nroPuerta-1);
if (semaphoreOperation == -1) exit(-1);
semaphoreOperation = semControl.wait(0);
if (semaphoreOperation == -1) exit(-1);
{
capacidadDisponible = !((*info).cantidad == (*info).cantidadMaxima);
}
}
(*info).puertasBloqueadas[nroPuerta - 1] = false;
sprintf (buffer, "Puerta Entrada: %d Museo abierto, capacidad disponible\n", nroPuerta);
write (fileno(stdout),buffer, strlen(buffer));
MensajeRespuesta respuesta;
respuesta.mtype = entrada.idPersona;
respuesta.resultado = true;
respuestaMessageQueue.enviarMensajeRespuesta(respuesta);
(*info).cantidad++;
shMem.writeInfo(info);
}
}
semaphoreOperation = semControl.signal(0);
if (semaphoreOperation == -1) exit(-1);
}
sprintf (buffer, "Puerta Entrada: %d Terminando\n", nroPuerta);
write (fileno(stdout),buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 2) {
strcpy (buffer, "Error Almacenadora: Cantidad de parametros invalida.\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int cantBotellas = 0;
sscanf(argv[1] , "%d", &cantBotellas);
sprintf(buffer, "Almacenadora: Iniciando\n");
write(fileno(stdout), buffer, strlen(buffer));
Semaphore semAlmacenadora = Semaphore();
Semaphore semEmbotelladora = Semaphore();
try {
semAlmacenadora.getSemaphore((char *)DIRECTORY, ID_SEM_ALMACENADORA, 1);
semEmbotelladora.getSemaphore((char *)DIRECTORY, ID_SEM_EMBOTELLADORA, 1);
}
catch (IPCException &ex) {
sprintf (buffer, "Almacenadora: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = (cantBotellas > 0);
while (deboSeguir) {
try {
srand(time(NULL));
int delay = (rand() % 3) + 1;
sprintf(buffer, "Almacenadora: Depositando botella vacia durante %d segundos\n", delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
semEmbotelladora.signal();
semAlmacenadora.wait();
delay = (rand() % 3) + 1;
sprintf(buffer, "Almacenadora: Depositando botella en caja durante %d segundos\n", delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
cantBotellas--;
deboSeguir = (cantBotellas > 0);
}
catch (IPCException &ex) {
sprintf (buffer, "Almacenadora: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
}
sprintf (buffer, "Almacenadora: Terminando\n");
write (fileno(stdout),buffer, strlen(buffer));
return 0;
}
