void ejecutar3RutinasDeMapYReducirlas()
{
ejecutar3RutinasDeMap();
/*
* Ejecutar reduce sobre los resultados de map
*/
printf("Ejecutando reduce sobre la salida de los maps anteriores\n");
Archivo *entrada1Reduce = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque1", LECTURA);
Archivo *entrada2Reduce = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque4", LECTURA);
Archivo *entrada3Reduce = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque8", LECTURA);
Archivo *salidaReduce = (Archivo*) newArchivoLocal("/tmp/salidaReduce", ESCRITURA);
t_list *listaDeArchivosAReducir = list_create();
list_add(listaDeArchivosAReducir, entrada1Reduce);
list_add(listaDeArchivosAReducir, entrada2Reduce);
list_add(listaDeArchivosAReducir, entrada3Reduce);
ejecutarRutinaDeReduce(RUTINA_REDUCE, listaDeArchivosAReducir, salidaReduce);
cerrarArchivo(entrada1Reduce);
cerrarArchivo(entrada2Reduce);
cerrarArchivo(entrada3Reduce);
cerrarArchivo(salidaReduce);
}
static void inicializar()
{
listaArchivos = list_create();
// Crear archivo apareado
Archivo *archivoLocal1 = (Archivo *) newArchivoLocal(PATH_ARCHIVO_1, ESCRITURA);
escribirRegistro(archivoLocal1, ARCHIVO1_REGISTRO0_0);
escribirRegistro(archivoLocal1, ARCHIVO1_REGISTRO1_2);
escribirRegistro(archivoLocal1, ARCHIVO1_REGISTRO2_5);
escribirRegistro(archivoLocal1, ARCHIVO1_REGISTRO3_6);
escribirRegistro(archivoLocal1, ARCHIVO1_REGISTRO4_7);
cerrarArchivo(archivoLocal1);
Archivo *archivoLocal2 = (Archivo *) newArchivoLocal(PATH_ARCHIVO_2, ESCRITURA);
escribirRegistro(archivoLocal2, ARCHIVO2_REGISTRO0_1);
escribirRegistro(archivoLocal2, ARCHIVO2_REGISTRO1_3);
escribirRegistro(archivoLocal2, ARCHIVO2_REGISTRO2_4);
cerrarArchivo(archivoLocal2);
archivoLocal1 = (Archivo *) newArchivoLocal(PATH_ARCHIVO_1, LECTURA);
archivoLocal2 = (Archivo *) newArchivoLocal(PATH_ARCHIVO_2, LECTURA);
list_add(listaArchivos, archivoLocal1);
list_add(listaArchivos, archivoLocal2);
archivoApareado = (Archivo *) newArchivoApareado(listaArchivos);
// Fin de crear archivo apareado
}
void obtenerSiguienteConjuntosRegistrosRemotos(SocketConecta *conexion, ArchivoLocal *archivoALeer)
{
if(! estaConectado(conexion))
{
cerrarArchivo((Archivo *)archivoALeer);
finalizarAtencionAConexion(conexion);
}
uint64_t tamanioCojuntoRegistros = 0;
char conjuntoRegistros[SIZE_CONJUNTO_REGISTROS];
conjuntoRegistros[0] = '\0';
uint64_t tamanioSiguienteRegistro = obtenerTamanioSiguienteRegistro(archivoALeer);
while(tamanioSiguienteRegistro > 0 && tamanioCojuntoRegistros + tamanioSiguienteRegistro + 1 < SIZE_CONJUNTO_REGISTROS)
{
char *registro = obtenerRegistro((Archivo *) archivoALeer);
tamanioCojuntoRegistros += strlen(registro);
strcat(conjuntoRegistros, registro);
free(registro);
tamanioSiguienteRegistro = obtenerTamanioSiguienteRegistro(archivoALeer);
}
if (tamanioCojuntoRegistros == 0)
enviarMensaje(conexion, &tamanioCojuntoRegistros, sizeof(uint64_t));
else
enviarTodo(conexion, conjuntoRegistros, tamanioCojuntoRegistros);
}
static void cerrarArchivoApareado(Archivo *archivo)
{
ArchivoApareado *archivoApareado = (ArchivoApareado *) archivo;
int i;
for (i = 0; i < list_size(archivoApareado->listaArchivos); i++)
{
Archivo *a = list_get(archivoApareado->listaArchivos, i);
cerrarArchivo(a);
}
}
void puedeEscribirRegistro()
{
Archivo *archivoEscritura = (Archivo *) newArchivoLocal(PATH_ARCHIVO_ESCRITURA, ESCRITURA);
escribirRegistro(archivoEscritura, NUEVO_REGISTRO_CON_SALTO_DE_LINEA);
cerrarArchivo(archivoEscritura);
Archivo *archivoLectura = (Archivo *) newArchivoLocal(PATH_ARCHIVO_ESCRITURA, LECTURA);
buffer = obtenerRegistro(archivoLectura);
CU_ASSERT_STRING_EQUAL(buffer, NUEVO_REGISTRO_CON_SALTO_DE_LINEA);
}
static void ejecutar3RutinasDeMap()
{
inicializarEspacioDeDatos();
printf("Ejecutando map sobre bloque 1\n");
BloqueDatos *bloque1 = getBloque(espacioDeDatos, 1);
Archivo *salidaMapBloque1 = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque1", ESCRITURA);
ejecutarRutinaDeMap(RUTINA_MAP, bloque1, salidaMapBloque1);
cerrarArchivo(salidaMapBloque1);
printf("Ejecutando map sobre bloque 4\n");
BloqueDatos *bloque4 = getBloque(espacioDeDatos, 4);
Archivo *salidaMapBloque4 = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque4", ESCRITURA);
ejecutarRutinaDeMap(RUTINA_MAP, bloque4, salidaMapBloque4);
cerrarArchivo(salidaMapBloque4);
printf("Ejecutando map sobre bloque 8\n");
BloqueDatos *bloque8 = getBloque(espacioDeDatos, 8);
Archivo *salidaMapBloque8 = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque8", ESCRITURA);
ejecutarRutinaDeMap(RUTINA_MAP, bloque8, salidaMapBloque8);
cerrarArchivo(salidaMapBloque8);
}
void alEscribirNoAgregaSaltoDeLineaSiYaLoTiene()
{
Archivo *archivoEscritura = (Archivo*) newArchivoLocal(PATH_ARCHIVO_ESCRITURA, ESCRITURA);
escribirRegistro(archivoEscritura, NUEVO_REGISTRO_CON_SALTO_DE_LINEA);
cerrarArchivo(archivoEscritura);
Archivo *archivoLectura = (Archivo*) newArchivoLocal(PATH_ARCHIVO_ESCRITURA, LECTURA);
buffer = obtenerRegistro(archivoLectura);
free(buffer);
buffer = obtenerRegistro(archivoLectura);
CU_ASSERT_PTR_EQUAL(buffer, NULL);
}
void terminoDePedir(SocketConecta *conexion, ArchivoLocal *archivoALeer)
{
loguear(LOG_LEVEL_INFO, "Se termino la transferencia del archivo");
if(! estaConectado(conexion))
{
cerrarArchivo((Archivo*) archivoALeer);
finalizarAtencionAConexion(conexion);
}
char termino = SI_TERMINO;
enviarMensaje(conexion,&termino,1);
cerrarConexionYArchivo(conexion,archivoALeer);
}
int tsce_init(){
FILE *pf;
int i = 100;
tsce_t_info info;
srand48(time(NULL)); //solo linux
if(!abrirArchivo(&pf,TSCE_DATOS,"wb",1))
return 0;
while(i){
info.x = rand() % (3+1);
setArchivo(&pf,&info);
i--;
}
cerrarArchivo(&pf,1);
return 1;
}
static int ejecutarTarea(Tarea *tarea, EspacioDatos *espacioDeDatos)
{
int resultado;
Archivo *archivoSalidaRutina = obtenerArchivoSalidaRutina(tarea->nombreArchivoResultado);
if (esMap(tarea))
{
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Ejecutando rutina de map\n\tBloque : %d\n\tRutina: %s\n\tSalida: %s",
tarea->bloque, tarea->pathRutina, tarea->nombreArchivoResultado);
BloqueDatos *bloque = getBloque(espacioDeDatos, tarea->bloque);
resultado = ejecutarRutinaDeMap(tarea->pathRutina, bloque, archivoSalidaRutina);
free(bloque);
}
else
{
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Ejecutando rutina de reduce. Salida: %s", tarea->nombreArchivoResultado);
resultado = ejecutarRutinaDeReduce(tarea->pathRutina, tarea->listaArchivosRemotos, archivoSalidaRutina);
}
cerrarArchivo(archivoSalidaRutina);
return resultado;
}
ArchivoLocal *tengoArchivo(SocketConecta *conexion)
{
char *pathCompleto = obtenerPathCompleto(conexion);
loguear(LOG_LEVEL_INFO, "Se recibio un pedido de archivo de parte de un nodo. Archivo: %s", pathCompleto);
ArchivoLocal *archivoALeer = newArchivoLocal(pathCompleto, LECTURA);
if (! estaConectado(conexion))
{
if (archivoALeer != NULL)
cerrarArchivo((Archivo *)archivoALeer);
finalizarAtencionAConexion(conexion);
}
if (archivoALeer == NULL)
enviarMensaje(conexion,NO_TENGO_ARCHIVO,1);
else
enviarMensaje(conexion,SI_TENGO_ARCHIVO,1);
return archivoALeer;
}
int main(int args, char **argv)
{
FILE *entrada;
char cadena[MAX_SIZE];
if(argv[1] == NULL)
{
printf("Cadena: ");
fgets(cadena, MAX_SIZE, stdin);
}
else
{
if(strcmp(argv[1], "--archivo") == 0)
{
if(argv[2] == NULL)
{
fprintf(stderr, "Archivo no especificado\n");
return -2;
}
else
{
abrirArchivo(argv[2], &entrada);
fgets(cadena, MAX_SIZE, entrada);
cerrarArchivo(&entrada);
}
}
else
{
fprintf(stderr, "Argumento invalido\n");
return -1;
}
}
ejercicioDos(getValorNumericoCadena(cadena));
return 0;
}
void mapSobreBloqueDeDatosYReduceSobreArchivosLocalesYRemotos(int argc, char *argv[])
{
if (argc < 2)
{
fprintf(stderr, "Warning: tenes que indicar si es cliente o servidor para probar el protocolo\n");
return;
}
if (strcmp(argv[1], "servidor") == 0)
{
Archivo *archivoLocal = (Archivo*) newArchivoLocal(PATH_ARCHIVO, ESCRITURA);
long i = 0;
for (i = 1; i <= 100000; i ++)
{
char registro[100];
sprintf(registro, "1\n");
escribirRegistro(archivoLocal, registro);
}
cerrarArchivo(archivoLocal);
escucharConexionesANodo(PUERTO, NULL);
}
else
{
char *ipServer;
if (argc == 3)
ipServer = strdup(argv[2]);
else
ipServer = strdup("127.0.0.1");
ejecutar3RutinasDeMap();
/*
* Ejecutar reduce sobre los resultados de map
*/
printf("Ejecutando reduce sobre la salida de los maps anteriores y 1 de red!\n");
Archivo *entrada1Reduce = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque1", LECTURA);
Archivo *entrada2Reduce = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque4", LECTURA);
Archivo *entrada3Reduce = (Archivo*) newArchivoLocal("/tmp/salidaMapBloque8", LECTURA);
SocketConecta *conexion = newSocketConecta(ipServer, PUERTO);
conectarAServidor(conexion);
Archivo *archivoRemoto = (Archivo*) newArchivoRemoto(NOMBRE_ARCHIVO, conexion);
t_list *listaDeArchivosAReducir = list_create();
list_add(listaDeArchivosAReducir, entrada1Reduce);
list_add(listaDeArchivosAReducir, entrada2Reduce);
list_add(listaDeArchivosAReducir, entrada3Reduce);
list_add(listaDeArchivosAReducir, archivoRemoto);
Archivo *salidaReduce = (Archivo*) newArchivoLocal("/tmp/salidaReduce", ESCRITURA);
int resultadoRutina = ejecutarRutinaDeReduce(RUTINA_REDUCE, listaDeArchivosAReducir, salidaReduce);
if (resultadoRutina == RUTINA_OK)
printf("La rutina de reduce termino OK\n");
else if (resultadoRutina == RUTINA_ERROR_EJECUCION)
printf("La rutina de reduce termino con errores: Error de ejecucion\n");
else if(resultadoRutina == RUTINA_ERROR_LECTURA_DATOS)
printf("La rutina de reduce termino con errores: Error de lectura de datos\n");
cerrarArchivo(entrada1Reduce);
cerrarArchivo(entrada2Reduce);
cerrarArchivo(entrada3Reduce);
cerrarArchivo(archivoRemoto);
cerrarArchivo(salidaReduce);
}
}
static void cerrarConexionYArchivo(SocketConecta *conexion, ArchivoLocal *archivoALeer)
{
cerrarArchivo((Archivo *)archivoALeer);
cerrarSocketConecta(conexion);
}
void transferirRegistrosRemotos(int argc, char *argv[])
{
/*
* PAra ejecutar las pruebas:
* ./NodoTest servidor
*
* ./NodoTest cliente
*/
if (argc < 2)
{
fprintf(stderr, "Warning: tenes que indicar si es cliente o servidor para probar el protocolo\n");
return;
}
if (strcmp(argv[1], "servidor") == 0)
{
Archivo *archivoLocal = (Archivo*) newArchivoLocal(PATH_ARCHIVO, ESCRITURA);
int i = 0;
for (i = 0; i <= 100000; i ++)
{
char registro[100];
sprintf(registro, "REGISTRO %d\n", i);
escribirRegistro(archivoLocal, registro);
}
cerrarArchivo(archivoLocal);
escucharConexionesANodo("12345", NULL);
}
else
{
char *ipServer;
if (argc == 3)
ipServer = strdup(argv[2]);
else
ipServer = strdup("127.0.0.1");
SocketConecta *conexion = newSocketConecta(ipServer, "12345");
conectarAServidor(conexion);
Archivo *archivoRemoto = (Archivo*) newArchivoRemoto(NOMBRE_ARCHIVO, conexion);
char *registro = obtenerRegistro(archivoRemoto);
while (registro != NULL && ! huboError(registro))
{
printf("Registro recibido: %s", registro);
free(registro);
registro = obtenerRegistro(archivoRemoto);
}
if (registro == NULL)
{
printf("Recibi el ultimo regisro\n");
cerrarArchivo(archivoRemoto);
}
else
printf("Se desconecto el server");
cerrarSocketConecta(conexion);
printf("Cerre la conexion\n"); fflush(stdout);
}
}
void cerrarUnArchivo(void *archivo)
{
cerrarArchivo((Archivo *)archivo);
}
