X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fget.cc;h=86d8cf2e13522b625cf35f4acd8a1de23636e733;hb=ae86283e79c226f2a24d5c74e3ffc8f38f0a66a8;hp=d0b01b336dedaee19471e5628298792f255131d5;hpb=498bcd4bb9f82435b8fb1ce8632732cc4f118bdd;p=awesomized%2Flibmemcached diff --git a/libmemcached/get.cc b/libmemcached/get.cc index d0b01b33..86d8cf2e 100644 --- a/libmemcached/get.cc +++ b/libmemcached/get.cc @@ -2,7 +2,7 @@ * * Libmemcached library * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/ * Copyright (C) 2006-2009 Brian Aker All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -35,8 +35,7 @@ * */ -#include "libmemcached/common.h" -#include +#include /* What happens if no servers exist? @@ -51,15 +50,14 @@ char *memcached_get(memcached_st *ptr, const char *key, flags, error); } -static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, - const char *group_key, - size_t group_key_length, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys, - bool mget_mode); - -char *memcached_get_by_key(memcached_st *ptr, +static memcached_return_t __mget_by_key_real(memcached_st *ptr, + const char *group_key, + size_t group_key_length, + const char * const *keys, + const size_t *key_length, + size_t number_of_keys, + const bool mget_mode); +char *memcached_get_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, const char *key, size_t key_length, @@ -67,82 +65,114 @@ char *memcached_get_by_key(memcached_st *ptr, uint32_t *flags, memcached_return_t *error) { - char *value; - size_t dummy_length; - uint32_t dummy_flags; - memcached_return_t dummy_error; + Memcached* ptr= memcached2Memcached(shell); + memcached_return_t unused; + if (error == NULL) + { + error= &unused; + } - unlikely (ptr->flags.use_udp) + uint64_t query_id= 0; + if (ptr) { - *error= MEMCACHED_NOT_SUPPORTED; - return NULL; + query_id= ptr->query_id; } /* Request the key */ - *error= memcached_mget_by_key_real(ptr, group_key, group_key_length, - (const char * const *)&key, - &key_length, 1, false); + *error= __mget_by_key_real(ptr, group_key, group_key_length, + (const char * const *)&key, &key_length, + 1, false); + if (ptr) + { + assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); + } + + if (memcached_failed(*error)) + { + if (ptr) + { + if (memcached_has_current_error(*ptr)) // Find the most accurate error + { + *error= memcached_last_error(ptr); + } + } + + if (value_length) + { + *value_length= 0; + } + + return NULL; + } + + char *value= memcached_fetch(ptr, NULL, NULL, + value_length, flags, error); + assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); - value= memcached_fetch(ptr, NULL, NULL, - value_length, flags, error); /* This is for historical reasons */ if (*error == MEMCACHED_END) + { *error= MEMCACHED_NOTFOUND; - + } if (value == NULL) { - if (ptr->get_key_failure && *error == MEMCACHED_NOTFOUND) + if (ptr->get_key_failure and *error == MEMCACHED_NOTFOUND) { - - memcached_result_reset(&ptr->result); - memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, &ptr->result); + memcached_result_st key_failure_result; + memcached_result_st* result_ptr= memcached_result_create(ptr, &key_failure_result); + memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, result_ptr); /* On all failure drop to returning NULL */ - if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED) + if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED) { if (rc == MEMCACHED_BUFFERED) { uint64_t latch; /* We use latch to track the state of the original socket */ latch= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS); if (latch == 0) + { memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1); + } rc= memcached_set(ptr, key, key_length, - (memcached_result_value(&ptr->result)), - (memcached_result_length(&ptr->result)), + (memcached_result_value(result_ptr)), + (memcached_result_length(result_ptr)), 0, - (memcached_result_flags(&ptr->result))); + (memcached_result_flags(result_ptr))); - if (rc == MEMCACHED_BUFFERED && latch == 0) + if (rc == MEMCACHED_BUFFERED and latch == 0) + { memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0); + } } else { rc= memcached_set(ptr, key, key_length, - (memcached_result_value(&ptr->result)), - (memcached_result_length(&ptr->result)), + (memcached_result_value(result_ptr)), + (memcached_result_length(result_ptr)), 0, - (memcached_result_flags(&ptr->result))); + (memcached_result_flags(result_ptr))); } - if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED) + if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED) { *error= rc; - *value_length= memcached_result_length(&ptr->result); - *flags= memcached_result_flags(&ptr->result); - return memcached_string_c_copy(&ptr->result.value); + *value_length= memcached_result_length(result_ptr); + *flags= memcached_result_flags(result_ptr); + char *result_value= memcached_string_take_value(&result_ptr->value); + memcached_result_free(result_ptr); + + return result_value; } } + + memcached_result_free(result_ptr); } + assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); return NULL; } - (void)memcached_fetch(ptr, NULL, NULL, - &dummy_length, &dummy_flags, - &dummy_error); - WATCHPOINT_ASSERT(dummy_length == 0); - return value; } @@ -155,51 +185,54 @@ memcached_return_t memcached_mget(memcached_st *ptr, } static memcached_return_t binary_mget_by_key(memcached_st *ptr, - uint32_t master_server_key, - bool is_group_key_set, + const uint32_t master_server_key, + const bool is_group_key_set, + const char * const *keys, + const size_t *key_length, + const size_t number_of_keys, + const bool mget_mode); + +static memcached_return_t __mget_by_key_real(memcached_st *ptr, + const char *group_key, + const size_t group_key_length, const char * const *keys, const size_t *key_length, size_t number_of_keys, - bool mget_mode); - -static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, - const char *group_key, - size_t group_key_length, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys, - bool mget_mode) + const bool mget_mode) { bool failures_occured_in_sending= false; - const char *get_command= "get "; - uint8_t get_command_length= 4; + const char *get_command= "get"; + uint8_t get_command_length= 3; unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */ - bool is_group_key_set= false; memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) + if (memcached_failed(rc= initialize_query(ptr, true))) { return rc; } - unlikely (ptr->flags.use_udp) - return MEMCACHED_NOT_SUPPORTED; + if (memcached_is_udp(ptr)) + { + return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT); + } LIBMEMCACHED_MEMCACHED_MGET_START(); if (number_of_keys == 0) - return MEMCACHED_NOTFOUND; - - if (ptr->flags.verify_key && (memcached_key_test(keys, key_length, number_of_keys) == MEMCACHED_BAD_KEY_PROVIDED)) { - return MEMCACHED_BAD_KEY_PROVIDED; + return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Numbers of keys provided was zero")); } - if (group_key && group_key_length) + if (memcached_failed((rc= memcached_key_test(*ptr, keys, key_length, number_of_keys)))) { - if (ptr->flags.verify_key and (memcached_key_test((const char * const *)&group_key, &group_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) - return MEMCACHED_BAD_KEY_PROVIDED; + assert(memcached_last_error(ptr) == rc); + return rc; + } + + bool is_group_key_set= false; + if (group_key and group_key_length) + { master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); is_group_key_set= true; } @@ -212,22 +245,25 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, */ for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - memcached_server_write_instance_st instance= - memcached_server_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); - if (memcached_server_response_count(instance)) + if (instance->response_count()) { char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; if (ptr->flags.no_block) - (void)memcached_io_write(instance, NULL, 0, true); + { + memcached_io_write(instance); + } - while(memcached_server_response_count(instance)) + while(instance->response_count()) + { (void)memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result); + } } } - if (ptr->flags.binary_protocol) + if (memcached_is_binary(ptr)) { return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys, key_length, number_of_keys, mget_mode); @@ -235,8 +271,8 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, if (ptr->flags.support_cas) { - get_command= "gets "; - get_command_length= 5; + get_command= "gets"; + get_command_length= 4; } /* @@ -247,7 +283,6 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, size_t hosts_connected= 0; for (uint32_t x= 0; x < number_of_keys; x++) { - memcached_server_write_instance_st instance; uint32_t server_key; if (is_group_key_set) @@ -259,41 +294,42 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - instance= memcached_server_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { - { get_command_length, get_command }, - { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) }, - { key_length[x], keys[x] }, - { 1, " " } + { get_command, get_command_length }, + { memcached_literal_param(" ") }, + { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, + { keys[x], key_length[x] } }; - if (memcached_server_response_count(instance) == 0) + if (instance->response_count() == 0) { rc= memcached_connect(instance); - if (rc != MEMCACHED_SUCCESS) + if (memcached_failed(rc)) { + memcached_set_error(*instance, rc, MEMCACHED_AT); continue; } hosts_connected++; - if ((memcached_io_writev(instance, vector, 4, false)) == -1) + if ((memcached_io_writev(instance, vector, 1, false)) == false) { failures_occured_in_sending= true; continue; } - WATCHPOINT_ASSERT(instance->cursor_active == 0); - memcached_server_response_increment(instance); - WATCHPOINT_ASSERT(instance->cursor_active == 1); + WATCHPOINT_ASSERT(instance->cursor_active_ == 0); + memcached_instance_response_increment(instance); + WATCHPOINT_ASSERT(instance->cursor_active_ == 1); } - else + { - if ((memcached_io_writev(instance, (vector + 1), 3, false)) == -1) + if ((memcached_io_writev(instance, (vector + 1), 3, false)) == false) { - memcached_server_response_reset(instance); + memcached_instance_response_reset(instance); failures_occured_in_sending= true; continue; } @@ -304,10 +340,12 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, { LIBMEMCACHED_MEMCACHED_MGET_END(); - if (rc != MEMCACHED_SUCCESS) + if (memcached_failed(rc)) + { return rc; + } - return MEMCACHED_NO_SERVERS; + return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT); } @@ -317,10 +355,9 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, bool success_happened= false; for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - memcached_server_write_instance_st instance= - memcached_server_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); - if (memcached_server_response_count(instance)) + if (instance->response_count()) { /* We need to do something about non-connnected hosts in the future */ if ((memcached_io_write(instance, "\r\n", 2, true)) == -1) @@ -336,24 +373,28 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, LIBMEMCACHED_MEMCACHED_MGET_END(); - if (failures_occured_in_sending && success_happened) + if (failures_occured_in_sending and success_happened) + { return MEMCACHED_SOME_ERRORS; + } if (success_happened) + { return MEMCACHED_SUCCESS; + } - return MEMCACHED_FAILURE; + return MEMCACHED_FAILURE; // Complete failure occurred } -memcached_return_t memcached_mget_by_key(memcached_st *ptr, +memcached_return_t memcached_mget_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, const char * const *keys, const size_t *key_length, size_t number_of_keys) { - return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys, - key_length, number_of_keys, true); + Memcached* ptr= memcached2Memcached(shell); + return __mget_by_key_real(ptr, group_key, group_key_length, keys, key_length, number_of_keys, true); } memcached_return_t memcached_mget_execute(memcached_st *ptr, @@ -369,7 +410,7 @@ memcached_return_t memcached_mget_execute(memcached_st *ptr, context, number_of_callbacks); } -memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr, +memcached_return_t memcached_mget_execute_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, const char * const *keys, @@ -379,10 +420,24 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr, void *context, unsigned int number_of_callbacks) { - if ((ptr->flags.binary_protocol) == 0) - return MEMCACHED_NOT_SUPPORTED; - + Memcached* ptr= memcached2Memcached(shell); memcached_return_t rc; + if (memcached_failed(rc= initialize_query(ptr, false))) + { + return rc; + } + + if (memcached_is_udp(ptr)) + { + return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT); + } + + if (memcached_is_binary(ptr) == false) + { + return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT, + memcached_literal_param("ASCII protocol is not supported for memcached_mget_execute_by_key()")); + } + memcached_callback_st *original_callbacks= ptr->callbacks; memcached_callback_st cb= { callback, @@ -394,20 +449,26 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr, rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys, key_length, number_of_keys); ptr->callbacks= original_callbacks; + return rc; } static memcached_return_t simple_binary_mget(memcached_st *ptr, - uint32_t master_server_key, + const uint32_t master_server_key, bool is_group_key_set, const char * const *keys, const size_t *key_length, - size_t number_of_keys, bool mget_mode) + const size_t number_of_keys, const bool mget_mode) { memcached_return_t rc= MEMCACHED_NOTFOUND; bool flush= (number_of_keys == 1); + if (memcached_failed(rc= memcached_key_test(*ptr, keys, key_length, number_of_keys))) + { + return rc; + } + /* If a server fails we warn about errors and start all over with sending keys to the server. @@ -415,7 +476,6 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, for (uint32_t x= 0; x < number_of_keys; ++x) { uint32_t server_key; - memcached_server_write_instance_st instance; if (is_group_key_set) { @@ -426,47 +486,57 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - instance= memcached_server_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); - if (memcached_server_response_count(instance) == 0) + if (instance->response_count() == 0) { rc= memcached_connect(instance); - if (rc != MEMCACHED_SUCCESS) + if (memcached_failed(rc)) + { continue; + } } protocol_binary_request_getk request= { }; //= {.bytes= {0}}; - request.message.header.request.magic= PROTOCOL_BINARY_REQ; + initialize_binary_request(instance, request.message.header); if (mget_mode) + { request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ; + } else + { request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK; + } - memcached_return_t vk; - vk= memcached_validate_key_length(key_length[x], - ptr->flags.binary_protocol); - unlikely (vk != MEMCACHED_SUCCESS) +#if 0 { - if (x > 0) + memcached_return_t vk= memcached_validate_key_length(key_length[x], ptr->flags.binary_protocol); + if (memcached_failed(rc= memcached_key_test(*memc, (const char **)&key, &key_length, 1))) { - memcached_io_reset(instance); - } + memcached_set_error(ptr, vk, MEMCACHED_AT, memcached_literal_param("Key was too long.")); + + if (x > 0) + { + memcached_io_reset(instance); + } - return vk; + return vk; + } } +#endif - request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key))); + request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace))); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; - request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->prefix_key))); + request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->_namespace))); - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { - { sizeof(request.bytes), request.bytes }, - { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) }, - { key_length[x], keys[x] } + { request.bytes, sizeof(request.bytes) }, + { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, + { keys[x], key_length[x] } }; - if (memcached_io_writev(instance, vector, 3, flush) == -1) + if (memcached_io_writev(instance, vector, 3, flush) == false) { memcached_server_response_reset(instance); rc= MEMCACHED_SOME_ERRORS; @@ -476,7 +546,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, /* We just want one pending response per server */ memcached_server_response_reset(instance); memcached_server_response_increment(instance); - if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS) + if ((x > 0 and x == ptr->io_key_prefetch) and memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS) { rc= MEMCACHED_SOME_ERRORS; } @@ -488,28 +558,20 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, Send a noop command to flush the buffers */ protocol_binary_request_noop request= {}; //= {.bytes= {0}}; - request.message.header.request.magic= PROTOCOL_BINARY_REQ; request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP; request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; for (uint32_t x= 0; x < memcached_server_count(ptr); ++x) { - memcached_server_write_instance_st instance= - memcached_server_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); - if (memcached_server_response_count(instance)) + if (instance->response_count()) { - if (memcached_io_write(instance, NULL, 0, true) == -1) - { - memcached_server_response_reset(instance); - memcached_io_reset(instance); - rc= MEMCACHED_SOME_ERRORS; - } - - if (memcached_io_write(instance, request.bytes, - sizeof(request.bytes), true) == -1) + initialize_binary_request(instance, request.message.header); + if ((memcached_io_write(instance) == false) or + (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1)) { - memcached_server_response_reset(instance); + memcached_instance_response_reset(instance); memcached_io_reset(instance); rc= MEMCACHED_SOME_ERRORS; } @@ -517,7 +579,6 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, } } - return rc; } @@ -526,14 +587,16 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, bool* dead_servers, const char *const *keys, const size_t *key_length, - size_t number_of_keys) + const size_t number_of_keys) { memcached_return_t rc= MEMCACHED_NOTFOUND; uint32_t start= 0; uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ); if (randomize_read) + { start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1); + } /* Loop for each replica */ for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica) @@ -543,25 +606,34 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, for (uint32_t x= 0; x < number_of_keys; ++x) { if (hash[x] == memcached_server_count(ptr)) + { continue; /* Already successfully sent */ + } - uint32_t server= hash[x] + replica; + uint32_t server= hash[x] +replica; /* In case of randomized reads */ - if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas))) - server += start; + if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas))) + { + server+= start; + } while (server >= memcached_server_count(ptr)) + { server -= memcached_server_count(ptr); + } if (dead_servers[server]) + { continue; + } - memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server); - if (memcached_server_response_count(instance) == 0) + if (instance->response_count() == 0) { rc= memcached_connect(instance); + if (memcached_failed(rc)) { memcached_io_reset(instance); @@ -572,11 +644,11 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, } protocol_binary_request_getk request= {}; - request.message.header.request.magic= PROTOCOL_BINARY_REQ; + initialize_binary_request(instance, request.message.header); request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK; - request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key))); + request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace))); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; - request.message.header.request.bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->prefix_key))); + request.message.header.request.bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->_namespace))); /* * We need to disable buffering to actually know that the request was @@ -588,14 +660,14 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, * that we might have processed some of the responses etc. For now, * just make sure we work _correctly_ */ - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { - { sizeof(request.bytes), request.bytes }, - { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) }, - { key_length[x], keys[x] } + { request.bytes, sizeof(request.bytes) }, + { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, + { keys[x], key_length[x] } }; - if (memcached_io_writev(instance, vector, 3, true) == -1) + if (memcached_io_writev(instance, vector, 3, true) == false) { memcached_io_reset(instance); dead_servers[server]= true; @@ -608,62 +680,59 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, } if (success) + { break; + } } return rc; } static memcached_return_t binary_mget_by_key(memcached_st *ptr, - uint32_t master_server_key, + const uint32_t master_server_key, bool is_group_key_set, const char * const *keys, const size_t *key_length, - size_t number_of_keys, - bool mget_mode) + const size_t number_of_keys, + const bool mget_mode) { - memcached_return_t rc; - if (ptr->number_of_replicas == 0) { - rc= simple_binary_mget(ptr, master_server_key, is_group_key_set, - keys, key_length, number_of_keys, mget_mode); + return simple_binary_mget(ptr, master_server_key, is_group_key_set, + keys, key_length, number_of_keys, mget_mode); } - else - { - uint32_t* hash= static_cast(libmemcached_malloc(ptr, sizeof(uint32_t) * number_of_keys)); - bool* dead_servers= static_cast(libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(bool))); - if (hash == NULL || dead_servers == NULL) - { - libmemcached_free(ptr, hash); - libmemcached_free(ptr, dead_servers); - return MEMCACHED_MEMORY_ALLOCATION_FAILURE; - } + uint32_t* hash= libmemcached_xvalloc(ptr, number_of_keys, uint32_t); + bool* dead_servers= libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool); - if (is_group_key_set) + if (hash == NULL or dead_servers == NULL) + { + libmemcached_free(ptr, hash); + libmemcached_free(ptr, dead_servers); + return MEMCACHED_MEMORY_ALLOCATION_FAILURE; + } + + if (is_group_key_set) + { + for (size_t x= 0; x < number_of_keys; x++) { - for (size_t x= 0; x < number_of_keys; x++) - { - hash[x]= master_server_key; - } + hash[x]= master_server_key; } - else + } + else + { + for (size_t x= 0; x < number_of_keys; x++) { - for (size_t x= 0; x < number_of_keys; x++) - { - hash[x]= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); - } + hash[x]= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } + } - rc= replication_binary_mget(ptr, hash, dead_servers, keys, - key_length, number_of_keys); - - libmemcached_free(ptr, hash); - libmemcached_free(ptr, dead_servers); + memcached_return_t rc= replication_binary_mget(ptr, hash, dead_servers, keys, + key_length, number_of_keys); - return MEMCACHED_SUCCESS; - } + WATCHPOINT_IFERROR(rc); + libmemcached_free(ptr, hash); + libmemcached_free(ptr, dead_servers); - return rc; + return MEMCACHED_SUCCESS; }