static char *obtenerPathCompleto(SocketConecta *conexion)
{
char *nombreArchivo;
size_t tamanioNombreArchivo;
char *pathCompleto;
recibirMensaje(conexion,&tamanioNombreArchivo,4 );
if (! estaConectado(conexion))
finalizarAtencionAConexion(conexion);
nombreArchivo = malloc(tamanioNombreArchivo + 1);
recibirMensaje(conexion,nombreArchivo,tamanioNombreArchivo);
if (! estaConectado(conexion))
finalizarAtencionAConexion(conexion);
nombreArchivo[tamanioNombreArchivo] = '\0';
pathCompleto = malloc(strlen(nombreArchivo) + strlen(obtenerPathEspacioTemporal()) + 1);
strcpy(pathCompleto,obtenerPathEspacioTemporal());
strcat(pathCompleto,nombreArchivo);
return pathCompleto;
}
static void atenderConexionConMensaje(SocketConecta *conexion)
{
int resultado;
if (!estaConectado(conexion))
return;
recibirMensaje(conexion, &resultado, sizeof(int));
if (!estaConectado(conexion))
return;
uint32_t idTarea;
recibirMensaje(conexion, &idTarea, sizeof(uint32_t));
if (!estaConectado(conexion))
return;
uint32_t idJob = idTarea >> 16;
switch(resultado)
{
case MENSAJE_TAREA_OK:
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Se recibio resultado de TAREA %d de JOB %d. TAREA finalizada correctamente.", idTarea, idJob);
planificadorMarcarTareaFinalizada(idTarea);
break;
case MENSAJE_TAREA_FALLO:
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Se recibio resultado de TAREA %d de JOB %d. La TAREA fallo.", idTarea, idJob);
planificadorMarcarTareaFallida(idTarea);
break;
case MENSAJE_NODO_DESCONECTADO:
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Se recibio resultado de TAREA %d de JOB %d. La TAREA fallo por desconexion de nodo.", idTarea, idJob);
planificadorMarcarTareaFallidaPorBajaDeNodo(idTarea);
break;
}
}
static void subirArchivoResultadoAMDFS(SocketConecta *conexionConJob, char *nombreArchivo)
{
int sizePathArchivoEnMDFS;
recibirMensaje(conexionConJob, &sizePathArchivoEnMDFS, sizeof(int));
char *pathArchivoEnMDFS = malloc(sizePathArchivoEnMDFS + 1);
recibirMensaje(conexionConJob, pathArchivoEnMDFS, sizePathArchivoEnMDFS);
pathArchivoEnMDFS[sizePathArchivoEnMDFS] = '\0';
int resultadoDeSubida = conectarAFilesystemYSubirArchivo(nombreArchivo, pathArchivoEnMDFS);
enviarMensaje(conexionConJob, &resultadoDeSubida, sizeof(int));
}
int enviarBloque(t_nodo *nodo, char *bloque, t_bloque *copiaBloque,SocketConecta *conexion)
{
off_t bytesEnviados = 0;
off_t bytesPorEnviar;
off_t retorno;
char respuestaNodo;
off_t tamanio = tamanioDelBloque(bloque);
marcarPosicionComoOcupadaEnArray(nodo->bloques,posicionLibreEnNodo(nodo->bloques));
if(estaConectado(conexion))
enviarMensaje(conexion,GRABAR_TEXTO,1);
if (estaConectado(conexion))
enviarMensaje(conexion,&copiaBloque->numeroDeBloqueEnNodo,sizeof(int));
bytesPorEnviar = tamanio;
while(bytesEnviados < bytesPorEnviar)
{
if(estaConectado(conexion))
{
retorno = enviarMensaje(conexion,(char*)(bloque + bytesEnviados),(bytesPorEnviar - bytesEnviados));
if(retorno <= 0)
break;
bytesEnviados += retorno;
}else
return 0;
}
recibirMensaje(conexion,&respuestaNodo,sizeof(char));
if (!estaConectado(conexion))
return 0;
nodo->bloquesUsados++;
return 1;
}
void *atenderANodo(void *argConexion)
{
SocketConecta *conexion = argConexion;
while(estaConectado(conexion))
{
char nombrePaquete;
t_nodo *nodo;
recibirMensaje(conexion, &nombrePaquete,1);
if(estaConectado(conexion))
{
if (nombrePaquete == CANTIDAD_BLOQUES)
nodo = crearNodo(conexion);
else if (nombrePaquete == BLOQUEAR_ATENDER_NODO){
reservarConexionNodo(nodo);
devolverConexionNodo(nodo);
}
}else
{
deshabilitarNodoPorDesconexion(nodo);
loguear(LOG_LEVEL_INFO,"Se desconecto el nodo %s\n",nodo->nombre);
cerrarSocketConecta(conexion);
}
}
return 0;
}
void realizarMovimiento(Posicion* posicionActual, Posicion* posicion, int socketNivel) {
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
MPS_MSG mensajeConfirmacion;
log_debug(logger, "El personaje esta ubicado en X:(%d) Y:(%d)", posicionActual->x, posicionActual->y);
log_debug(logger, "El personaje procede a moverse a la caja en X:(%d) Y:(%d)", posicion->x, posicion->y);
if (posicionActual->x != posicion->x) {
if (posicionActual->x < posicion->x) {
posicionActual->x++;
} else if (posicionActual->x > posicion->x) {
posicionActual->x--;
}
} else if (posicionActual->y != posicion->y) {
if (posicionActual->y < posicion->y) {
posicionActual->y++;
} else if (posicionActual->y > posicion->y) {
posicionActual->y--;
}
}
Posicion* posicionNueva = malloc(sizeof(Posicion));
posicionNueva->x = posicionActual->x;
posicionNueva->y = posicionActual->y;
armarMensaje(mensaje, AVISO_MOVIMIENTO, sizeof(Posicion), posicionNueva);
enviarMensaje(socketNivel, mensaje);
recibirMensaje(socketNivel, &mensajeConfirmacion);
if (mensajeConfirmacion.PayloadDescriptor == MOVIMIENTO_EXITO) {
log_debug(logger, "El personaje se movio a X:(%d) Y:(%d)", posicionActual->x, posicionActual->y);
}
free(mensaje);
free(posicionNueva);
}
void recibirYChequearConexion(SocketConecta *socket,void * mensaje, int tam)
{
recibirMensaje(socket,mensaje,tam);
if(!estaConectado(socket))
{
fprintf(stderr,"ERROR: Se desconecto marta \n");
exit(1);
}
}
int pedirRecurso(char recursoAPedir, int socketNivel) {
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
armarMensaje(mensaje, PEDIR_RECURSO, sizeof(char), &recursoAPedir);
enviarMensaje(socketNivel, mensaje);
recibirMensaje(socketNivel, mensaje);
if (mensaje->PayloadDescriptor == SIN_RECURSOS) {
log_debug(logger, "El recurso (%c) no esta disponible.", recursoAPedir);
free(mensaje);
return 0;
}
free(mensaje);
return 1;
}
char* informarAdminMemoriaComandoLeer(int32_t pid, char* pagina, sock_t* socketMemoria){
int32_t status;
int32_t numeroPagina = atoi(pagina);
int32_t cabecera = LEER;
uint32_t offset=0;
uint32_t tamanio = sizeof(cabecera) + sizeof(pid) + sizeof(numeroPagina);
char* message = malloc(tamanio);
memcpy(message, &cabecera, sizeof(cabecera));
offset = sizeof(cabecera);
memcpy(message + offset, &pid, sizeof(pid));
offset = offset + sizeof(pid);
memcpy(message + offset, &numeroPagina, sizeof(numeroPagina));
offset = offset + sizeof(numeroPagina);
status = send(socketMemoria->fd,message,tamanio,0);
free(message);
if(!status) {
printf("No se envió el mensaje leer Administrador de Memoria.\n");
}
char* mensaje = string_new();
int32_t lectura = deserializarEntero(socketMemoria);
if(lectura==PEDIDO_ERROR){
log_error(CPULog,"El pedido de lectura no fue exitoso.\n");
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje," - El pedido de lectura no fue exitoso.\n");
}else if(lectura==ABORTAR){
log_warning(CPULog,"[PID:%s] El pedido de lectura abortó el proceso.\n",string_itoa(pid));
string_append(&mensaje, "ABORTAR");
}else{
char* contenido = recibirMensaje(socketMemoria);
log_info(CPULog,"[PID:%s] Lectura realizada. Contenido: %s",string_itoa(pid),contenido);
//mProc 10 - Pagina 2 leida: contenido
cabecera = RESPUESTA_PLANIFICADOR_LOGEAR;
offset = 0;
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje, " - Pagina ");
string_append(&mensaje, pagina);
string_append(&mensaje," leida: ");
string_append(&mensaje,contenido);
string_append(&mensaje,"\n");
}
return mensaje;
}
static void recibirYChequearConexionNodo(SocketConecta *socket,void * mensaje, int tam,SocketConecta *marta,int idOp)
{
recibirMensaje(socket,mensaje,tam);
if(!estaConectado(socket))
{
//Le aviso a marta que la rutina fallo porque se desconecto el nodo
pthread_mutex_lock(&semaforoMarta);
int dos=2;
enviarMensaje(marta,&dos,sizeof(int));
enviarMensaje(marta,&idOp,sizeof(int));
logCabeceraEnvia("Id de map");
pthread_mutex_unlock(&semaforoMarta);
logCabeceraEnvia("Fallo map, se desconecto el nodo");
mostrarFinalizacion(1,idOp);
pthread_exit(0);
}
}
int esperarConfirmacionDelPlanificador(int socketPlanificador) {
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
recibirMensaje(socketPlanificador, mensaje);
// En el caso de que le confirme el movimiento al personaje
if (mensaje->PayloadDescriptor == MOVIMIENTO_PERMITIDO) {
free(mensaje);
return 1;
}
// En el caso de que le confirme la muerte correcta.
else if (mensaje->PayloadDescriptor == MUERTE_PERSONAJE) {
free(mensaje);
log_debug(logger, "El personaje (%s) fue sacado del planificador con exito", personaje->simbolo);
return 1;
}
log_error(logger, "Se recibio un mensaje del planificador inesperado. Descriptor: (%d). Personaje (%s)", mensaje->PayloadDescriptor, personaje->nombre);
free(mensaje);
exit(EXIT_FAILURE);
}
void esperarDesbloqueo(int socketOrquestador) {
MPS_MSG mensajeARecibir;
int bloqueado = 1;
log_debug(logger, "El personaje está a la espera de ser desbloqueado");
while (bloqueado) {
recibirMensaje(socketOrquestador, &mensajeARecibir);
if (mensajeARecibir.PayloadDescriptor == DESBLOQUEAR) {
bloqueado = 0;
}
if (mensajeARecibir.PayloadDescriptor == MUERTE_PERSONAJE) {
int resultado = perderVida(true);
if (resultado == 1) {
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
}
}
int consultarUbicacionCaja(char cajaABuscar, int socketNivel, Posicion* posicion) {
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
MPS_MSG* mensajeARecibir = malloc(sizeof(MPS_MSG));
armarMensaje(mensaje, UBICACION_CAJA, sizeof(char), &cajaABuscar);
enviarMensaje(socketNivel, mensaje);
recibirMensaje(socketNivel, mensajeARecibir);
if (mensajeARecibir->PayloadDescriptor == CAJAFUERALIMITE) {
log_debug(logger, "El personaje %s no puede acceder a la caja (%c) porque esta fuera del limite", personaje->nombre, cajaABuscar);
free(mensaje);
free(mensajeARecibir);
return 0;
}
*posicion = *(Posicion*) mensajeARecibir->Payload;
log_debug(logger, "La caja necesaria esta en X:(%d) Y:(%d)", posicion->x, posicion->y);
free(mensaje);
free(mensajeARecibir);
return 1;
}
static off_t recibirYVerificarConexion(SocketConecta *conexion, void *buffer, off_t longitudBuffer)
{
if (!estaConectado(conexion))
{
loguear(LOG_LEVEL_DEBUG, "Se perdio la conexion con el nodo");
terminarEjecucionDeTarea();
}
ssize_t bytesRecibidos = recibirMensaje(conexion, buffer, longitudBuffer);
if (!estaConectado(conexion))
{
loguear(LOG_LEVEL_DEBUG, "Se perdio la conexion con el nodo");
terminarEjecucionDeTarea();
}
return bytesRecibidos;
}
int main(void){
//Señales
// signal(SIGTERM,manejador);
// signal(SIGINT,manejador);
// signal(SIGUSR1,manejador);
//al usar signal el recv actua de manera q reinicia la solicitud en vez de tirar error, pero al usar sigaction y omitir la flag de reiniciar si se interrumpe
struct sigaction new_action;
new_action.sa_handler = manejador;
sigemptyset (&new_action.sa_mask);
new_action.sa_flags = SA_RESTART;
sigaction (SIGTERM, &new_action, NULL);
sigaction (SIGUSR1, &new_action, NULL);
config=config_create("config.txt");
//Se inicializan las variables para el logueo
t_log_level detail = LOG_LEVEL_TRACE;
log = log_create("LogPersonaje.log","Personaje",true,detail);
//obtener recurso de config
char** obj;
char** niveles;
char** ipPuertoOrq;
char* val;
char* aux;
char* aux1;
char* nivelActual;
char objNivel[20]="obj[Nivel1]";
char corchete[2]="]";
int veclong, llego, cantNiv,c,ii,puertoOrq;
Header h;
niveles=config_get_array_value(config,"planDeNiveles");
vidas=config_get_int_value(config,"vidas");
charPer=config_get_string_value(config,"simbolo")[0];
cantNiv=config_keys_amount(config)-5/*cant de keys fijas*/;
log_info(log,"Se obtuvieron los recursos del config");
aux1=config_get_string_value(config,"orquestador");
ipPuertoOrq=string_split(aux1, ":");
puertoOrq=(int)strtol(ipPuertoOrq[1], &aux, 10);
for(c=0;c<cantNiv;c++){ //for each nivel
ConxNivPlan ipNivelPlanif;
ipNivelPlanif.portNivel=0;
struct sigaction new_action;
new_action.sa_handler = manejador;
sigemptyset (&new_action.sa_mask);
new_action.sa_flags = SA_RESTART;
sigaction (SIGTERM, &new_action, NULL);
while(ipNivelPlanif.portNivel==0){//checkea q el nivel haya llegado al planif y sino entra en un ciclo hasta que entre
memcpy(objNivel+4,niveles[c],strlen(niveles[c]));
memcpy(objNivel+4+strlen(niveles[c]),corchete,2);
// numNiv=(int)strtol(niveles[c]+5, &aux, 10);
nivelActual=niveles[c];
obj=config_get_array_value(config,objNivel);
val=config_get_string_value(config,objNivel);
veclong=lengthVecConfig(val);
pos.x=0;
pos.y=0;
rec.x=-1;
rec.y=-1;
//conexion solicitud de ip:puerto al orquestator y cierre de esa conex
int unSocketOrq;
unSocketOrq = quieroUnPutoSocketAndando(ipPuertoOrq[0],puertoOrq);
char* auxC;
auxC=malloc(sizeof(char));
*auxC=charPer;
//handshake Orquestador-Personaje
if (mandarMensaje(unSocketOrq ,0 , sizeof(char),auxC)>0) {
if(recibirMensaje(unSocketOrq,(void**)&auxC)>0) {
log_debug("Handshake contestado del Orquestador %c",*auxC);
}
}
int tipomsj=1;
log_debug(log,"seMurio: %d",seMurio);
if((seMurio==-1)||(seMurio==1)){tipomsj=3;seMurio=0;}
if((seMurio==-2)){tipomsj=4;seMurio=0;}
if(seMurio==-3){tipomsj=6;seMurio=0;}
if(seMurio==-4){tipomsj=7;seMurio=-4;}
if(seMurio==2){
c=0;
seMurio=-2;
}
Header unHeader;
if((c!=0)&&(tipomsj==1)){//si no es la primera vez q se conecta al orq manda el nombre del nivel anterior
//mandar nivel que termino
mandarMensaje(unSocketOrq,2,strlen(niveles[c-1])+1,niveles[c-1]);
log_debug(log,"NivelAnterior: %s",nivelActual);
}
//esperar solicitud de info nivel/Planif
mandarMensaje(unSocketOrq,tipomsj,strlen(nivelActual)+1,nivelActual);
log_debug(log,"MsjType: %d NivelActual: %s",tipomsj,nivelActual);
if(recibirHeader(unSocketOrq,&unHeader)>0){
if(recibirData(unSocketOrq,unHeader,(void**)&ipNivelPlanif)>0){
//Obtener info de ip & port
log_debug(log,"IPNivel:%s PortNivel:%d IPPlanf:%s PortPlanf:%d",ipNivelPlanif.ipNivel,ipNivelPlanif.portNivel,ipNivelPlanif.ipPlanificador,ipNivelPlanif.portPlanificador);
}
}
close(unSocketOrq);
usleep(1*1000000);
}
seMurio=0;
new_action.sa_handler = manejador;
sigemptyset (&new_action.sa_mask);
new_action.sa_flags =0; //settea las señales como interruptoras del recv
sigaction (SIGTERM, &new_action, NULL);
//conectar con Planificador
int unSocketPlanif;
unSocketPlanif = quieroUnPutoSocketAndando(ipPuertoOrq[0],ipNivelPlanif.portPlanificador);
log_info(log,"Se creo un nuevo socket con el Planificador. Direccion: %s // Puerto: %d // Socket: %d",ipPuertoOrq[0],ipNivelPlanif.portPlanificador,unSocketPlanif);
char* charbuf;
charbuf=malloc(sizeof(char));
*charbuf=charPer;
//handshake
if (mandarMensaje(unSocketPlanif,0 , sizeof(char),charbuf)>0) {
log_info(log,"Se envío el Handshake al planificador");
if(recibirMensaje(unSocketPlanif, (void**)&charbuf)>0) {
log_info(log,"Llego el Handshake del Planificador: %c",*charbuf);
}
else {
log_error(log,"No llego al cliente la confirmacion del Planificador (handshake)");
}
} else {
log_error(log,"No llego al planif la confirmacion del personaje (handshake)");
}
//conectar con nivel
int unSocket;
unSocket = quieroUnPutoSocketAndando(ipNivelPlanif.ipNivel,ipNivelPlanif.portNivel);
log_info(log,"Se creo un nuevo socket con el nivel. Direccion: %s // Puerto: %d // Socket: %d",ipNivelPlanif.ipNivel,ipNivelPlanif.portNivel,unSocket);
*charbuf=charPer;
if (mandarMensaje(unSocket,0 , sizeof(char),charbuf)>0) {
log_info(log,"Llego el OK al nivel");
if(recibirMensaje(unSocket, (void**)&charbuf)>0) {
log_info(log,"Llego el OK del nivel char %c",*charbuf);
}
else {
log_error(log,"No llego al cliente la confirmacion del nivel (handshake)");
}
} else {
log_error(log,"No llego al nivel la confirmacion del personaje (handshake)");
}
void* buffer;
for(ii=0;ii<=veclong;ii++){//for each recurso
if(ii<veclong)//para evitar SF
recActual=*obj[ii];
//solicitar posicion recurso Recurso: recactual
//esperar posicion del recurso posicion : rec
llego=1;
while(llego){
Header unHeader;
// esperar mensaje de movPermitido para continuar
char* charAux;
log_info(log,"Esperando permiso de movimiento...");
int alive=1;
if(recibirHeader(unSocketPlanif,&unHeader)>0){
if(unHeader.type==8){//planificador autorizo el movimiento
recibirData(unSocketPlanif,unHeader,(void**)&charAux);
log_info(log,"Permiso de Movimiento Recibido");
alive=1;
if(ii==veclong){//esto solo sucede cuando el PJ queda bloqueado al pedir el ultimo recurso de sus objetivos en ese nivel
alive=0;//se evita todos los msjs
llego=0;
mandarMensaje(unSocket,4 , sizeof(char),&charPer);//se le manda el char del personaje como señuelo para asignar el recurso q se le concedio
MensajePersonaje respAlPlanf;
respAlPlanf.bloqueado=0;
respAlPlanf.solicitaRecurso=0;
respAlPlanf.finNivel=1;
respAlPlanf.recursoSolicitado='0';
mandarMensaje(unSocketPlanif,8,sizeof(MensajePersonaje),&respAlPlanf);
log_info(log,"Se envio respuesta de turno concluido al Planificador LastResourse");
log_debug(log,"ii:%d veclong:%d c:%d",ii,veclong,c);
}
}
if(unHeader.type==9){//orquestador mato al personaje
recibirData(unSocketPlanif,unHeader,(void**)&charAux);
log_info(log,"Orquestador ha matado al personaje");
vidas--;
//cerrar conexion con el nivel
mandarMensaje(unSocket,4 , sizeof(char),&recActual);
c--;
if(vidas==0) {
c=-1;
vidas=config_get_int_value(config,"vidas");//reiniciar plan de niveles
}
llego=0;
ii=veclong;
alive=0;
seMurio=-3;
//logica de muerte
}
if(unHeader.type==10){
recibirData(unSocketPlanif,unHeader,(void**)&charAux);
log_info(log,"El nivel se ha desconectado y se volvera a solcitar su informacion");
//cerrar conexion con el nivel
c--;
llego=0;
ii=veclong;
alive=0;
seMurio=-4;
//logica de muerte
}
}else{
if(seMurio==0){
log_error(log,"Se perdio la conexion con el planificador");
exit(0);
}else {
mandarMensaje(unSocket,4 , sizeof(char),&recActual);
c--;
llego=0;
ii=veclong;
if(seMurio==2) {
c=-1;//reiniciar plan de niveles
seMurio=-2;
}else seMurio=-1;
MensajePersonaje respAlPlanf;
respAlPlanf.bloqueado=0;
respAlPlanf.solicitaRecurso=0;
respAlPlanf.finNivel=1;
respAlPlanf.recursoSolicitado='0';
mandarMensaje(unSocketPlanif,8,sizeof(MensajePersonaje),&respAlPlanf);
}
alive=0;
}
if(alive) {//si el orquestador no lo mato
if((rec.x==-1)&&(rec.y==-1)){ //si no tiene asignada un destino solicitar uno
buffer= &recActual;
//solicitar Posicion del recurso recActual
if (mandarMensaje(unSocket,1, sizeof(char),buffer)>0) {
log_info(log,"Solicitada la posicion del recurso actual %c necesario al nivel",recActual);
Header unHeader;
if (recibirHeader(unSocket,&unHeader)>0) {
log_debug(log,"pos %d %d %d %d",pos.x,pos.y,unHeader.payloadlength,unHeader.type);
Posicion lifeSucks;
recibirData(unSocket,unHeader,(void**)&lifeSucks);
rec=lifeSucks;
log_info(log,"Llego la posicion del Recurso %c: X:%d Y:%d",recActual,rec.x,rec.y);
}
}
}
MensajePersonaje respAlPlanf;
respAlPlanf.bloqueado=0;
respAlPlanf.solicitaRecurso=0;
respAlPlanf.finNivel=0;
respAlPlanf.recursoSolicitado='0';
if (pos.x!=rec.x) {
(rec.x-pos.x)>0?pos.x++:pos.x--;
}
else if (pos.y!=rec.y) {
(rec.y-pos.y)>0?pos.y++:pos.y--;
}
log_info(log,"El personaje esta en la posicion X: %d Y: %d",pos.x,pos.y);
//aviso posicion pos al nivel
h.type = 2;
buffer=&pos;
char* sth;
if (mandarMensaje(unSocket,2 , sizeof(Posicion),buffer)>0) {
log_info(log,"Llego el header de la posicion del personaje %d %d",pos.x,pos.y);
if (recibirMensaje(unSocket, (void**)&sth)>0) {
log_info(log,"Llego header respuesta: %c del nivel",*sth);
}
}
if((pos.y==rec.y)&(pos.x==rec.x)) {
//todo Ver como resolver el tema que el personaje si se queda bloqueado por el ultimo recurso de los objetivos del nivel, este termina el nivel y no se queda bloqueado.
//Solicitar instancia del recActual
//esperar OK
h.type = 3;
h.payloadlength = 1;
llego=0;
buffer = &recActual;
if (mandarMensaje(unSocket,(int8_t)3 , sizeof(char),buffer)>0) {
log_info(log,"Se envio el mensaje de peticion de recurso %c al nivel",recActual);
Header unHeader;
Posicion lifeSucks;
respAlPlanf.recursoSolicitado=recActual;
if (recibirHeader(unSocket,&unHeader)>0) {
int * respRec;
respRec=malloc(sizeof(int));
recibirData(unSocket,unHeader,(void**)respRec);
log_info(log,"Llego respuesta %d del nivel",*respRec);
respAlPlanf.solicitaRecurso=1;
if(*respRec){
respAlPlanf.bloqueado=0;
log_info(log,"Se entrego una instancia del Recurso %c",recActual);
}else{
respAlPlanf.bloqueado=1;
log_info(log,"No se entrego una instancia del Recurso %c",recActual);
}
rec.x=-1;
rec.y=-1;
free(respRec);
}
}
if((ii+1==veclong)) {
//cerrar conexion con el nivel
if(!respAlPlanf.bloqueado){//si no quedo bloqueado desp de pedir el ultimo recurso cierra conexion, de lo contrario sigue una vuelta mas
mandarMensaje(unSocket,4 , sizeof(char),&recActual);
ii++;//evita q de una vuelta extra
}
respAlPlanf.finNivel=1;
// close(unSocket);
if(seMurio>0) {//Muerte del personaje
//cerrar conexion con el nivel
respAlPlanf.finNivel=1;
c--;
seMurio=-1;
if(seMurio==2) {
c=-1;//reiniciar plan de niveles
seMurio=-2;
}
llego=0;
log_debug(log,"Se murio1 %d %d %d",ii,c,llego);
ii=veclong+1;
log_debug(log,"Se murio1 %d",ii);
}
//exit(0);
}
}
//mandar mensaje de resp al Planif
if(seMurio>0) {
//cerrar conexion con el nivel
mandarMensaje(unSocket,4 , sizeof(char),&recActual);
respAlPlanf.finNivel=1;
c--;
seMurio=-1;
if(seMurio==2) {
c=-1;//reiniciar plan de niveles
seMurio=-2;
}
llego=0;
log_debug(log,"Se murio2 ii:%d c:%d llego:%d",ii,c,llego);
ii=veclong+1;
log_debug(log,"Se murio2 ii:%d",ii);
seMurio=0;
}
mandarMensaje(unSocketPlanif,8,sizeof(MensajePersonaje),&respAlPlanf);
log_debug(log,"veclong: %d ii: %d c: %d llego: %d",veclong,ii,c,llego);
log_info(log,"Se envio respuesta de turno concluido al Planificador");
}//fin if(alive)
}//fin while(llego)
}//fin for each recurso
}//fin for each nivel
int unSocketOrq;
unSocketOrq = quieroUnPutoSocketAndando(ipPuertoOrq[0],puertoOrq);
char* auxC;
auxC=malloc(sizeof(char));
*auxC=charPer;
//handshake Orquestador-Personaje
if (mandarMensaje(unSocketOrq ,0 , sizeof(char),auxC)>0) {
if(recibirMensaje(unSocketOrq,(void**)&auxC)>0) {
log_debug("Handshake contestado del Orquestador %c",*auxC);
}
}
//esperar solicitud de info nivel/Planif
int tipomsj=5;
mandarMensaje(unSocketOrq,tipomsj,strlen(nivelActual)+1,nivelActual);
log_info(log,"Se envio Msj Fin de Plan de Niveles al Orquestador");
close(unSocketOrq);
log_info(log,"Finalizado Plan de Niveles");
return EXIT_SUCCESS;
}
int conectarAFilesystemYSubirArchivo(char *nombreArchivo, char *pathArchivoEnMDFS)
{
ConfiguracionNodo *config = obtenerConfiguracionNodo();
SocketConecta *conexion = newSocketConecta(config->ip_fs, config->puerto_fs);
conectarAServidor(conexion);
if (! estaConectado(conexion))
return SUBIDA_FALLO;
char pedidoSubidaArchivo = MENSAJE_PEDIDO_SUBIDA_ARCHIVO;
enviarMensaje(conexion, &pedidoSubidaArchivo, 1);
int contador = strlen(pathArchivoEnMDFS);
while(pathArchivoEnMDFS[contador] != '/')
contador--;
char *pathDirectorio;
if (contador == 0)
pathDirectorio = "/";
else
pathDirectorio = string_substring_until(pathArchivoEnMDFS, contador);
char *nombre = string_substring_from(pathArchivoEnMDFS, contador + 1);
int longitudMensaje = strlen(pathDirectorio);
enviarMensaje(conexion, &longitudMensaje, sizeof(int));
enviarMensaje(conexion, pathDirectorio, longitudMensaje);
longitudMensaje = strlen(nombre);
enviarMensaje(conexion, &longitudMensaje, sizeof(int));
enviarMensaje(conexion, nombre, longitudMensaje);
char *pathEspacioTemporal = obtenerPathEspacioTemporal();
char *rutaArchivo = malloc(strlen(pathEspacioTemporal) + strlen(nombreArchivo) + 2);
strcpy(rutaArchivo, pathEspacioTemporal);
strcat(rutaArchivo, "/");
strcat(rutaArchivo, nombreArchivo);
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subiendo archivo %s al MDFS en %s", rutaArchivo, pathArchivoEnMDFS);
FILE *contenidoArchivo = fopen(rutaArchivo, "r");
char buffer[SIZE_BLOQUE_DE_ENVIO + 1];
size_t bytesLeidos = fread(buffer, 1, SIZE_BLOQUE_DE_ENVIO, contenidoArchivo);
while(bytesLeidos > 0)
{
enviarTodo(conexion, buffer, bytesLeidos);
bytesLeidos = fread(buffer, 1, SIZE_BLOQUE_DE_ENVIO, contenidoArchivo);
char siguiente;
recibirMensaje(conexion, &siguiente, 1);
}
int cero = 0;
enviarMensaje(conexion, &cero, sizeof(int));
char resultadoSubida;
recibirMensaje(conexion, &resultadoSubida, 1);
if (resultadoSubida == MENSAJE_SUBIDA_OK)
{
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subida de archivo %s al MDFS en %s finalizada", nombreArchivo, pathArchivoEnMDFS);
return SUBIDA_OK;
}
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subida de archivo %s al MDFS en %s fallida", nombreArchivo, pathArchivoEnMDFS);
return SUBIDA_FALLO;
}
int perderVida(bool porDeadlock) {
if (sacarVida(personaje) > 0) {
if (porDeadlock) {
log_debug(logger, "El personaje %s perdio una vida, ahora le quedan (%d), causa:DEADLOCK", personaje->nombre, personaje->vidas);
} else {
log_debug(logger, "El personaje %s perdio una vida, ahora le quedan (%d) causa:SIGTERM", personaje->nombre, personaje->vidas);
}
if (!porDeadlock) {
log_debug(logger, "Notificando muerte al planificador. Personaje:%s", personaje->nombre);
notificarMuerte(socketPlanificador);
esperarConfirmacionDelPlanificador(socketPlanificador);
log_debug(logger, "Notifico la liberacion de recursos. Personaje:%s", personaje->nombre);
liberarRecursos(socketNivel);
} else if (porDeadlock) {
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = MUERTE_POR_DEADLOCK;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = personaje->simbolo;
log_debug(logger, "Notifico muerte por deadlock al nivel. Personaje:%s", personaje->nombre);
enviarMensaje(socketNivel, mensajeAEnviar);
free(mensajeAEnviar);
}
MPS_MSG* mensajeARecibir = malloc(sizeof(MPS_MSG));
recibirMensaje(socketNivel, mensajeARecibir);
if (mensajeARecibir->PayloadDescriptor != MUERTE_CORRECTA) {
return EXIT_FAILURE;
}
free(mensajeARecibir);
close(socketPlanificador);
close(socketNivel);
int resultado = procesar();
if (resultado == 1) {
return EXIT_FAILURE;
}
finalizar();
} else {
if (porDeadlock) {
log_debug(logger, "El personaje %s se quedo sin vidas, causa:DEADLOCK", personaje->nombre, personaje->vidas);
} else {
log_debug(logger, "El personaje %s se quedo sin vidas, causa:SIGTERM", personaje->nombre, personaje->vidas);
}
if (!porDeadlock) {
log_debug(logger, "Notificando muerte al planificador. Personaje:%s", personaje->nombre);
notificarMuerte(socketPlanificador);
esperarConfirmacionDelPlanificador(socketPlanificador);
log_debug(logger, "Notifico la liberacion de recursos. Personaje:%s", personaje->nombre);
liberarRecursos(socketNivel);
} else if (porDeadlock) {
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = MUERTE_POR_DEADLOCK;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = personaje->simbolo;
log_debug(logger, "Notifico muerte por deadlock al nivel. Personaje:%s", personaje->nombre);
enviarMensaje(socketNivel, mensajeAEnviar);
free(mensajeAEnviar);
}
MPS_MSG* mensajeARecibir = malloc(sizeof(MPS_MSG));
recibirMensaje(socketNivel, mensajeARecibir);
if (mensajeARecibir->PayloadDescriptor != MUERTE_CORRECTA) {
return EXIT_FAILURE;
}
free(mensajeARecibir);
close(socketPlanificador);
close(socketNivel);
int levantarConfig = levantarPersonaje(path);
if (levantarConfig == 1) {
return EXIT_FAILURE;
}
int resultado = procesar();
if (resultado == 1) {
return EXIT_FAILURE;
}
finalizar();
}
return EXIT_SUCCESS;
}
void esperarConfirmacion(int socket) {
MPS_MSG mensajeARecibir;
recibirMensaje(socket, &mensajeARecibir);
log_debug(logger, "Recibimos confirmacion (%d)", mensajeARecibir.PayloadDescriptor);
}
int32_t handshakeConPlataforma(){ //SE CONECTA A PLATAFORMA Y PASA LOS VALORES INICIALES
pthread_mutex_lock(&mutex_log);
log_info(logger, "El %s se conectara a la plataforma en %s ",nombre,direccionIPyPuerto);
pthread_mutex_unlock(&mutex_log);
char ** IPyPuerto = string_split(direccionIPyPuerto,":");
char ** numeroNombreNivel = string_split(nombre,"l");
int32_t numeroNivel=atoi(numeroNombreNivel[1]);
char * IP=IPyPuerto[0];
log_info(logger, "Este es el nivel %d",numeroNivel);
char * buffer=malloc(sizeof(char)*50);
int32_t puerto= atoi(IPyPuerto[1]);
socketDeEscucha= cliente_crearSocketDeConexion(IP,puerto);
if(socketDeEscucha==-1){
kill(getpid(), SIGKILL); //PROCESO MUERTO POR TIMEOUT
}
sprintf(buffer,"%d,%s,%d,%d,%d",numeroNivel,algoritmo,quantum,retardo,distancia);
pthread_mutex_lock(&mutex_mensajes);
int32_t ok= enviarMensaje(socketDeEscucha, NIV_handshake_ORQ,buffer);
pthread_mutex_unlock(&mutex_mensajes);
enum tipo_paquete unMensaje = PER_handshake_ORQ;
char* elMensaje=NULL;
pthread_mutex_lock(&mutex_mensajes);
recibirMensaje(socketDeEscucha,&unMensaje,&elMensaje);
pthread_mutex_unlock(&mutex_mensajes);
if(unMensaje==ORQ_handshake_NIV){
if(ok==0){
pthread_mutex_lock(&mutex_log);
log_info(logger, "El %s envio correctamente handshake a plataforma en %s ",nombre,direccionIPyPuerto);
pthread_mutex_unlock(&mutex_log);
return socketDeEscucha;
}else{
pthread_mutex_lock(&mutex_log);
log_info(logger, "El %s no pudo enviar handshake a plataforma en %s, el nivel se cierra ",nombre,direccionIPyPuerto);
pthread_mutex_unlock(&mutex_log);
kill(getpid(), SIGKILL);
}
}
free(buffer);
return socketDeEscucha;
}
void mensajesConPlataforma(int32_t socketEscucha) {//ATIENDE LA RECEPCION Y POSTERIOR RESPUESTA DE MENSAJES DEL ORQUESTADOR
enum tipo_paquete unMensaje = PER_conexionNivel_ORQ;
char* elMensaje=NULL;
pthread_mutex_lock(&mutex_log);
log_info(logger,"Voy a esperar recibir un mensaje de %d", socketEscucha);
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes); //(matyx)
recibirMensaje(socketEscucha, &unMensaje,&elMensaje);
pthread_mutex_unlock(&mutex_mensajes);
sleep(1);
pthread_mutex_lock(&mutex_log);
log_info(logger, "Llego el tipo de paquete: %s .",obtenerNombreEnum(unMensaje));
log_info(logger, "Llego este mensaje: %s .",elMensaje);
pthread_mutex_unlock(&mutex_log);
switch (unMensaje) {
case PLA_movimiento_NIV: {//graficar y actualizar la lista RECIBE "@,1,3"
char ** mens = string_split(elMensaje,",");
char idPers = mens[0][0];
if(huboCambios==true){
pthread_mutex_lock(&mutex_log);
log_info(logger,"envio los cambios de configuracion");
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketDeEscucha, NIV_cambiosConfiguracion_PLA,buffer1);
pthread_mutex_unlock(&mutex_mensajes);
huboCambios=false;
pthread_mutex_lock(&mutex_log);
log_info(logger,"me preparo para recibir el ok");
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
recibirMensaje(socketEscucha, &unMensaje,&elMensaje);
pthread_mutex_unlock(&mutex_mensajes);
pthread_mutex_lock(&mutex_log);
log_info(logger,"deberia haber recibido el OK1");
pthread_mutex_unlock(&mutex_log);
if(unMensaje==OK1){
pthread_mutex_lock(&mutex_log);
log_info(logger,"ya envie el cambio de configuracion, y me dieron el ok");
pthread_mutex_unlock(&mutex_log);
if(existePersonajeEnListaItems(idPers)){
pthread_mutex_lock(&mutex_listas);
MoverPersonaje(items, idPers,atoi(mens[1]), atoi(mens[2]));
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %s se movio a %s %s ",mens[0],mens[1],mens[2]);
pthread_mutex_unlock(&mutex_log);
if(graficar)
nivel_gui_dibujar(items,nombre);
}
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha,NIV_movimiento_PLA,"0"); //"0" SI ES VALIDO
pthread_mutex_unlock(&mutex_mensajes);
} else {
pthread_mutex_lock(&mutex_log);
log_info(logger,"no recibi OK1,recibi cualquiera");
pthread_mutex_unlock(&mutex_log);
}
} else {
if(existePersonajeEnListaItems(idPers)){
pthread_mutex_lock(&mutex_listas);
MoverPersonaje(items, elMensaje[0],atoi(mens[1]), atoi(mens[2]));
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %s se movio a %s %s ",mens[0],mens[1],mens[2]);
pthread_mutex_unlock(&mutex_log);
if(graficar)
nivel_gui_dibujar(items,nombre);
}
pthread_mutex_lock(&mutex_log);
log_info(logger, "Confirmo que el personaje %s puede moverse",mens[0]);
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha,NIV_movimiento_PLA,"0"); //"0" SI ES VALIDO
pthread_mutex_unlock(&mutex_mensajes);
}
break;
}
case PLA_personajeMuerto_NIV:{ //RECIBE "@" MUERTE POR ENEMIGOS
char id=elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));
pthread_mutex_lock(&mutex_listas);
// liberarRecursosDelPersonaje(personaje->recursosActuales); // tambien suma sus recursos a disponible
borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha muerto ",id);
pthread_mutex_unlock(&mutex_log);
break;
}
case PLA_nuevoPersonaje_NIV:{ //RECIBE "@" LA POSICION DE INICIO SERA SIEMPRE 0,0 POR LO QUE NO LA RECIBE
char * simbolo = malloc(strlen(elMensaje)+1);
strcpy(simbolo,elMensaje);
pthread_mutex_lock(&mutex_listas);
CrearPersonaje(items,elMensaje[0],0,0);
pthread_mutex_unlock(&mutex_listas);
//ACA CREO UNA LISTA DE PERSONAJES CON SUS RESPECTIVOS RECURSOS ASIGNADOS
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje->simbolo = string_substring_until(elMensaje,1);
personaje->recursosActuales = list_create();
personaje->recursoBloqueante = string_new();
personaje->posicion = posicion_create_pos(0,0);
personaje->ingresoSistema = ingresoAlSistema;
ingresoAlSistema++;
pthread_mutex_lock(&mutex_listas);
list_add(listaPersonajesRecursos,personaje);
pthread_mutex_unlock(&mutex_listas);
if(graficar)
nivel_gui_dibujar(items,nombre);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El nuevo personaje %c se dibujo en el mapa",elMensaje[0]);
pthread_mutex_unlock(&mutex_log);
break;
}
case PLA_posCaja_NIV:{ // RECIBE "F" SI ESTA SOLICITANDO UNA FLOR, POR EJEMPLO
char * pos = string_new();
ITEM_NIVEL * caja = buscarRecursoEnLista(items, elMensaje);
string_append(&pos, string_from_format("%d",caja->posx));
string_append(&pos, ",");
string_append(&pos, string_from_format("%d",caja->posy));
pthread_mutex_lock(&mutex_log);
log_info(logger,"enviare la posicion de la caja");
pthread_mutex_unlock(&mutex_log);
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha, NIV_posCaja_PLA,pos); //"X,Y"
pthread_mutex_unlock(&mutex_mensajes);
pthread_mutex_lock(&mutex_log);
log_info(logger, "Envio posicion del recurso %s coordenadas %s ",elMensaje,pos);
pthread_mutex_unlock(&mutex_log);
free(pos);
break;
}
case PLA_solicitudRecurso_NIV:{ // LE CONTESTO SI EL RECURSOS ESTA DISPONIBLE
// El mensaje de ejemplo es : "@,H"
char * rta;
bool hayRecurso = determinarRecursoDisponible (string_substring_from(elMensaje, 2)); //SI ESTA EL RECURSO TMB LO RESTA
t_personaje_niv1 * pers = buscarPersonajeListaPersonajes(listaPersonajesRecursos, string_substring_until(elMensaje,1));
if (hayRecurso){
rta = "0";
pthread_mutex_lock(&mutex_listas);
list_add(pers->recursosActuales, string_substring_from(elMensaje, 2));
pers->recursoBloqueante = string_new();
pthread_mutex_unlock(&mutex_listas);
}else{
pthread_mutex_lock(&mutex_listas);
pers->recursoBloqueante = string_substring_from(elMensaje, 2);
rta = "1";
pthread_mutex_unlock(&mutex_listas);
}
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketEscucha, NIV_recursoConcedido_PLA,rta);//"0" CONCEDIDO, "1" NO CONCEDIDO
pthread_mutex_unlock(&mutex_mensajes);
break;
}
case PLA_personajesDesbloqueados_NIV:{//"5,@,#,....." recorro lista personaje recursos y actualizo recBloqueante a vacio
char ** mens = string_split(elMensaje,",");
int i;
int cantPersonajes=atoi(mens[0]);
for(i=1;i<=cantPersonajes;i++){
char * unPersDesbloqueado=mens[i];
t_personaje_niv1 * unPers=buscarPersonajeListaPersonajes(listaPersonajesRecursos,unPersDesbloqueado);
pthread_mutex_lock(&mutex_listas);
unPers->recursoBloqueante=string_new();
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "Personajes %s desbloqueados",mens[i]);
pthread_mutex_unlock(&mutex_log);
}
break;
}
case PLA_actualizarRecursos_NIV:{ //"3;F,1;C,3;....." actualizo la lista de recursos sumandole esas cantidades
char ** mens = string_split(elMensaje,";");
int cantRecursos= atoi(mens[0]);
int i;
pthread_mutex_lock(&mutex_log);
log_info(logger, "Recursos desbloqueados: %s",elMensaje);
pthread_mutex_unlock(&mutex_log);
for(i=1;i<=cantRecursos;i++){
char** mensajeIndividual= string_split(mens[i],",");
pthread_mutex_lock(&mutex_listas);
int cantidad=atoi(mensajeIndividual[1]);
sumarRecurso(items, mensajeIndividual[0][0],cantidad);
pthread_mutex_unlock(&mutex_listas);
if(graficar)
nivel_gui_dibujar(items,nombre);
}
break;
}
case PLA_nivelFinalizado_NIV:{ //recibe personaje que termino el nivel ej: "@"
char id=elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));
pthread_mutex_lock(&mutex_listas);
// liberarRecursosDelPersonaje(personaje->recursosActuales);
BorrarItem(items,id);
borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha terminado el nivel ",id);
pthread_mutex_unlock(&mutex_log);
if(graficar){
nivel_gui_dibujar(items,nombre);
}
break;
}
case PLA_perMuereInterbloqueo_NIV:{
char id=elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje,1));
pthread_mutex_lock(&mutex_listas);
// liberarRecursosDelPersonaje(personaje->recursosActuales);
BorrarItem(items,id);
borrarPersonajeListaPersonajes(listaPersonajesRecursos,elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha muerto por interbloqueo ",id);
pthread_mutex_unlock(&mutex_log);
if(graficar)
nivel_gui_dibujar(items,nombre);
break;
}
case PLA_perMuereNaturalmente_NIV: {
char id = elMensaje[0];
t_personaje_niv1 * personaje = malloc(sizeof(t_personaje_niv1));
personaje = buscarPersonajeListaPersonajes(listaPersonajesRecursos,string_substring_until(elMensaje, 1));
pthread_mutex_lock(&mutex_listas);
liberarRecursosDelPersonaje(personaje->recursosActuales);
BorrarItem(items, id);
borrarPersonajeListaPersonajes(listaPersonajesRecursos, elMensaje);
pthread_mutex_unlock(&mutex_listas);
pthread_mutex_lock(&mutex_log);
log_info(logger, "El personaje %c ha muerto por causas externas", id);
pthread_mutex_unlock(&mutex_log);
if (graficar)
nivel_gui_dibujar(items, nombre);
break;
}
{
default:
pthread_mutex_lock(&mutex_log);
log_info(logger, "Recibi mensaje inexistente, la ejecucion del nivel finalizara");
pthread_mutex_unlock(&mutex_log);
eliminarEstructuras();
break;
}
free(elMensaje);
}
}
