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