virtual void fecharPista (int idPista)
{
_mLanes->Wait();
if(_pdLanes[idPista]==Plane::LAND)
_pdLanes[idPista]=Plane::LAND_CLOSED;
else
_pdLanes[idPista]=Plane::LIFT_CLOSED;
_mLanes->Signal();
}
int Listasemaforos::get_congestion(int i)
{
Semaforo *aux;
aux=busca_SemaforoNumero1(i);
if(aux!=NULL) return aux->congestion();
else return -1;
}
virtual void abrirPista (int idPista)
{
_mLanes->Wait();
if(_pdLanes[idPista]==Plane::LAND_CLOSED)
_pdLanes[idPista]=Plane::LAND;
else
_pdLanes[idPista]=Plane::LIFTOFF;
SignalRespectiveWaitingList(_pdLanes[idPista]);
_mLanes->Signal();
}
virtual void libertarPista(Plane * p)
{
if(!p->_finishedWork)
return;
_mLanes->Wait();
_bLanes[p->_idLane]=true;
Plane::PlaneDirection pd = _pdLanes[p->_idLane];
_mLanes->Signal();
SignalRespectiveWaitingList(pd);
}
virtual bool SetLanePriorityTo (Plane::PlaneDirection direction, int idLane)
{
_mLanes->Wait();
if (!_bLanes[idLane])
{
_mLanes->Signal();
return false;
}
_pdLanes[idLane] = direction;
_mLanes->Signal();
return true;
}
void SignalRespectiveWaitingList(Plane::PlaneDirection pd)
{
if(pd==Plane::LAND && _planeListToLand->next != _planeListToLand
|| pd==Plane::LIFTOFF && _planeListToLift->next == _planeListToLift)
{
_sWaitingListLanding->Signal();
}
else if(pd==Plane::LIFTOFF && _planeListToLift->next != _planeListToLift
|| pd==Plane::LAND && _planeListToLand->next == _planeListToLand)
{
_sWaitingListLiftoff->Signal();
}
}
/**
* THREAD -> Controla el tiempo que debe durar el torneo
*/
void* temporizadorTorneo(void* data) {
struct thTemporizador_data *torneo;
torneo = (struct thTemporizador_data *) data;
sem_inicializarTemporizador.P();
cout << "Comienza el temporizador" << endl;
cout << "mutex comenzoConteo temporizadorTorneo" << endl;
pthread_mutex_lock(&mutex_comenzoConteo);
comenzoConteo = true;
pthread_mutex_unlock(&mutex_comenzoConteo);
cout << "unmutex comenzoConteo temporizadorTorneo" << endl;
cout << "MMMMMMMMMMMMMMMMMMMMMMMM empieza a contar" << endl;
sleep(torneo->duracion * 20);
cout << "MMMMMMMMMMMMMMMMMMMMMMMM termina de contar" << endl;
cout << "mutex_timeIsUp temporizadorTorneo --" << endl;
pthread_mutex_lock(&mutex_timeIsUp);
timeIsUp = true;
cout << "TIMEISUP =" << timeIsUp << endl;
pthread_mutex_unlock(&mutex_timeIsUp);
cout << "unmutex_timeIsUp temporizadorTorneo --" << endl;
//sem_inicializarTemporizador.close();
//pthread_cancel(torneo->thEstablecerPartidas);
pthread_cancel(torneo->thAceptarJugadores);
cout << "HACE LOS DOS CANCEL THREAD" << endl;
pthread_exit(NULL);
}
void trabajar() {
bool seguir = true;
while (seguir){
int pidKid, res;
pipeEntrePuertas->leer(&pidKid, sizeof(int));
if (pidKid != -1) {
string ruta = PREFIJO_FIFO_FILA_KIDS + toString(pidKid);
//le dice al chico que pase. No hay problema con usar el mismo fifo en ambas filas.
//para que no deje pasar a mas de los que pueden subir "considera" cuantos quiere la calesita
res = semColaCal->p(-1);
if ( controlErrores1(res, logger, info) == MUERTE_POR_ERROR) { kill(ppid,SIGINT);}
FifoEscritura fifoAKid(ruta + SUFIJO_FIFO_FILA_KIDS);
res = fifoAKid.abrir();
if ( controlErrores2(res, logger, info) == MUERTE_POR_ERROR) { kill(ppid,SIGINT);}
logger->log("Pasa el chico: " + toString(pidKid),info);
fifoAKid.escribir( &VALOR_PASAR2, sizeof(int) );
fifoAKid.cerrar();
fifoAKid.eliminar();
}else{
seguir = false;
}
}
}
//As threads são desbloqueadas através de um método que indicará
//qual a pista a libertar e consoante a sua prioridade irá libertar
//uma thread da lista correspondente ou uma de outra, caso não haja.
virtual Plane * UseLaneTo(Plane::PlaneDirection direction, Plane * planeList, Semaforo * mPlaneList, Semaforo * sWaitingList)
{
mPlaneList->Wait();
Plane * p = AddNewPlaneInEndOf(planeList,direction);
p->_finishedWork = false;
mPlaneList->Signal();
do{
_mLanes->Wait();
int nLane = findLaneTo(direction);
if(nLane == -1)
{
if(direction==Plane::LAND && _planeListToLift->next==_planeListToLift)
{
nLane = findLaneTo(Plane::LIFTOFF);
}
else if(direction==Plane::LIFTOFF && _planeListToLand->next==_planeListToLand)
{
nLane = findLaneTo(Plane::LAND);
}
if(nLane==-1)
{
_mLanes->Signal();
sWaitingList->Wait();
}
}
if(nLane!=-1)
{
_bLanes[nLane]=false;
_mLanes->Signal();
//obter o aviao consoante a direccao
mPlaneList->Wait();
p = planeList->next;
Remove(p);
mPlaneList->Signal();
p->_finishedWork = true;
p->_idLane = nLane;
break;
}
}while(true);
return p;
}
void Listasemaforos::ubicarMiAuto(Vehiculo *v)
{
Nodosemaforo *nodo = czo;
Semaforo *aux = NULL;
while(nodo != NULL)
{
if(nodo->get_dato()->get_ubicacion() == v->get_origen()){
aux = nodo->get_dato();
//continue;
}
nodo = nodo->get_next();
}
if(aux != NULL) {
if(!aux->rojo(v)) cout<<"El semaforo estaba colmado. No se pudo insertar el vehiculo mat.: "<<v->get_matricula()<<endl;
}
else cout<<"Error en la busqueda del semaforo (UbicarMiAuto) "<<endl;
}
void Listasemaforos::ubicarAleatorio(Vehiculo *v)
{
int rnd = rand()%cantSemaforos;
Semaforo *aux;
aux=busca_SemaforoNumero1(rnd);
while(aux->get_ubicacion() == v->get_destino()){ //
rnd= rand()%cantSemaforos;
aux=busca_SemaforoNumero1(rnd);
}
if(aux != NULL) {
if(aux->rojo(v)) { //Si 'v' se pudo encolar en la cola de 'aux':
v->set_origen(aux->get_ubicacion()); //Seteo origen y pos_actual de 'v' relativos al semaforo 'aux'
v->set_posicionActual(aux->get_ubicacion());
}
else cout<<"El semaforo estaba colmado. No se pudo insertar el vehiculo mat.: "<<v->get_matricula()<<endl;
}
else cout<<"Error en la busqueda del semaforo (UbicarAleatorio) "<<endl;
}
void iniciar(char** argv) {
logger->log("Arranca la fila de la calesita",info);
//recibe pipes
int fdReadPuerta,fdWritePuerta;
fdReadPuerta = toInt(argv[1]);
fdWritePuerta = toInt(argv[2]);
pipeEntrePuertas = new Pipe(fdReadPuerta,fdWritePuerta);
pipeEntrePuertas->setearModo(Pipe::LECTURA);
//agarra semaforo
semColaCal = new Semaforo(ARCH_SEM, SEM_COLA_CAL);
int res = semColaCal->crear();
if ( controlErrores1(res, logger, info) == MUERTE_POR_ERROR) { kill(ppid,SIGINT);}
}
int main()
{
Semaforo semaforo;
while (semaforo.buscar() != NULL)
{
Nodo* actual = semaforo.buscar();
semaforo.asignar(actual);
semaforo.buscarPermitidos();
}
semaforo.sortGraph();
semaforo.print();
while(true)
{
}
}
/**
* THREAD -> Crea los servidores de partidas
*/
void* establecerPartidas(void* data) {
pid_t pid;
int idJugador;
int idOponente;
int nroPartida = 1;
string nombreSemaforo;
int i = 1;
while (!torneoFinalizado()) {
cout << "pasada de busqueda nro: " << i++ << " PID:" << getpid() << endl;
//recorro la lista de jugadores viendo a quien le puedo asignar un oponente y que comienze la partida
cout << "mutex establecerPartidas" << endl;
pthread_mutex_lock(&mutex_listJugadores);
for (map<int, Jugador*>::iterator it = listJugadores.begin(); it != listJugadores.end(); it++) {
idJugador = it->first;
idOponente = it->second->obtenerOponente();
//si no se encuentra jugando actualmente y se encontro un oponente lanzo el servidor de partida
if (idOponente > 0) {
//habilito el temporizador del torneo
if (nroPartida == 1) {
cout << "Se crea la primer partida y doy permiso a iniciar el temporizador" << endl;
sem_inicializarTemporizador.V();
}
nroPartida++;
puertoPartida++;
key_t key = ftok("/bin/ls", puertoPartida);
if (key == -1) {
cout << "Error al generar clave de memoria compartida" << endl;
break;
}
cout<<"ftok key generada: "<<key<<endl;
int idShm = shmget(key, sizeof(struct puntajesPartida) * 1, IPC_CREAT | PERMISOS_SHM);
if (idShm == -1) {
cout << "Error al obtener memoria compartida" << endl;
break;
}
cout << "SERV TORNEO Partida: " << puertoPartida << " ID SHM: " << idShm << endl;
//inicializo el BLOQUE DE SHM
puntajesPartida* resumenPartida = (struct puntajesPartida *) shmat(idShm, (char *) 0, 0);
resumenPartida->idJugador1 = idJugador;
resumenPartida->idJugador2 = idOponente;
resumenPartida->jugando = true;
resumenPartida->keepAlivePartida = true;
resumenPartida->keepAliveTorneo = true;
resumenPartida->puntajeJugador1 = 0;
resumenPartida->puntajeJugador2 = 0;
//genero y cargo los datos de la partida en una lista
datosPartida structuraDatosPartida;
structuraDatosPartida.idShm = idShm;
structuraDatosPartida.lecturasFallidasSHM_Partida = 0;
string nombreSemaforoPartida = "/" + intToString(puertoPartida) + "_Partida";
string nombreSemaforoTorneo = "/" + intToString(puertoPartida) + "_Torneo";
Semaforo* semaforoPartida = new Semaforo(nombreSemaforoPartida.c_str(), 1);
Semaforo* semaforoTorneo = new Semaforo(nombreSemaforoTorneo.c_str(), 0);
structuraDatosPartida.semaforo_pointerSem_t_Partida = semaforoPartida->getSem_t();
structuraDatosPartida.semaforo_pointerSem_t_Torneo = semaforoTorneo->getSem_t();
cout << "SERV TORNEO nombre SEM Torneo" << semaforoTorneo->getName() << endl;
cout << "SERV TORNEO nombre SEM Partida" << semaforoPartida->getName() << endl;
cout << "SERV TORNEO Sem_t * semaforo Torneo: " << semaforoTorneo->getSem_t() << endl;
cout << "SERV TORNEO Sem_t * semaforo Partida: " << semaforoPartida->getSem_t() << endl;
cout << "mutex establecerPartidas partidasActivas" << endl;
pthread_mutex_lock(&mutex_partidasActivas);
partidasActivas.push_back(structuraDatosPartida);
pthread_mutex_unlock(&mutex_partidasActivas);
cout << "unmutex establecerPartidas partidasActivas" << endl;
//Le mando a los jugadores el nro de Puerto en el que comenzara la partida
char auxPuertoNuevaPartida[LONGITUD_CONTENIDO];
sprintf(auxPuertoNuevaPartida, "%d", puertoPartida);
string message(CD_PUERTO_PARTIDA);
message.append(fillMessage(auxPuertoNuevaPartida));
cout << "Puerto para partida " << message << endl;
listJugadores[idJugador]->SocketAsociado->SendNoBloq(message.c_str(), message.length());
listJugadores[idOponente]->SocketAsociado->SendNoBloq(message.c_str(), message.length());
if ((pid = fork()) == 0) {
//Proceso hijo. Hacer exec
cout << "J" << idJugador << " Crear Partida en el puerto: " << (puertoPartida - 1) << " (" << idJugador << "vs" << idOponente << ")" << endl;
char auxCantVidas[2];
sprintf(auxCantVidas, "%d", cantVidas);
char *argumentos[] = { auxPuertoNuevaPartida, auxCantVidas, NULL };
execv("../Servidor Partida/Debug/Servidor Partida", argumentos);
cout << "ERROR al ejecutar execv Nueva Partida" << endl;
exit(1);
} else if (pid < 0) {
//Hubo error
cout << "Error al forkear" << endl;
} else {
//Soy el padre.
}
} else {
//cout << "J" << idJugador << " No puede jugar" << endl;
}
}
pthread_mutex_unlock(&mutex_listJugadores);
cout << "unmutex establecerPartidas" << endl;
usleep(INTERVALO_ENTRE_BUSQUEDA_DE_OPONENTES);
}
cout << "Thread EstablecerPartidas va a hacer un Exit" << endl;
pthread_exit(NULL);
}
int main(int argc, char* argv[]) {
if (argc <= 1) {
cout << "Error: No hay direccion del archivo" << endl;
return -1;
}
if (argc >= 3 && !strcmp(argv[1],"-t")) {
for(int i = 2; i < argc; ++i) {
/* Los hijos del proceso realizarán el interior del if,
*termina en exit(0), para que los hijos no realicen el for */
if(!fork()) {
procesa_xml(argv[i],i); // i representará el m_type con que enviará mensajes al buzón
exit(0);
}
}
// Semáforos para impresor-padre
Semaforo mySemaphore;
Semaforo sonSemaphore;
struct tag {
char tag_name[MAX_CHAR]; // Nombre de la etiqueta
int cantidad_tag; // Cantidad de la etiqueta
};
int share_mem_id = shmget(KEY, sizeof(tag)*BUFER_SIZE, 0700 | IPC_CREAT); // Memoria compartida
int share_mem_id_i = shmget(KEY_i, sizeof(int), 0700 | IPC_CREAT); // Memoria compartida
int* i_share = (int*) shmat( share_mem_id_i, NULL, 0 );
*(i_share) = 0;
/* Codigo de hijo impresor */
if(!fork()) {
const tag* const area = (tag*) shmat( share_mem_id , NULL, 0 );
cout << "\nConteo de etiquetas de los archivos en orden alfabetico\n" << endl;
cout << left << setw(28) << "Nombre de la etiqueta" << "Numero de veces" << endl;
cout.fill('_'); cout << left << setw(42) << ' ' << '\n' << endl;
mySemaphore.wait(); // Espera la primera llamada del padre
while(*(i_share) != -1){
for(int i = 0; i < *(i_share); ++i){
cout.fill(' '); cout << left << setw(28) << area[i].tag_name << right << setw(8) << area[i].cantidad_tag << endl;
}
sonSemaphore.signal(); // Signal al proceso padre
mySemaphore.wait(); // Se queda esperando a la proxima estructura a ejecutar
}
cout.fill('_'); cout << left << setw(43) << ' ' << endl;
sonSemaphore.signal();
exit(0);
}
/* Instrucciones que realizará el padre */
tag tmp;
// Vectores que se utilizarán para el ordenamiento alfabético de las estructuras
tag tagVec[argc];
bool flagVec[argc];
for(int i = 2; i < argc; ++i) {
flagVec[i] = true;
}
// Llena los vectores con los primeros mensajes enviados por los hijos
for(int i = 2; i < argc; ++i) {
myMailbox.recibir(tmp.tag_name,MAX_CHAR,tmp.cantidad_tag,i,0);
strcpy(tagVec[i].tag_name,tmp.tag_name);
tagVec[i].cantidad_tag = tmp.cantidad_tag;
}
// Los mensajes de los hijos que tengan "END", indican que terminó su ejecución
for(int i = 2; i < argc; ++i) {
if(!strcmp(tagVec[i].tag_name,"END"))
flagVec[i] = false;
}
tag* area = (tag*) shmat(share_mem_id , NULL, 0);
char bandera = ' ';
// Extrae la menor etiqueta y la envía a impresión
bool finish = false;
do {
int index_menor_etiqueta = 2;
for(int i = 3; i < argc; ++i) {
if(flagVec[i]) {
int comparacion = strcmp(tagVec[i].tag_name,tagVec[index_menor_etiqueta].tag_name);
if( comparacion < 0 ) { // tagVec[i].tag_name es menor
index_menor_etiqueta = i;
}
else if(comparacion == 0 && index_menor_etiqueta != i) {
/* Como hay 2 etiquetas iguales, se pasará a sumar las etiqeutas a alguna de las 2
* luego, se pedirá la siguiente etiqueta (buzón) para que no hayan conflictos */
tagVec[index_menor_etiqueta].cantidad_tag += tagVec[i].cantidad_tag;
myMailbox.recibir(tmp.tag_name,MAX_CHAR,tmp.cantidad_tag,i,0);
strcpy(tagVec[i].tag_name,tmp.tag_name);
if(!strcmp(tagVec[i].tag_name,"END"))
flagVec[i] = false;
tagVec[i].cantidad_tag = tmp.cantidad_tag;
}
}
}
if(bandera != tagVec[index_menor_etiqueta].tag_name[1] && bandera != ' '){
mySemaphore.signal();
sonSemaphore.wait();
*(i_share) = 0;
}
// Envía los datos a impresor
strcpy(area[*i_share].tag_name,tagVec[index_menor_etiqueta].tag_name);
area[*i_share].cantidad_tag = tagVec[index_menor_etiqueta].cantidad_tag;
*(i_share) += 1;
bandera = tagVec[index_menor_etiqueta].tag_name[1];
// Al sacar el menor del vector, se llama a la siguiente etiqueta
myMailbox.recibir(tmp.tag_name,MAX_CHAR,tmp.cantidad_tag,index_menor_etiqueta,0);
strcpy(tagVec[index_menor_etiqueta].tag_name,tmp.tag_name);
if(!strcmp(tagVec[index_menor_etiqueta].tag_name,"END"))
flagVec[index_menor_etiqueta] = false;
tagVec[index_menor_etiqueta].cantidad_tag = tmp.cantidad_tag;
bool tmp = true;
for(int i = 2; i < argc; ++i){
if(flagVec[i])
tmp = false;
}
if(tmp)
finish = true;
} while(!finish);
mySemaphore.signal();
sonSemaphore.wait(); // Envía el último estructura de etiquetas al impresor
*(i_share) = -1;
mySemaphore.signal();
sonSemaphore.wait();
shmdt(area);
shmctl( share_mem_id, IPC_RMID, NULL );
shmctl( share_mem_id_i, IPC_RMID, NULL );
mySemaphore.destroy();
sonSemaphore.destroy();
}
else {
// Caso de un solo archivo
procesa_xml_un_archivo(argv[1]);
}
myMailbox.destroy();
return 0;
}
/*
* destruye los ipc
*/
int main(int argc, char** argv) {
Logger::init(PATH_LOG,argv[0]);
//destruir mutex
Semaforo mutex = Semaforo(PATH_IPC_MUTEX.c_str());
mutex.destroy();
(Logger::getLogger())->escribir(MSJ,"Mutex destruido.");
//destruir sem museo lleno
Semaforo museo_lleno = Semaforo(PATH_IPC_MUSEOLLENO.c_str());
museo_lleno.destroy();
(Logger::getLogger())->escribir(MSJ,"Semaforo de museo lleno destruido.");
//obtener memoria compartida
key_t key = ftok(PATH_IPC_SHM.c_str(),SHM);
int shm_id = shmget(key,sizeof(MUSEO),0666);
if (shm_id == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo obtener la memoria compartida para destruirla.");
Logger::destroy();
exit(1);
}
MUSEO* museo_shm = static_cast<MUSEO*>(shmat(shm_id,0,0));
if (museo_shm == (MUSEO*)(-1)) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo inicializar la memoria compartida.");
Logger::destroy();
exit(1);
}
//obtengo la cant de puertas
int cantidad_puertas = museo_shm->cant_puertas;
int res = shmdt(museo_shm);
if (res < 0) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo desatachear la memoria compartida al inicializar.");
Logger::destroy();
exit(1);
}
//elimino la memoria
res = shmctl(shm_id,IPC_RMID,NULL);
if (res == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo destruir la memoria compartida.");
Logger::destroy();
exit(1);
}
(Logger::getLogger())->escribir(MSJ,"Memoria compartida destruida.");
//eliminar colas de puertas
static char puerta[MAX_DIG_PUERTA];
for (int i=0;i<cantidad_puertas;i++) {
sprintf(puerta,"%d",i);
//eliminar cola entrada
key_t key = ftok(PATH_IPC_COLAENTRADA.c_str(),i);
int id_cola = msgget(key,0666);
if (id_cola == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo obtener la cola de entrada para la puerta "+puerta+" para eliminarla.");
Logger::destroy();
exit(1);
}
int res = msgctl(id_cola,IPC_RMID,NULL);
if (res == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo destruir la cola de entrada para puerta "+puerta+".");
Logger::destroy();
exit(1);
}
Logger::getLogger()->escribir(MSJ,string("Eliminada exitosamente cola de entrada para puerta ")+puerta+".");
//eliminar cola entrada respuesta
key = ftok(PATH_IPC_COLAENTRADA_RESP.c_str(),i);
id_cola = msgget(key,0666);
if (id_cola == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo obtener la cola de entrada de respuesta para la puerta "+puerta+" para eliminarla.");
Logger::destroy();
exit(1);
}
res = msgctl(id_cola,IPC_RMID,NULL);
if (res == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo destruir la cola de entrada de respuesta para puerta "+puerta+".");
Logger::destroy();
exit(1);
}
Logger::getLogger()->escribir(MSJ,string("Eliminada exitosamente cola de entrada de respuesta para puerta ")+puerta+".");
//eliminar cola de salida
key = ftok(PATH_IPC_COLASALIDA.c_str(),i);
id_cola = msgget(key,0666);
if (id_cola == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo obtener la cola de salida para la puerta "+puerta+" para eliminarla.");
Logger::destroy();
exit(1);
}
res = msgctl(id_cola,IPC_RMID,NULL);
if (res == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo destruir la cola de salida para puerta "+puerta+".");
Logger::destroy();
exit(1);
}
Logger::getLogger()->escribir(MSJ,string("Eliminada exitosamente cola de salida para puerta ")+puerta+".");
//eliminar cola salida respuesta
key = ftok(PATH_IPC_COLASALIDA_RESP.c_str(),i);
id_cola = msgget(key,0666);
if (id_cola == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo obtener la cola de salida de respuesta para la puerta "+puerta+" para eliminarla.");
Logger::destroy();
exit(1);
}
res = msgctl(id_cola,IPC_RMID,NULL);
if (res == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo destruir la cola de salida de respuesta para puerta "+puerta+".");
Logger::destroy();
exit(1);
}
Logger::getLogger()->escribir(MSJ,string("Eliminada exitosamente cola de salida de respuesta para puerta ")+puerta+".");
}
//eliminar cola de museo cerrado
key = ftok(PATH_IPC_COLAMUSEOCERRADO.c_str(),COLA_MUSEO_CERR);
int cola_museo_cerrado = msgget(key,0666);
if (cola_museo_cerrado == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo obtener la cola de aviso de museo cerrado para eliminarla.");
Logger::destroy();
exit(1);
}
res = msgctl(cola_museo_cerrado,IPC_RMID,NULL);
if (res == -1) {
(Logger::getLogger())->escribir(ERROR,std::string(strerror(errno))+" No se pudo destruir la cola de aviso de museo cerrado.");
Logger::destroy();
exit(1);
}
Logger::getLogger()->escribir(MSJ,string("Eliminada exitosamente cola de de aviso de museo cerrado."));
(Logger::getLogger())->escribir(MSJ,"------------------------------------------------------");
Logger::destroy();
return 0;
}