/**
* @brief Funcion que ejecuta el automata de los mensajes
*/
void ZIGBEE_recepcion_mensajes(void){
unsigned char * pantalla;
MENSAJEClass m_mensaje; /*Cuerpo del mensaje que se recibe por zigbee*/
tBoolean b_mensaje = false; /*Si se ha recibido un mensaje completo*/
b_mensaje = hay_mensaje();
if(b_mensaje){
m_mensaje = recibir_mensaje();
if(m_mensaje.id != NULL){
if(g_i_numero_mensaje < (MAX_MENSAJES / 2)){
g_cm_mensajes[g_i_numero_mensaje] = m_mensaje;
g_i_numero_mensaje++;
}else{
borrar_mensaje_lista();
g_cm_mensajes[(g_i_numero_mensaje - 1)] = m_mensaje;
}
//TODO: enviar mendiante bluetooth
pantalla = malloc(sizeof(unsigned char) * 20);
switch(m_mensaje.tipo){
case TRAFICO_DENSO:
sprintf(pantalla, "M_TR_DENSO %d", m_mensaje.id);
gs_i_tamano = gs_i_numero_cabecera + 16;
break;
case OBRAS:
sprintf(pantalla, "M_OBRAS %d", m_mensaje.id);
gs_i_tamano = gs_i_numero_cabecera + 16;
break;
case VEHICULO_NO_VISIBLE:
sprintf(pantalla, "M_NO_VIS %d", m_mensaje.id);
gs_i_tamano = gs_i_numero_cabecera + 16;
break;
case POCA_VISIBILIDAD:
sprintf(pantalla, "M_POCA_VIS %d", m_mensaje.id);
gs_i_tamano = gs_i_numero_cabecera + 16;
break;
case ESTADO_CARRETERA:
sprintf(pantalla, "M_EST_CAR %d", m_mensaje.id);
gs_i_tamano = gs_i_numero_cabecera + 17;
break;
case ACCIDENTE_CARRETERA:
sprintf(pantalla, "M_ACC_CAR %d", m_mensaje.id);
gs_i_tamano = gs_i_numero_cabecera + 16;
break;
}
DISPLAY_escribir(pantalla);
reenviar_mensaje(m_mensaje);
}
}
}
void obtener_siguiente_hilo(void) {
t_msg *msg = id_message(CPU_TCB);
if(enviar_mensaje(Kernel,msg) == -1) {
puts("ERROR: No se pudo obtener el siguiente hilo a ejecutar.");
exit(EXIT_FAILURE);
}
destroy_message(msg);
if((msg = recibir_mensaje(Kernel)) == NULL || msg->header.id != NEXT_TCB) {
puts("ERROR: No se pudo obtener el siguiente hilo a ejecutar.");
exit(EXIT_FAILURE);
}
Quantum = msg->argv[0];
Execution_State = RETURN_TCB;
memcpy(&Hilo,msg->stream,sizeof(t_hilo));
destroy_message(msg);
}
void destruir_segmento(uint32_t baseSegmento) {
t_msg *msg = argv_message(DESTROY_SEGMENT,2,PID,baseSegmento);
if(enviar_mensaje(MSP,msg) == -1) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
destroy_message(msg);
if((msg = recibir_mensaje(MSP)) == NULL) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
if(msg->header.id != OK_DESTROY) {
Quantum = 0;
KernelMode = false;
Execution_State = CPU_ABORT;
}
destroy_message(msg);
}
void escribir_memoria(uint32_t pid,uint32_t direccionLogica,char *bytesAEscribir,uint32_t size) {
t_msg *msg = string_message(WRITE_MEMORY,bytesAEscribir,2,pid,direccionLogica);
msg->header.length = size;
if(enviar_mensaje(MSP,msg) == -1) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
destroy_message(msg);
free(bytesAEscribir);
if((msg = recibir_mensaje(MSP)) == NULL) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
if(msg->header.id != OK_WRITE) {
Quantum = 0;
KernelMode = false;
Execution_State = CPU_ABORT;
}
destroy_message(msg);
}
main() {
char * id;
int fd = client_socket("127.0.0.1",2233);
while(getchar() != EOF) {
t_msg *msg = argv_message(REQUEST_MEMORY, 3, 74, 127, 30);
enviar_mensaje(fd,msg);
puts("Mensaje enviado");
msg = recibir_mensaje(fd);
printf("%s\n%s",id = id_string(msg->header.id),msg->stream);
free(msg);
}
}
uint32_t crear_segmento(uint32_t size) {
uint32_t aux;
t_msg *msg = argv_message(CREATE_SEGMENT,2,PID,size);
if(enviar_mensaje(MSP,msg) == -1) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
destroy_message(msg);
if((msg = recibir_mensaje(MSP)) == NULL) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
if(msg->header.id == OK_CREATE)
aux = (uint32_t) msg->argv[0];
else {
Quantum = 0;
KernelMode = false;
Execution_State = CPU_ABORT;
}
destroy_message(msg);
return aux;
}
char* solicitar_memoria(uint32_t pid,uint32_t direccionLogica,uint32_t size) {
char *buffer = malloc(size);
t_msg *msg = argv_message(REQUEST_MEMORY,3,pid,direccionLogica,size);
if(enviar_mensaje(MSP,msg) == -1) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
destroy_message(msg);
if((msg = recibir_mensaje(MSP)) == NULL) {
puts("ERROR: Se ha perdido la conexión con la MSP.");
exit(EXIT_FAILURE);
}
if(msg->header.id == OK_REQUEST)
memcpy(buffer,msg->stream,size);
else {
free(buffer);
buffer = NULL;
Quantum = 0;
KernelMode = false;
Execution_State = CPU_ABORT;
}
destroy_message(msg);
return buffer;
}
void esperarTareas() {
log_debug_consola("Se comienza a recibir solicitudes de tareas de map o reduce de MaRTA");
fd_set read_fds; // master file descriptor list
int socket_actual;
int fdmax;
FD_ZERO(&read_fds);
FD_SET(marta_sock, &read_fds);
fdmax = marta_sock;
while (true) {
if (select(fdmax + 1, &read_fds, NULL, NULL, NULL) == -1) {
log_error_consola("Fallo el select");
perror("Fallo el select. Error");
}
for (socket_actual = 0; socket_actual <= fdmax; socket_actual++) {
if (FD_ISSET(socket_actual, &read_fds)) {
if (socket_actual == marta_sock) {
t_msg* mensaje_actual = recibir_mensaje(marta_sock);
if (!mensaje_actual) {
log_error_consola("Se perdio la conexion con MaRTA IP: %s - Puerto: %d", configuracion->ip_marta, configuracion->puerto_marta);
exit(1);
}
log_debug_interno("Se recibio mensaje de MaRTA. Header.Id: %s - Argc: %d - Largo Stream: %d", id_string(mensaje_actual->header.id),
mensaje_actual->header.argc, mensaje_actual->header.length);
if (mensaje_actual->header.id == EJECUTAR_REDUCE) {
t_params_hiloReduce* paramsR = (t_params_hiloReduce*) malloc(sizeof(t_params_hiloMap));
char** argumentos;
argumentos = string_split(mensaje_actual->stream, "|");
paramsR->archivos_tmp = queue_create();
strcpy(paramsR->ip, argumentos[0]);
paramsR->nombre_nodo = string_duplicate(argumentos[1]);
paramsR->puerto = mensaje_actual->argv[0];
paramsR->id_operacion = mensaje_actual->argv[1];
paramsR->id_job = mensaje_actual->argv[2];
paramsR->archivo_final = argumentos[2];
mensaje_actual = recibir_mensaje(marta_sock);
if (!mensaje_actual) {
log_error_consola("Se perdio la conexion con MaRTA IP: %s - Puerto: %d", configuracion->ip_marta, configuracion->puerto_marta);
exit(1);
}
while (mensaje_actual->header.id != FIN_ENVIO_MENSAJE) {
log_debug_interno("Se recibio mensaje de MaRTA. Header.Id: %s - Argc: %d - Largo Stream: %d", id_string(mensaje_actual->header.id),
mensaje_actual->header.argc, mensaje_actual->header.length);
queue_push(paramsR->archivos_tmp, (void*) mensaje_actual);
mensaje_actual = recibir_mensaje(marta_sock);
if (!mensaje_actual) {
log_error_consola("Se perdio la conexion con MaRTA IP: %s - Puerto: %d", configuracion->ip_marta, configuracion->puerto_marta);
exit(1);
}
}
levantarHiloReduce(paramsR);
} else if (mensaje_actual->header.id == EJECUTAR_MAP) {
t_params_hiloMap* params = (t_params_hiloMap*) malloc(sizeof(t_params_hiloMap));
char** argumentos = string_split(mensaje_actual->stream, "|");
strcpy(params->ip, argumentos[0]);
params->nombre_nodo = string_duplicate(argumentos[1]);
params->archivo_final = string_duplicate(argumentos[2]);
params->puerto = mensaje_actual->argv[0];
params->id_operacion = mensaje_actual->argv[1];
params->id_job = mensaje_actual->argv[2];
params->bloque = mensaje_actual->argv[3];
levantarHiloMapper(params);
} else if (mensaje_actual->header.id == GET_ARCHIVO_TMP_OK) {
log_info_consola("El Job finalizo con exito");
exit(EXIT_SUCCESS);
} else if (mensaje_actual->header.id == MDFS_NO_OPERATIVO) {
log_info_consola("ERROR - El MDFS no esta operativo. Reintente mas tarde.");
exit(EXIT_FAILURE);
} else if (mensaje_actual->header.id == INFO_ARCHIVO_ERROR) {
log_info_consola("ERROR - No se encontro la informacion del archivo %s.Compruebe la existencia del archivo y vuelva a intentarlo.",
mensaje_actual->stream);
exit(EXIT_FAILURE);
} else if (mensaje_actual->header.id == FIN_MAP_ERROR) {
log_info_consola("ERROR - No se pudo ejecutar map. Revise disponibilidad de los archivos y vuelva a ejecutar.");
exit(EXIT_FAILURE);
} else if (mensaje_actual->header.id == FIN_REDUCE_ERROR) {
log_info_consola("ERROR - No se pudo ejecutar reduce. Revise estado del MDFS y vuelva a ejecutar.");
exit(EXIT_FAILURE);
} else if (mensaje_actual->header.id == GET_ARCHIVO_TMP_ERROR) {
log_info_consola("ERROR - No se pudo copiar el archivo final en el MDFS. Revise estado del MDFS y vuelva a ejecutar.");
exit(EXIT_FAILURE);
}
}
}
}
}
}
void * LTS_demorado(void * var){
char *buffer_2=(char *)malloc(1024);
bzero(buffer_2,1024);
char *prioridad=(char *)malloc(64);
bzero(prioridad,64);
char *paso_mensaje=(char *)malloc(256);
while(1){
sem_wait(sem_lts_demorado);
pthread_t id_hilo=pthread_self();
int retorno;
int socket_demorado;
proceso proceso;
pthread_mutex_lock(&mutexListaDemorados);
if((socket_demorado=sacar_conexion_demorada(listaConeccionesDemoradas))>0){
pthread_mutex_unlock(&mutexListaDemorados);
pthread_mutex_lock(&mutexVarMMP);
pthread_mutex_unlock(&mutexVarMMP);
if( (retorno = validar_mmp_demorado(socket_demorado)) == 0){
enviar_mensaje("Enviame el codigo\n",socket_demorado);
recibir_mensaje(&buffer_2,socket_demorado);
recibir_mensaje(&prioridad,socket_demorado);
//printf("Me llego la prioridad: %s\n",prioridad);
proceso = crear_proceso(buffer_2,prioridad,socket_demorado);
bzero(paso_mensaje,256);
sprintf(paso_mensaje,"Se creo el proceso con PID=%d\n",proceso.pcb.pid);
enviar_mensaje(paso_mensaje,socket_demorado);
logx(proceso.pcb.pid,"LTS_demorado",id_hilo,"INFO","El proceso ha sido creado.");
char *log_text=(char *)malloc(127);
sprintf(log_text,"La prioridad del proceso es %d.",proceso.prioridad);
logx(proceso.pcb.pid,"LTS_demorado",id_hilo,"DEBUG",log_text);
// if ( buffer_2 != NULL ){
// free(buffer_2);
// }
pthread_mutex_lock(&mutexListaNuevos);
agregar_proceso(listaProcesosNuevos,proceso);
pthread_mutex_unlock(&mutexListaNuevos);
sem_post(sem_sts);
logx(proceso.pcb.pid,"LTS_demorado",id_hilo,"LSCH","Agregue el proceso a la lista de Nuevos.");
pthread_mutex_lock(&mutexVarMMP);
mmp++;
pthread_mutex_unlock(&mutexVarMMP);
logx(proceso.pcb.pid,"LTS",id_hilo,"INFO","Se aumento el grado de multiprogramacion.");
}else{
if( retorno == -2){
logx(proceso.pcb.pid,"LTS",id_hilo,"ERROR","Se sobrepaso el maximo grado de multiprogramacion.");
logx(proceso.pcb.pid,"LTS",id_hilo,"INFO","Se aumento el grado de multiprogramacion.");
}
}
//FD_CLR(socket_demorado,&(*master));
}else{
pthread_mutex_unlock(&mutexListaDemorados);
}
sleep(1);
}
return 0;
}