void cargar_semaforos()
{
char** semaforosArray = config_get_array_value(config, "SEMAFOROS");
char** valorSemaforosArray = config_get_array_value(config, "VALOR_SEMAFORO");
semaforos = dictionary_create();
int i;
semaforo_t *semaforo;
for(i = 0; semaforosArray[i] != NULL && valorSemaforosArray[i] != NULL; i++)
{
semaforo = malloc(sizeof(semaforo_t));
semaforo->valor = atoi(valorSemaforosArray[i]);
semaforo->cola = queue_create();
dictionary_put(semaforos, semaforosArray[i], semaforo);
}
string_iterate_lines(semaforosArray, free);
string_iterate_lines(valorSemaforosArray, free);
free(semaforosArray);
free(valorSemaforosArray);
}
void test_read_empty_array() {
char* empty_array_expected[] = {NULL};
t_config* config = config_create(PATH_CONFIG);
CU_ASSERT_EQUAL(config_keys_amount(config), KEYS_AMOUNT);
CU_ASSERT_TRUE(config_has_property(config, "EMPTY_ARRAY"));
CU_ASSERT_STRING_EQUAL(config_get_string_value(config, "EMPTY_ARRAY"), "[]");
char** empty_array = config_get_array_value(config, "EMPTY_ARRAY");
_assert_equals_array(empty_array_expected, empty_array, 0);
free(empty_array);
config_destroy(config);
}
void test_read_empty_array() {
t_config* config = config_create(PATH_CONFIG);
CU_ASSERT_EQUAL(config_keys_amount(config), KEYS_AMOUNT);
CU_ASSERT_TRUE(config_has_property(config, "EMPTY_ARRAY"));
CU_ASSERT_STRING_EQUAL(config_get_string_value(config, "EMPTY_ARRAY"), "[]");
char** empty_array = config_get_array_value(config, "EMPTY_ARRAY");
CU_ASSERT_PTR_NOT_NULL(empty_array);
CU_ASSERT_PTR_EQUAL(empty_array[0], NULL);
string_iterate_lines(empty_array, (void*) free);
free(empty_array);
config_destroy(config);
}
void test_read_full_array() {
char* numbers_expected[] = {"1", "2", "3", "4", "5", NULL};
t_config* config = config_create(PATH_CONFIG);
CU_ASSERT_EQUAL(config_keys_amount(config), KEYS_AMOUNT);
CU_ASSERT_TRUE(config_has_property(config, "NUMBERS"));
CU_ASSERT_STRING_EQUAL(config_get_string_value(config, "NUMBERS"), "[1, 2, 3, 4, 5]");
char** numbers = config_get_array_value(config, "NUMBERS");
_assert_equals_array(numbers_expected, numbers, 5);
string_iterate_lines(numbers, (void*) free);
free(numbers);
config_destroy(config);
}
void cargar_variablesCompartidas()
{
char** variablesCompartidasArray = config_get_array_value(config, "VARIABLES_COMPARTIDAS");
variablesCompartidas = dictionary_create();
int i;
for(i = 0; variablesCompartidasArray[i] != NULL; i++)
{
int32_t *valor = malloc(sizeof(int32_t));
*valor = 0;
dictionary_put(variablesCompartidas, variablesCompartidasArray[i], valor);
}
string_iterate_lines(variablesCompartidasArray, free);
free(variablesCompartidasArray);
}
void test_read_full_array() {
t_config* config = config_create(PATH_CONFIG);
CU_ASSERT_EQUAL(config_keys_amount(config), KEYS_AMOUNT);
CU_ASSERT_TRUE(config_has_property(config, "NUMBERS"));
CU_ASSERT_STRING_EQUAL(config_get_string_value(config, "NUMBERS"), "[1, 2, 3, 4, 5]");
char** numeros = config_get_array_value(config, "NUMBERS");
CU_ASSERT_PTR_NOT_NULL(numeros);
CU_ASSERT_PTR_EQUAL(numeros[5], NULL);
int i;
for (i = 1; i <= 5; ++i) {
char* value = string_from_format("%d", i);
CU_ASSERT_STRING_EQUAL(numeros[i - 1], value);
free(value);
}
string_iterate_lines(numeros, (void*) free);
free(numeros);
config_destroy(config);
}
t_personaje* personaje_crear(char* config_path) {
//creamos una instancia de personaje
alloc(self, t_personaje);
//creamos una instancia del lector de archivos de config
t_config* config = config_create(config_path);
t_config* global_config = config_create("global.cfg");
//datos basicos del personaje
self->nombre = string_duplicate(config_get_string_value(config, "Nombre"));
self->simbolo = *config_get_string_value(config, "Simbolo");
int vidas = config_get_int_value(config, "Vidas");
self->vidas_iniciales = vidas;
self->vidas = vidas;
//misc
if(config_has_property(global_config, "AutoContinue")) self->auto_continue = config_get_int_value(global_config, "AutoContinue");
else self->auto_continue = 0;
//datos del logger
char* log_file;
if(config_has_property(config,"LogFile")) log_file = string_duplicate(config_get_string_value(config, "LogFile"));
else log_file = string_from_format("%s.log", self->nombre);
char* log_level;
if(config_has_property(global_config, "LogLevel")) log_level = config_get_string_value(global_config, "LogLevel");
else if(config_has_property(config, "LogLevel")) log_level = config_get_string_value(config, "LogLevel");
else log_level = "INFO";
//inicializamos el logger
logger_initialize(log_file, "personaje", log_level, 1);
self->logger = logger_new_instance();
var(logger, self->logger);
//datos de plataforma
char* plataforma;
if(config_has_property(global_config, "Plataforma"))
plataforma = string_duplicate(config_get_string_value(global_config, "Plataforma"));
else
plataforma = string_duplicate(config_get_string_value(config, "Plataforma"));
self->ippuerto_orquestador = plataforma;
//datos de niveles y objetivos
char** nombres_niveles = config_get_array_value(config, "Niveles");
t_list* niveles = list_create();
int i = 0;
char* nombre_nivel = nombres_niveles[i];
while(nombre_nivel != null) {
alloc(nivel, t_nivel);
nivel->nombre = string_duplicate(nombre_nivel);
nivel->objetivos = list_create();
char* key_objetivos = string_from_format("Obj[%s]", nombre_nivel);
char* objetivos = config_get_string_value(config, key_objetivos);
logger_info(logger, "Nivel: %s", nivel->nombre);
logger_info(logger, "Objetivos: %s", objetivos);
int ii = 0;
while(objetivos != null && objetivos[ii] != '\0') {
char* objetivo = string_from_format("%c" , objetivos[ii]);
list_add(nivel->objetivos, objetivo);
ii++;
}
free(key_objetivos);
list_add(niveles, nivel);
i++;
nombre_nivel = nombres_niveles[i];
}
self->niveles = niveles;
logger_info(logger, "Log File:%s", log_file);
free(log_file);
logger_info(logger, "Log Level:%s", log_level);
//liberamos recursos
config_destroy(config);
config_destroy(global_config);
liberar_niveles(nombres_niveles);
return self;
}
int loadInfo(stEstado* info, char inotify) {
t_config* miConf, *otraConf;
if (inotify==0) {
miConf = config_create(info->path_conf); /*Estructura de configuracion*/
info->dispositivos = list_create();
inicializar_semaforos();
inicializar_lista_shared_var();
if (miConf == NULL) {
log_error("Error iniciando la configuracion...\n");
return EXIT_FAILURE;
}
if (config_has_property(miConf, "IP")) {
info->miIP = config_get_string_value(miConf, "IP");
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "IP");
return EXIT_FAILURE;
}
if (config_has_property(miConf, "PUERTO")) {
info->miPuerto = config_get_int_value(miConf, "PUERTO");
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "PUERTO");
return EXIT_FAILURE;
}
if (config_has_property(miConf, "IP_UMC")) {
info->ipUmc = config_get_string_value(miConf, "IP_UMC");
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "IP_UMC");
return EXIT_FAILURE;
}
if (config_has_property(miConf, "PUERTO_UMC")) {
info->puertoUmc = config_get_int_value(miConf, "PUERTO_UMC");
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "PUERTO_UMC");
return EXIT_FAILURE;
}
if (config_has_property(miConf, "QUANTUM")) {
info->quantum = config_get_int_value(miConf, "QUANTUM");
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "QUANTUM");
return EXIT_FAILURE;
}
if (config_has_property(miConf, "QUANTUM_SLEEP")) {
info->quantumSleep = config_get_int_value(miConf, "QUANTUM_SLEEP");
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "QUANTUM_SLEEP");
return EXIT_FAILURE;
}
if (!config_has_property(miConf, "SEM_IDS") || !config_has_property(miConf, "SEM_INIT")) {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "SEM_IDS");
return EXIT_FAILURE;
} else {
cargar_semaforos(config_get_array_value(miConf, "SEM_IDS"), config_get_array_value(miConf, "SEM_INIT"));
}
if (!config_has_property(miConf, "IO_IDS") || !config_has_property(miConf, "IO_SLEEP")) {
log_error("Parametros de dispositivos no cargados en el archivo de configuracion");
return EXIT_FAILURE;
} else {
cargar_dipositivos(info, config_get_array_value(miConf, "IO_IDS"), config_get_array_value(miConf, "IO_SLEEP"));
}
if (config_has_property(miConf, "SHARED_VARS")) {
cargar_sharedVars(config_get_array_value(miConf, "SHARED_VARS"));
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "SHARED_VARS");
return EXIT_FAILURE;
}
if (config_has_property(miConf, "STACK_SIZE")) {
info->stackSize = config_get_int_value(miConf, "STACK_SIZE");
} else {
log_error("Parametro no cargado en el archivo de configuracion\n \"%s\" \n", "STACK_SIZE");
return EXIT_FAILURE;
}
inotify++;
return EXIT_SUCCESS;
} else {
otraConf = config_create(info->path_conf);
if (config_has_property(otraConf, "QUANTUM")) {
info->quantum = config_get_int_value(otraConf, "QUANTUM");
info->quantumSleep = config_get_int_value(otraConf, "QUANTUM_SLEEP");
} else {
return EXIT_FAILURE;
}
config_destroy(otraConf);
log_info("Quantum [%d], Quantum Sleep [%d]", info->quantum, info->quantumSleep);
return EXIT_SUCCESS;
}
}
struct h_t_param_nivel leer_nivel_config(int rows, int cols) {
t_config* config;
struct h_t_param_nivel param;
t_recusos *list_recursos; //declaro el tipo nodo
char *aux_str;
int i, j;
char **aux;
char *aux_char;
log_in_disk_niv(LOG_LEVEL_TRACE,
"comienzo lectura archivo de configuracion del nivel en el %s ",
PATH_CONFIG_NIVEL);
log_in_disk_niv(LOG_LEVEL_TRACE, "limites de pantalla x = %d ,y = %d", rows,
cols);
param.recusos = list_create(); //creo lista de hilos
config = config_create(PATH_CONFIG_NIVEL);
//param.nom_nivel = nivel; //copio el nombre del nivel que pase por parametro en el main
aux_char = config_get_string_value(config, "PLATAFORMA");
aux = string_split(aux_char, ":");
param.IP = aux[0];
param.PUERTO_PLATAFORMA = atoi(aux[1]);
param.PUERTO = config_get_int_value(config, "PUERTO");
param.nom_nivel = config_get_string_value(config, "NOMBRE");
i = 1;
aux_str = string_from_format("%s%d", "CAJA", i);
while ((aux = config_get_array_value(config, aux_str)) != NULL ) {
list_recursos = malloc(sizeof(t_recusos)); //creo el nodo
j = 0;
strcpy(list_recursos->NOMBRE, aux[j++]);
if (!strcmp(list_recursos->NOMBRE, "Fin")) {
break; //salgo del for cuando encuentro la caja de fin
}
list_recursos->SIMBOLO = aux[j++][0];
list_recursos->cantidad = atoi(aux[j++]);
list_recursos->posX = atoi(aux[j++]);
list_recursos->posY = atoi(aux[j]);
if (val_pos_recurso(rows, cols, list_recursos->posX,
list_recursos->posY)) {
log_in_disk_niv(LOG_LEVEL_TRACE,
"Cargo a la lista la caja %s que contiene el recurso %s con el simbolo %c y la candidad %d en la poscion [x,y] [%d][%d] ",
aux_str, list_recursos->NOMBRE, list_recursos->SIMBOLO,
list_recursos->cantidad, list_recursos->posX,
list_recursos->posY);
list_add(param.recusos, list_recursos); //agrego el nuevo nodo
} else {
log_in_disk_niv(LOG_LEVEL_ERROR,
"Cargo a la lista la caja %s que contiene el recurso %s con el simbolo %c y la candidad %d en la poscion [x,y] [%d][%d] ES INVELIDA!!",
aux_str, list_recursos->NOMBRE, list_recursos->SIMBOLO,
list_recursos->cantidad, list_recursos->posX,
list_recursos->posY);
}
aux_str = string_from_format("%s%d", "CAJA", ++i);
}
param.TiempoChequeoDeadlock = config_get_int_value(config,
"TiempoChequeoDeadlock");
param.Recovery = config_get_int_value(config, "RECOVERY");
return param;
}
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;
}
////////////////////////////////////////////////////ESPACIO DE FUNCIONES////////////////////////////////////////////////////
int leerArchivoConfiguracion(){
//VOY A LEER EL ARCHIVO DE CONFIGURACION DE UN NIVEL//
char *PATH_LOG = config_get_string_value(config, "PATH_LOG");
graficar = config_get_int_value(config, "graficar");
nombre= config_get_string_value(config, "Nombre");
if(graficar){
logger = log_create(PATH_LOG, "NIVEL", false, LOG_LEVEL_INFO);
pthread_mutex_lock(&mutex_log);
log_info(logger, "La config de graficado para el %s es %d",nombre,graficar);
pthread_mutex_unlock(&mutex_log);
}else{
logger = log_create(PATH_LOG, "NIVEL", true, LOG_LEVEL_INFO);
pthread_mutex_lock(&mutex_log);
log_info(logger, "La config de graficado para el %s es %d",nombre,graficar);
pthread_mutex_unlock(&mutex_log);
}
pthread_mutex_lock(&mutex_log);
log_info(logger, "Voy a leer mi archivo de configuracion");
log_info(logger, "Encontramos los atributos de %s",nombre);
pthread_mutex_unlock(&mutex_log);
quantum = config_get_int_value(config, "quantum");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El quantum para %s es de %d ut",nombre,quantum);
pthread_mutex_unlock(&mutex_log);
recovery = config_get_int_value(config, "Recovery");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El recovery para %s es de %d ut",nombre,recovery);
pthread_mutex_unlock(&mutex_log);
enemigos = config_get_int_value(config, "Enemigos");
pthread_mutex_lock(&mutex_log);
log_info(logger, "La cantidad de enemigos de %s es %d",nombre,enemigos);
pthread_mutex_unlock(&mutex_log);
tiempoDeadlock = config_get_long_value(config, "TiempoChequeoDeadlock");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El tiempo de espera para ejecucion del hilo de deadlock para %s es de %d ut",nombre,tiempoDeadlock);
pthread_mutex_unlock(&mutex_log);
sleepEnemigos = config_get_long_value(config, "Sleep_Enemigos");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El tiempo de espera para mover los enemigos para %s es de %d ut",nombre,sleepEnemigos);
pthread_mutex_unlock(&mutex_log);
algoritmo=config_get_string_value(config,"algoritmo");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El %s se planificara con algoritmo %s",nombre,algoritmo);
pthread_mutex_unlock(&mutex_log);
direccionIPyPuerto = config_get_string_value(config, "Plataforma");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El %s tiene la platforma cuya direccion es %s",nombre,direccionIPyPuerto);
pthread_mutex_unlock(&mutex_log);
retardo = config_get_int_value(config, "retardo");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El retardo para el %s es de %d milisegundos",nombre,retardo);
pthread_mutex_unlock(&mutex_log);
distancia = config_get_int_value(config, "distancia");
pthread_mutex_lock(&mutex_log);
log_info(logger, "El remaining distance para el %s es de %d",nombre,distancia);
pthread_mutex_unlock(&mutex_log);
crearLosEnemigos = config_get_int_value(config, "crearLosEnemigos");
activarInterbloqueo = config_get_int_value(config, "activarInterbloqueo");
// LEO LAS CAJAS DEL NIVEL //
char litCaja[6]="Caja1\0";
bool ret = config_has_property(config, litCaja);
while (ret!=true){ //POR SI EMPIEZA EN UNA CAJA DISTINTA DE 1
litCaja[4]++;
}
while (ret == true){
char **caja = config_get_array_value(config, litCaja);
crearCaja(caja);
litCaja[4]++;
pthread_mutex_lock(&mutex_log);
log_info(logger, "El %s tiene %s cuyo simbolo es %s tiene %s instancias y su posicion x e y son %s %s",nombre,caja[0], caja[1],caja[2],caja[3],caja[4]);
pthread_mutex_unlock(&mutex_log);
ret = config_has_property(config, litCaja);
}
return EXIT_SUCCESS;
}
void configurar(char *config_file){
config = malloc(sizeof(Configuration));
config_file_name = strdup(config_file ? config_file : NUCLEO_CONFIG_PATH);
t_config* nConfig = config_create(config_file_name);
if(nConfig==NULL){
//para debuggear desde eclipse
free(config_file_name);
config_file_name = strdup(NUCLEO_CONFIG_PATH_ECLIPSE);
nConfig = config_create(config_file_name);
if(nConfig==NULL){
printf("No se encontro el archivo de configuracion.\n");
exit (1);
} else {
config_dir = strdup(".");
}
} else {
config_dir = strdup(".");
}
config->puerto_nucleo_cpu = config_get_int_value(nConfig,PUERTO_CPU);
config->puerto_nucleo_prog = config_get_int_value(nConfig,PUERTO_PROG);
config->ip_nucleo = strdup(config_get_string_value(nConfig,IP_NUCLEO));
config->ip_umc = strdup(config_get_string_value(nConfig,IP_UMC));
config->puerto_umc = config_get_int_value(nConfig,PUERTO_UMC);
//planificador
config->quantum = config_get_int_value(nConfig,QUANTUM);
config->quantum_sleep = config_get_int_value(nConfig,QUANTUM_SLEEP);
config->stack_size = config_get_int_value(nConfig,STACK_SIZE);
//configuracion de log
config->log_level = strdup(config_get_string_value(nConfig,LOG_LEVEL));
config->log_file = strdup(config_get_string_value(nConfig,LOG_FILE));
config->log_program_name = strdup(config_get_string_value(nConfig,LOG_PROGRAM_NAME));
config->log_print_console = config_get_int_value(nConfig,LOG_PRINT_CONSOLE);
//levanto los dispositivos de entrada/salida
config->io_ids = config_get_array_value(nConfig,IO_IDS);
int len=0;
while(config->io_ids[len]!=NULL){
len++;
}
config->io_length = len;
char** io_sleep_aux = config_get_array_value(nConfig,IO_SLEEP);
config->io_sleep = malloc(sizeof(int)*len);
int i;
for(i=0; i<len; i++){
config->io_sleep[i] = atoi(io_sleep_aux[i]);
free(io_sleep_aux[i]);
}
free(io_sleep_aux);
//levanto los semaforos
config->sem_ids = config_get_array_value(nConfig,SEM_IDS);
len=0;
while(config->sem_ids[len]!=NULL){
len++;
}
config->sem_length = len;
char** sem_init_aux = config_get_array_value(nConfig,SEM_INIT);
config->sem_init = malloc(sizeof(int)*len);
for(i=0; i<len; i++){
config->sem_init[i] = atoi(sem_init_aux[i]);
free(sem_init_aux[i]);
}
free(sem_init_aux);
//levanto variables compartidas
config->shared_vars = config_get_array_value(nConfig,SHARED_VARS);
len=0;
while(config->shared_vars[len]!=NULL){
len++;
}
config->shared_vars_length = len;
config_destroy(nConfig);
}
