t_param_plat leer_archivo_plataforma_config() {
t_config* config;
t_param_plat param;
log_in_disk_plat(LOG_LEVEL_TRACE,
"comienzo lectura archivo de configuracion plataforma en el %s ",
PATH_CONFIG_PLATAFORMA);
config = config_create(PATH_CONFIG_PLATAFORMA);
param.PUERTO = config_get_int_value(config, "PUERTO");
param.SEGUNDOS_ESPERA = config_get_double_value(config, "SEGUNDOS_ESPERA");
param.CUANTUM = config_get_int_value(config, "CUANTUM");
log_in_disk_plat(LOG_LEVEL_TRACE,
"Parametros planificador puerto %d segundos de planificacions %.2f cuantum %d ",
param.PUERTO, param.SEGUNDOS_ESPERA, param.CUANTUM);
//param.planificador_nivel = config_get_array_value(config, "planDeNiveles");
//solo entro en el loop si el mivel de log es LOG_LEVEL_TRACE
// if (LOG_LEVEL_TRACE == 0) {
// int i = 0;
// while (param.planificador_nivel[i] != '\0') {
// log_in_disk_plat(LOG_LEVEL_TRACE, "Niveles de planificador %s ",
// param.planificador_nivel[i]);
// i++;
// }
// }
return param;
}
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 inicializar_CPU(char *path, uint32_t *retardo) {
t_config* config = config_create(path);
*retardo = config_get_int_value(config,"RETARDO");
uint16_t puertoMSP = config_get_int_value(config,"PUERTO_MSP");
char *direccionIpMSP = config_get_string_value(config,"IP_MSP");
uint16_t puertoKernel = config_get_int_value(config,"PUERTO_KERNEL");
char *direccionIpKernel = config_get_string_value(config,"IP_KERNEL");
if((Kernel = client_socket(direccionIpKernel, puertoKernel)) < 0) {
puts("ERROR: No se pudo conectar al Kernel.");
exit(EXIT_FAILURE);
}
t_msg *handshake = id_message(CPU_CONNECT);
enviar_mensaje(Kernel, handshake);
destroy_message(handshake);
if((MSP = client_socket(direccionIpMSP, puertoMSP)) < 0) {
puts("ERROR: No se pudo conectar a la MSP.");
exit(EXIT_FAILURE);
}
config_destroy(config);
MapRegistros['A'-'A'] = &Registros.registros_programacion[0];
MapRegistros['B'-'A'] = &Registros.registros_programacion[1];
MapRegistros['C'-'A'] = &Registros.registros_programacion[2];
MapRegistros['D'-'A'] = &Registros.registros_programacion[3];
MapRegistros['E'-'A'] = &Registros.registros_programacion[4];
MapRegistros['K'-'A'] = &Registros.K;
MapRegistros['I'-'A'] = &Registros.I;
MapRegistros['M'-'A'] = &Registros.M;
MapRegistros['P'-'A'] = &Registros.P;
MapRegistros['S'-'A'] = &Registros.S;
MapRegistros['X'-'A'] = &Registros.X;
inicializar_tabla_instrucciones();
}
void
readConfig(char *path)
{
t_config *configKernel;
configKernel = config_create(path);
configuration.ipUMV = config_get_string_value(configKernel, "IPUMV");
configuration.ipKernel = config_get_string_value(configKernel, "IPKERNEL");
configuration.puertoUMV = config_get_string_value(configKernel, "PUERTO_UMV");
/*configuration.puertoKERNEL = config_get_string_value(configKernel,
"PUERTO_KERNEL");*/
configuration.puertoProg = config_get_string_value(configKernel,
"PUERTO_PROG");
configuration.puertoCPU = config_get_string_value(configKernel, "PUERTO_CPU");
configuration.quantum = config_get_int_value(configKernel, "QUANTUM");
configuration.grado_multiprog = config_get_int_value(configKernel,
"MULTIPROGRAMACION");
configuration.retardo = config_get_int_value(configKernel, "RETARDO");
configuration.tamanio_pila = config_get_int_value(configKernel,
"TAMANIO_STACK");
configuration.semaforos = config_get_array_value(configKernel, "SEMAFOROS");
configuration.valor_semaforos = config_get_array_value(configKernel,
"VALOR_SEMAFORO");
configuration.valorHIO = config_get_array_value(configKernel, "HIO");
configuration.var_compartidas = config_get_array_value(configKernel,
"VARIABLES_GLOBALES");
configuration.idHIO = config_get_array_value(configKernel, "ID_HIO");
//config_destroy(configKernel); TODO esto tiene un leak mas grande que uan casa
}
void levantarArchivoConfiguracionPlataforma() {
t_config *config;
config = config_create(PATH_CONFIG_PLATAFORMA);
if (config->properties->elements_amount == 0) {
printf("\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION %s \n", PATH_CONFIG_PLATAFORMA);
perror("\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION\n( Don't PANIC! Si estas por consola ejecuta: ln -s ../plataforma.conf plataforma.conf )\n\n");
config_destroy(config);
exit(-1);
}
//Levanto los parametros necesarios para el planificador
configPlat.PUERTO = config_get_int_value(config, "PUERTO");
strcpy(configPlat.KOOPA, config_get_string_value(config, "KOOPA"));
strcpy(configPlat.SCRIPT, config_get_string_value(config, "SCRIPT"));
strcpy(configPlat.FILESYSTEM, config_get_string_value(config, "FILESYSTEM"));
configPlat.SLEEP_KOOPA = config_get_int_value(config, "SLEEP_KOOPA");
configPlat.RD = config_get_int_value(config, "RD");
strcpy(configPlat.LOG_PATH, config_get_string_value(config, "LOG_PATH"));
configPlat.LOG_NIVEL = obtenerLogLevel( config_get_string_value(config, "LOG_NIVEL"));
configPlat.LOG_CONSOLA = config_get_int_value(config, "LOG_CONSOLA");
// Una vez que se levantaron los datos del archivo de configuracion
// puedo/debo destruir la estructura config.
config_destroy(config);
}
void init(){
LOGGER = log_create(LOG_PATH, "MaRTA", true, LOG_LEVEL_DEBUG);
CONF = config_create(CONF_PATH); //HACK estaba mal el nombre de la funcion o no la encontraba o no se
if(LOGGER == NULL){
perror("ERROR! no pudo levantar ni el log!");
exit(EXIT_FAILURE);
}
if(CONF == NULL){
log_error(LOGGER, "\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION\n( Don't PANIC! Si estas por consola ejecuta: ln -s ../%s %s )\n\n"
, CONF_PATH
, CONF_PATH);
exit(EXIT_FAILURE);
}
// if(!validarConfig()){ //HACK no lo necesitaba, no entendi el codigo del map y no me servia, anda :P
// log_error(LOGGER, "No pudo obtenerse alguno de los parametros de configuracion");
// exit(EXIT_FAILURE);
// }
mapa_nodos = dictionary_create();
lista_jobs = list_create();
pthread_mutex_init(&mutex_mapa_nodos, NULL);
pthread_mutex_init(&mutex_lista_jobs, NULL);
log_info(LOGGER, "intenta conectarse a la ip %s con puerto %d", config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
while (socketFS == -1) {
log_info(LOGGER, "Filesystem no levantado. Se reintenta conexion en unos segundos");
sleep(5);
socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
}
header_t header;
initHeader(&header);
header.tipo = MARTA_TO_FS_HANDSHAKE;
header.largo_mensaje = 0;
header.cantidad_paquetes = 1;
log_info(LOGGER, "Conectado a FS! envio header %s", getDescription(header.tipo));
enviar_header(socketFS, &header);
t_mensaje mensaje;
memset(&mensaje, 0, sizeof(t_mensaje));
recibir_t_mensaje(socketFS, &mensaje);
log_info(LOGGER, "recibo respuesta %s de FS", getDescription(mensaje.tipo));
while(mensaje.tipo != ACK){
log_info(LOGGER, "Todavia el FS no esta disponible. Header recibido: %s. Reintento en 5 segundos", getDescription(header.tipo));
sleep(5);
enviar_header(socketFS, &header);
recibir_t_mensaje(socketFS, &mensaje);
}
recibirNodosFS();
log_info(LOGGER, "%s: FS está operativo. Continúo", getDescription(header.tipo));
}
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;
}
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);
}
void initFileSystem()
{
logFile = log_create("./FileSystem.log","FileSystem", true, LOG_LEVEL_TRACE);
pthread_mutex_init(&mLogFile, NULL);
t_config* archivoConfig = config_create("./FileSystem.config");
PUERTO_LISTEN = config_get_int_value(archivoConfig, "PUERTO_LISTEN");
char* tmp = config_get_string_value(archivoConfig, "IP_LISTEN");
strcpy(IP_LISTEN,tmp);
free(tmp);
LISTA_NODOS = config_get_int_value(archivoConfig, "LISTA_NODOS");
//config_destroy(archivoConfig);
listaArchivos = list_create();
pthread_mutex_init(&mListaArchivos, NULL);
listaDirs = list_create();
pthread_mutex_init(&mListaDirs, NULL);
t_reg_directorio* raiz = malloc(sizeof(t_reg_directorio));
strcpy(raiz->directorio, "\0");
raiz->padre = -1;
list_add(listaDirs, raiz);
initConsola();
initComandos();
initConexiones();
leerPersistencia();
}
void initNucleo(t_config* config){
quantum = config_get_int_value(config, "QUANTUM");
quantum_sleep = config_get_int_value(config, "QUANTUM_SLEEP");
io_ids = config_get_array_value(config, "IO_ID");
io_sleep_times = config_get_array_value(config, "IO_SLEEP");
semaforos_ids = config_get_array_value(config, "SEM_IDS");
semaforos_init_values = config_get_array_value(config, "SEM_INIT");
shared_values = config_get_array_value(config, "SHARED_VARS");
stack_size = config_get_int_value(config, "STACK_SIZE");
umc_ip = config_get_string_value(config, "UMC_IP");
test_mode = config_get_int_value(config, "TEST_MODE");
io_thread_sleep = config_get_int_value(config, "IO_THREAD_SLEEP");
//Estruturas para control de estados
READY_Process_Queue = queue_create();
BLOCKED_Process_Queue = queue_create();
RUNNING_Process_List = list_create();
General_Process_List = list_create();
//Creación de lista de dispositivos
IO_Device_List = list_create();
set_IO_devices_list();
//Lista de control de CPUs conectadas
CPU_control_list = list_create();
//Creación de lista de semáforos
semaforo_control_list = list_create();
set_semaforo_list();
//Creación del diccionario de variables
vars_control_dictionary = dictionary_create();
set_vars_dictionary();
}
void leerConfiguracion(void){
config=config_create(PATH);
configuracion_cpu.ip_kernel=config_get_string_value(config,"Direccion IP para conectarse al Kernel");
configuracion_cpu.puerto_kernel=config_get_int_value(config,"Puerto TCP para conectarse al Kernel");
configuracion_cpu.ip_umv=config_get_string_value(config,"Direccion IP para conectarse a la UMV");
configuracion_cpu.puerto_umv=config_get_int_value(config,"Puerto TCP para conectarse a la UMV");
}
// Funciones
void setearValores_config(t_config * archivoConfig) {
config = reservarMemoria(sizeof(t_configuracion));
config->puerto = config_get_int_value(archivoConfig, "PUERTO_ESCUCHA");
config->nombreSwap = strdup(config_get_string_value (archivoConfig, "NOMBRE_SWAP"));
config->cantidadPaginas = config_get_int_value(archivoConfig, "CANTIDAD_PAGINAS");
config->tamanioPagina = config_get_int_value(archivoConfig, "TAMANIO_PAGINA");
config->retardoCompactacion = config_get_int_value(archivoConfig, "RETARDO_COMPACTACION");
config->retardoAcceso = config_get_int_value(archivoConfig , "RETARDO_ACCESO");
}
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 setearValores(t_config * archivoConfig) {
puertoEscucha = config_get_string_value(archivoConfig, "PUERTO");
ip_Swap = config_get_string_value(archivoConfig, "IP_SWAP");
puerto_Swap = config_get_string_value(archivoConfig, "PUERTO_SWAP");
marcos = config_get_int_value(archivoConfig, "MARCOS");
marco_Size = config_get_int_value(archivoConfig, "MARCO_SIZE");
marco_x_proc = config_get_int_value(archivoConfig, "MARCO_X_PROC");
algoritmoDeReemplazo = config_get_string_value(archivoConfig, "ALGORITMO");
entradas_TLB = config_get_int_value(archivoConfig, "ENTRADAS_TLB");
espera = config_get_int_value(archivoConfig, "RETARDO");
}
void crear_estructura_config(char* path)
{
t_config* archConfig = config_create(path);
arch = malloc(sizeof(ProcesoSwap));
arch->puerto_escucha = config_get_int_value(archConfig, "PUERTO_ESCUCHA");
arch->nombre_swap = config_get_string_value(archConfig, "NOMBRE_SWAP");
arch->cantidad_paginas = config_get_int_value(archConfig, "CANTIDAD_PAGINAS");
arch->tamanio_pagina= config_get_int_value(archConfig, "TAMANIO_PAGINA");
arch->retardo= config_get_int_value(archConfig, "RETARDO_SWAP");
arch->retardo_comp= config_get_int_value(archConfig, "RETARDO_COMPACTACION");
}
void *comienzaPCP() {
listaVarCompartidas = list_create(); // Lista de las variables compartidas
listaSemaforos = list_create(); // Lista de Semaforos
listaIO = list_create(); // Lista de los Dispositivos IO
listaBloqueados = list_create(); //Lista de procesos bloqueados por semaforo
config = config_create(getenv("CONFIG_KERNEL"));
log_pcp = creacionLog(config_get_string_value(config, "LOG_KERNEL"), "PCP");
log_debug(log_pcp, "Inicia el proceso PCP..");
log_trace(log_pcp, "Creado log del PCP");
log_trace(log_pcp, "Cargado el archivo de configuracion");
// ######################## Cargo Archivo de config ######################## //
// Cargo QUANTUM y retardo Quantum en estructuraInicial
estructuraInicial = malloc(sizeof(t_EstructuraInicial));
estructuraInicial->Quantum = config_get_int_value(config, "QUANTUM");
estructuraInicial->RetardoQuantum = config_get_int_value(config, "RETARDO");
log_trace(log_pcp, "Cargado el Quantum: %d , retardoQuantum:%d",
estructuraInicial->Quantum, estructuraInicial->RetardoQuantum);
cpuAcerrar=0;
// Cargo las varCompartidas en listaVarCompartidas asi es mas comodo manejarlas
cargoVarCompartidasEnLista();
// Cargo los semaforos en listaSemaforos
cargoSemaforosEnLista();
// Cargo los IO en listaIO
cargoIOenLista();
pthread_t hiloIO, hiloPCB; //hilo por IO y PCB
sem_init(&semClienteOcioso, 1, 0); // Semaforo para clientes ociosos
//Creo hilo por cada dispositivo
void _creoHilos(void* entradaSalida) {
if (pthread_create(&hiloIO, NULL, hiloPorIO, (void*) entradaSalida)
!= 0) {
perror("could not create thread");
}
}
list_iterate(listaIO, (void*) _creoHilos);
// creo hilo para manejar programas que se cierren inesperadamente
if (pthread_create(&hiloPCB, NULL, (void*) hiloPCBaFinalizar, NULL ) != 0) {
perror("could not create thread");
}
// ######################## Fin loading ######################## //
server_cpu();
config_destroy(config);
log_destroy(log_pcp);
list_destroy_and_destroy_elements(listaVarCompartidas, free);
list_destroy_and_destroy_elements(listaIO, free);
list_destroy_and_destroy_elements(listaSemaforos, free);
return 0;
}
//TODO: dos main en el proyecto me rompen todo ;)
void* checkEvent() {
char buffer[BUF_LEN];
// Al inicializar inotify este nos devuelve un descriptor de archivo
int file_descriptor = inotify_init();
if (file_descriptor < 0) {
perror("inotify_init");
}
// Creamos un monitor sobre un path indicando que eventos queremos escuchar
int watch_descriptor = inotify_add_watch(file_descriptor, "/config", IN_CLOSE_WRITE );
// El file descriptor creado por inotify, es el que recibe la información sobre los eventos ocurridos
// para leer esta información el descriptor se lee como si fuera un archivo comun y corriente pero
// la diferencia esta en que lo que leemos no es el contenido de un archivo sino la información
// referente a los eventos ocurridos
int length = read(file_descriptor, buffer, BUF_LEN);
if (length < 0) {
perror("read");
}
int offset = 0;
// Luego del read buffer es un array de n posiciones donde cada posición contiene
// un eventos ( inotify_event ) junto con el nombre de este.
while (offset < length) {
// El buffer es de tipo array de char, o array de bytes. Esto es porque como los
// nombres pueden tener nombres mas cortos que 24 caracteres el tamaño va a ser menor
// a sizeof( struct inotify_event ) + 24.
struct inotify_event *event = (struct inotify_event *) &buffer[offset];
// El campo "len" nos indica la longitud del tamaño del nombre
if (event->len) {
// Dentro de "mask" tenemos el evento que ocurrio y sobre donde ocurrio
// sea un archivo o un directorio
if (event->mask & IN_CLOSE) {
//create config otra vez
//chequear que el campo haya cambiado (quantum o lo que sea)
t_config* config = getConfig("nucleo.config");
quantum = config_get_int_value(config, "QUANTUM");
quantum_sleep = config_get_int_value(config, "QUANTUM_SLEEP");
}
}
offset += sizeof (struct inotify_event) + event->len;
}
inotify_rm_watch(file_descriptor, watch_descriptor);
close(file_descriptor);
return EXIT_SUCCESS;
}
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;
}
bool conectarUMV()
{
socketUMV = conectar(config_get_string_value(config, "IP_UMV"), config_get_int_value(config, "PUERTO_UMV"), logplp);
if (socketUMV == -1) {
log_error(logplp, "No se pudo establecer la conexion con la UMV");
return false;
}
log_info(logplp, "Conectado con la UMV");
socket_header handshake;
handshake.size = sizeof(socket_header);
handshake.code = 'k'; //Kernel
if( send(socketUMV, &handshake, sizeof(socket_header), 0) <= 0 )
{
log_error(logplp, "No se puedo enviar Handshake a la UMV");
sem_post(&semKernel);
return false;
}
return true;
}
void leerConfiguracion(void){
t_config* config=config_create(PATH_config);
configuracion_programa.ip_kernel = config_get_string_value(config,"Direccion IP para conectarse al Kernel");
configuracion_programa.puerto_kernel = config_get_int_value(config,"Puerto TCP para recibir conexiones del Kernel");
}
Nivel* levantarConfiguracion(char *rutaArchivo) {
Nivel *nivel;
nivel = malloc(sizeof(Nivel));
nivel->items = list_create();
ITEM_NIVEL *itemNivel;
t_config *config = config_create(rutaArchivo);
nivel->nombre = config_get_string_value(config, "Nombre");
nivel->recovery = config_get_int_value(config, "Recovery");
nivel->tiempoChequeoDeadLock = config_get_int_value(config,
"TiempoChequeoDeadlock");
int masCajas = 1;
int i = 1;
while (masCajas) {
itemNivel = malloc(sizeof(ITEM_NIVEL));
//Armamos el string de la caja
//que vamos a buscar
char c[2];
//Convertimos el int a un char
sprintf(c, "%d", i);
char caja[10] = "Caja";
strcat(caja, c);
char *datosCaja = config_get_string_value(config, caja);
if (datosCaja) {
strsep(&datosCaja, ",");
itemNivel->id =* strsep(&datosCaja, ",");
itemNivel->quantity = atoi(strsep(&datosCaja, ","));
itemNivel->posx = atoi(strsep(&datosCaja, ","));
itemNivel->posy = atoi(strsep(&datosCaja, ","));
itemNivel->item_type = 'C';
list_add(nivel->items,itemNivel);
free(datosCaja);
i++;
} else {
masCajas = 0;
}
}
//La funcion strsep sirve para separar strings, aca la usamos para
//separar la IP y el PUERTO
char *ipCompleta = config_get_string_value(config, "orquestador");
nivel->ip = strsep(&ipCompleta, ":");
nivel->puerto = atoi(ipCompleta);
return nivel;
}
void readFSCConfig(char* configPath, char** IP, uint32_t* port, char** IPcache,
uint32_t* portCache,char** logFilePath,t_log_level* logLevelDetail,uint32_t* cantidadDeConexiones) { //se tiene que ampliar para leer la ip el puerto y otras cosas mas
fsc_config = config_create(configPath);
*IP = calloc(1,strlen(config_get_string_value(fsc_config, "IP"))+1);
strncpy(*IP, config_get_string_value(fsc_config, "IP"),
strlen(config_get_string_value(fsc_config, "IP"))+1);
*port = config_get_int_value(fsc_config, "Port");
*IPcache = malloc(strlen(config_get_string_value(fsc_config, "IPcache"))+1);
strncpy(*IPcache, config_get_string_value(fsc_config, "IPcache"),
strlen(config_get_string_value(fsc_config, "IPcache"))+1);
*portCache = config_get_int_value(fsc_config, "PortCache");
*logFilePath= config_get_string_value(fsc_config,"ArchivoLog");
*logLevelDetail=config_get_int_value(fsc_config,"DetalleLog");
*cantidadDeConexiones=config_get_int_value(fsc_config,"CantidadDeConexiones");
}
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);
}
int leerArchivoConfiguracion(char *ruta_archivo) {
int devolver = 0;
config = config_create(ruta_archivo);
printf("Leyendo archivo de configuraciones: %s\n", ruta_archivo);
PUERTO_ESCUCHA = config_get_int_value(config, "PUERTO_ESCUCHA");
IP_SWAP = config_get_string_value(config, "IP_SWAP");
PUERTO_SWAP = config_get_int_value(config, "PUERTO_SWAP");
MAXIMO_MARCOS_POR_PROCESO=config_get_int_value(config,"MAXIMO_MARCOS_POR_PROCESO");
CANTIDAD_MARCOS=config_get_int_value(config,"CANTIDAD_MARCOS");
TAMANIO_MARCO=config_get_int_value(config,"TAMANIO_MARCOS");
ENTRADAS_TLB=config_get_int_value(config,"ENTRADAS_TLB");
TLB_HABILITADA=config_get_string_value(config,"TLB_HABILITADA");
RETARDO=config_get_int_value(config,"RETARDO");
printf("Puerto de la Memoria que escucha: %d\n", PUERTO_ESCUCHA);
printf("IP del Swap: %s\n", IP_SWAP);
printf("Puerto del Swap: %d\n", PUERTO_SWAP);
printf("Cantidad maxima de marcos por proceso: %d\n", MAXIMO_MARCOS_POR_PROCESO);
printf("Cantidad de Marcos: %d\n", CANTIDAD_MARCOS);
printf("Tamanio de cada marco: %d\n", TAMANIO_MARCO);
printf("Cantidad de entradas TLB: %d\n", ENTRADAS_TLB);
printf("TLB habilitada: %s\n", TLB_HABILITADA);
printf("Tiempo de retardo: %d\n", RETARDO);
puts("Listo.\n");
return devolver;
}
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);
}
}
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;
}
t_param_persoje leer_personaje_config() {
t_config* config;
t_param_persoje param;
t_recusos *list_recursos; //declaro el tipo nodo
char *aux_char;
char *aux_str;
char **aux;
int i;
log_in_disk_per(LOG_LEVEL_TRACE,
"comienzo lectura archivo de configuracion del personaje en el %s ",
PATH_CONFIG_PERSONAJE);
param.RECURSOS = list_create(); //creo lista de recursos
config = config_create(PATH_CONFIG_PERSONAJE);
//param.nom_nivel = nivel; //copio el nombre del nivel que pase por parametro en el main
param.NOMBRE = config_get_string_value(config, "NOMBRE");
aux_char = config_get_string_value(config, "SIMBOLO");
param.SMBOLO = aux_char[0];
param.PLAN_NIVELES = config_get_array_value(config, "PLANDENIVELES");
param.VIDAS = config_get_int_value(config, "VIDAS");
aux_char = config_get_string_value(config, "PLATAFORMA");
aux = string_split(aux_char, ":");
param.IP = aux[0];
param.PUERTO_PLATAFORMA = atoi(aux[1]);
i = 0;
while (param.PLAN_NIVELES[i] != '\0') {
list_recursos = malloc(sizeof(t_recusos));
//sprintf(aux_str, "OBJ[%s]", param.PLAN_NIVELES[i]);
aux_str = string_from_format("OBJ[%s]", param.PLAN_NIVELES[i]);
log_in_disk_per(LOG_LEVEL_TRACE, "Niveles de planificador %s ",
param.PLAN_NIVELES[i]);
list_recursos->RECURSOS = config_get_array_value(config, aux_str);
strcpy(list_recursos->NOMBRE, param.PLAN_NIVELES[i]);
list_add(param.RECURSOS, list_recursos); //agrego el nuevo nodo
log_in_disk_per(LOG_LEVEL_TRACE,
"Niveles de planificador %s con los recursos %s",
param.PLAN_NIVELES[i],
config_get_string_value(config, aux_str));
i++;
}
return param;
}
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;
}
}
//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;
}
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;
}
