void* conexionNucleo(int socketEscuchaNucleo){
socketNucleo = socketEscuchaNucleo;
int seguir = 1;
int tamanioPag = umcConfg.configuracionUMC.MARCO_SIZE;
while(seguir){
int* header = recibirStream(socketEscuchaNucleo,sizeof(int));
/*int* id = leerHeader(socketEscuchaNucleo);
cambiarProceso(*id);*/
if(header==NULL){
header = malloc(sizeof(int));
*header = -1;
}
log_trace(logConexiones,"Header recibido en Nucleo: %d\n", *header);
switch (*header) {
case FINALIZACIONPROGRAMA:
finalizar_programa();
break;
case NUEVOPROGRAMA:
inicializar_programa();
break;
case CAMBIOPROCESO:
change_Proceso();
break;
case SOLICITAR:
solicitar_Bytes_NL();
break;
case ALMACENAR:
almacenar_Byte_NL();
break;
case 666:
enviarStream(socketEscuchaNucleo,666,sizeof(int),&tamanioPag);
break;
case -1:
printf("Se desconecto Nucleo, terminado thread\n");
log_trace(logConexiones,"Nucleo desconectado.");
seguir = 0;
break;
default:
break;
}
free(header);
//free(id);
}
}
void eliminar_programa_pid_2_sin_ningun_frame_asignado(){
//inicializacion_para_test(10, 90);
inicializar_estructuras();
crear_swap_mock();
char * codigo;
cargar_nuevo_programa(1, 40, codigo);
cargar_nuevo_programa(2, 20, codigo);
cargar_nuevo_programa(3, 10, codigo);
//busco los valores previos a finalizar el programa
int viejo_size = list_size(lista_tabla_de_paginas);
t_tabla_de_paginas * tabla= buscar_tabla_de_paginas_de_pid(2);
finalizar_programa(2);
//busco los valores nuevos luego de finalizar el programa
int nuevo_size = list_size(lista_tabla_de_paginas);
CU_ASSERT_EQUAL(viejo_size -1, nuevo_size);
}
void atender_UMC(t_paquete *paquete, int socket_conexion) {
int id_mensaje_recibido = paquete->header->id_mensaje;
int id_proceso_emisor = paquete->header->id_proceso_emisor;
int retorno_de_funcion;
switch (id_mensaje_recibido) {
case MENSAJE_HANDSHAKE:
//TODO: Tomar valor de pagina
log_trace(loggerManager,"[Comunicacion UMC][Mensaje recibido - cod 0] handshake");
if(id_proceso_emisor == PROCESO_UMC)
enviar_header_al_UMC(socket_conexion, RESPUESTA_HANDSHAKE);
else
handshake_error(socket_conexion);
break;
case MENSAJE_LEER_PAGINA_PARA_ESCRIBIR:
case MENSAJE_LEER_PAGINA:
//TODO: Revisar/evaluar si el umc estaba pidiendo desde la pagina 1 porque piensa que es la primera (debería de ser 0? revisar). no debería, porque a priori las lecturas les dieron resultados correctos a los chicos, si no explotaria feo
log_trace(loggerManager,"[Comunicacion UMC][Mensaje recibido - cod 1-6] leer_pagina");
t_pagina *pagina = malloc (sizeof (t_pagina));
deserializar_pagina(paquete->payload, pagina);
t_pagina_completa *pagina_completa_lectura= malloc (sizeof (t_pagina_completa)); //Se va a usar para responder ok
pagina_completa_lectura->id_programa = pagina->id_programa;
pagina_completa_lectura->pagina = pagina->pagina;
pagina_completa_lectura->offset = pagina->offset;
pagina_completa_lectura->tamanio = pagina->tamanio;
pagina_completa_lectura->socket_pedido = pagina->socket_pedido;
pagina_completa_lectura->valor = malloc(pagina->tamanio);
retorno_de_funcion = leer_bytes_swap(pagina, pagina_completa_lectura->valor);
t_buffer *buffer_pagina = serializar_pagina(pagina);
t_buffer *buffer_pagina_completa_lectura = serializar_pagina_completa(pagina_completa_lectura);
//Diferentes retornos de mensajes dependiendo de la situación. PD: Si quedó horrible pero el tiempo está en nuestra contra :P
if (retorno_de_funcion != -1 && id_mensaje_recibido == MENSAJE_LEER_PAGINA)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, RESPUESTA_LEER_PAGINA, buffer_pagina_completa_lectura);
else if (retorno_de_funcion != -1 && id_mensaje_recibido == MENSAJE_LEER_PAGINA_PARA_ESCRIBIR)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, RESPUESTA_LEER_PAGINA_PARA_ESCRIBIR, buffer_pagina_completa_lectura);
else if (retorno_de_funcion == -1 && id_mensaje_recibido == MENSAJE_LEER_PAGINA)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, ERROR_LEER_PAGINA, buffer_pagina);
else if (retorno_de_funcion == -1 && id_mensaje_recibido == MENSAJE_LEER_PAGINA_PARA_ESCRIBIR)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, ERROR_LEER_PAGINA_PARA_ESCRIBIR, buffer_pagina);
free (pagina);
free (pagina_completa_lectura->valor);
free (pagina_completa_lectura);
free (buffer_pagina->contenido_buffer);
free (buffer_pagina);
free (buffer_pagina_completa_lectura->contenido_buffer);
free (buffer_pagina_completa_lectura);
break;
case MENSAJE_ESCRIBIR_PAGINA_NUEVA:
case MENSAJE_ESCRIBIR_PAGINA:
log_trace(loggerManager,"[Comunicacion UMC][Mensaje recibido - cod 2-7] escribir_pagina");
t_pagina_completa *pagina_completa_escritura = malloc (sizeof (t_pagina_completa));
deserializar_pagina_completa(paquete->payload , pagina_completa_escritura);
retorno_de_funcion = escribir_bytes_swap(pagina_completa_escritura);
t_buffer *buffer_pagina_completa_escritura = serializar_pagina_completa(pagina_completa_escritura);
//Diferentes retornos de mensajes dependiendo de la situación. PD: Si quedó horrible pero el tiempo está en nuestra contra :P
if (retorno_de_funcion != -1 && id_mensaje_recibido == MENSAJE_ESCRIBIR_PAGINA)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, RESPUESTA_ESCRIBIR_PAGINA, buffer_pagina_completa_escritura);
else if (retorno_de_funcion != -1 && id_mensaje_recibido == MENSAJE_ESCRIBIR_PAGINA_NUEVA)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, RESPUESTA_ESCRIBIR_PAGINA_NUEVA, buffer_pagina_completa_escritura);
else if (retorno_de_funcion == -1 && id_mensaje_recibido == MENSAJE_ESCRIBIR_PAGINA)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, ERROR_ESCRIBIR_PAGINA, buffer_pagina_completa_escritura);
else if (retorno_de_funcion == -1 && id_mensaje_recibido == MENSAJE_ESCRIBIR_PAGINA_NUEVA)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, ERROR_ESCRIBIR_PAGINA_NUEVA, buffer_pagina_completa_escritura);
free (pagina_completa_escritura);
free (buffer_pagina_completa_escritura->contenido_buffer);
free (buffer_pagina_completa_escritura);
break;
case MENSAJE_INICIAR_PROGRAMA:
log_trace(loggerManager,"[Comunicacion UMC][Mensaje recibido - cod 3] iniciar_programa");
t_programa_nuevo *programa_nuevo = malloc (sizeof (t_programa_nuevo));
deserializar_programa_nuevo(paquete->payload , programa_nuevo);
retorno_de_funcion = inicializar_programa (programa_nuevo);
t_buffer *buffer_con_programa_nuevo = serializar_programa_nuevo(programa_nuevo);
if (retorno_de_funcion != -1)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, RESPUESTA_INICIALIZAR_PROGRAMA, buffer_con_programa_nuevo);
else
enviar_mensaje_con_buffer_al_UMC(socket_conexion, ERROR_INICIALIZAR_PROGRAMA, buffer_con_programa_nuevo);
free (programa_nuevo);
free (buffer_con_programa_nuevo->contenido_buffer);
free (buffer_con_programa_nuevo);
break;
case MENSAJE_FINALIZAR_PROGRAMA:
log_trace(loggerManager,"[Comunicacion UMC][Mensaje recibido - cod 4] finalizar_programa");
t_programa *programa = malloc (sizeof (t_programa));
deserializar_programa(paquete->payload, programa);
retorno_de_funcion = finalizar_programa (programa);
t_buffer *buffer_con_programa = serializar_programa(programa);
if (retorno_de_funcion != -1)
enviar_mensaje_con_buffer_al_UMC(socket_conexion, RESPUESTA_FINALIZAR_PROGRAMA, buffer_con_programa);
else
enviar_mensaje_con_buffer_al_UMC(socket_conexion, ERROR_FINALIZAR_PROGRAMA, buffer_con_programa);
free (programa);
free(buffer_con_programa->contenido_buffer);
free(buffer_con_programa);
break;
default:
log_error(loggerManager,"[Comunicacion UMC] El código de mensaje: %i, no es un mensaje aceptado por el SWAP", id_mensaje_recibido);
break;
}
}
