void* conectarseConWorkerRedGlobal(void* params){
parametrosReduccionGlobal* parametrosConexion= malloc(sizeof(parametrosReduccionGlobal));
respuestaReduccionGlobal* infoRedGlobal =(respuestaReduccionGlobal*) params;
respuesta confirmacionWorker;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(infoRedGlobal->ip.cadena,infoRedGlobal->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarFalloEnReduccion();
return 0;
}
log_trace(loggerMaster, "Inicio Red. Global con Worker %d para Job %d", infoRedGlobal->numero, infoRedGlobal->job);
struct stat fileStat;
if(stat(miJob->rutaReductor.cadena,&fileStat) < 0){
printf("No se pudo abrir el archivo\n");
return 0;
}
int fd = open(miJob->rutaReductor.cadena,O_RDWR);
int size = fileStat.st_size;
parametrosConexion->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
parametrosConexion->contenidoScript.longitud = size;
parametrosConexion->archivoTemporal.cadena = strdup(infoRedGlobal->archivoTemporal.cadena);
parametrosConexion->archivoTemporal.longitud = infoRedGlobal->archivoTemporal.longitud;
parametrosConexion->infoWorkers = list_create();
list_add_all(parametrosConexion->infoWorkers,infoRedGlobal->parametros->infoWorkers);
empaquetar(socketWorker, mensajeProcesarRedGlobal, 0, parametrosConexion);
confirmacionWorker = desempaquetar(socketWorker);
if (munmap(parametrosConexion->contenidoScript.cadena, parametrosConexion->contenidoScript.longitud) == -1){
perror("Error un-mmapping the file");
exit(EXIT_FAILURE);
}
close(fd);
switch(confirmacionWorker.idMensaje){
case mensajeOk:
case mensajeRedGlobalCompleta:
log_trace(loggerMaster, "Informo YAMA fin de Reduccion Global en nodo %i",infoRedGlobal->numero);
empaquetar(socketYama, mensajeRedGlobalCompleta, 0 , 0);
estadisticas->cantTareas[RED_GLOBAL]++;
finalizarTiempo(estadisticas->tiempoFinRedGlobal,infoRedGlobal->numero);
break;
case mensajeDesconexion:
case mensajeFalloRedGlobal:
log_trace(loggerMaster, "Informo a YAMA fallo en Reduccion Global del nodo %d.",infoRedGlobal->numero);
estadisticas->cantFallos++;
mandarFalloEnReduccion();
break;
}
return 0;
}
void* conectarseConWorkersTransformacion(void* params) {
parametrosTransformacion* infoTransformacion= (parametrosTransformacion*)params;
respuesta confirmacionWorker;
bloqueYNodo* bloqueOK;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(infoTransformacion->ip.cadena,infoTransformacion->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarAReplanificar(infoTransformacion);
return 0;
}
log_trace(loggerMaster, "Conexion con Worker %d para bloque %d", infoTransformacion->numero, infoTransformacion->bloquesConSusArchivos.numBloque);
struct stat fileStat;
if(stat(miJob->rutaTransformador.cadena,&fileStat) < 0){
printf("No se pudo abrir el archivo\n");
return 0;
}
int fd = open(miJob->rutaTransformador.cadena,O_RDWR);
int size = fileStat.st_size;
infoTransformacion->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
infoTransformacion->contenidoScript.longitud = size;
empaquetar(socketWorker, mensajeProcesarTransformacion, 0, infoTransformacion);
confirmacionWorker = desempaquetar(socketWorker);
if (munmap(infoTransformacion->contenidoScript.cadena, infoTransformacion->contenidoScript.longitud) == -1){
perror("Error un-mmapping the file");
exit(EXIT_FAILURE);
}
close(fd);
switch(confirmacionWorker.idMensaje){
case mensajeTransformacionCompleta:
log_trace(loggerMaster, "Informo a YAMA fin Transformacion para bloque %d en nodo %d.",infoTransformacion->bloquesConSusArchivos.numBloque,infoTransformacion->numero);
bloqueOK = malloc(sizeof(bloqueYNodo));
bloqueOK->workerId = infoTransformacion->numero;
bloqueOK->bloque = infoTransformacion->bloquesConSusArchivos.numBloque;
empaquetar(socketYama, mensajeTransformacionCompleta, 0 , bloqueOK);
finalizarTiempo(estadisticas->tiempoFinTrans,bloqueOK->bloque);
estadisticas->cantTareas[TRANSFORMACION]++;
free(bloqueOK);
break;
case mensajeDesconexion:
mandarAReplanificar(infoTransformacion);
break;
}
return 0;
}
void esperarInstruccionesDeYama() {
respuesta instruccionesYama;
respuestaSolicitudTransformacion* infoTransformacion ;
nodosRedLocal* infoRedLocal;
respuestaReduccionGlobal* infoRedGlobal;
workerDesdeYama* worker;
respuestaAlmacenamiento* almacenamiento;
int fallo;
while (1) {
instruccionesYama = desempaquetar(socketYama);
switch (instruccionesYama.idMensaje) {
case mensajeRespuestaTransformacion:
infoTransformacion = (respuestaSolicitudTransformacion*)instruccionesYama.envio;
log_trace(loggerMaster, "Recibo Transformacion de YAMA.");
inicializarTiemposTransformacion(infoTransformacion);
crearHilosConexionTransformacion(infoTransformacion);
break;
case mensajeRespuestaRedLocal:
infoRedLocal = (nodosRedLocal*)instruccionesYama.envio;
log_trace(loggerMaster, "Recibo Reduccion Local en nodo %d de YAMA.",infoRedLocal->numeroNodo);
crearHilosConexionRedLocal(infoRedLocal);
break;
case mensajeDesconexion:
log_error(loggerMaster, "Error inesperado al recibir instrucciones de YAMA.");
exit(1);
break;
case mensajeReplanificacion:
worker= instruccionesYama.envio;
log_trace(loggerMaster, "Recibo Replanificacion para bloque en nodo %d de YAMA.",worker->numeroWorker);
crearHilosPorBloqueTransformacion(worker);
break;
case mensajeFinJob:
fallo = *(int*)instruccionesYama.envio;
log_trace(loggerMaster, "Finaliza job.");
finalizarJob(fallo);
break;
case mensajeRespuestaRedGlobal:
infoRedGlobal = (respuestaReduccionGlobal*)instruccionesYama.envio;
log_trace(loggerMaster, "Recibo Reduccion Global en nodo %d de YAMA.",infoRedGlobal->numero);
enviarAEncargadoRedGlobal(infoRedGlobal);
break;
case mensajeRespuestaAlmacenamiento:
almacenamiento = (respuestaAlmacenamiento*)instruccionesYama.envio;
log_trace(loggerMaster, "Recibo Almacenamiento Final en nodo %d de YAMA.",almacenamiento->nodo);
enviarAlmacenamientoFinal(almacenamiento);
break;
}
}
}
void* conectarseConWorkersRedLocal(void* params){
parametrosReduccionLocal* infoRedLocal= (parametrosReduccionLocal*)params;
respuesta confirmacionWorker;
int numeroNodo;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(infoRedLocal->ip.cadena,infoRedLocal->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarFalloEnReduccion();
return 0;
}
log_trace(loggerMaster, "Conexion con Worker %d para estos tmp %d", infoRedLocal->numero, list_size(infoRedLocal->archivosTemporales));
struct stat fileStat;
if(stat(miJob->rutaReductor.cadena,&fileStat) < 0){
printf("No se pudo abrir el archivo\n");
return 0;
}
int fd = open(miJob->rutaReductor.cadena,O_RDWR);
int size = fileStat.st_size;
infoRedLocal->contenidoScript.cadena = mmap(NULL,size,PROT_READ,MAP_SHARED,fd,0);
infoRedLocal->contenidoScript.longitud = size;
empaquetar(socketWorker, mensajeProcesarRedLocal, 0, infoRedLocal);
confirmacionWorker = desempaquetar(socketWorker);
if (munmap(infoRedLocal->contenidoScript.cadena, infoRedLocal->contenidoScript.longitud) == -1){
perror("Error un-mmapping the file");
exit(EXIT_FAILURE);
}
close(fd);
switch(confirmacionWorker.idMensaje){
case mensajeRedLocalCompleta:
log_trace(loggerMaster, "Informo a YAMA fin Reduccion Local en nodo %d.",infoRedLocal->numero);
numeroNodo = *(int*)confirmacionWorker.envio;
empaquetar(socketYama, mensajeRedLocalCompleta, 0 , &numeroNodo);
finalizarTiempo(estadisticas->tiempoFinRedLocal,numeroNodo);
estadisticas->cantTareas[RED_LOCAL]++;
break;
case mensajeDesconexion:
case mensajeFalloRedLocal:
log_trace(loggerMaster, "Informo a YAMA fallo en Reduccion Local en nodo %d.",infoRedLocal->numero);
estadisticas->cantFallos++;
mandarFalloEnReduccion();
break;
}
return 0;
}
void conectarseConYama(char* ip, int port) {
socketYama = crearSocket();
struct sockaddr_in direccion = cargarDireccion(ip, port);
conectarCon(direccion, socketYama, 2); //2 id master
respuesta respuestaHandShake = desempaquetar(socketYama);
if(respuestaHandShake.idMensaje != mensajeOk){
log_error(loggerMaster, "Conexion fallida con YAMA");
perror("Conexion fallida con YAMA");
log_destroy(loggerMaster);
exit(1);
}
log_trace(loggerMaster, "Conexion con Yama establecida");
}
void enviarJobAYama(job* miJob) {
empaquetar(socketYama,mensajeSolicitudTransformacion, 0 ,miJob);
log_trace(loggerMaster,"Enviando solicitud de etapa Transformacion a YAMA");
respuesta respuestaYama = desempaquetar(socketYama);
if(respuestaYama.idMensaje != mensajeOk){
log_error(loggerMaster,"No se pudo iniciar correctamente el job");
exit(1);
}
log_trace(loggerMaster, "Envio correcto de datos a Yama.");
}
int main (int argc, char* argv[])
{
int bitsPorMuestreo;
if ( argc != 4 ){
printf( "Faltan argumentos - Deben ser 3 archivos:\n" );
printf( " - archivo de entrada 1 (monofonico)\n" );
printf( " - archivo de entrada 2 (monofonico)\n" );
printf( " - archivo de salida (esfonico)\n" );
system( "pause" );
return -1;
}
printf( "Archivo fuente 1 %s\n", argv[1] );
printf( "Archivo fuente 2 %s\n", argv[2] );
printf( "Archivo Destino %s\n", argv[3] );
system( "pause" );
cargarWAVE( &Header, &pistaEntrada1, argv[1] );
cargarWAVE( &Header, &pistaEntrada2, argv[2] );
bitsPorMuestreo = detectarBitsPorMuestreo( &pistaEntrada1 );
if ( bitsPorMuestreo != detectarBitsPorMuestreo( &pistaEntrada2 ) ){
printf( "Los archivos tienen diferente numero de bits por muestreo\n" );
}
empaquetar( &pistaEntrada1, bitsPorMuestreo );
empaquetar( &pistaEntrada2, bitsPorMuestreo );
pistaSalida.bitsPerSample = bitsPorMuestreo;
pistaSalida.numSamples = pistaEntrada1.numSamples;
pistaSalida.SoundLength = 2*pistaEntrada1.SoundLength;
pistaSalida.Sample = (unsigned short*)malloc( pistaSalida.SoundLength );
unirArchivosWAVE( pistaEntrada1.numSamples, pistaEntrada1.Sample, pistaEntrada2.Sample, pistaSalida.Sample, bitsPorMuestreo );
corregirHeader( &Header );
desempaquetar( &pistaSalida, bitsPorMuestreo );
escribirWAVE( &Header, &pistaSalida, argv[3] );
printf ("Concluy� exitosamente.\n");
system("pause");
return 0;
}
void* conectarseConWorkerAlmacenamiento(void* params){
parametrosAlmacenamiento* parametrosConexion= malloc(sizeof(parametrosAlmacenamiento));
respuestaAlmacenamiento* almacenamiento =(respuestaAlmacenamiento*) params;
respuesta confirmacionWorker ;
int socketWorker = crearSocket();
struct sockaddr_in direccion = cargarDireccion(almacenamiento->ip.cadena,almacenamiento->puerto);
if(!conectarCon(direccion, socketWorker, 2)){//2 id master
mandarFalloEnReduccion();
return 0;
}
log_trace(loggerMaster, "Inicio Almacenamiento Final con Worker %d", almacenamiento->nodo);
parametrosConexion->rutaAlmacenamiento.longitud = miJob->rutaResultado.longitud;
parametrosConexion->rutaAlmacenamiento.cadena= strdup(miJob->rutaResultado.cadena);
parametrosConexion->archivoTemporal.cadena = strdup(almacenamiento->archivo.cadena);
parametrosConexion->archivoTemporal.longitud = almacenamiento->archivo.longitud;
empaquetar(socketWorker, mensajeProcesarAlmacenamiento, 0, parametrosConexion);
confirmacionWorker = desempaquetar(socketWorker);
switch(confirmacionWorker.idMensaje){
case mensajeAlmacenamientoCompleto:
log_trace(loggerMaster, "Informo YAMA fin de Almacenamiento Final en nodo.",almacenamiento->nodo);
empaquetar(socketYama, mensajeAlmacenamientoCompleto, 0 , 0);
break;
case mensajeFalloAlmacenamiento:
case mensajeDesconexion:
log_trace(loggerMaster, "Informo a YAMA fallo en Almacenamiento Final del nodo %d.",almacenamiento->nodo);
estadisticas->cantFallos++;
empaquetar(socketYama, mensajeFalloAlmacenamiento, 0 , 0);
break;
}
return 0;
}
