X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_get.c;h=12d301ec35319d0faabbe336f75e002a0d024777;hb=8ce1a267a6593221cdd887643517364694ea985f;hp=a29deab3bfac2818f2385cb9bd500f777b5d074e;hpb=f4ff3ba0a9f212ac1323fc056d61fefd3782093c;p=awesomized%2Flibmemcached diff --git a/lib/memcached_get.c b/lib/memcached_get.c index a29deab3..12d301ec 100644 --- a/lib/memcached_get.c +++ b/lib/memcached_get.c @@ -1,182 +1,107 @@ -#include - -static char *memcached_value_fetch(memcached_st *ptr, char *key, size_t *key_length, - size_t *value_length, - uint16_t *flags, - memcached_return *error, - char load_key, - unsigned int server_key) -{ - char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; - char *string_ptr; - - *value_length= 0; - - memset(buffer, 0, MEMCACHED_DEFAULT_COMMAND_SIZE); - *error= memcached_response(ptr, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, server_key); - - if (*error == MEMCACHED_SUCCESS) - { - char *end_ptr; - - string_ptr= buffer; - string_ptr+= 6; /* "VALUE " */ - - /* We load the key */ - if (load_key) - { - memset(key, 0, MEMCACHED_MAX_KEY); - for (end_ptr= string_ptr; *end_ptr != ' '; end_ptr++) - { - *key= *end_ptr; - key++; - } - } - else /* Skip characters */ - for (end_ptr= string_ptr; *end_ptr != ' '; end_ptr++); - - /* Flags fetch */ - string_ptr= end_ptr + 1; - for (end_ptr= string_ptr; *end_ptr != ' '; end_ptr++); - *flags= (uint16_t)strtol(string_ptr, &end_ptr, 10); - - /* Length fetch */ - string_ptr= end_ptr + 1; - for (end_ptr= string_ptr; *end_ptr != ' '; end_ptr++); - *value_length= strtoll(string_ptr, &end_ptr, 10); - - /* Skip past the \r\n */ - string_ptr= end_ptr +2; - - if (*value_length) - { - size_t read_length; - char *value; - - /* We add two bytes so that we can walk the \r\n */ - value= (char *)malloc(((*value_length) +2) * sizeof(char)); - - if (!value) - { - *value_length= 0; - *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE; - return NULL; - } - - read_length= read(ptr->hosts[server_key].fd, value, (*value_length)+2); - - if ((read_length -2) != *value_length) - { - free(value); - *error= MEMCACHED_PARTIAL_READ; - - return NULL; - } - - return value; - } - } - - return NULL; -} +#include "common.h" +#include "memcached_io.h" +/* + What happens if no servers exist? +*/ char *memcached_get(memcached_st *ptr, char *key, size_t key_length, size_t *value_length, - uint16_t *flags, + uint32_t *flags, memcached_return *error) { + return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length, + flags, error); +} + +char *memcached_get_by_key(memcached_st *ptr, + char *master_key, size_t master_key_length, + char *key, size_t key_length, + size_t *value_length, + uint32_t *flags, + memcached_return *error) +{ + unsigned int server_key; size_t send_length; char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; - unsigned int server_key; + memcached_result_st *result_buffer= &ptr->result; + memcached_return rc[MEMCACHED_MAX_REPLICAS]; + uint8_t replicas= 0; - *value_length= 0; - *error= memcached_connect(ptr); - - if (*error != MEMCACHED_SUCCESS) - return NULL; - - server_key= memcached_generate_hash(key, key_length) % ptr->number_of_hosts; - - send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "get %.*s\r\n", - (int)key_length, key); - if (*error != MEMCACHED_SUCCESS) + if (ptr->number_of_hosts == 0) + { + *error= MEMCACHED_NO_SERVERS; return NULL; + } - if ((write(ptr->hosts[server_key].fd, buffer, send_length) == -1)) + if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test(&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) { - *error= MEMCACHED_WRITE_FAILURE; + *value_length= 0; + *error= MEMCACHED_BAD_KEY_PROVIDED; return NULL; } - return memcached_value_fetch(ptr, key, &key_length, value_length, flags, - error, 0, server_key); -} - -memcached_return memcached_mget(memcached_st *ptr, - char **keys, size_t *key_length, - unsigned int number_of_keys) -{ - char buffer[HUGE_STRING_LEN]; - char *buffer_ptr; - unsigned int x; - memcached_return rc; + if (master_key) + server_key= memcached_generate_hash(ptr, master_key, master_key_length); + else + server_key= memcached_generate_hash(ptr, key, key_length); - ptr->cursor_server= 0; - memset(buffer, 0, HUGE_STRING_LEN); + send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, + "get %.*s\r\n", (int)key_length, key); - rc= memcached_connect(ptr); + do + { + char response_buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; - if (rc != MEMCACHED_SUCCESS) - return rc; + if (memcached_server_response_count(&ptr->hosts[server_key])) + { + if (ptr->flags & MEM_NO_BLOCK) + (void)memcached_io_write(&ptr->hosts[server_key], NULL, 0, 1); - memcpy(buffer, "get", strlen("get")); - buffer_ptr= buffer; - buffer_ptr+=strlen("get"); + while(memcached_server_response_count(&ptr->hosts[server_key])) + (void)memcached_response(&ptr->hosts[server_key], response_buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, result_buffer); + } - for (x= 0; x < number_of_keys; x++) - { - *buffer_ptr= ' '; - buffer_ptr++; - memcpy(buffer_ptr, keys[x], key_length[x]); - buffer_ptr+= key_length[x]; - } + rc[replicas]= memcached_do(&ptr->hosts[server_key], buffer, send_length, 1); + if (rc[replicas] != MEMCACHED_SUCCESS) + goto error; - memcpy(buffer_ptr, "\r\n", 2); - buffer_ptr+=2; + rc[replicas]= memcached_response(&ptr->hosts[server_key], response_buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, result_buffer); - /* - This must be fixed. Right now we hit every server, and send keys - to all servers. We should fix this quickly. - */ - for (x= 0; x < ptr->number_of_hosts; x++) - { - if ((write(ptr->hosts[x].fd, buffer, (size_t)(buffer_ptr - buffer)) == -1)) + /* On no key found, we check the replica */ + if (rc[replicas] == MEMCACHED_END) /* END means that we move on to the next */ { - memcached_quit(ptr); - rc= MEMCACHED_SOME_ERRORS; + memcached_server_response_reset(&ptr->hosts[server_key]); } - } + else if (rc[replicas] == MEMCACHED_SUCCESS) + { + *value_length= memcached_string_length(&result_buffer->value); + + if (result_buffer->flags) + *flags= result_buffer->flags; - return rc; -} + *error= MEMCACHED_SUCCESS; + return memcached_string_c_copy(&result_buffer->value); + } -char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length, - size_t *value_length, - uint16_t *flags, - memcached_return *error) -{ - char *value_check; + /* On error we just jump to the next potential server */ +error: + if (ptr->number_of_replicas > 1) + { + if (server_key == (ptr->number_of_hosts - 1)) + server_key= 0; + else + server_key++; + } + } while ((++replicas) < ptr->number_of_replicas); - while (ptr->cursor_server < ptr->number_of_hosts) - { - value_check= memcached_value_fetch(ptr, key, key_length, value_length, flags, - error, 1, ptr->cursor_server); - - if (*error == MEMCACHED_NOTFOUND) - ptr->cursor_server++; - else - return value_check; - } + /* TODO: An error on replica 1 of host down, but not found on 2, will give wrong error */ + /* This is for historical reasons */ + if (rc[0] == MEMCACHED_END) + *error= MEMCACHED_NOTFOUND; + else + *error= rc[0]; + + *value_length= 0; return NULL; }