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 devolver_hilo() {
t_msg *msg = Kernel_Msg == NULL ? tcb_message(Execution_State, &Hilo, 0) : Kernel_Msg;
if(enviar_mensaje(Kernel, msg) == -1) {
puts("ERROR: No se pudo enviar el TCB del hilo en ejecución al Kernel.");
exit(EXIT_FAILURE);
}
destroy_message(msg);
Kernel_Msg = NULL;
}
void ejecuta_reduce(t_job* job, t_reduce* reduce) {
char* stream = string_duplicate(reduce->arch_tmp.nodo.ip);
string_append(&stream, "|");
string_append(&stream, reduce->arch_tmp.nodo.nombre);
string_append(&stream, "|");
string_append(&stream, string_duplicate(reduce->arch_tmp.nombre));
t_msg* message = string_message(EJECUTAR_REDUCE, stream, 3, reduce->arch_tmp.nodo.puerto, reduce->id, job->id);
reduce->estado = EN_EJECUCION;
enviar_mensaje(job->socket, message);
void _genera_mensaje(t_temp* temp) {
stream = string_duplicate(temp->nodo.ip);
string_append(&stream, "|");
string_append(&stream, temp->nodo.nombre);
string_append(&stream, "|");
string_append(&stream, string_duplicate(temp->nombre));
t_msg* message = string_message(ARCHIVOS_NODO_REDUCE, stream, 1, temp->nodo.puerto);
enviar_mensaje(job->socket, message);
}
void *loader(void *arg)
{
while (1) {
if(sem_wait(&sem_loader) == -1) {
perror("loader");
exit(EXIT_FAILURE);
}
if(!thread_alive)
return NULL;
pthread_mutex_lock(&loader_mutex);
t_msg *recibido = queue_pop(loader_queue);
pthread_mutex_unlock(&loader_mutex);
t_console *console = new_console(recibido->argv[0]);
pthread_mutex_lock(&console_list_mutex);
list_add(console_list, console);
pthread_mutex_unlock(&console_list_mutex);
conexion_consola(console->pid);
log_trace(logger_old, "[NEW_CONNECTION @ LOADER]: (CONSOLE_ID %u, CONSOLE_SOCK %u).", console->pid, console->sock_fd);
t_hilo *new_tcb = ult_tcb(console->pid);
int status = reservar_memoria(new_tcb, recibido);
if (status == -1) {
log_warning(logger_old, "No se pudo cargar a memoria el hilo principal de la Consola %u.", console->pid);
new_tcb->cola = EXIT;
list_add(process_list, new_tcb);
t_msg *msg = string_message(KILL_CONSOLE, "Finalizando consola. Motivo: no hay espacio suficiente en MSP.", 0);
if(enviar_mensaje(console->sock_fd, msg) == -1) {
log_warning(logger_old, "Se perdio la conexion con la consola %u.", console->pid);
remove_console_by_sock_fd(console->sock_fd);
}
destroy_message(msg);
} else {
pthread_mutex_lock(&process_list_mutex);
list_add(process_list, new_tcb);
pthread_mutex_unlock(&process_list_mutex);
log_trace(logger_old, "[LOADER]: (PID %u, TID %u) => NEW.", new_tcb->pid, new_tcb->tid);
sem_post(&sem_planificador);
}
}
return NULL;
}
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);
}
/**
* Rutina de recuperación del svr_c
* @param nroPuerto puerto de conexion al servidor
* @param he Nombre del servidor al que se enviara el mensaje
* @return 0 si tuvo exito -1 si no
*/
int recuperar(int nroPuerto, struct hostent *he){
FILE *archRec = fopen(RECUPERA,"r");
char *mensaje = Pedir_Memoria(BUFFER_LEN);
while (feof(archRec)==0){
sleep(1);
fgets(mensaje,BUFFER_LEN,archRec);
mensaje[strlen(mensaje)-1]='\0';
printf("%s\n",mensaje);
if (enviar_mensaje(nroPuerto,he,mensaje)==-1){
fclose(archRec);
return -1;
}
}
fclose(archRec);
free(mensaje);
return 0;
}
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);
}
int main(void) {
t_msg *msg[100];
int sock_fd = client_socket("127.0.0.1", 1122);
if(sock_fd < 0) {
puts("No se pudo conectar con el Kernel.");
return 1;
}
int i;
for(i = 0; i < 100; i++)
msg[i] = beso_message(KILL_CONSOLE, "../file.bin", 0);
for(i = 0; i < 100; i++) {
int j = enviar_mensaje(sock_fd, msg[i]);
printf("Enviado mensaje nro. %d, length %d.\n", i + 1, j);
destroy_message(msg[i]);
}
return 0;
}
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);
}
void handshakeMarta() {
char* str_mensaje = string_new();
int ret;
string_append(&str_mensaje, configuracion->resultado);
string_append(&str_mensaje, "|");
string_append(&str_mensaje, configuracion->archivos);
t_msg* mensaje = string_message(CONEXION_JOB, str_mensaje, 1, configuracion->combiner);
log_debug_interno("Enviando mensaje de solicitud de inicio de Job a MaRTA. Header.ID: %s - Archivos: %s - Resultado: %s", id_string(CONEXION_JOB),
configuracion->archivos, configuracion->resultado);
ret = enviar_mensaje(marta_sock, mensaje);
if (ret < 0) {
log_error_consola("Fallo el envio de mensaje de solicitud de inicio de Job");
exit(1);
}
destroy_message(mensaje);
}
void ejecuta_maps(t_job* job) {
void _ejecuta_map(t_map* map) {
if (map->estado == PENDIENTE || map->estado == FIN_ERROR) {
char* stream = string_duplicate(map->arch_tmp.nodo.ip);
string_append(&stream, "|");
string_append(&stream, map->arch_tmp.nodo.nombre);
string_append(&stream, "|");
string_append(&stream, string_duplicate(map->arch_tmp.nombre));
t_msg* message = string_message(EJECUTAR_MAP, stream, 4, map->arch_tmp.nodo.puerto, map->id, job->id, map->arch_tmp.nodo.numero_bloque);
map->estado = EN_EJECUCION;
enviar_mensaje(job->socket, message);
log_info_interno("Enviando MAP. job: %d, id_operacion: %d, ip_nodo: %s,puerto_nodo: %d, bloque: %d,nombre_temp: %s", job->id, map->id,
map->arch_tmp.nodo.ip, map->arch_tmp.nodo.puerto, map->arch_tmp.nodo.numero_bloque, map->arch_tmp.nombre);
destroy_message(message);
}
}
log_debug_consola("creando map threads. Job: %d", job->id);
list_iterate(job->maps, (void*) _ejecuta_map);
log_debug_consola("map threads creados. Job: %d", job->id);
}
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;
}
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);
}
}
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;
}
int hiloMap(void* dato) {
//sumar_hilo();
t_msg* mensaje;
t_msg* mensaje_respuesta;
t_params_hiloMap* args = (t_params_hiloMap*) dato;
int nodo_sock = client_socket(args->ip, args->puerto);
int res = 0;
if (nodo_sock < 0) {
log_error_consola("No se pudo conectar al proceso %s - IP: %s - Puerto: %d", args->nombre_nodo, args->ip, args->puerto);
mensaje_respuesta = argv_message(FIN_MAP_ERROR, 2, args->id_operacion, args->id_job);
} else {
mensaje = string_message(EJECUTAR_MAP, args->archivo_final, 2, args->id_operacion, args->bloque);
log_debug_interno("Enviando mensaje de solicitud de reduce. Header.ID: %s - Argc: %d - Largo Stream: %d", id_string(mensaje->header.id),
mensaje->header.argc, mensaje->header.length);
res = enviar_mensaje(nodo_sock, mensaje);
if (res == -1) {
log_error_consola("Fallo envio mensaje EJECUTAR_MAP");
shutdown(nodo_sock, 2);
}
mensaje = rutina_message(RUTINA, configuracion->mapper, configuracion->tamanio_mapper);
log_debug_interno("Enviando mensaje de rutina. Header.ID: %s - Argc: %d - Largo Stream: %d Al nodo: %s", id_string(mensaje->header.id),
mensaje->header.argc, mensaje->header.length, args->nombre_nodo);
res = enviar_mensaje(nodo_sock, mensaje);
if (res == -1) {
log_error_consola("Fallo envio mensaje RUTINA");
shutdown(nodo_sock, 2);
}
log_info_consola("Se envio SOLICITUD DE MAP correctamente. id_op: %d, nodo: %s", args->id_operacion, args->nombre_nodo);
mensaje = recibir_mensaje_sin_mutex(nodo_sock);
if (!mensaje) { //Significa que recibir_mensaje devolvio NULL o sea que hubo un error en el recv o el nodo se desconecto
log_info_consola("El MAP id_op: %d en el nodo: %s fallo, enviando a MaRTA", args->id_operacion, args->nombre_nodo);
mensaje_respuesta = argv_message(FIN_MAP_ERROR, 2, args->id_operacion, args->id_job);
} else {
log_info_consola("El MAP id_op: %d, en el nodo: %s finalizo bien. enviando a MaRTA", args->id_operacion, args->nombre_nodo);
mensaje_respuesta = argv_message(mensaje->header.id, 2, args->id_operacion, args->id_job);
log_debug_interno("Se recibio mensaje de %s. Header.Id: %s - Argc: %d - Largo Stream: %d", args->nombre_nodo, id_string(mensaje->header.id),
mensaje->header.argc, mensaje->header.length);
destroy_message(mensaje);
}
}
//Se envia el resultado del map a marta
log_debug_interno("Enviando mensaje respuesta a MaRTA. Header.ID: %s - Argc: %d - Largo Stream: %d", id_string(mensaje_respuesta->header.id),
mensaje_respuesta->header.argc, mensaje_respuesta->header.length);
res = enviar_mensaje(marta_sock, mensaje_respuesta);
if (res == -1) {
log_error_consola("Fallo envio de Mensaje a MaRTA.");
shutdown(nodo_sock, 2);
return res;
}
log_info_consola("Respuesta MAP enviada a MaRTA. id_op: %d, nodo: %s", args->id_operacion, args->nombre_nodo);
destroy_message(mensaje_respuesta);
//CERRAR CONEXIoN CON EL NODO//
shutdown(nodo_sock, 2);
//restar_hilo();
return res;
}
int hiloReduce(void* dato) {
//sumar_hilo();
t_msg* mensaje;
t_msg* mensaje_respuesta;
int res = 0;
int i;
t_params_hiloReduce* args = (t_params_hiloReduce*) dato;
int nodo_sock = client_socket(args->ip, args->puerto);
if (nodo_sock < 0) {
log_error_consola("No se pudo conectar al proceso %s - IP: %s - Puerto: %d", args->nombre_nodo, args->ip, args->puerto);
mensaje_respuesta = argv_message(FIN_REDUCE_ERROR, 1, args->id_operacion);
} else {
log_debug_consola("Se conecto al proceso %s - IP: %s - Puerto: %d", args->nombre_nodo, args->ip, args->puerto);
mensaje = string_message(EJECUTAR_REDUCE, args->archivo_final, 1, args->id_operacion);
log_debug_interno("Enviando mensaje de solicitud de reduce. Header.ID: %s - Argc: %d - Largo Stream: %d", id_string(mensaje->header.id),
mensaje->header.argc, mensaje->header.length);
res = enviar_mensaje(nodo_sock, mensaje);
if (res == -1) {
log_error_consola("Fallo envio mensaje EJECUTAR_REDUCE");
shutdown(nodo_sock, 2);
return res;
}
mensaje = rutina_message(RUTINA, configuracion->reduce, configuracion->tamanio_reduce);
log_debug_interno("Enviando mensaje rutina. Header.ID: %s - Argc: %d - Largo Stream: %d", id_string(mensaje->header.id), mensaje->header.argc,
mensaje->header.length);
res = enviar_mensaje(nodo_sock, mensaje);
if (res == -1) {
log_error_consola("Fallo envio mensaje RUTINA");
shutdown(nodo_sock, 2);
return res;
}
int cant_elementos = queue_size(args->archivos_tmp);
for (i = 0; i < cant_elementos; i++) {
mensaje = queue_pop(args->archivos_tmp);
log_debug_interno("Enviando mensaje archivos de reduce. Header.ID: %s - Argc: %d - Largo Stream: %d", id_string(mensaje->header.id),
mensaje->header.argc, mensaje->header.length);
res = enviar_mensaje(nodo_sock, mensaje);
if (res == -1) {
log_error_consola("Fallo envio mensaje ARCHIVOS_NODOS_REDUCE");
shutdown(nodo_sock, 2);
return res;
}
}
mensaje = id_message(FIN_ENVIO_MENSAJE);
log_debug_interno("Enviando mensaje fin de Mensaje. Header.ID: %s - Argc: %d - Largo Stream: %d", id_string(mensaje->header.id), mensaje->header.argc,
mensaje->header.length);
res = enviar_mensaje(nodo_sock, mensaje);
if (res == -1) {
log_error_consola("Fallo envio mensaje FIN_ENVIO_MENSAJE");
shutdown(nodo_sock, 2);
return res;
}
log_info_consola("Envio REDUCE a Job OK. id_op:%d , nodo: %s ", args->id_operacion, args->nombre_nodo);
mensaje = recibir_mensaje_sin_mutex(nodo_sock);
if (!mensaje) { //Significa que recibir_mensaje devolvio NULL o sea que hubo un error en el recv o el nodo se desconecto
log_info_consola("Respuesta REDUCE Error. id_op: %d, nodo: %s, enviando mensaje a MaRTA", args->id_operacion, args->nombre_nodo);
mensaje_respuesta = argv_message(FIN_REDUCE_ERROR, 2, args->id_operacion, args->id_job);
} else {
log_info_consola("Respuesta REDUCE OK. id_op: %d, nodo: %s, enviando mensaje a MaRTA", args->id_operacion, args->nombre_nodo);
mensaje_respuesta = argv_message(mensaje->header.id, 2, args->id_operacion, args->id_job);
log_debug_interno("Se recibio mensaje de %s. Header.Id: %s - Argc: %d - Largo Stream: %d", args->nombre_nodo, id_string(mensaje->header.id),
mensaje->header.argc, mensaje->header.length);
}
}
//Se reenvia el resultado del reduce a marta
log_debug_interno("Enviando mensaje respuesta a MaRTA. Header.ID: %s - Argc: %d - Largo Stream: %d", id_string(mensaje_respuesta->header.id),
mensaje_respuesta->header.argc, mensaje_respuesta->header.length);
res = enviar_mensaje(marta_sock, mensaje_respuesta);
if (res == -1) {
log_error_consola("fallo mensaje respuesta a MaRTA");
shutdown(nodo_sock, 2);
return res;
}
log_info_consola("Respuesta REDUCE enviada. id_op: %d, nodo: %s", args->id_operacion, args->nombre_nodo);
destroy_message(mensaje_respuesta);
shutdown(nodo_sock, 2);
//restar_hilo();
return res;
}
int main(void) {
//***************************************************************************************//
//*****************ARRANCAMOS LA CONFIGURACION DEL PIC **********************************//
//***************************************************************************************//
Init_Hw();
Delay1msT1(0); //Configuramos el puertos y quitamos analogicos
Init_Pll();
Delay1msT1(0); //configuramos el pll que abiasmos arracamos sin él
Init_PWM();
Delay1msT1(0); //configuramos el PWM
init_interr_extern();
Delay1msT1(0); //configuramos las interrupciones externas
Init_Bluetooh();
Delay1msT1(0); //Configuramos el serial-Bluetooth
cargar_datos_ajuste();
Init_I2C();
Delay1msT1(0); //incializamos el I2c
set_inicial();
Delay1msT1(0); //Configuramos la incialicacion de sensor
getAngle_init();
Delay1msT1(0); //Incializamos el filtro kalman
set_inicial();
Delay1msT1(0); //Incializamos el acelerometro
LED_ALL_ON();
for (i = 0; i < 2500; i++) Delay_Nop(2000);
LED_ALL_OFF();
//***************************************************************************************//
//***************************************************************************************//
//*****************CALIBRAMOS EL ACELEROMETRO Y GIROSCOPO *******************************//
// get_calibrado_acelerometro(5, 50); //cojemos los valres por defecto del giroscopo y aceletometro
LED_ALL_OFF();
//***************************************************************************************//
//*****************INICIALIZAMOS EL PID Y LAS VARIABLES ********************************//
// pid_dsp_configuracion();
//***************************************************************************************//
LED_ALL_OFF();
//*****************ARRANCAMOS INTERRUPCION DEL BUCLE PRINCIPAL *************************//
SetupT3ForXmsPID(Tsample); //configuramos la interrupcion principal
SetupT4For20msPID(); //configuramos la interrupcion principal
StartInterrup4(); //incializamos la interrupcion
StartInterrup3(); //incializamos la interrupcion
enviar_mensaje("------------------------------------------------------");
//***************************************************************************************//
while (1) {
}
}
int main(int argc, char *argv[])
{
int sock_tcp, new_fd;/* listen en sock_tcp, nuevas conexiones en new_tcp*/
int socket_subs;
FILE *fd;
struct sockaddr_storage their_addr; // connector's address information
socklen_t sin_size = sizeof their_addr;
char s[INET6_ADDRSTRLEN];
char line[100];
int n;
Tema* aux = malloc(sizeof(Tema*));
Msg* mensaje = malloc(sizeof(Msg*));
Subscriptor *aus = malloc(sizeof(Subscriptor*));
if (argc!=3) {
fprintf(stderr, "Uso: %s puerto fichero_temas\n", argv[0]);
return 1;
}
sock_tcp = crear_socket_TCP(atoi(argv[1]));//Crear socket
fd = fopen(argv[2],"r");
while (fgets(line, 100, fd) != NULL){// Incluír en la estructura de datos los temas
n = (int) strlen (line);
line[--n] = '\0';
insertar_tema(line);//Crear nuevo tema
}
insertar_tema("meta");//tema usado para subscriptores creados
fclose(fd);
if (listen(sock_tcp, BACKLOG) == -1)
exit(-1);
while(1) { // main accept() loop
printf("\nSERVER: waiting for connections...\n");
new_fd = accept(sock_tcp, (struct sockaddr *)&their_addr, &sin_size);
if (new_fd == -1)
perror("accept");
inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr),s, sizeof s);//direccion del llamante
printf("server: got connection from %s\n", s);
mensaje = recv_msg(new_fd);// Recibir Msg de Editor o subscriptor
switch(mensaje->op){/* 0:Nuevo_subscriptor, 1:Crear Tema, 2:Eliminar tema, 3:Alta, 4:Baja, 5:Generar evento, 6:Eliminar subscriptor*/
case 0:
printf("\nNUEVO SUBSCRIPTOR --------- \n");
if(!insertar_subs("meta", atoi(mensaje->valor),s)){
enviar_mensaje(new_fd, "er");
break;
}
enviar_mensaje(new_fd, "ok");
// Enviar cada tema al subscriptor
aux = inicio;
while(aux!=NULL){
if(strcmp(aux->nombre,"meta")!=0){
socket_subs = abrir_conexion_tcp_con_servidor(atoi(mensaje->valor), s);
send_msg(socket_subs, aux->nombre,"cebar",0);
close(socket_subs);
}
aux = aux->next;
}
printf("NUEVO: FIN\n");
break;
case 1: /* Crear tema */
printf("\nCREAR: INICIO\n");
if(insertar_tema(mensaje->tema)){
enviar_mensaje(new_fd, "er");
break;
}
enviar_mensaje(new_fd, "ok");
close(new_fd);
// 2. Avisar a todos los subscriptores
aux = get_tema("meta");
if(aux==NULL){
break;
}
aus = aux->subs;
while(aus!=NULL){
socket_subs = abrir_conexion_tcp_con_servidor(aus->socket, aus->direccion);
send_msg(socket_subs, mensaje->tema,"crear",0);
if(!recibir_confirmacion(socket_subs))break;
close(socket_subs);
aus = aus->next;
}
printf("FIN CREAR\n");
break;
case 2: /* Eliminar tema */
printf("ELIMINAR: INICIO\n");
aux = get_tema(mensaje->tema);
if(aux == NULL){
enviar_mensaje(new_fd, "er");
break;
}
enviar_mensaje(new_fd,"ok");
close(new_fd);
aus = aux->subs;
while(aus!=NULL){
socket_subs = abrir_conexion_tcp_con_servidor(aus->socket, aus->direccion);
send_msg(socket_subs, mensaje->tema,"eliminar",0);
if(!recibir_confirmacion(socket_subs))break;
close(socket_subs);
aus = aus->next;
}
eliminar_tema(mensaje->tema);
printf("ELIMINAR: FIN\n");
break;
case 3: // Alta subs
printf("\nALTA: INICIO ----------- \n");
if(!insertar_subs(mensaje->tema,atoi(mensaje->valor),s)){
enviar_mensaje(new_fd, "er");
break;
}
enviar_mensaje(new_fd,"ok");
printf("ALTA: FIN ----------- \n");
break;
case 4: // BAJA
printf("\nBAJA: INICIO- --- ----\n");
if(!eliminar_subs(mensaje->tema,atoi(mensaje->valor))){
enviar_mensaje(new_fd, "er");
break;
}
enviar_mensaje(new_fd,"ok");
printf("FIN: BAJA ---------------\n");
break;
case 5: //Generar Evento
aux = get_tema(mensaje->tema);
if(aux==NULL){
enviar_mensaje(new_fd, "er");
break;
}
enviar_mensaje(new_fd,"ok");
close(new_fd);
aus = aux->subs;
while(aus!=NULL){
socket_subs = abrir_conexion_tcp_con_servidor(aus->socket, aus->direccion);
send_msg(socket_subs, mensaje->tema,mensaje->valor,0);
close(socket_subs);
aus = aus->next;
}
printf("FIN EVENTO -------------\n");
break;
case 6: //eliminar subscriptor
printf("\nELIMINAR SUBSCRIPTOR: INICIO -------\n");
aux = inicio;
while(aux!=NULL){
if(strcmp(aux->nombre,"meta") == 0){
if(!eliminar_subs(aux->nombre,atoi(mensaje->valor))){
enviar_mensaje(new_fd, "er");
break;
}
enviar_mensaje(new_fd, "ok");
}else{
eliminar_subs(aux->nombre,atoi(mensaje->valor));
}
aux = aux->next;
}
printf("ELIMINAR SUBSCRIPTOR: FIN\n");
break;
}
close(new_fd); // parent doesn't need this
}
return 0;
}
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;
}
t_KER_PRO_CPU_UMV* manejo_conexiones(t_KER_PRO_CPU_UMV* msg){
// ACA SE MANEJAN LOS MENSAJES QUE PUEDEN LLEGAR
if (msg != NULL) {
// SI NO ES NULO
t_KER_PRO_CPU_UMV gen_msg = obtener_nueva_shared_str();
memcpy(&gen_msg,msg,sizeof(t_KER_PRO_CPU_UMV));
printf("el MENSAJE es de tipo: (%d) \n", gen_msg.gen_msg.id_MSJ);
t_KER_PRO_CPU_UMV resp_msg = obtener_nueva_shared_str();
switch(gen_msg.gen_msg.id_MSJ){
case (HANDSHAKE_CPU_UMV):
// SI ES UN HANDSHAKE
puts("PRIMER MENSAJE RECIBIDO SE RESPONDE CON HANDSHAKE\n");
// resp_msg->gen_msg.disconnected = 0;
resp_msg.gen_msg.socket_descriptor = gen_msg.gen_msg.socket_descriptor;
resp_msg.gen_msg.socket_descriptor_server = gen_msg.gen_msg.socket_descriptor_server;
resp_msg.gen_msg.id_MSJ = HANDSHAKE_CPU_UMV;
resp_msg.gen_msg.size_str = sizeof(t_KER_PRO_CPU_UMV);
resp_msg.OK = 1;
puts("ENVIO HANDSHAKE\n");
// Se responde con el mismo handshake del tipo
enviar_mensaje(resp_msg.gen_msg.socket_descriptor_server,resp_msg.gen_msg.id_MSJ,&resp_msg);
puts("mensaje enviado respuesta handshake\n");
break;
case (SOLICITAR_BYTES):
// SI RECIBE SOLICITUD DE DATOS
puts("----------------------RECIBO SOLICITUD DE ENVIO DE DATOS----------------------\n");
resp_msg.gen_msg.socket_descriptor = gen_msg.gen_msg.socket_descriptor;
resp_msg.gen_msg.socket_descriptor_server = gen_msg.gen_msg.socket_descriptor_server;
resp_msg.gen_msg.id_MSJ = SOLICITAR_BYTES;
resp_msg.gen_msg.size_str = sizeof(t_KER_PRO_CPU_UMV);
resp_msg.base_bytes = gen_msg.base_bytes;
resp_msg.offset_bytes = gen_msg.offset_bytes;
resp_msg.tamanio_bytes = gen_msg.tamanio_bytes;
resp_msg.buffer = (char*)malloc(resp_msg.tamanio_bytes);
resp_msg.OK = 1;
printf("CPU solicita los datos [Base,Offset,Tamanio] : %i,%i,%i\n",resp_msg.base_bytes,resp_msg.offset_bytes,resp_msg.tamanio_bytes);
memcpy(resp_msg.buffer,memoria+resp_msg.base_bytes+resp_msg.offset_bytes,resp_msg.tamanio_bytes);
imprimirStream(resp_msg.buffer,resp_msg.tamanio_bytes);
// printf("El buffer del pedido solicitado es: %s\n",resp_msg.buffer);
enviar_mensaje(resp_msg.gen_msg.socket_descriptor_server,resp_msg.gen_msg.id_MSJ, &resp_msg);
puts("-------------------- ENVIO DATOS SOLICITADOS ---------------------------------\n");
break;
case (CAMBIO_PROCESO_ACTIVO):
// Recibo indicacion de programa activo
printf("El id del programa activo es %i\n",gen_msg.PCB.id);
resp_msg.gen_msg.socket_descriptor = gen_msg.gen_msg.socket_descriptor;
resp_msg.gen_msg.socket_descriptor_server = gen_msg.gen_msg.socket_descriptor_server;
resp_msg.gen_msg.id_MSJ = CAMBIO_PROCESO_ACTIVO;
resp_msg.OK = 1;
enviar_mensaje(resp_msg.gen_msg.socket_descriptor_server,resp_msg.gen_msg.id_MSJ, &resp_msg);
break;
case (ENVIAR_BYTES):
// SI RECIBE SOLICITUD DE DATOS
puts("----------------------RECIBO DATOS A SER GRABADOS----------------------\n");
resp_msg.gen_msg.socket_descriptor = gen_msg.gen_msg.socket_descriptor;
resp_msg.gen_msg.socket_descriptor_server = gen_msg.gen_msg.socket_descriptor_server;
resp_msg.gen_msg.id_MSJ = ENVIAR_BYTES;
resp_msg.gen_msg.size_str = sizeof(t_KER_PRO_CPU_UMV);
resp_msg.base_bytes = gen_msg.base_bytes;
resp_msg.offset_bytes = gen_msg.offset_bytes;
resp_msg.tamanio_bytes = gen_msg.tamanio_bytes;
resp_msg.OK = 1;
printf("CPU graba los datos [Base,Offset,Tamanio] : %i,%i,%i\n",resp_msg.base_bytes,resp_msg.offset_bytes,resp_msg.tamanio_bytes);
memcpy(memoria+resp_msg.base_bytes+resp_msg.offset_bytes,resp_msg.buffer,resp_msg.tamanio_bytes);
imprimirStream(resp_msg.buffer,resp_msg.tamanio_bytes);
enviar_mensaje(resp_msg.gen_msg.socket_descriptor_server,resp_msg.gen_msg.id_MSJ, &resp_msg);
puts("-------------------- ENVIO CONFIRMACION DE GRABAR DATOS ---------------------------------\n");
break;
case (DESTRUIR_SEGMENTOS):
puts("----------------------RECIBO AVISO DE DESTRUIR SEGMENTOS----------------------\n");
resp_msg.gen_msg.socket_descriptor = gen_msg.gen_msg.socket_descriptor;
resp_msg.gen_msg.socket_descriptor_server = gen_msg.gen_msg.socket_descriptor_server;
resp_msg.gen_msg.id_MSJ = DESTRUIR_SEGMENTOS;
resp_msg.gen_msg.size_str = sizeof(t_KER_PRO_CPU_UMV);
resp_msg.OK = 1;
enviar_mensaje(resp_msg.gen_msg.socket_descriptor_server,resp_msg.gen_msg.id_MSJ, &resp_msg);
puts("------------- Segmentos destruidos----------------\n");
break;
default:
printf("Recibi un mje default del tipo %i\n",gen_msg.gen_msg.id_MSJ);
puts("NO ENTIENDO EL MENSAJE SOLICITADO\n");
break;
}
// free(resp_msg);
}
puts("Fin primera recepcion");
return NULL;
}