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); }