static int knh_Actor_getPortNum(memcached_st *memc)
{
int port = 1234;
const char *val = memcached_getValue(memc, "port");
if (val == NULL) {
const char *key = "port";
const char *val = "1234";
memcached_setValue(memc, key, val);
return port;
}
port = atoi(val);
return port;
}
int dir_read(const char *path, void *buffer, fuse_fill_dir_t rellenar,
off_t offset, struct fuse_file_info *info) {
int exit = 0;
char key[255] = "LC";
strcat(key, path);
int i;
/* Me conecto con la Memcached*/
memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools);
/* Hago el GET */
uint32_t size;
char* value;
/* Deserializo los directorios. Recordar que se separan con # */
if (memcached_getValue(memcached, key, &value, &size)
== MEMCACHED_SUCCESS) {
char mensajeCacheGet[255];
sprintf(mensajeCacheGet, "Operacion: Actualizar Cache - path:%s", path);
log_debug(teLogueo, mensajeCacheGet);
char** vector_memcached;
vector_memcached = string_split(value, "#");
for (i = 0; vector_memcached[i] != NULL; i++) {
rellenar(buffer, vector_memcached[i], NULL, 0);
}
for (i = 0; vector_memcached[i] != NULL; i++) {
free(vector_memcached[i]);
}
//memcached_finishHer(memcached, &servers);
free(vector_memcached);
free(value);
} else {
/*
* Si return_value es MEMCACHED_NOTFOUND
*/
t_stream *stream = serializar_pedido_nombre(READ_DIR, path);
int descriptor = connectionPool_extractAvaibleSocket(pools);
enviar_paquete(descriptor, stream->data, stream->length);
char mensaje[255];
sprintf(mensaje, "Operacion: Leer Directorio - path:%s", path);
log_debug(teLogueo, mensaje);
char *cabecera_recibida = recibir_paquete(descriptor, 3);
t_header *header = deserializadorHeader(cabecera_recibida);
if (header->type == NO_EXISTE) {
connectionPool_depositeAvaibleMemcached(pools, memcached);
connectionPool_depositeAvaibleSocket(pools, descriptor);
perror("No existe el archivo");
return -ENOENT;
}
if (header->type == NAME_TOO_LONG) {
connectionPool_depositeAvaibleMemcached(pools, memcached);
connectionPool_depositeAvaibleSocket(pools, descriptor);
perror("El nombre es demasiado largo");
return -ENAMETOOLONG;
}
char* mensaje_recibido = recibir_paquete(descriptor, header->length);
/* Accedo a la cache y le envio el payload */
memcached_addOrReplace(memcached, key, mensaje_recibido,
header->length);
char mensajeCacheActualizar[255];
sprintf(mensajeCacheActualizar, "Operacion: Actualizar Cache - path:%s",
path);
log_debug(teLogueo, mensajeCacheActualizar);
char** vector;
vector = string_split(mensaje_recibido, "#");
for (i = 0; vector[i] != NULL; i++) {
rellenar(buffer, vector[i], NULL, 0);
}
free(vector);
free(cabecera_recibida);
free(stream);
free(mensaje_recibido);
free(header);
//memcached_finishHer(memcached, &servers);
connectionPool_depositeAvaibleSocket(pools, descriptor);
}
connectionPool_depositeAvaibleMemcached(pools, memcached);
return exit;
}
int file_getattr(const char *path, struct stat *attr) {
int exit = 0;
memset(attr, 0, sizeof(struct stat));
/* Me conecto con la Memcached */
memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools);
/* Hago el GET */
uint32_t size;
char* value;
//Para diferenciar las claves dependiendo si es un getattr o un readdir, se le agregara a la key los caracteres
//AC, que indica ATRIBUTOS de CLIENTE.
char* key = calloc(2 + strlen(path), sizeof(char));
memcpy(key, "AC", strlen("AC"));
memcpy(key + strlen("AC"), path, strlen(path));
if (memcached_getValue(memcached, key, &value, &size)
== MEMCACHED_SUCCESS) {
char mensajeCacheGet[255];
sprintf(mensajeCacheGet,
"Operacion: Obtener un valor de la Cache - path:%s", path);
log_debug(teLogueo, mensajeCacheGet);
t_respuesta_get_attr* attrCache = deserializar_respuesta_get_attr(value,
size);
attr->st_ino = attrCache->nroInodo;
attr->st_mode = attrCache->mode;
attr->st_nlink = attrCache->hdlinks;
attr->st_size = attrCache->size;
attr->st_blksize = attrCache->blocksize;
attr->st_blocks = attrCache->blocks;
free(attrCache);
//memcached_finishHer(memcached, &servers);
free(value);
free(key);
} else {
t_stream *stream = serializar_pedido_nombre(GET_ATTR, path);
int descriptor = connectionPool_extractAvaibleSocket(pools);
enviar_paquete(descriptor, stream->data, stream->length);
char mensaje[255];
sprintf(mensaje, "Operacion:Obtener Atributos - path:%s", path);
log_debug(teLogueo, mensaje);
char *cabecera_recibida = malloc(3);
recibir(descriptor, cabecera_recibida, 3);
t_header *header = deserializadorHeader(cabecera_recibida);
if (header->type == NO_EXISTE) {
connectionPool_depositeAvaibleMemcached(pools, memcached);
connectionPool_depositeAvaibleSocket(pools, descriptor);
printf("No existe el archivo %s\n", path);
free(cabecera_recibida);
return -ENOENT;
}
if (header->type == NAME_TOO_LONG) {
connectionPool_depositeAvaibleMemcached(pools, memcached);
connectionPool_depositeAvaibleSocket(pools, descriptor);
perror("El nombre es demasiado largo");
free(cabecera_recibida);
return -ENAMETOOLONG;
}
char* mensaje_recibido = malloc(header->length);
recibir(descriptor, mensaje_recibido, header->length);
t_respuesta_get_attr *file_attr = deserializar_respuesta_get_attr(
mensaje_recibido, header->length);
attr->st_ino = file_attr->nroInodo;
if ((file_attr->mode & S_IFMT) == S_IFDIR) {
attr->st_mode = S_IFDIR | 0755;
} else if ((file_attr->mode & S_IFMT) == S_IFREG) {
attr->st_mode = S_IFREG | 0666;
} else {
printf("NO TENGO LA MAS PUTA IDEA QUE ES \n");
}
attr->st_nlink = file_attr->hdlinks;
attr->st_size = file_attr->size;
attr->st_blksize = file_attr->blocksize;
attr->st_blocks = file_attr->blocks;
memcached_addOrReplace(memcached, key, mensaje_recibido,
header->length);
char mensajeCacheActualizar[255];
sprintf(mensajeCacheActualizar, "Operacion: Actualizar Cache - path:%s",
path);
log_debug(teLogueo, mensajeCacheActualizar);
free(mensaje_recibido);
free(cabecera_recibida);
free(stream);
connectionPool_depositeAvaibleSocket(pools, descriptor);
//memcached_finishHer(memcached, &servers);
}
connectionPool_depositeAvaibleMemcached(pools, memcached);
return exit;
}
static const char *knh_Actor_getActorPathFromMemcached(const char *actor_name)
{
memcached_st *memc = new_memcached("localhost");
return memcached_getValue(memc, actor_name);
}
