void init(){
LOGGER = log_create(LOG_PATH, "MaRTA", true, LOG_LEVEL_DEBUG);
CONF = config_create(CONF_PATH); //HACK estaba mal el nombre de la funcion o no la encontraba o no se
if(LOGGER == NULL){
perror("ERROR! no pudo levantar ni el log!");
exit(EXIT_FAILURE);
}
if(CONF == NULL){
log_error(LOGGER, "\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION\n( Don't PANIC! Si estas por consola ejecuta: ln -s ../%s %s )\n\n"
, CONF_PATH
, CONF_PATH);
exit(EXIT_FAILURE);
}
// if(!validarConfig()){ //HACK no lo necesitaba, no entendi el codigo del map y no me servia, anda :P
// log_error(LOGGER, "No pudo obtenerse alguno de los parametros de configuracion");
// exit(EXIT_FAILURE);
// }
mapa_nodos = dictionary_create();
lista_jobs = list_create();
pthread_mutex_init(&mutex_mapa_nodos, NULL);
pthread_mutex_init(&mutex_lista_jobs, NULL);
log_info(LOGGER, "intenta conectarse a la ip %s con puerto %d", config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
while (socketFS == -1) {
log_info(LOGGER, "Filesystem no levantado. Se reintenta conexion en unos segundos");
sleep(5);
socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
}
header_t header;
initHeader(&header);
header.tipo = MARTA_TO_FS_HANDSHAKE;
header.largo_mensaje = 0;
header.cantidad_paquetes = 1;
log_info(LOGGER, "Conectado a FS! envio header %s", getDescription(header.tipo));
enviar_header(socketFS, &header);
t_mensaje mensaje;
memset(&mensaje, 0, sizeof(t_mensaje));
recibir_t_mensaje(socketFS, &mensaje);
log_info(LOGGER, "recibo respuesta %s de FS", getDescription(mensaje.tipo));
while(mensaje.tipo != ACK){
log_info(LOGGER, "Todavia el FS no esta disponible. Header recibido: %s. Reintento en 5 segundos", getDescription(header.tipo));
sleep(5);
enviar_header(socketFS, &header);
recibir_t_mensaje(socketFS, &mensaje);
}
recibirNodosFS();
log_info(LOGGER, "%s: FS está operativo. Continúo", getDescription(header.tipo));
}
int main(void) {
tipoConfigCPU* configuracion = cargarArchivoDeConfiguracionDeCPU("cfgCPU");
socketCpu = crearSocket();
conectarAServidor(socketCpu,configuracion->ipMemoria,configuracion->puertoMemoria);
pid=19;
/*
ejecutarInstruccion(INICIAR,4,"");
ejecutarInstruccion(ESCRIBIR,1,"negro");
ejecutarInstruccion(ESCRIBIR,3,"blanco");
ejecutarInstruccion(LEER,3,"");*/
/*ejecutarInstruccion(INICIAR,1,"");
ejecutarInstruccion(ESCRIBIR,0,"loboNegro");
ejecutarInstruccion(ESCRIBIR,1,"javiGorro");*/
ejecutarInstruccion(INICIAR,3,"");
ejecutarInstruccion(ESCRIBIR,0,"todoOk");
ejecutarInstruccion(LEER,1,"javiGorro");
getchar();
liberarSocket(socketCpu);
destruirConfigCPU(configuracion);
return EXIT_SUCCESS;
}
static t_list *convertirMensajeAListaArchivosRemotos(char *mensaje)
{
t_list *archivosRemotos = list_create();
char **datosArchivosRemotos = string_split(mensaje, SEPARADOR_ARCHIVOS);
int i;
for (i = 0; datosArchivosRemotos[i] != NULL; i ++)
{
char **datosArchivo = string_split(datosArchivosRemotos[i], SEPARADOR_CAMPOS_ARCHIVO);
Archivo *archivoAReducir;
if (esMiIpYPuerto(datosArchivo[0], datosArchivo[1]))
{
char *pathArchivo = obtenerPathDeArchivoEnEspacioTemporal(datosArchivo[2]);
archivoAReducir = (Archivo *) newArchivoLocal(pathArchivo, LECTURA);
free(pathArchivo);
}
else
{
SocketConecta *conexion = newSocketConecta(datosArchivo[0], datosArchivo[1]);
conectarAServidor(conexion);
archivoAReducir = (Archivo*) newArchivoRemoto(datosArchivo[2], conexion);
}
list_add(archivosRemotos, archivoAReducir);
free(datosArchivo);
}
free(datosArchivosRemotos);
return archivosRemotos;
}
void *enviarMapperYObtenerResultado(void *arghiloM)
{
t_hiloMapper *hiloM = arghiloM;
logOperacion("Comienza hilo mapper, ID_TAREA: %d...",hiloM->idMap);
SocketConecta *conectarANodo = newSocketConecta(hiloM->ipNodo,hiloM->puertoNodo);
conectarAServidor(conectarANodo);
if(!estaConectado(conectarANodo))
{
//Le aviso a marta que la rutina fallo porque se desconecto el nodo
pthread_mutex_lock(&semaforoMarta);
int dos=2;
enviarMensaje(hiloM->conectarAMarta,&dos,sizeof(int));
enviarMensaje(hiloM->conectarAMarta,&hiloM->idMap,sizeof(int));
pthread_mutex_unlock(&semaforoMarta);
logCabeceraEnvia("Fallo map, se desconecto el nodo");
mostrarFinalizacion(2,hiloM->idMap);
pthread_exit(0);
}
if(!estaConectado(hiloM->conectarAMarta))
{
logOperacion("Finalizo el hilo mapper (ID_TAREA: %d) porque se desconecto marta", hiloM->idMap);
//El hilo se finaliza a si mismo
pthread_exit(0);
}else
{
//Aviso al nodo que soy un job
char soyJob = 'J';
enviarMensaje(conectarANodo,&soyJob,1);
logCabeceraEnvia("Soy job");
//Mando el contenido de la rutina al Nodo
enviarArchivoANodo(conectarANodo,hiloM->mapper);
//Le aviso que es un map y le mando el bloque
int tamanioMap = 4;
enviarMensaje(conectarANodo,&tamanioMap, sizeof(int));
enviarMensaje(conectarANodo,"map",tamanioMap);
logCabeceraEnvia("Hacer un map");
enviarMensaje(conectarANodo,&(hiloM->bloque),sizeof(int));
logCabeceraEnvia("Bloque del nodo");
//Envio al nodo donde se guarda el resultado del map
int tamanio = strlen(hiloM->resulMap);
enviarMensaje(conectarANodo,&tamanio,sizeof(int));
enviarMensaje(conectarANodo,hiloM->resulMap,tamanio);
logCabeceraEnvia("Nombre de archivo de resultado");
//Recibo el resultado de la operacion
int resultado=0;
/*0:Salio bien
*1:salio mal, fallo la rutina
*2:se desconecto el nodo, lo mando al principio
*/
recibirYChequearConexionNodo(conectarANodo,&resultado,sizeof(int),hiloM->conectarAMarta,hiloM->idMap);
logCabeceraRecibe("Resultado de map");
//Envio el resultado a Marta (Si se desconecto el nodo tambien mando mensaje aparte)
pthread_mutex_lock(&semaforoMarta);
enviarMensaje(hiloM->conectarAMarta,&resultado,sizeof(int));
logCabeceraEnvia("Resultado de map");
enviarMensaje(hiloM->conectarAMarta,&hiloM->idMap,sizeof(int));
logCabeceraEnvia("Id de map");
pthread_mutex_unlock(&semaforoMarta);
mostrarFinalizacion(resultado,hiloM->idMap);
//Borro el socket y el semaforo del nodo
deleteSocketConecta(conectarANodo);
//Libero la estructura del hilo
liberarEstructuraHiloMap(hiloM);
}
return 0;
}
int main(void) {
//////////////////////////INICIALIZACION DE VARIABLES////////////////////////////////
tipoConfigMemoria* configuracion = cargarArchivoDeConfiguracionDeMemoria("cfgMemoria");
int socketParaCpus = crearSocket();
int socketParaSwap = crearSocket();
int socketCpuEntrante;
bool memoriaActiva = true;
//--------------ACA EMPIEZA FERNILANDIA--------------------------
//t_list* listaRAM = list_create();
//t_list* listaTLB = list_create();
//t_list* listaAdministracionPaginas = list_create();
fd_set listaPrincipal;
fd_set listaFiltrada;
FD_ZERO(&listaPrincipal);
FD_ZERO(&listaFiltrada);
FD_SET(socketParaCpus,&listaPrincipal);
tipoEstructuraMemoria* datosMemoria = malloc(sizeof(tipoEstructuraMemoria));
//datosMemoria->listaRAM = listaRAM;
//datosMemoria->listaTLB = listaTLB;
datosMemoria->socketSWAP = socketParaSwap;
datosMemoria->maximoSocket = socketParaCpus;
datosMemoria->configuracion = configuracion;
datosMemoria->cpusATratar = &listaFiltrada;
//datosMemoria->administradorPaginas = listaAdministracionPaginas;
datosMemoria->memoriaActiva = &memoriaActiva;
datosMemoria->socketCpus = socketParaCpus;
setearEstructuraMemoria(datosMemoria);
//-------------END OF FERNILANDIA-----------------------------------
asociarAPuerto(socketParaCpus,configuracion->puertoDeEscucha);
conectarAServidor(socketParaSwap,configuracion->ipSWAP,configuracion->puertoSWAP);
escucharConexiones(socketParaCpus,maxConexionesEntrantes);
pthread_t hiloSignals;
crearThread(&hiloSignals,funcionPrueba,datosMemoria);
/////////////////////////////////////////////////////////////////////////////////////
while(memoriaActiva){
FD_ZERO(&listaFiltrada);
listaFiltrada = listaPrincipal;
select(datosMemoria->maximoSocket+1,&listaFiltrada,NULL,NULL,NULL);
if(FD_ISSET(socketParaCpus,&listaFiltrada)){
socketCpuEntrante = crearSocketParaAceptarSolicitudes(socketParaCpus);
FD_SET(socketParaCpus,&listaPrincipal);
FD_SET(socketCpuEntrante,&listaFiltrada);
datosMemoria->maximoSocket = maximoEntre(datosMemoria->maximoSocket,socketCpuEntrante);
}
tratarPeticiones(&datosMemoria);
}
destruirConfigMemoria(configuracion);
return EXIT_SUCCESS;
}
int conectarAFilesystemYSubirArchivo(char *nombreArchivo, char *pathArchivoEnMDFS)
{
ConfiguracionNodo *config = obtenerConfiguracionNodo();
SocketConecta *conexion = newSocketConecta(config->ip_fs, config->puerto_fs);
conectarAServidor(conexion);
if (! estaConectado(conexion))
return SUBIDA_FALLO;
char pedidoSubidaArchivo = MENSAJE_PEDIDO_SUBIDA_ARCHIVO;
enviarMensaje(conexion, &pedidoSubidaArchivo, 1);
int contador = strlen(pathArchivoEnMDFS);
while(pathArchivoEnMDFS[contador] != '/')
contador--;
char *pathDirectorio;
if (contador == 0)
pathDirectorio = "/";
else
pathDirectorio = string_substring_until(pathArchivoEnMDFS, contador);
char *nombre = string_substring_from(pathArchivoEnMDFS, contador + 1);
int longitudMensaje = strlen(pathDirectorio);
enviarMensaje(conexion, &longitudMensaje, sizeof(int));
enviarMensaje(conexion, pathDirectorio, longitudMensaje);
longitudMensaje = strlen(nombre);
enviarMensaje(conexion, &longitudMensaje, sizeof(int));
enviarMensaje(conexion, nombre, longitudMensaje);
char *pathEspacioTemporal = obtenerPathEspacioTemporal();
char *rutaArchivo = malloc(strlen(pathEspacioTemporal) + strlen(nombreArchivo) + 2);
strcpy(rutaArchivo, pathEspacioTemporal);
strcat(rutaArchivo, "/");
strcat(rutaArchivo, nombreArchivo);
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subiendo archivo %s al MDFS en %s", rutaArchivo, pathArchivoEnMDFS);
FILE *contenidoArchivo = fopen(rutaArchivo, "r");
char buffer[SIZE_BLOQUE_DE_ENVIO + 1];
size_t bytesLeidos = fread(buffer, 1, SIZE_BLOQUE_DE_ENVIO, contenidoArchivo);
while(bytesLeidos > 0)
{
enviarTodo(conexion, buffer, bytesLeidos);
bytesLeidos = fread(buffer, 1, SIZE_BLOQUE_DE_ENVIO, contenidoArchivo);
char siguiente;
recibirMensaje(conexion, &siguiente, 1);
}
int cero = 0;
enviarMensaje(conexion, &cero, sizeof(int));
char resultadoSubida;
recibirMensaje(conexion, &resultadoSubida, 1);
if (resultadoSubida == MENSAJE_SUBIDA_OK)
{
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subida de archivo %s al MDFS en %s finalizada", nombreArchivo, pathArchivoEnMDFS);
return SUBIDA_OK;
}
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Subida de archivo %s al MDFS en %s fallida", nombreArchivo, pathArchivoEnMDFS);
return SUBIDA_FALLO;
}
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);
}
}
int main(int argc, char *argv[]) {
if(argc!=2)//Validar que reciba archivo de configuracion por parametro
{
fprintf(stderr,"ERROR: el job debe recibir por parametro el path del archivo de configuracion \n");
exit(1);
}
pthread_mutex_init(&semaforoMarta,NULL);
Job *job = levantarArchivoConfiguracion(argv[1]);
iniciarYEstablecerRutaArchivoLog(job->path_log);
logDebug("Comenzando el job...");
//Conectarse a marta
SocketConecta *conectarAMarta = newSocketConecta(job->ip_marta, job->puerto_marta);
conectarAServidor(conectarAMarta);
if(estaConectado(conectarAMarta))
{
//Muestro por pantalla la conexion a marta
logConexionMarta("Se ha conectado correctamente a Marta con IP: %s y PUERTO: %s \n",job->ip_marta, job->puerto_marta);
}else {logDebug("No se pudo conectar a Marta");exit(1);}
enviarMensaje(conectarAMarta,job->combiner,2);/*envio si soporto combiner(string) si o no*/
logCabeceraEnvia("Soporte de combiner");
//Envio archivos
int i=0;
while(job->archivos[i]!=NULL)
{
//Envio la longitud del string del archivo
int tamanio = strlen(job->archivos[i]);
enviarMensaje(conectarAMarta,&tamanio,sizeof(int));
logCabeceraEnvia("Longitud de path de archivo");
//Envio el archivo actual
enviarMensaje(conectarAMarta,job->archivos[i],strlen(job->archivos[i]));
logCabeceraEnvia("Envio de archivo");
i++;
}
//Aviso a marta que termine de mandar los archivos
int finArch =12;
enviarMensaje(conectarAMarta,&finArch,sizeof(int));
enviarMensaje(conectarAMarta,"Fin archivos",12);
logCabeceraEnvia("Finalizacion de envio de archivos");
//Recibo un 0 si no termina, recibo 1 cuando es el fin del job (YA NO ES ASI)
//int fin = 0;
int cantidadHilos=0;
t_list *listaHilos = list_create();
while(1)
{
char *rutina=malloc(4);
//Recibo que rutina se va a ejecutar (map o red) con '\0' al final, si recibo "fin" termino el job
recibirYChequearConexion(conectarAMarta,rutina,4);
logCabeceraRecibe("Rutina a ejecutar");
// SOLO ACA PUEDE TERMINAR EL JOB, RECIBO UNA RUTINA A EJECUTAR QUE SEA "fin"
if(strcmp(rutina,"fin")==0)
{
free(rutina);
finalizarJob(cantidadHilos,listaHilos,conectarAMarta,job,i);
return EXIT_SUCCESS;
}
//Recibo ip del nodo al que le comunico
int tamIp=0;
recibirYChequearConexion(conectarAMarta,&tamIp,sizeof(int));
char *ipNodo=malloc(tamIp);
recibirYChequearConexion(conectarAMarta,ipNodo,tamIp);
logCabeceraRecibe("Ip del nodo");
//Recibo puerto del nodo
int tamPuerto=0;
recibirYChequearConexion(conectarAMarta,&tamPuerto,sizeof(int));
char *puertoNodo=malloc(tamPuerto);
recibirYChequearConexion(conectarAMarta,puertoNodo,tamPuerto);
logCabeceraRecibe("Puerto del nodo");
//Recibo donde se guarda el resultado de la operacion en espacio temporal
int tamResul = 0;
recibirYChequearConexion(conectarAMarta,&tamResul,sizeof(int));
char *resulOperacion=malloc(tamResul);
recibirYChequearConexion(conectarAMarta,resulOperacion,tamResul);
logCabeceraRecibe("Archivo de resultado de la operacion");
//Segun que rutina sea creo un hilo para enviar la rutina al nodo
if(strcmp(rutina,"map")==0)
{
free(rutina);
//Recibo bloque e id de la operacion
int bloque = 0;
int idMap = 0;
recibirYChequearConexion(conectarAMarta,&bloque,sizeof(int));
logCabeceraRecibe("Bloque del nodo");
recibirYChequearConexion(conectarAMarta,&idMap,sizeof(int));
logCabeceraRecibe("Id de operacion map");
//Cargo la estructura hiloM
t_hiloMapper *hiloM= malloc(sizeof(t_hiloMapper));
hiloM->ipNodo=strdup(ipNodo);
hiloM->puertoNodo=strdup(puertoNodo);
hiloM->mapper=strdup(job->mapper);
hiloM->conectarAMarta=conectarAMarta;
hiloM->bloque=bloque;
hiloM->resulMap=strdup(resulOperacion);
hiloM->idMap=idMap;
pthread_t hiloMapper;
pthread_create(&hiloMapper,NULL,enviarMapperYObtenerResultado,hiloM);
list_add(listaHilos,&hiloMapper);
cantidadHilos++;
free(resulOperacion);
//Muestro que se creo un hilo
logCreacionHiloMapper("Se creo un hilo mapper con parametros: Ip_Nodo: %s, Puerto_Nodo: %s, Rutina de map: %s",ipNodo,puertoNodo,job->mapper);
}else if(strcmp(rutina,"red")==0)
{
free(rutina);
//Recibo los archivos y nodos en los que se ejecuta el reduce
// int tamArchivosYNodos=0;
// recibirYChequearConexion(conectarAMarta,&tamArchivosYNodos,sizeof(int));
// char *archivosYNodos=malloc(tamArchivosYNodos);
// recibirYChequearConexion(conectarAMarta,archivosYNodos,tamArchivosYNodos);
char *archivosYNodos;
recibirTodo(conectarAMarta, (void**)&archivosYNodos);
logCabeceraRecibe("Archivos y nodos");
int idReduce=0;
recibirYChequearConexion(conectarAMarta,&idReduce,sizeof(int));
logCabeceraRecibe("Id de operacion reduce");
//Cargo la estructura hiloR
t_hiloReducer *hiloR= malloc(sizeof(t_hiloReducer));
//Recibo si soy el ultimo reduce o no (Si: 1, No: 0)
int soyUltimo = 0;
recibirYChequearConexion(conectarAMarta,&soyUltimo,sizeof(int));
//Si soy el ultimo cargo en la estructura del hilo el path del resultado en FS
if(soyUltimo)
{
hiloR->resultado=strdup(job->resultado);
}
hiloR->soyUltimo = soyUltimo;
hiloR->ipNodo=strdup(ipNodo);
hiloR->puertoNodo=strdup(puertoNodo);
hiloR->reducer=strdup(job->reduce);
hiloR->conectarAMarta=conectarAMarta;
hiloR->archivosYNodos=strdup(archivosYNodos);
hiloR->idReduce=idReduce;
hiloR->resulReduce=strdup(resulOperacion);
pthread_t hiloReducer;
pthread_create(&hiloReducer,NULL,enviarReducerYObtenerResultado,hiloR);
list_add(listaHilos,&hiloReducer);
cantidadHilos++;
free(archivosYNodos);
free(resulOperacion);
//Muestro que se creo un hilo
logCreacionHiloReducer("Se creo un hilo reducer con parametros: Ip_Nodo: %s, Puerto_Nodo: %s, Rutina de reduce: %s, Archivo de resultado: %s",ipNodo,puertoNodo,job->reduce,job->resultado);
}
//recibirYChequearConexion(conectarAMarta,&fin,sizeof(int));
//logCabeceraRecibe("Termino el job?");
//Libero ip y puerto del nodo
free(ipNodo);
free(puertoNodo);
}
return EXIT_SUCCESS;
}
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);
}
}
