tipoConfigSWAP* cargarArchivoDeConfiguracionDeSWAP(char* rutaDelArchivoDeConfiguracion){
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracion);
tipoConfigSWAP* cfg = crearConfigSWAP();
validarErrorYAbortar(config_has_property(archivoCfg,PUERTO_ESCUCHA)
&& config_has_property(archivoCfg,NOMBRE_SWAP)
&& config_has_property(archivoCfg,CANTIDAD_PAGINAS)
&& config_has_property(archivoCfg,TAMANIO_PAGINA)
&& config_has_property(archivoCfg,RETARDO_COMPACTACION),
"Las claves del archivo de configuracion no coinciden con las que requiere el SWAP");
cfg->puertoDeEscucha = config_get_int_value(archivoCfg,PUERTO_ESCUCHA);
cfg->nombreDeSWAP = string_duplicate(config_get_string_value(archivoCfg,NOMBRE_SWAP));
cfg->cantidadDePaginas = config_get_int_value(archivoCfg,CANTIDAD_PAGINAS);
cfg->retardoDeCompactacion = config_get_int_value(archivoCfg,RETARDO_COMPACTACION);
cfg->tamanioDePagina = config_get_int_value(archivoCfg,TAMANIO_PAGINA);
config_destroy(archivoCfg);
return cfg;
}
/*
* FUNCION : Valida parámetros de configuración necesarios para el proceso CPU
* Recibe : puntero a estructura de configuración
* Devuelve : bool
*/
bool validarParametrosDeConfiguracion(t_config* config){
return ( config_has_property(config, "NUCLEO_IP")
&& config_has_property(config, "NUCLEO_PUERTO")
&& config_has_property(config, "UMC_IP")
&& config_has_property(config, "UMC_PUERTO")
&& config_has_property(config, "CPU_ID"));
}
void obtenerDatosAlgorimo(informacion_planificacion_t* datosAlgoritmo) {
t_config* conF = config_create(CONFIG_PATH);
if (config_has_property(conF, "Nombre")) {
datosAlgoritmo->nombreNivel = malloc(
strlen(config_get_string_value(conF, "Nombre")) + 1);
strcpy(datosAlgoritmo->nombreNivel,
config_get_string_value(conF, "Nombre"));
}
if (config_has_property(conF, "algoritmo")) {
char* algoritmo = config_get_string_value(conF, "algoritmo");
datosAlgoritmo->algoritmo =
strcmp("RR", algoritmo) == 0 ? ROUND_ROBIN : SRDF;
}
if (config_has_property(conF, "quantum")) {
datosAlgoritmo->quantum = config_get_int_value(conF, "quantum");
}
if (config_has_property(conF, "retardo")) {
datosAlgoritmo->retardo = config_get_int_value(conF, "retardo");
}
config_destroy(conF);
}
int cargarConfiguraciones(void){
char* pathConfig=getenv("ANSISOP_CONFIG");
t_config* configuracion = config_create(pathConfig);
if (config_has_property(configuracion,"Puerto") && config_has_property(configuracion,"IP")){
puerto=config_get_string_value(configuracion,"Puerto");
ip=config_get_string_value(configuracion,"IP");
return 0;
} else {
return CONFIG_INVALIDA;
}
}
//**********************************Init Config****************************************//
int initConfig(char* configFile) {
t_config* _config;
int failure = 0;
int getConfigInt(char *property) {
if (config_has_property(_config, property)) {
return config_get_int_value(_config, property);
}
failure = 1;
log_error(logger, "Config not found for key %s", property);
return -1;
}
char* getConfigString(char* property) {
if (config_has_property(_config, property)) {
return config_get_string_value(_config, property);
}
failure = 1;
log_error(logger, "Config not found for key %s", property);
return "";
}
_config = config_create(configFile);
cfgJob = malloc(sizeof(t_configJob));
cfgJob->PUERTO_MARTA = getConfigInt("PUERTO_MARTA");
cfgJob->IP_MARTA = strdup(getConfigString("IP_MARTA"));
cfgJob->MAPPER = strdup(getConfigString("MAPPER"));
cfgJob->REDUCER = strdup(getConfigString("REDUCER"));
cfgJob->RESULTADO = strdup(getConfigString("RESULTADO"));
cfgJob->LIST_ARCHIVOS = strdup(getConfigString("LIST_ARCHIVOS"));
cfgJob->COMBINER = strdup(getConfigString("COMBINER"));
if (!failure) {
log_info(logger, "PUERTO MARTA: %d", cfgJob->PUERTO_MARTA);
log_info(logger, "IP MARTA: %s", cfgJob->IP_MARTA);
log_info(logger, "MAPPER: %s", cfgJob->MAPPER);
log_info(logger, "REDUCER: %s", cfgJob->REDUCER);
log_info(logger, "RESULTADO: %s", cfgJob->RESULTADO);
log_info(logger, "ARCHIVOS: %s", cfgJob->LIST_ARCHIVOS);
log_info(logger, "COMBINER: %s", cfgJob->COMBINER);
}
config_destroy(_config);
return !failure;
}
void test_read_config() {
t_config* config = config_create(PATH_CONFIG);
CU_ASSERT_EQUAL(config_keys_amount(config), KEYS_AMOUNT);
CU_ASSERT_TRUE(config_has_property(config, "IP"));
CU_ASSERT_STRING_EQUAL(config_get_string_value(config, "IP"), "127.0.0.1");
CU_ASSERT_TRUE(config_has_property(config, "PORT"));
CU_ASSERT_EQUAL(config_get_int_value(config, "PORT"), 8080);
CU_ASSERT_TRUE(config_has_property(config, "LOAD"));
CU_ASSERT_EQUAL(config_get_double_value(config, "LOAD"), 0.5);
config_destroy(config);
}
void levantarCfg(char **ip, int32_t *port,t_log_level *log_level, uint8_t *maxThreads, char **nombreArchivo, char** ipCache, int32_t *portCache) {
char *log_level_str;
t_config *s_cfg = config_create("cfgRfs.txt");
if(config_has_property(s_cfg,"port")) {
*port = config_get_int_value(s_cfg,"port");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"ip")) {
*ip = config_get_string_value(s_cfg,"ip");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"log")) {
log_level_str = config_get_string_value(s_cfg,"log");
*log_level = log_level_from_string(log_level_str);
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"hilos")) {
*maxThreads = config_get_int_value(s_cfg,"hilos");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"archivo")) {
*nombreArchivo = config_get_string_value(s_cfg,"archivo");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"delay")) { //delay var global
delay = (config_get_int_value(s_cfg,"delay"))*1000;
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"ipCache")) { //delay var global
*ipCache = config_get_string_value(s_cfg,"ipCache");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
if(config_has_property(s_cfg,"portCache")) { //delay var global
*portCache = config_get_int_value(s_cfg,"portCache");
}else{
puts("Faltan campos en el cfg");
exit(0);
}
}
void setearValorEntero(int* valorASetear,char* parametroABuscar){
if (config_has_property(CPU_config,parametroABuscar)){
*valorASetear = config_get_int_value(CPU_config,parametroABuscar);
printf("%s = %d \n",parametroABuscar, *valorASetear);
}
else{
printf("No se encontro %s\n",parametroABuscar);
}
}
void setearValorChar(char** valorASetear,char* parametroABuscar){
if (config_has_property(CPU_config,parametroABuscar)){
*valorASetear = strdup(config_get_string_value(CPU_config,parametroABuscar));
printf("%s = %s \n",parametroABuscar, *valorASetear);
}
else{
printf("No se encontro %s\n",parametroABuscar);
}
}
char* leerString(t_config *config, char* key) {
char * datoString = malloc(sizeof(config_get_string_value(config, key)));
if (config_has_property(config, key)) {
datoString = config_get_string_value(config, key);
} else {
error_show("No se leyó el %s de la config \n", key);
}
return datoString;
}
unsigned leerUnsigned(t_config *config, char* key) {
unsigned datoInt = 0;
if (config_has_property(config, key)) {
datoInt = config_get_int_value(config, key);
} else {
error_show("No se leyó el %s de la config \n", key);
}
return datoInt;
}
int initConfig(char* configFile) {
t_config* _config;
int failure = 0;
int getConfigInt(char *property) {
if (config_has_property(_config, property)) {
return config_get_int_value(_config, property);
}
failure = 1;
log_error(logger, "Config not found for key %s", property);
return -1;
}
char* getConfigString(char *property) {
if (config_has_property(_config, property)) {
return config_get_string_value(_config, property);
}
failure = 1;
log_error(logger, "Config not found for key %s", property);
return "";
}
_config = config_create(configFile);
cfgMaRTA = malloc(sizeof(t_configMaRTA));
log_info(logger, "Loading config...");
cfgMaRTA->listenPort = getConfigInt("PUERTO_LISTEN");
cfgMaRTA->fsIP = strdup(getConfigString("IP_FILE_SYSTEM"));
cfgMaRTA->fsPort = getConfigInt("PUERTO_FILE_SYSTEM");
if (!failure) {
log_info(logger, "Port to listen: %d", cfgMaRTA->listenPort);
log_info(logger, "FileSystem IP: %s", cfgMaRTA->fsIP);
log_info(logger, "FileSystem Port: %d", cfgMaRTA->fsPort);
}
config_destroy(_config);
return !failure;
}
//Cargar archivo de configuracion
tipoConfig* cargarArchivoDeConfiguracion(char* rutaDelArchivoDeConfiguracion){
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracion);
validarExistenciaDeArchivoDeConfiguracion(rutaDelArchivoDeConfiguracion);
tipoConfig* cfg = crearConfig();
validarErrorYAbortar(config_has_property(archivoCfg,PUERTO_ESCUCHA)
&& config_has_property(archivoCfg,QUANTUM),
"Las claves del archivo de configuracion no coinciden con las que requiere el Panificador");
cfg->puertoPlanificador = config_get_int_value(archivoCfg,PUERTO_ESCUCHA);
cfg->quantum = config_get_int_value(archivoCfg,QUANTUM);
config_destroy(archivoCfg);
return cfg;
}
void actualizarDelay(int fd) {
char buffer[1024];
read( fd, buffer, 1024 ); //leo para q el select no entre otra vez
t_config *s_cfg = config_create("cfgRfs.txt");
if(config_has_property(s_cfg,"delay")) {
delay = (config_get_int_value(s_cfg,"delay"))*1000;
}
}
void obtenerConfiguracion(char* nombre_archivo) {
t_config* config;
configuracion = (t_Datos_configuracion*) malloc(sizeof(t_Datos_configuracion));
char* path = file_combine(PATH_CONFIG, nombre_archivo);
config = config_create(path);
if (config_has_property(config, "IP_MARTA")) {
configuracion->ip_marta = strdup(config_get_string_value(config, "IP_MARTA"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un IP_MARTA", path);
exit(1);
}
if (config_has_property(config, "REDUCE")) {
configuracion->reduce = read_whole_file(config_get_string_value(config, "REDUCE"));
configuracion->tamanio_reduce = file_get_size(config_get_string_value(config, "REDUCE"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un REDUCE", path);
exit(1);
}
if (config_has_property(config, "MAPPER")) {
configuracion->mapper = read_whole_file(config_get_string_value(config, "MAPPER"));
configuracion->tamanio_mapper = file_get_size(config_get_string_value(config, "MAPPER"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un MAPPER", path);
exit(1);
}
if (config_has_property(config, "PUERTO_MARTA")) {
configuracion->puerto_marta = config_get_int_value(config, "PUERTO_MARTA");
} else {
log_error_consola("El archivo de configuracion %s debe tener un PUERTO_MARTA", path);
exit(1);
}
if (config_has_property(config, "COMBINER")) {
configuracion->combiner = !strcmp(config_get_string_value(config, "COMBINER"), "SI") ? 1 : 0;
} else {
log_error_consola("El archivo de configuracion %s debe tener un COMBINER", path);
exit(1);
}
if (config_has_property(config, "RESULTADO")) {
configuracion->resultado = strdup(config_get_string_value(config, "RESULTADO"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un RESULTADO", path);
exit(1);
}
if (config_has_property(config, "ARCHIVOS")) {
configuracion->archivos = strdup(config_get_string_value(config, "ARCHIVOS"));
} else {
log_error_consola("El archivo de configuracion %s debe tener un ARCHIVOS", path);
exit(1);
}
log_info_consola("El archivo de configuracion %s fue cargado con exito", path);
config_destroy(config);
}
int32_t validarConfig(t_config *config) {
if (!config_has_property(config, "TAMANIO_UMV")) {
perror("Falta TAMANIO_UMV");
return EXIT_FAILURE;
}
if (!config_has_property(config, "RETARDO")) {
perror("Falta RETARDO");
return EXIT_FAILURE;
}
if (!config_has_property(config, "ALGORITMO")) {
perror("Falta ALGORITMO");
return EXIT_FAILURE;
}
if (!config_has_property(config, "PUERTO")) {
perror("Falta PUERTO");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
tipoConfigMemoria* cargarArchivoDeConfiguracionDeMemoria(
char* rutaDelArchivoDeConfiguracion) {
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracion);
tipoConfigMemoria* cfg = crearConfigMemoria();
validarErrorYAbortar(
config_has_property(archivoCfg, PUERTO_ESCUCHA)
&& config_has_property(archivoCfg, IP_SWAP)
&& config_has_property(archivoCfg, PUERTO_SWAP)
&& config_has_property(archivoCfg,
MAXIMO_MARCOS_POR_PROCESO)
&& config_has_property(archivoCfg, CANTIDAD_MARCOS)
&& config_has_property(archivoCfg, TAMANIO_MARCO)
&& config_has_property(archivoCfg, ENTRADAS_TLB)
&& config_has_property(archivoCfg, TLB_HABILITADA)
&& config_has_property(archivoCfg, RETARDO_MEMORIA)
&& config_has_property(archivoCfg, ALGORITMO_RAM),
"Las claves del archivo de configuracion no coinciden con las que requiere el Administrador de Memoria.");
cfg->puertoDeEscucha = config_get_int_value(archivoCfg, PUERTO_ESCUCHA);
cfg->ipSWAP = string_duplicate(
config_get_string_value(archivoCfg, IP_SWAP));
cfg->puertoSWAP = config_get_int_value(archivoCfg, PUERTO_SWAP);
cfg->maximoDeMarcosPorProceso = config_get_int_value(archivoCfg,
MAXIMO_MARCOS_POR_PROCESO);
cfg->cantidadDeMarcos = config_get_int_value(archivoCfg, CANTIDAD_MARCOS);
cfg->tamanioDeMarco = config_get_int_value(archivoCfg, TAMANIO_MARCO);
cfg->entradasDeTLB = config_get_int_value(archivoCfg, ENTRADAS_TLB);
cfg->TLBHabilitada = string_duplicate(
config_get_string_value(archivoCfg, TLB_HABILITADA));
cfg->retardoDeMemoria = config_get_double_value(archivoCfg, RETARDO_MEMORIA);
cfg->algoritmoRAM = string_duplicate(
config_get_string_value(archivoCfg, ALGORITMO_RAM));
config_destroy(archivoCfg);
return cfg;
}
tipoConfigCPU* cargarArchivoDeConfiguracionDeCPU(char* rutaDelArchivoDeConfiguracionDelCPU){
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracionDelCPU);
tipoConfigCPU* cfg = crearConfigCPU();
validarErrorYAbortar(config_has_property(archivoCfg,IP_PLANIFICADOR)
&& config_has_property(archivoCfg,PUERTO_PLANIFICADOR)
&& config_has_property(archivoCfg,IP_MEMORIA)
&& config_has_property(archivoCfg,PUERTO_MEMORIA)
&& config_has_property(archivoCfg,CANTIDAD_HILOS)
&& config_has_property(archivoCfg,RETARDO),
"Las claves del archivo de configuracion no coinciden con las que requiere el CPU");
cfg->ipPlanificador = string_duplicate(config_get_string_value(archivoCfg,IP_PLANIFICADOR));
cfg->puertoPlanificador = config_get_int_value(archivoCfg,PUERTO_PLANIFICADOR);
cfg->ipMemoria = string_duplicate(config_get_string_value(archivoCfg,IP_MEMORIA));
cfg->puertoMemoria = config_get_int_value(archivoCfg,PUERTO_MEMORIA);
cfg->cantidadDeHilos = config_get_int_value(archivoCfg,CANTIDAD_HILOS);
cfg->retardo = config_get_int_value(archivoCfg,RETARDO);
config_destroy(archivoCfg);
return cfg;
}
void levantar_configuracion() {
t_config* config;
config = config_create(ARCHIVO_CONFIG);
if (config == NULL) {
log_error_consola("No se pudo abrir el archivo de configuracion");
exit(1);
}
log_debug_interno("Leyendo archivo de configuracion");
if (config_has_property(config, "PUERTO_LISTEN")) {
PUERTO_LISTEN = config_get_string_value(config, "PUERTO_LISTEN");
} else {
log_error_consola("El archivo de configuracion debe tener un PUERTO_LISTEN");
exit(1);
}
if (config_has_property(config, "CANTIDAD_NODOS")) {
CANTIDAD_NODOS = config_get_int_value(config, "CANTIDAD_NODOS");
} else {
log_error_consola("El archivo de configuracion debe tener una CANTIDAD_NODOS");
exit(1);
}
log_info_interno("Archivo de configuracion cargado correctamente");
}
bool validar_configuracion()
{
bool ret = true;
int elements = sizeof(cofig_properties)/sizeof(cofig_properties[0]);
int i;
for(i = 0; i < elements; i++) {
if( !config_has_property(config, &cofig_properties[i]) ) {
ret = false;
break;
}
}
return ret;
}
void GetInfoConfFile(void)
{
t_config* config;
config = config_create(PATH_CONFIG);
if (config_has_property(config, "IP"))
{
myip = (char*) malloc(strlen(config_get_string_value(config, "IP")) + 1);
strcpy(myip, config_get_string_value(config, "IP"));
}
strcpy(algoritmo,config_get_string_value(config, "ALGORITMO"));
port = config_get_int_value(config, "PORT");
space = config_get_int_value(config, "DISK_SPACE");
retardo = config_get_int_value(config, "RETARDO");
return;
}
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_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 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);
}
NIVEL_CONF* inicializarCongiuracionNivel() {
t_config* conF = config_create(CONFIG_PATH);
NIVEL_CONF *configObj = malloc(sizeof(NIVEL_CONF));
if (config_has_property(conF, "Nombre")) {
configObj->nombre = malloc(
strlen(config_get_string_value(conF, "Nombre")) + 1);
strcpy(configObj->nombre, config_get_string_value(conF, "Nombre"));
}
if (config_has_property(conF, "TiempoChequeoDeadlock")) {
configObj->deadlockTime = config_get_int_value(conF,
"TiempoChequeoDeadlock");
}
if (config_has_property(conF, "Recovery")) {
configObj->recovery = config_get_int_value(conF, "Recovery");
}
char *tok = ":";
if (config_has_property(conF, "orquestador")) {
char *orqaddr = strdup(config_get_string_value(conF, "orquestador"));
configObj->orquestadoraddr = strtok(orqaddr, tok);
configObj->orquestadorport = strtok(NULL, tok);
}
if (config_has_property(conF, "localhost")) {
char *locaddr = strdup(config_get_string_value(conF, "localhost"));
configObj->localhostaddr = strtok(locaddr, tok);
configObj->localhostport = strtok(NULL, tok);
}
if (config_has_property(conF, "Log")) {
configObj->logLevel = malloc(
strlen(config_get_string_value(conF, "Log")));
strcpy(configObj->logLevel, config_get_string_value(conF, "Log"));
}
if (config_has_property(conF, "Enemigos")) {
configObj->enemigos = config_get_int_value(conF, "Enemigos");
}
if (config_has_property(conF, "Sleep_Enemigos")) {
configObj->sleepEnemigos = config_get_int_value(conF, "Sleep_Enemigos");
}
config_destroy(conF);
return configObj;
}
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);
}
////////////////////////////////////////////////////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;
}
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;
}
}
t_nivel* configuracion_inicializar(char* path) {
t_nivel* nivel = malloc(sizeof(t_nivel));
nivel->lista_items = NULL;
t_config* configuracion_nivel = config_create(path);
//nombre
nivel->nombre = string_duplicate(
config_get_string_value(configuracion_nivel, "Nombre"));
//deadlock
nivel->deadlock = config_get_int_value(configuracion_nivel,
"TiempoChequeoDeadlock");
//recovery
nivel->recovery = config_get_int_value(configuracion_nivel, "Recovery");
//ip y puerto
char* ip_puerto = config_get_string_value(configuracion_nivel,
"orquestador");
char**ip = string_split(ip_puerto, ":");
strcpy(nivel->ip, ip[0]);
//puerto
char* puerto = ip[1];
nivel->puerto = atoi(puerto);
free(ip[0]);
free(ip[1]);
free(ip);
//ip y puerto del nivel todo get ip
char* ip_puerto_nivel= config_get_string_value(configuracion_nivel,
"ip_nivel");
char**ip_nivel = string_split(ip_puerto_nivel, ":");
strcpy(nivel->ip_nivel, ip_nivel[0]);
//puerto
char* puerto_nivel = ip_nivel[1];
nivel->puerto_nivel = atoi(puerto_nivel);
free(ip_nivel[0]);
free(ip_nivel[1]);
free(ip_nivel);
//cantidad de key en el archivo, que son de cajas nada mas, resto 6 por ahora
cantidad_key = config_keys_amount(configuracion_nivel) - 5;
//los numeros de caja empiezan de 1 y van en orden(siempre)
int count;
for (count = 1; count <= cantidad_key; count++) {
//armo las keys de las cajas
char* key = string_from_format("Caja %d", count);
if (config_has_property(configuracion_nivel, key)) {
char* caja = (char*) config_get_string_value(configuracion_nivel,
key);
char** array_values = string_split(caja, ",");
//del array saco el char del string que me viene
char id = array_values[1][1];
CrearCaja(&(nivel->lista_items), id, atoi(array_values[3]),
atoi(array_values[4]), atoi(array_values[2]));
}
}
config_destroy(configuracion_nivel);
nivel->personajes_deadlock = list_create();
log_info(logger, "se ha inicializado un nivel");
return nivel;
}
