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);
}
int leerConfiguracion(char *ruta, datosConfiguracion **datos) {
t_config* archivoConfiguracion = config_create(ruta);//Crea struct de configuracion
if (archivoConfiguracion == NULL) {
return 0;
} else {
int cantidadKeys = config_keys_amount(archivoConfiguracion);
if (cantidadKeys < 7) {
return 0;
} else {
(*datos)->puerto = buscarInt(archivoConfiguracion, "PUERTO");
char* nombreSwap=string_new();
string_append(&nombreSwap,config_get_string_value(archivoConfiguracion, "NOMBRE_SWAP"));
(*datos)->nombre_swap =nombreSwap;
(*datos)->cantidadPaginas = buscarInt(archivoConfiguracion, "CANTIDAD_PAGINAS");
(*datos)->tamPagina = buscarInt(archivoConfiguracion, "TAMANIO_PAGINA");
(*datos)->retardoAcceso = buscarInt(archivoConfiguracion, "RETARDO_ACCESO");
(*datos)->retardoCompactacion = buscarInt(archivoConfiguracion, "RETARDO_COMPACTACION");
char* ip=string_new();
string_append(&ip,config_get_string_value(archivoConfiguracion,"IP"));
(*datos)->ip=ip;
config_destroy(archivoConfiguracion);
return 1;
}
}
}
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 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));
}
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
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
}
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 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 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");
}
void levantar_configuraciones() {
t_config * archivo_configuracion = config_create("CPU.confg");
config_cpu.PUERTO_NUCLEO = config_get_string_value(archivo_configuracion, "PUERTO_NUCLEO");
config_cpu.IP_NUCLEO = config_get_string_value(archivo_configuracion, "IP_NUCLEO");
config_cpu.PUERTO_UMC = config_get_string_value(archivo_configuracion, "PUERTO_UMC");
config_cpu.IP_UMC = config_get_string_value(archivo_configuracion, "IP_UMC");
}
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;
}
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;
}
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);
}
}
int Cmain(void){
t_config * archivo = config_create("/home/utnso//archivos_de_nivel/nivel1");
char * nombre = config_get_string_value(archivo,"Nombre");
char * caja1 = config_get_string_value(archivo,"caja1");
char * caja2 = config_get_string_value(archivo,"caja2");
char * caja3 = config_get_string_value(archivo,"caja3");
//////////////
/* int i=1;
char* mensaje=malloc(sizeof(10));
sprintf(mensaje,"caja%d",i);
t_list* cajas= list_create();
t_caja unaCaja=(t_caja*)malloc(sizeof(t_caja));
unaCaja->nombre=vec[0];
unaCaja->Simbolo=vec[1];
void _imprimirCajas(t_caja * unaCaja) {
printf("Nombre=%s",unaCaja->nombre);
printf("Nombre=%s",unaCaja->nombre);
printf("Nombre=%s",unaCaja->nombre);
printf("Nombre=%s",unaCaja->nombre);
printf("Nombre=%s",unaCaja->nombre);
}
list_iterate(cajas,(void*)_imprimirCajas);
list_add(cajas,unaCaja);
/////////////
*/
//char** aP = string_get_string_as_array(nombre);
char ** vec = string_split(caja1,",");
printf("%s\n",caja2);
printf("%s\n",caja3);
printf("%s\n",caja1);
int i;
for(i=1;i<strlen(caja1);i++){
printf("%s\n",vec[i]);
}
return 0;
}
t_datos_kernel connectToKernel() {
char* IPKernel = config_get_string_value(configuracion_CPU, "IPKernel");
char* puertoKernel = config_get_string_value(configuracion_CPU,
"PuertoKernel");
pcpSocket = connect_to(IPKernel, puertoKernel);
if (pcpSocket == -1) {
log_debug(logger, "Failure connecting to Kernel");
destroyOnConnectionFailure();
}
return doHandshakeKernel();
}
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 connectToUMV() {
char* IP_UMV = config_get_string_value(configuracion_CPU, "IPUMV");
char* puertoUMV = config_get_string_value(configuracion_CPU, "PuertoUMV");
umvSocket = connect_to(IP_UMV, puertoUMV);
if (umvSocket == -1) {
log_debug(logger, "Connection to UMV failed. Ending");
destroyOnConnectionFailure();
}
log_debug(logger, "Connection to UMV is ready, preparing handshake...");
doHandshakeUMV();
}
void leerArchivoDeConfiguracion(int argc, char *argv[]) {
char* logMsg = NULL;
if (argc < 2) {
logMsg =
string_from_format(
"Debe especificar la ruta al archivo de configuracion, al invocar al programa, por ejemplo: ./Memoria /home/utnso/tp-2015-2c-tpso/Memoria/config_memoria.cfg\n");
puts(logMsg);
my_log_error(logMsg);
exit(-1);
}
char* nombreArchivoConfig = nombreArchivoConfig = strdup(argv[1]);
uint8_t result = checkearRutaArchivoConfig(nombreArchivoConfig);
if (result == -1) {
logMsg = string_from_format("Archivo de configuracion no encontrado. Parametro especificado: %s\n", nombreArchivoConfig);
puts(logMsg);
my_log_error(logMsg);
exit(-1);
} else {
t_config* archivoConfig;
archivoConfig = config_create(nombreArchivoConfig);
//warning asignacion diferentes tipos
configuracion = iniciarArchivoConfig();
configuracion->puertoEscucha = config_get_int_value(archivoConfig, "PUERTO_ESCUCHA");
configuracion->puertoSwap = config_get_int_value(archivoConfig, "PUERTO_SWAP");
configuracion->ipSwap = strdup(config_get_string_value(archivoConfig, "IP_SWAP"));
char* nombreMemoria = config_get_string_value(archivoConfig, "NOMBRE_MEMORIA");
configuracion->nombreMemoria = strdup(nombreMemoria != NULL ? nombreMemoria : "NOMBRE_MEMORIA");
configuracion->maximosMarcosPorProceso = config_get_int_value(archivoConfig, "MAXIMO_MARCOS_POR_PROCESO");
configuracion->cantidadMarcos = config_get_int_value(archivoConfig, "CANTIDAD_MARCOS");
configuracion->tamanioMarcos = config_get_int_value(archivoConfig, "TAMANIO_MARCO");
configuracion->entradasTlb = config_get_int_value(archivoConfig, "ENTRADAS_TLB");
if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"SI")){
configuracion->tlbHabilitada=1;
}
else if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"NO")){
configuracion->tlbHabilitada=0;
}
configuracion->retardoMemoria = config_get_int_value(archivoConfig, "RETARDO_MEMORIA");
configuracion->algoritmo_reemplazo = strdup(config_get_string_value(archivoConfig, "ALGORITMO_REEMPLAZO"));
my_log_info("[INFO]: Archivo de configuracion leido correctamente\n");
logMsg = string_from_format("Archivo de configuracion leido correctamente\n");
puts(logMsg);
//config_destroy(archivoConfig);
}
}
void setearValores(t_config * archivoConfig){
vg_puerto_escucha = config_get_int_value(archivoConfig, "PUERTO_ESCUCHA");
vg_ip_swap = strdup(config_get_string_value(archivoConfig, "IP_SWAP"));
vg_puerto_swap = config_get_int_value(archivoConfig, "PUERTO_SWAP");
vg_maximo_marcos_por_proceso = config_get_int_value(archivoConfig, "MAXIMO_MARCOS_POR_PROCESO");
vg_cantidad_marcos = config_get_int_value(archivoConfig, "CANTIDAD_MARCOS");
vg_tamanio_marco = config_get_int_value(archivoConfig, "TAMANIO_MARCO");
vg_entradas_tlb = config_get_int_value(archivoConfig, "ENTRADAS_TLB");
vg_tlb_habilitada = strdup(config_get_string_value(archivoConfig, "TLB_HABILITADA"));
vg_retardo_memoria = config_get_int_value(archivoConfig, "RETARDO_MEMORIA");
}
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;
}
}
/*
* PLATAFORMA
*/
int main(int argc, char*argv[]) {
signal(SIGINT, cerrarTodoSignal);
if (argc <= 1) {
printf("[ERROR] Se debe pasar como parametro el archivo de configuracion.\n");
exit(EXIT_FAILURE);
}
int thResult;
pthread_t thOrquestador;
// Creamos el archivo de configuracion
configPlataforma = config_try_create(argv[1], "puerto,koopa,script");
// Obtenemos el puerto
usPuerto = config_get_int_value(configPlataforma, "puerto");
// Obtenemos el path donde va a estar koopa
pathKoopa = config_get_string_value(configPlataforma, "koopa");
// Obtenemos el path donde va a estar el script para el filesystem
pathScript = config_get_string_value(configPlataforma, "script");
// Obtenemos el mountpoint
mountpoint = config_get_string_value(configPlataforma, "mountpoint");
logger = logInit(argv, "PLATAFORMA");
// Inicializo el semaforo
pthread_mutex_init(&semNivel, NULL);
pthread_mutex_init(&mtxlNiveles, NULL);
// Inicializa la lista de personajes
personajes_jugando = list_create();
thResult = pthread_create(&thOrquestador, NULL, orquestador, (void *) &usPuerto);
if (thResult != 0) {
log_error(logger, "No se pudo crear el hilo orquestador.");
exit(EXIT_FAILURE);
}
pthread_join(thOrquestador, NULL);
log_destroy(logger);
exit(EXIT_SUCCESS);
}
/*
* FUNCION : Carga los datos de configuración de la cpu. Valida parametros obtenidos.
* Recibe : estructura de configuracion para la cpu, path del archivo de configuración
* Devuelve : void
*/
void levantarDatosDeConfiguracion(t_configuracion_cpu* configuracion, char* config_path){
t_config* config = config_create(config_path);
if(validarParametrosDeConfiguracion(config)){
log_info(logger, "El archivo de configuración tiene todos los parametros requeridos.");
configuracion->nucleo_ip = config_get_string_value(config,"NUCLEO_IP");
/*char* nucleo_ip = config_get_string_value(config,"NUCLEO_IP");
configuracion->nucleo_ip = malloc(strlen(nucleo_ip));
memcpy(configuracion->nucleo_ip, nucleo_ip, strlen(nucleo_ip));
configuracion->nucleo_ip[strlen(nucleo_ip)] = '\0';*/
configuracion->nucleo_puerto = config_get_string_value(config, "NUCLEO_PUERTO");
/*char* nucleo_puerto = config_get_string_value(config,"NUCLEO_PUERTO");
configuracion->nucleo_puerto = malloc(strlen(nucleo_puerto)+1);
memcpy(configuracion->nucleo_puerto, nucleo_puerto, strlen(nucleo_puerto));
configuracion->nucleo_puerto[strlen(nucleo_puerto)] = '\0';*/
configuracion->umc_ip = config_get_string_value(config,"UMC_IP");
// char* umc_ip = config_get_string_value(config,"UMC_IP");
// configuracion->umc_ip = malloc(strlen(umc_ip));
// memcpy(configuracion->umc_ip, umc_ip, strlen(umc_ip));
// configuracion->umc_ip[strlen(umc_ip)] = '\0';
configuracion->umc_puerto = config_get_string_value(config,"UMC_PUERTO");
// char* umc_puerto = config_get_string_value(config,"UMC_PUERTO");
// configuracion->umc_puerto = malloc(strlen(umc_puerto)+1);
// memcpy(configuracion->umc_puerto, umc_puerto, strlen(umc_puerto));
// configuracion->umc_puerto[strlen(umc_puerto)] = '\0';
configuracion->cpu_id = config_get_int_value(config, "CPU_ID");
// int cpu_id = config_get_int_value(config,"CPU_ID");
// configuracion->cpu_id = malloc(sizeof configuracion->cpu_id);
// memcpy(configuracion->cpu_id, &cpu_id, sizeof(int));
//config_destroy(config);
}else{
log_error_y_cerrar_logger(logger, "Configuracion invalida.");
config_destroy(config);
exit(EXIT_FAILURE);
}
}
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 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);
}
//---------------------------------------------- <COMMUNICATION>
void com_initConsolaListener(t_config* config){
char* puerto_prog = config_get_string_value(config, "PUERTO_PROG");
consola_listener = crear_puerto_escucha(puerto_prog);
FD_ZERO(&consola_sockets_set); // clear the master and temp sets
FD_SET(consola_listener, &consola_sockets_set);
fd_consola_max = consola_listener;
}
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 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){
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");
}
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 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();
}
