X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=src%2Flibmemcached%2Fget.cc;h=d625adce3824feb3e733ec2d794faad06b1d3e8e;hb=2f289c64f625962d945ec3bee80f36bc5c61ee35;hp=86d8cf2e13522b625cf35f4acd8a1de23636e733;hpb=5e760300d15ef4c5b7eed3fb9f37920ebca2f6ec;p=awesomized%2Flibmemcached diff --git a/src/libmemcached/get.cc b/src/libmemcached/get.cc index 86d8cf2e..d625adce 100644 --- a/src/libmemcached/get.cc +++ b/src/libmemcached/get.cc @@ -1,165 +1,111 @@ -/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * Libmemcached library - * - * 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 - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following disclaimer - * in the documentation and/or other materials provided with the - * distribution. - * - * * The names of its contributors may not be used to endorse or - * promote products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#include - /* - What happens if no servers exist? + +--------------------------------------------------------------------+ + | libmemcached - C/C++ Client Library for memcached | + +--------------------------------------------------------------------+ + | Redistribution and use in source and binary forms, with or without | + | modification, are permitted under the terms of the BSD license. | + | You should have received a copy of the license in a bundled file | + | named LICENSE; in case you did not receive a copy you can review | + | the terms online at: https://opensource.org/licenses/BSD-3-Clause | + +--------------------------------------------------------------------+ + | Copyright (c) 2006-2014 Brian Aker https://datadifferential.com/ | + | Copyright (c) 2020 Michael Wallner | + +--------------------------------------------------------------------+ */ -char *memcached_get(memcached_st *ptr, const char *key, - size_t key_length, - size_t *value_length, - uint32_t *flags, - memcached_return_t *error) -{ - return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length, - flags, error); + +#include "libmemcached/common.h" +#include "p9y/random.hpp" + +char *memcached_get(memcached_st *ptr, const char *key, size_t key_length, size_t *value_length, + uint32_t *flags, memcached_return_t *error) { + return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length, flags, error); } -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, +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, - size_t *value_length, - uint32_t *flags, - memcached_return_t *error) -{ - Memcached* ptr= memcached2Memcached(shell); +char *memcached_get_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, + const char *key, size_t key_length, size_t *value_length, + uint32_t *flags, memcached_return_t *error) { + Memcached *ptr = memcached2Memcached(shell); memcached_return_t unused; - if (error == NULL) - { - error= &unused; + if (error == NULL) { + error = &unused; } - uint64_t query_id= 0; - if (ptr) - { - query_id= ptr->query_id; + uint64_t query_id = 0; + if (ptr) { + query_id = ptr->query_id; } /* Request the key */ - *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."); + *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_failed(*error)) { + if (ptr) { if (memcached_has_current_error(*ptr)) // Find the most accurate error { - *error= memcached_last_error(ptr); + *error = memcached_last_error(ptr); } } - if (value_length) - { - *value_length= 0; + 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."); + 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."); /* This is for historical reasons */ - if (*error == MEMCACHED_END) - { - *error= MEMCACHED_NOTFOUND; + if (*error == MEMCACHED_END) { + *error = MEMCACHED_NOTFOUND; } - if (value == NULL) - { - if (ptr->get_key_failure and *error == MEMCACHED_NOTFOUND) - { + if (value == NULL) { + if (ptr->get_key_failure and *error == MEMCACHED_NOTFOUND) { 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); + 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 or rc == MEMCACHED_BUFFERED) - { - if (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) - { + 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(result_ptr)), - (memcached_result_length(result_ptr)), - 0, - (memcached_result_flags(result_ptr))); + rc = memcached_set(ptr, key, key_length, (memcached_result_value(result_ptr)), + (memcached_result_length(result_ptr)), 0, + (memcached_result_flags(result_ptr))); - if (rc == MEMCACHED_BUFFERED and 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(result_ptr)), - (memcached_result_length(result_ptr)), - 0, - (memcached_result_flags(result_ptr))); + } else { + rc = memcached_set(ptr, key, key_length, (memcached_result_value(result_ptr)), + (memcached_result_length(result_ptr)), 0, + (memcached_result_flags(result_ptr))); } - if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED) - { - *error= rc; - *value_length= memcached_result_length(result_ptr); - *flags= memcached_result_flags(result_ptr); - char *result_value= memcached_string_take_value(&result_ptr->value); + if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED) { + *error = rc; + if (value_length) { + *value_length = memcached_result_length(result_ptr); + } + if (flags) { + *flags = memcached_result_flags(result_ptr); + } + char *result_value = memcached_string_take_value(&result_ptr->value); memcached_result_free(result_ptr); return result_value; @@ -168,7 +114,8 @@ char *memcached_get_by_key(memcached_st *shell, memcached_result_free(result_ptr); } - assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); + assert_msg(ptr->query_id == query_id + 1, + "Programmer error, the query_id was not incremented."); return NULL; } @@ -176,65 +123,52 @@ char *memcached_get_by_key(memcached_st *shell, return value; } -memcached_return_t memcached_mget(memcached_st *ptr, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys) -{ +memcached_return_t memcached_mget(memcached_st *ptr, const char *const *keys, + const size_t *key_length, size_t number_of_keys) { return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys); } -static memcached_return_t binary_mget_by_key(memcached_st *ptr, - 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, +static memcached_return_t binary_mget_by_key(memcached_st *ptr, 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, - const bool mget_mode) -{ - bool failures_occured_in_sending= false; - 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! */ +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, + const bool mget_mode) { + bool failures_occured_in_sending = false; + 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! */ memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr, true))) - { + if (memcached_failed(rc = initialize_query(ptr, true))) { return rc; } - if (memcached_is_udp(ptr)) - { + 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_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Numbers of keys provided was zero")); + if (number_of_keys == 0) { + return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, + memcached_literal_param("Numbers of keys provided was zero")); } - if (memcached_failed((rc= memcached_key_test(*ptr, keys, key_length, number_of_keys)))) - { + if (memcached_failed((rc = memcached_key_test(*ptr, keys, key_length, number_of_keys)))) { 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; + 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; } /* @@ -243,36 +177,30 @@ static memcached_return_t __mget_by_key_real(memcached_st *ptr, It might be optimum to bounce the connection if count > some number. */ - for (uint32_t x= 0; x < memcached_server_count(ptr); x++) - { - memcached_instance_st* instance= memcached_instance_fetch(ptr, x); + for (uint32_t x = 0; x < memcached_server_count(ptr); x++) { + memcached_instance_st *instance = memcached_instance_fetch(ptr, x); - if (instance->response_count()) - { + if (instance->response_count()) { char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; - if (ptr->flags.no_block) - { + if (ptr->flags.no_block || ptr->flags.buffer_requests) { memcached_io_write(instance); } - while(instance->response_count()) - { - (void)memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result); + while (instance->response_count()) { + (void) memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result); } } } - 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); + 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); } - if (ptr->flags.support_cas) - { - get_command= "gets"; - get_command_length= 4; + if (ptr->flags.support_cas) { + get_command = "gets"; + get_command_length = 4; } /* @@ -280,45 +208,35 @@ static memcached_return_t __mget_by_key_real(memcached_st *ptr, to the server. */ WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS); - size_t hosts_connected= 0; - for (uint32_t x= 0; x < number_of_keys; x++) - { + size_t hosts_connected = 0; + for (uint32_t x = 0; x < number_of_keys; x++) { uint32_t server_key; - if (is_group_key_set) - { - server_key= master_server_key; - } - else - { - server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); + if (is_group_key_set) { + server_key = master_server_key; + } else { + server_key = memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); - - libmemcached_io_vector_st vector[]= - { - { get_command, get_command_length }, - { memcached_literal_param(" ") }, - { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, - { keys[x], key_length[x] } - }; + memcached_instance_st *instance = memcached_instance_fetch(ptr, server_key); + libmemcached_io_vector_st vector[] = { + {get_command, get_command_length}, + {memcached_literal_param(" ")}, + {memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace)}, + {keys[x], key_length[x]}}; - if (instance->response_count() == 0) - { - rc= memcached_connect(instance); + if (instance->response_count() == 0) { + rc = memcached_connect(instance); - if (memcached_failed(rc)) - { + if (memcached_failed(rc)) { memcached_set_error(*instance, rc, MEMCACHED_AT); continue; } hosts_connected++; - if ((memcached_io_writev(instance, vector, 1, false)) == false) - { - failures_occured_in_sending= true; + if ((memcached_io_writev(instance, vector, 1, false)) == false) { + failures_occured_in_sending = true; continue; } WATCHPOINT_ASSERT(instance->cursor_active_ == 0); @@ -327,145 +245,111 @@ static memcached_return_t __mget_by_key_real(memcached_st *ptr, } { - if ((memcached_io_writev(instance, (vector + 1), 3, false)) == false) - { + if ((memcached_io_writev(instance, (vector + 1), 3, false)) == false) { memcached_instance_response_reset(instance); - failures_occured_in_sending= true; + failures_occured_in_sending = true; continue; } } } - if (hosts_connected == 0) - { + if (hosts_connected == 0) { LIBMEMCACHED_MEMCACHED_MGET_END(); - if (memcached_failed(rc)) - { + if (memcached_failed(rc)) { return rc; } return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT); } - /* Should we muddle on if some servers are dead? */ - bool success_happened= false; - for (uint32_t x= 0; x < memcached_server_count(ptr); x++) - { - memcached_instance_st* instance= memcached_instance_fetch(ptr, x); + bool success_happened = false; + for (uint32_t x = 0; x < memcached_server_count(ptr); x++) { + memcached_instance_st *instance = memcached_instance_fetch(ptr, x); - if (instance->response_count()) - { + 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) - { - failures_occured_in_sending= true; - } - else - { - success_happened= true; + if ((memcached_io_write(instance, "\r\n", 2, true)) == -1) { + failures_occured_in_sending = true; + } else { + success_happened = true; } } } LIBMEMCACHED_MEMCACHED_MGET_END(); - if (failures_occured_in_sending and success_happened) - { + if (failures_occured_in_sending and success_happened) { return MEMCACHED_SOME_ERRORS; } - if (success_happened) - { + if (success_happened) { return MEMCACHED_SUCCESS; } return MEMCACHED_FAILURE; // Complete failure occurred } -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) -{ - 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_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) { + 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, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys, - memcached_execute_fn *callback, - void *context, - unsigned int number_of_callbacks) -{ - return memcached_mget_execute_by_key(ptr, NULL, 0, keys, key_length, - number_of_keys, callback, +memcached_return_t memcached_mget_execute(memcached_st *ptr, const char *const *keys, + const size_t *key_length, size_t number_of_keys, + memcached_execute_fn *callback, void *context, + unsigned int number_of_callbacks) { + return memcached_mget_execute_by_key(ptr, NULL, 0, keys, key_length, number_of_keys, callback, context, number_of_callbacks); } -memcached_return_t memcached_mget_execute_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, - memcached_execute_fn *callback, - void *context, - unsigned int number_of_callbacks) -{ - Memcached* ptr= memcached2Memcached(shell); +memcached_return_t memcached_mget_execute_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, + memcached_execute_fn *callback, void *context, + unsigned int number_of_callbacks) { + Memcached *ptr = memcached2Memcached(shell); memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr, false))) - { + if (memcached_failed(rc = initialize_query(ptr, false))) { return rc; } - if (memcached_is_udp(ptr)) - { + 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()")); + 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, - context, - number_of_callbacks - }; + memcached_callback_st *original_callbacks = ptr->callbacks; + memcached_callback_st cb = {callback, context, number_of_callbacks}; - ptr->callbacks= &cb; - rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys, - key_length, number_of_keys); - ptr->callbacks= original_callbacks; + ptr->callbacks = &cb; + 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, - const uint32_t master_server_key, - bool is_group_key_set, - const char * const *keys, - const size_t *key_length, - const size_t number_of_keys, const bool mget_mode) -{ - memcached_return_t rc= MEMCACHED_NOTFOUND; +static memcached_return_t simple_binary_mget(memcached_st *ptr, const uint32_t master_server_key, + bool is_group_key_set, const char *const *keys, + const size_t *key_length, const size_t number_of_keys, + const bool mget_mode) { + memcached_return_t rc = MEMCACHED_NOTFOUND; - bool flush= (number_of_keys == 1); + bool flush = (number_of_keys == 1); - if (memcached_failed(rc= memcached_key_test(*ptr, keys, key_length, number_of_keys))) - { + if (memcached_failed(rc = memcached_key_test(*ptr, keys, key_length, number_of_keys))) { return rc; } @@ -473,39 +357,30 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, If a server fails we warn about errors and start all over with sending keys to the server. */ - for (uint32_t x= 0; x < number_of_keys; ++x) - { + for (uint32_t x = 0; x < number_of_keys; ++x) { uint32_t server_key; - if (is_group_key_set) - { - server_key= master_server_key; - } - else - { - server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); + if (is_group_key_set) { + server_key = master_server_key; + } else { + server_key = memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); + memcached_instance_st *instance = memcached_instance_fetch(ptr, server_key); - if (instance->response_count() == 0) - { - rc= memcached_connect(instance); - if (memcached_failed(rc)) - { + if (instance->response_count() == 0) { + rc = memcached_connect(instance); + if (memcached_failed(rc)) { continue; } } - protocol_binary_request_getk request= { }; //= {.bytes= {0}}; + protocol_binary_request_getk request = {}; //= {.bytes= {0}}; 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; + if (mget_mode) { + request.message.header.request.opcode = PROTOCOL_BINARY_CMD_GETKQ; + } else { + request.message.header.request.opcode = PROTOCOL_BINARY_CMD_GETK; } #if 0 @@ -525,21 +400,20 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, } #endif - 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->_namespace))); + 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->_namespace))); - libmemcached_io_vector_st vector[]= - { - { request.bytes, sizeof(request.bytes) }, - { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, - { keys[x], key_length[x] } - }; + libmemcached_io_vector_st vector[] = { + {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) == false) - { + if (memcached_io_writev(instance, vector, 3, flush) == false) { memcached_server_response_reset(instance); - rc= MEMCACHED_SOME_ERRORS; + rc = MEMCACHED_SOME_ERRORS; continue; } @@ -548,32 +422,29 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, memcached_server_response_increment(instance); if ((x > 0 and x == ptr->io_key_prefetch) and memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS) { - rc= MEMCACHED_SOME_ERRORS; + rc = MEMCACHED_SOME_ERRORS; } } - if (mget_mode) - { + if (mget_mode) { /* Send a noop command to flush the buffers */ - protocol_binary_request_noop request= {}; //= {.bytes= {0}}; - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP; - request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; + protocol_binary_request_noop request = {}; //= {.bytes= {0}}; + 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_instance_st* instance= memcached_instance_fetch(ptr, x); + for (uint32_t x = 0; x < memcached_server_count(ptr); ++x) { + memcached_instance_st *instance = memcached_instance_fetch(ptr, x); - if (instance->response_count()) - { + if (instance->response_count()) { 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)) + if ((memcached_io_write(instance) == false) + or (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1)) { memcached_instance_response_reset(instance); memcached_io_reset(instance); - rc= MEMCACHED_SOME_ERRORS; + rc = MEMCACHED_SOME_ERRORS; } } } @@ -582,73 +453,63 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, return rc; } -static memcached_return_t replication_binary_mget(memcached_st *ptr, - uint32_t* hash, - bool* dead_servers, - const char *const *keys, +static memcached_return_t replication_binary_mget(memcached_st *ptr, uint32_t *hash, + bool *dead_servers, const char *const *keys, const size_t *key_length, - 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); + 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) - { - bool success= true; + for (uint32_t replica = 0; replica <= ptr->number_of_replicas; ++replica) { + bool success = true; - for (uint32_t x= 0; x < number_of_keys; ++x) - { - if (hash[x] == memcached_server_count(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 and ((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)) - { + while (server >= memcached_server_count(ptr)) { server -= memcached_server_count(ptr); } - if (dead_servers[server]) - { + if (dead_servers[server]) { continue; } - memcached_instance_st* instance= memcached_instance_fetch(ptr, server); + memcached_instance_st *instance = memcached_instance_fetch(ptr, server); - if (instance->response_count() == 0) - { - rc= memcached_connect(instance); + if (instance->response_count() == 0) { + rc = memcached_connect(instance); - if (memcached_failed(rc)) - { + if (memcached_failed(rc)) { memcached_io_reset(instance); - dead_servers[server]= true; - success= false; + dead_servers[server] = true; + success = false; continue; } } - protocol_binary_request_getk request= {}; + protocol_binary_request_getk request = {}; 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->_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->_namespace))); + request.message.header.request.opcode = PROTOCOL_BINARY_CMD_GETK; + 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->_namespace))); /* * We need to disable buffering to actually know that the request was @@ -659,28 +520,24 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, * and we used the callback interface from memcached_mget_execute so * that we might have processed some of the responses etc. For now, * just make sure we work _correctly_ - */ - libmemcached_io_vector_st vector[]= - { - { request.bytes, sizeof(request.bytes) }, - { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, - { keys[x], key_length[x] } - }; + */ + libmemcached_io_vector_st vector[] = { + {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) == false) - { + if (memcached_io_writev(instance, vector, 3, true) == false) { memcached_io_reset(instance); - dead_servers[server]= true; - success= false; + dead_servers[server] = true; + success = false; continue; } memcached_server_response_increment(instance); - hash[x]= memcached_server_count(ptr); + hash[x] = memcached_server_count(ptr); } - if (success) - { + if (success) { break; } } @@ -688,47 +545,36 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, return rc; } -static memcached_return_t binary_mget_by_key(memcached_st *ptr, - const uint32_t master_server_key, - bool is_group_key_set, - const char * const *keys, - const size_t *key_length, - const size_t number_of_keys, - const bool mget_mode) -{ - if (ptr->number_of_replicas == 0) - { - return simple_binary_mget(ptr, master_server_key, is_group_key_set, - keys, key_length, number_of_keys, mget_mode); +static memcached_return_t binary_mget_by_key(memcached_st *ptr, const uint32_t master_server_key, + bool is_group_key_set, const char *const *keys, + const size_t *key_length, const size_t number_of_keys, + const bool mget_mode) { + if (ptr->number_of_replicas == 0) { + return simple_binary_mget(ptr, master_server_key, is_group_key_set, keys, key_length, + number_of_keys, mget_mode); } - uint32_t* hash= libmemcached_xvalloc(ptr, number_of_keys, uint32_t); - bool* dead_servers= libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool); + uint32_t *hash = libmemcached_xvalloc(ptr, number_of_keys, uint32_t); + bool *dead_servers = libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool); - if (hash == NULL or dead_servers == NULL) - { + 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++) - { - hash[x]= master_server_key; + if (is_group_key_set) { + for (size_t x = 0; x < number_of_keys; x++) { + hash[x] = master_server_key; } - } - else - { - for (size_t x= 0; x < number_of_keys; x++) - { - hash[x]= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); + } else { + for (size_t x = 0; x < number_of_keys; x++) { + hash[x] = memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } } - memcached_return_t rc= replication_binary_mget(ptr, hash, dead_servers, keys, - key_length, number_of_keys); + memcached_return_t rc = + replication_binary_mget(ptr, hash, dead_servers, keys, key_length, number_of_keys); WATCHPOINT_IFERROR(rc); libmemcached_free(ptr, hash);