job* crearJob(char* argv[]){
job* nuevo = (job*)malloc(sizeof(job));
nuevo->id = 0;
nuevo->socketFd = 0;
if( access( argv[2], F_OK ) == -1 ) {
finalizarJob(FALLO_INGRESO);
}
if( access( argv[3], F_OK ) == -1 ) {
finalizarJob(FALLO_INGRESO);
}
nuevo->rutaTransformador.cadena = string_duplicate(argv[2]);
nuevo->rutaTransformador.longitud = string_length(nuevo->rutaTransformador.cadena);
nuevo->rutaReductor.cadena = string_duplicate(argv[3]);
nuevo->rutaReductor.longitud = string_length(nuevo->rutaReductor.cadena);
nuevo->rutaDatos.cadena= string_duplicate(argv[4]);
nuevo->rutaDatos.longitud = string_length(nuevo->rutaDatos.cadena);
nuevo->rutaResultado.cadena = string_duplicate(argv[5]);
nuevo->rutaResultado.longitud = string_length(nuevo->rutaResultado.cadena);
estadisticas = crearEstadisticasProceso();
return nuevo;
}
/* ---------------------------------------------------------------------- */
void
copy_defaults (struct defaults *dest_ptr, struct defaults *src_ptr)
/* ---------------------------------------------------------------------- */
{
int i;
dest_ptr->count_iso = src_ptr->count_iso;
dest_ptr->density = src_ptr->density;
dest_ptr->iso =
(struct iso *) PHRQ_malloc (sizeof (struct iso) * src_ptr->count_iso);
if (dest_ptr->iso == NULL)
{
malloc_error ();
}
else
{
for (i = 0; i < src_ptr->count_iso; i++)
{
dest_ptr->iso[i] = src_ptr->iso[i];
dest_ptr->iso[i].name = string_duplicate (src_ptr->iso[i].name);
}
}
dest_ptr->pe = src_ptr->pe;
dest_ptr->ph = src_ptr->ph;
dest_ptr->redox = string_duplicate (src_ptr->redox);
dest_ptr->temp = src_ptr->temp;
dest_ptr->units = string_duplicate (src_ptr->units);
dest_ptr->water = src_ptr->water;
}
tipoConfigCPU* cargarArchivoDeConfiguracionDeCPU(char* rutaDelArchivoDeConfiguracionDelCPU){
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracionDelCPU);
tipoConfigCPU* cfg = crearConfigCPU();
validarErrorYAbortar(config_has_property(archivoCfg,IP_PLANIFICADOR)
&& config_has_property(archivoCfg,PUERTO_PLANIFICADOR)
&& config_has_property(archivoCfg,IP_MEMORIA)
&& config_has_property(archivoCfg,PUERTO_MEMORIA)
&& config_has_property(archivoCfg,CANTIDAD_HILOS)
&& config_has_property(archivoCfg,RETARDO),
"Las claves del archivo de configuracion no coinciden con las que requiere el CPU");
cfg->ipPlanificador = string_duplicate(config_get_string_value(archivoCfg,IP_PLANIFICADOR));
cfg->puertoPlanificador = config_get_int_value(archivoCfg,PUERTO_PLANIFICADOR);
cfg->ipMemoria = string_duplicate(config_get_string_value(archivoCfg,IP_MEMORIA));
cfg->puertoMemoria = config_get_int_value(archivoCfg,PUERTO_MEMORIA);
cfg->cantidadDeHilos = config_get_int_value(archivoCfg,CANTIDAD_HILOS);
cfg->retardo = config_get_int_value(archivoCfg,RETARDO);
config_destroy(archivoCfg);
return cfg;
}
static void test_string_trim_right() {
char *string;
string = string_duplicate("Hola");
string_trim_right(&string);
CU_ASSERT_STRING_EQUAL(string, "Hola");
free(string);
string = string_duplicate("Hola ");
string_trim_right(&string);
CU_ASSERT_STRING_EQUAL(string, "Hola");
free(string);
}
/*!
* Callback for the foreach statement.
*
* \param element Current element in the hash table.
* \param data Configuration object.
* \return Always true.
*/
static bool _config_set_key_value (struct hashtable_t *element, void *data)
{
struct config_t *conf = (struct config_t *) data;
char *sql = NULL;
char *key = NULL;
char *val = NULL;
int type = TYPE_NULL;
/* retrieve key/value pair */
key = allocate (element->size);
memcpy (key, element->key, element->size);
type = element->val.type;
switch (type)
{
case TYPE_INT:
val = string_duplicate ("%d", element->val.data.i);
break;
case TYPE_DOUBLE:
val = string_duplicate ("%lf", (double) element->val.data.f);
break;
case TYPE_BOOLEAN:
val = string_duplicate ("%s", element->val.data.b ? "true" : "false");
break;
case TYPE_STRING:
val = string_duplicate ("%s", element->val.data.s);
break;
default:
break;
}
/* create SQL statement */
sql = string_duplicate (CONFIG_SQL_UPDATE, key, val, type);
deallocate (key);
deallocate (val);
sqlite3_exec (conf->db, sql, NULL, NULL, NULL); /* if this fail, what can we do ? */
deallocate (sql);
return true;
}
static void test_string_equals_ignore_case() {
char *string = string_duplicate("Hello WorLd");
CU_ASSERT_TRUE(string_equals_ignore_case(string, "hello world"));
free(string);
}
char *
conf_add_group(struct conf *cf, struct command *cmd, void *conf)
{
rstatus_t status;
uint8_t *p;
struct array *a;
struct string *field, *value;
p = conf;
a = (struct array *)(p + cmd->offset);
field = array_push(a);
if (field == NULL) {
return CONF_ERROR;
}
string_init(field);
value = array_top(&cf->arg);
status = string_duplicate(field, value);
if (status != NC_OK) {
return CONF_ERROR;
}
return CONF_OK;
}
/**
* @brief ggs_match_off
*
* Parse a "match off" from a GGS input text.
*
* @param match GGS match off.
* @param text GGS input text.
* @return 'true' if the text is a valid match end.
*/
static bool ggs_match_off(GGSMatchOff *match, Text *text)
{
const char *line = text->line[0];
char word[WORD_SIZE];
line = parse_word(line, word, WORD_SIZE);
if (strcmp("/os:", word) != 0) return false;
line = parse_word(line, word, WORD_SIZE);
if (strcmp("-", word) != 0) return false;
line = parse_word(line, word, WORD_SIZE);
if (strcmp("match", word) != 0) return false;
line = parse_word(line, word, WORD_SIZE);
match->id = string_duplicate(word);
line = parse_word(line, word, WORD_SIZE);
if (!ggs_player_set(&(match->player[0]), line, word)) return false;
line = parse_skip_word(line);
line = parse_word(line, word, WORD_SIZE);
if (!ggs_player_set(&(match->player[1]), line, word)) return false;
return true;
}
tipoRespuesta* leerPagina(t_list* listaDeHuecosUtilizados,int pidProceso,int dirLogicaDePagina,int tamanioDePagina,char* particion, t_log* logger, int retardoDeLectura){
tipoRespuesta* respuestaASolicitudDeLectura;
char* contenidoDePagina;
char* textoALogear = string_new();
//buscarPIDEnListaDeHuecos
tipoHuecoUtilizado* huecoDelProceso = buscarHuecoUtilizadoPorPID(listaDeHuecosUtilizados,pidProceso);
//traducirDireccionLogicaEnFisica
int direccionFisicaEnParticion = traducirDireccionLogicaAFisica(huecoDelProceso,dirLogicaDePagina);
//direccionFisicaEnParticion es la posicion donde comienza la pagina en el archivo de particion
//buscarEnContenidoEnParticion
contenidoDePagina = string_duplicate(leerBloqueMapeado(particion,direccionFisicaEnParticion,tamanioDePagina));
//retornarContenidoDePagina
respuestaASolicitudDeLectura = crearTipoRespuesta(PERFECTO,contenidoDePagina);
sleep(retardoDeLectura);
string_append_with_format(&textoALogear,"Lectura realizada | PID: %d | Byte inicial: %d | Tamanio: %d | Contenido: %s",pidProceso,dirLogicaDePagina*tamanioDePagina,string_length(contenidoDePagina),contenidoDePagina);
logearSeguimiento(textoALogear,logger);
free(textoALogear);
free(contenidoDePagina);
return respuestaASolicitudDeLectura;
}
char* socket_ip(char* direccionCompleta){
char * dir = string_duplicate(direccionCompleta);
string_append(&dir,"basura"); // Le agrego al final cualquier cosa, cuestion de que si me mandan "127.0.0.1:", pueda dividirlo correctamente
char * resultado = ( string_split(dir, ":") )[0]; //Divido en el ":", en un array de char* y digo que me de la primera parte.
free(dir);
return resultado;
}
tipoConfigSWAP* cargarArchivoDeConfiguracionDeSWAP(char* rutaDelArchivoDeConfiguracion){
t_config* archivoCfg = config_create(rutaDelArchivoDeConfiguracion);
tipoConfigSWAP* cfg = crearConfigSWAP();
validarErrorYAbortar(config_has_property(archivoCfg,PUERTO_ESCUCHA)
&& config_has_property(archivoCfg,NOMBRE_SWAP)
&& config_has_property(archivoCfg,CANTIDAD_PAGINAS)
&& config_has_property(archivoCfg,TAMANIO_PAGINA)
&& config_has_property(archivoCfg,RETARDO_COMPACTACION),
"Las claves del archivo de configuracion no coinciden con las que requiere el SWAP");
cfg->puertoDeEscucha = config_get_int_value(archivoCfg,PUERTO_ESCUCHA);
cfg->nombreDeSWAP = string_duplicate(config_get_string_value(archivoCfg,NOMBRE_SWAP));
cfg->cantidadDePaginas = config_get_int_value(archivoCfg,CANTIDAD_PAGINAS);
cfg->retardoDeCompactacion = config_get_int_value(archivoCfg,RETARDO_COMPACTACION);
cfg->tamanioDePagina = config_get_int_value(archivoCfg,TAMANIO_PAGINA);
config_destroy(archivoCfg);
return cfg;
}
void inicializar_panel(t_tipo_proceso tipo_proceso, char* path){
char* tipo_proceso_str;
if (tipo_proceso == KERNEL)
tipo_proceso_str = "kernel";
else if (tipo_proceso == CPU)
tipo_proceso_str = "cpu";
else
tipo_proceso_str = "?";
proceso_tipo = tipo_proceso;
char* logFile = string_duplicate(path);
string_append(&logFile, tipo_proceso_str);
string_append(&logFile, ".log");
remove(logFile);
logger = log_create(logFile, tipo_proceso_str, true, LOG_LEVEL_INFO);
log_info(logger, "Inicializando panel para %s, en \"%s\"", tipo_proceso_str, logFile);
free(logFile);
kernel_cpus_conectadas = list_create();
kernel_consolas_conectadas = list_create();
}
void label_init(t_label *label, t_token *label_token)
{
assert(label_token->type == TOKEN_TYPE_LABEL_DEF);
label->name = string_duplicate(label_token->string_value);
label->instr = NULL;
label->position = label_token->position;
}
char *
conf_set_hashtag(struct conf *cf, struct command *cmd, void *conf)
{
rstatus_t status;
uint8_t *p;
struct string *field, *value;
p = conf;
field = (struct string *)(p + cmd->offset);
if (field->data != CONF_UNSET_PTR) {
return "is a duplicate";
}
value = array_top(&cf->arg);
if (value->len != 2) {
return "is not a valid hash tag string with two characters";
}
status = string_duplicate(field, value);
if (status != NC_OK) {
return CONF_ERROR;
}
return CONF_OK;
}
rstatus_t
stats_pool_copy_init(struct stats_pool *stp, struct server_pool *sp, struct hash_table **sit)
{
rstatus_t status;
uint32_t nserver;
string_init(&stp->name);
string_duplicate(&stp->name, &sp->name);
array_null(&stp->metric);
array_null(&stp->server);
status = array_init(&stp->metric, STATS_POOL_NFIELD, sizeof(struct stats_metric));
if (status != NC_OK) {
return status;
}
nserver = array_n(&sp->server) == 0 ? array_n(&stp->server):array_n(&sp->server);
status = array_init(&stp->server, nserver, sizeof(struct stats_server));
if (status != NC_OK) {
return status;
}
(*sit) = assoc_create_table(sp->key_hash, array_n(&sp->server));
if ((*sit) == NULL)
{
return NC_ERROR;
}
return NC_OK;
}
/**
* @brief ggs_match_on
*
* Parse a "match on" from a GGS input text.
*
* @param match GGS match on.
* @param text GGS input text.
* @return 'true' if the text is a valid match start.
*/
static bool ggs_match_on(GGSMatchOn *match, Text *text)
{
const char *line = text->line[0];
char word[WORD_SIZE];
line = parse_word(line, word, WORD_SIZE);
if (strcmp("/os:", word) != 0) return false;
line = parse_word(line, word, WORD_SIZE);
if (strcmp("+", word) != 0) return false;
line = parse_word(line, word, WORD_SIZE);
if (strcmp("match", word) != 0) return false;
line = parse_word(line, word, WORD_SIZE);
match->id = string_duplicate(word);
line = parse_word(line, word, WORD_SIZE);
if (!ggs_player_set(&(match->player[0]), line, word))return false;
line = parse_skip_word(line);
line = parse_word(line, word, WORD_SIZE);
if (!ggs_player_set(&(match->player[1]), line, word)) return false;
line = parse_skip_word(line);
line = parse_word(line, word, WORD_SIZE);
ggs_match_type_set(match->match_type, word);
line = parse_word(line, word, WORD_SIZE);
match->match_type->is_rated = (strcmp(word, "R") == 0) ? 1 : 0;
return true;
}
t_fileContent *getFileContent(char *archivoTemporal) {
/*obtengo la ruta del archivo
char *rutaArchivo = malloc(256);
sprintf(rutaArchivo, "%s%s", directorioTemporal, archivoTemporal);
*/
char *rutaTemporal = string_duplicate("/tmp");
string_append(&rutaTemporal,archivoTemporal);
//abrir el archivo
int archivo = open(rutaTemporal,O_RDONLY);
if (archivo == -1) {
log_info(log_nodo, "FALLO AL ABRIR ARCHIVO EN GETFILECONTENT");
}
//perror("");
//leer todo el archivo
struct stat infoArchivo;
stat(rutaTemporal, &infoArchivo);
char *contenido = malloc(infoArchivo.st_size);
read(archivo, contenido, infoArchivo.st_size);
close(archivo);
t_fileContent *fileContent = malloc(sizeof(t_fileContent));
fileContent->contenido = contenido;
fileContent->size = infoArchivo.st_size;
return fileContent;
}
t_log* log_create(char* file, char *program_name, bool is_active_console, t_log_level detail) {
t_log* logger = malloc(sizeof(t_log));
if (logger == NULL) {
perror("Cannot create logger");
return NULL;
}
FILE *file_opened = NULL;
if (file != NULL) {
file_opened = txt_open_for_append(file);
if (file_opened == NULL) {
perror("Cannot create/open log file");
free(logger);
return NULL;
}
}
logger->file = file_opened;
logger->is_active_console = is_active_console;
logger->detail = detail;
logger->pid = process_getpid();
logger->program_name = string_duplicate(program_name);
return logger;
}
int socket_puerto(char* direccionCompleta){
char * dir = string_duplicate("basura");
string_append(&dir,direccionCompleta); // Le agrego al principio cualquier cosa, cuestion de que si me mandan ":2532", pueda dividirlo correctamente
int resultado = atoi(( string_split(dir, ":") )[1]); //Divido en el ":", en un array de char* y digo que me de la segunda parte en forma de int.
free(dir);
return resultado;
}
static void test_string_to_upper() {
char *string = string_duplicate("Hello World");
string_to_upper(string);
CU_ASSERT_STRING_EQUAL(string, "HELLO WORLD");
free(string);
}
static void test_string_to_lower() {
char *string = string_duplicate("Hello World");
string_to_lower(string);
CU_ASSERT_STRING_EQUAL(string, "hello world");
free(string);
}
String &String::operator^=(CStrRef v) {
const char *s1 = data();
const char *s2 = v.data();
int len1 = size();
int len2 = v.size();
char *copy = NULL;
if (len2 < len1) {
copy = string_duplicate(s2, len2);
for (int i = 0; i < len2; i++) copy[i] ^= s1[i];
SmartPtr<StringData>::operator=(NEW(StringData)(copy, len2, AttachString));
} else {
copy = string_duplicate(s1, len1);
for (int i = 0; i < len1; i++) copy[i] ^= s2[i];
SmartPtr<StringData>::operator=(NEW(StringData)(copy, len1, AttachString));
}
return *this;
}
static rstatus_t
conf_pool_init(struct conf_pool *cp, struct string *name)
{
rstatus_t status;
string_init(&cp->name);
string_init(&cp->listen.pname);
string_init(&cp->listen.name);
cp->listen.port = 0;
memset(&cp->listen.info, 0, sizeof(cp->listen.info));
cp->listen.valid = 0;
cp->hash = CONF_UNSET_HASH;
string_init(&cp->hash_tag);
cp->distribution = CONF_UNSET_DIST;
cp->timeout = CONF_UNSET_NUM;
cp->backlog = CONF_UNSET_NUM;
cp->client_connections = CONF_UNSET_NUM;
cp->tcpkeepalive = CONF_UNSET_NUM;
string_init(&cp->redis_auth);
cp->redis_db = CONF_UNSET_NUM;
cp->server_connections = CONF_UNSET_NUM;
array_null(&cp->groups);
cp->sentinel_heartbeat = CONF_UNSET_NUM;
array_null(&cp->sentinels);
cp->valid = 0;
status = string_duplicate(&cp->name, name);
if (status != NC_OK) {
return status;
}
status = array_init(&cp->groups, CONF_DEFAULT_GROUPS,
sizeof(struct string));
if (status != NC_OK) {
string_deinit(&cp->name);
return status;
}
status = array_init(&cp->sentinels, CONF_DEFAULT_SENTINELS,
sizeof(struct conf_server));
if (status != NC_OK) {
array_deinit(&cp->groups);
string_deinit(&cp->name);
return status;
}
log_debug(LOG_VVERB, "init conf pool %p, '%.*s'", cp, name->len, name->data);
return NC_OK;
}
void agregarHeader(char** mensaje){
char* head=string_new();
char* numero=header(string_length(*mensaje));
string_append(&head,numero);
string_append(&head,*mensaje);
*mensaje=string_duplicate(head);
free(numero);
free (head);
}
char* completarBloque(char* bloqueACompletar, int tamanioDeBloque){
int cantACompletar = tamanioDeBloque - string_length(bloqueACompletar);
char* aux = string_duplicate(bloqueACompletar);
string_append(&aux,string_repeat(CARACTER_VACIO,cantACompletar));
return aux;
}
// Make sure that this StringData* is safe to modify. It may leave the pointer
// untouched. It may create a new StringData, modify the pointer, and decref
// the old data.
void string_touch(StringData** data)
{
ca_assert((*data)->refCount > 0);
if ((*data)->refCount == 1)
return;
StringData* dup = string_duplicate(*data);
decref(*data);
*data = dup;
}
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);
}
static rstatus_t
conf_pool_init(struct conf_pool *cp, struct string *name)
{
rstatus_t status;
string_init(&cp->name);
string_init(&cp->listen.pname);
string_init(&cp->listen.name);
string_init(&cp->redis_auth);
cp->listen.port = 0;
memset(&cp->listen.info, 0, sizeof(cp->listen.info));
cp->listen.valid = 0;
cp->hash = CONF_UNSET_HASH;
string_init(&cp->hash_tag);
cp->distribution = CONF_UNSET_DIST;
cp->timeout = CONF_UNSET_NUM;
cp->backlog = CONF_UNSET_NUM;
cp->client_connections = CONF_UNSET_NUM;
cp->redis = CONF_UNSET_NUM;
cp->tcpkeepalive = CONF_UNSET_NUM;
cp->redis_db = CONF_UNSET_NUM;
cp->proto = CONF_UNSET_PROTO;
cp->preconnect = CONF_UNSET_NUM;
cp->auto_eject_hosts = CONF_UNSET_NUM;
cp->server_connections = CONF_UNSET_NUM;
cp->server_retry_timeout = CONF_UNSET_NUM;
cp->server_failure_limit = CONF_UNSET_NUM;
array_null(&cp->server);
cp->valid = 0;
status = string_duplicate(&cp->name, name);
if (status != NC_OK) {
return status;
}
status = array_init(&cp->server, CONF_DEFAULT_SERVERS,
sizeof(struct conf_server));
if (status != NC_OK) {
string_deinit(&cp->name);
return status;
}
log_debug(LOG_VVERB, "init conf pool %p, '%.*s'", cp, name->len, name->data);
return NC_OK;
}
void* orquestador(void* plat) {
t_plataforma* plataforma = (t_plataforma*) plat;
t_orquestador* self = orquestador_create(PUERTO_ORQUESTADOR, plataforma);
t_socket_client* acceptClosure(t_socket_server* server) {
t_socket_client* client = sockets_accept(server);
t_mensaje* mensaje = mensaje_recibir(client);
if (mensaje == NULL) {
sockets_destroyClient(client);
pthread_mutex_lock(&plataforma->logger_mutex);
log_warning(plataforma->logger,
"%s:%d -> Orquestador - Error al recibir datos en el accept",
sockets_getIp(client->socket),
sockets_getPort(client->socket));
pthread_mutex_unlock(&plataforma->logger_mutex);
return NULL;
}
int tipo_mensaje = mensaje->type;
mensaje_destroy(mensaje);
switch (tipo_mensaje) {
case M_HANDSHAKE_PERSONAJE:
responder_handshake(client, plataforma->logger,
&plataforma->logger_mutex, "Orquestador");
orquestador_guardar_personaje(self, client, plataforma);
break;
case M_HANDSHAKE_NIVEL:
responder_handshake(client, plataforma->logger,
&plataforma->logger_mutex, "Orquestador");
if (!procesar_handshake_nivel(self, client, plataforma)) {
orquestador_send_error_message("Error al procesar el handshake",
client);
return NULL;
}
break;
default:
pthread_mutex_lock(&plataforma->logger_mutex);
char* error_msg = string_from_format(
"Tipo del mensaje recibido no válido tipo: %d",
tipo_mensaje);
log_warning(plataforma->logger, error_msg);
mensaje_create_and_send(M_ERROR, string_duplicate(error_msg),
strlen(error_msg) + 1, client);
free(error_msg);
pthread_mutex_unlock(&plataforma->logger_mutex);
orquestador_send_error_message("Request desconocido", client);
return NULL ;
}
return client;
}
void replanificarMapFallado(t_job* job, t_map* map){
int idNodoNuevo = *(map->idNodoOpcion2);
int idBloqueNuevo = *(map->idBloqueOpcion2);
bool by_idNodo(t_nodo* n) {
return (*(n->id) == idNodoNuevo);
}
t_nodo* nodo = list_find(nodosList, (void*)by_idNodo);
//guardo valores anteriores
int idNodoViejo = *(map->idNodo);
int idBloqueViejo = *(map->idBloque);
//actualizo el map
*(map->idNodo) = idNodoNuevo;
*(map->idBloque) = idBloqueNuevo;
list_add(job->maps, map);
char* mensajeAJob = string_new();
string_append(&mensajeAJob, MAP);
string_append(&mensajeAJob, "*");
char* resultFileName = string_new();
string_append(&resultFileName, TEMPLATE);
string_append(&mensajeAJob, nodo->ip);
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, nodo->puerto);
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, string_itoa(idNodoNuevo));
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, string_itoa(idBloqueNuevo));
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, string_duplicate(resultFileName));
string_append(&mensajeAJob, string_itoa(idNodoNuevo));
string_append(&mensajeAJob, string_itoa(idBloqueNuevo));
if(strlen(mensajeAJob) > 999){
char* nuevoheader = string_new();
string_append(&nuevoheader, SOY_MARTA); //1 digito
string_append(&nuevoheader, string_itoa(strlen(mensajeAJob)));//4 digitos
enviar(*(job->socket), "9999", 4); //falso header
enviar(*(job->socket), nuevoheader, 5); //header de 5
}else{
sendHeader(SOY_MARTA, strlen(mensajeAJob), *(job->socket));
}
enviar(*(job->socket), mensajeAJob, strlen(mensajeAJob));
printf("Replanificacion nodo %d, bloque %d enviada a job.\nNuevo map en nodo %d, bloque %d\n", idNodoViejo, idBloqueViejo, idNodoNuevo, idBloqueNuevo);
}
