X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fauto.cc;h=28550a18c1e73940a36523122fde7d416d002770;hb=5a6b3168c8b796b919fc77465320b0d3b84ef4ba;hp=507ae366d52cddbd0de2aa1dba4a2850939add33;hpb=473a604470aa72c043242128a7cbe006999d9e19;p=m6w6%2Flibmemcached diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc index 507ae366..28550a18 100644 --- a/libmemcached/auto.cc +++ b/libmemcached/auto.cc @@ -37,129 +37,105 @@ #include -static memcached_return_t text_incr_decr(memcached_st *ptr, - const char *verb, - const char *group_key, size_t group_key_length, +static memcached_return_t text_incr_decr(memcached_server_write_instance_st instance, + const bool is_incr, const char *key, size_t key_length, - uint64_t offset, - uint64_t *value) + const uint64_t offset, + const bool reply, + uint64_t& numeric_value) { char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; - uint32_t server_key; - memcached_server_write_instance_st instance; - bool no_reply= ptr->flags.no_reply; - if (memcached_failed(memcached_key_test(*ptr, (const char **)&key, &key_length, 1))) + int send_length= snprintf(buffer, sizeof(buffer), " %" PRIu64, offset); + if (size_t(send_length) >= sizeof(buffer) or send_length < 0) { - return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT); + return memcached_set_error(*instance, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, + memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)")); } - server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - instance= memcached_server_instance_fetch(ptr, server_key); - - int send_length; - send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "%s %.*s%.*s %" PRIu64 "%s\r\n", verb, - memcached_print_array(ptr->_namespace), - (int)key_length, key, - offset, no_reply ? " noreply" : ""); - if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE || send_length < 0) + libmemcached_io_vector_st vector[]= { - return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, - memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)")); - } + { NULL, 0 }, + { memcached_literal_param("incr ") }, + { memcached_array_string(instance->root->_namespace), memcached_array_size(instance->root->_namespace) }, + { key, key_length }, + { buffer, send_length }, + { " noreply", reply ? 0 : memcached_literal_param_size(" noreply") }, + { memcached_literal_param("\r\n") } + }; - memcached_return_t rc= memcached_do(instance, buffer, (size_t)send_length, true); - if (no_reply or memcached_failed(rc)) + if (is_incr == false) { - return rc; + vector[1].buffer= "decr "; } - rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); + memcached_return_t rc= memcached_vdo(instance, vector, 7, true); - if (rc != MEMCACHED_SUCCESS) + if (reply == false) { - return memcached_set_error(*instance, rc, MEMCACHED_AT); + return MEMCACHED_SUCCESS; } - /* - So why recheck responce? Because the protocol is brain dead :) - The number returned might end up equaling one of the string - values. Less chance of a mistake with strncmp() so we will - use it. We still called memcached_response() though since it - worked its magic for non-blocking IO. - */ - if (not strncmp(buffer, memcached_literal_param("ERROR\r\n"))) + if (memcached_failed(rc)) { - *value= 0; - rc= MEMCACHED_PROTOCOL_ERROR; - } - else if (not strncmp(buffer, memcached_literal_param("CLIENT_ERROR\r\n"))) - { - *value= 0; - rc= MEMCACHED_PROTOCOL_ERROR; - } - else if (not strncmp(buffer, memcached_literal_param("NOT_FOUND\r\n"))) - { - *value= 0; - rc= MEMCACHED_NOTFOUND; - } - else - { - *value= strtoull(buffer, (char **)NULL, 10); - rc= MEMCACHED_SUCCESS; + numeric_value= UINT64_MAX; + return rc; } + rc= memcached_response(instance, buffer, sizeof(buffer), NULL, numeric_value); + return memcached_set_error(*instance, rc, MEMCACHED_AT); } -static memcached_return_t binary_incr_decr(memcached_st *ptr, uint8_t cmd, - const char *group_key, size_t group_key_length, - const char *key, size_t key_length, - uint64_t offset, uint64_t initial, - uint32_t expiration, +static memcached_return_t binary_incr_decr(memcached_server_write_instance_st instance, + protocol_binary_command cmd, + const char *key, const size_t key_length, + const uint64_t offset, + const uint64_t initial, + const uint32_t expiration, + const bool reply, uint64_t *value) { - bool no_reply= ptr->flags.no_reply; - - uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key); - - if (no_reply) + if (reply == false) { if(cmd == PROTOCOL_BINARY_CMD_DECREMENT) + { cmd= PROTOCOL_BINARY_CMD_DECREMENTQ; + } if(cmd == PROTOCOL_BINARY_CMD_INCREMENT) + { cmd= PROTOCOL_BINARY_CMD_INCREMENTQ; + } } protocol_binary_request_incr request= {}; // = {.bytes= {0}}; request.message.header.request.magic= PROTOCOL_BINARY_REQ; request.message.header.request.opcode= cmd; - request.message.header.request.keylen= htons((uint16_t)(key_length + memcached_array_size(ptr->_namespace))); + request.message.header.request.keylen= htons((uint16_t)(key_length + memcached_array_size(instance->root->_namespace))); request.message.header.request.extlen= 20; request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; - request.message.header.request.bodylen= htonl((uint32_t)(key_length + memcached_array_size(ptr->_namespace) +request.message.header.request.extlen)); + request.message.header.request.bodylen= htonl((uint32_t)(key_length + memcached_array_size(instance->root->_namespace) +request.message.header.request.extlen)); request.message.body.delta= memcached_htonll(offset); request.message.body.initial= memcached_htonll(initial); request.message.body.expiration= htonl((uint32_t) expiration); - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { + { NULL, 0 }, { request.bytes, sizeof(request.bytes) }, - { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, + { memcached_array_string(instance->root->_namespace), memcached_array_size(instance->root->_namespace) }, { key, key_length } }; memcached_return_t rc; - if (memcached_failed(rc= memcached_vdo(instance, vector, 3, true))) + if (memcached_failed(rc= memcached_vdo(instance, vector, 4, true))) { memcached_io_reset(instance); - return (rc == MEMCACHED_SUCCESS) ? MEMCACHED_WRITE_FAILURE : rc; + return MEMCACHED_WRITE_FAILURE; } - if (no_reply) + if (reply == false) { return MEMCACHED_SUCCESS; } @@ -196,7 +172,7 @@ memcached_return_t memcached_increment_by_key(memcached_st *ptr, value= &local_value; } - if (memcached_failed(rc= initialize_query(ptr))) + if (memcached_failed(rc= initialize_query(ptr, true))) { return rc; } @@ -206,17 +182,28 @@ memcached_return_t memcached_increment_by_key(memcached_st *ptr, return rc; } + if (memcached_failed(rc= memcached_key_test(*ptr, (const char **)&key, &key_length, 1))) + { + return memcached_set_error(*ptr, rc, MEMCACHED_AT); + } + + uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); + memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key); + + bool reply= memcached_is_replying(instance->root); + LIBMEMCACHED_MEMCACHED_INCREMENT_START(); - if (ptr->flags.binary_protocol) + if (memcached_is_binary(ptr)) { - rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT, - group_key, group_key_length, key, key_length, - (uint64_t)offset, 0, MEMCACHED_EXPIRATION_NOT_ADD, + rc= binary_incr_decr(instance, PROTOCOL_BINARY_CMD_INCREMENT, + key, key_length, + uint64_t(offset), 0, MEMCACHED_EXPIRATION_NOT_ADD, + reply, value); } else { - rc= text_incr_decr(ptr, "incr", group_key, group_key_length, key, key_length, offset, value); + rc= text_incr_decr(instance, true, key, key_length, offset, reply, *value); } LIBMEMCACHED_MEMCACHED_INCREMENT_END(); @@ -237,28 +224,34 @@ memcached_return_t memcached_decrement_by_key(memcached_st *ptr, } memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) + if (memcached_failed(rc= initialize_query(ptr, true))) { return rc; } - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) + if (memcached_failed(rc= memcached_key_test(*ptr, (const char **)&key, &key_length, 1))) { - return rc; + return memcached_set_error(*ptr, rc, MEMCACHED_AT); } + uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); + memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key); + + bool reply= memcached_is_replying(instance->root); + LIBMEMCACHED_MEMCACHED_DECREMENT_START(); - if (ptr->flags.binary_protocol) + if (memcached_is_binary(ptr)) { - rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_DECREMENT, - group_key, group_key_length, key, key_length, - (uint64_t)offset, 0, MEMCACHED_EXPIRATION_NOT_ADD, + rc= binary_incr_decr(instance, PROTOCOL_BINARY_CMD_DECREMENT, + key, key_length, + offset, 0, MEMCACHED_EXPIRATION_NOT_ADD, + reply, value); } else { - rc= text_incr_decr(ptr, "decr", group_key, group_key_length, key, key_length, offset, value); + rc= text_incr_decr(instance, false, key, key_length, offset, reply, *value); } LIBMEMCACHED_MEMCACHED_DECREMENT_END(); @@ -274,12 +267,6 @@ memcached_return_t memcached_increment_with_initial(memcached_st *ptr, time_t expiration, uint64_t *value) { - uint64_t local_value; - if (value == NULL) - { - value= &local_value; - } - return memcached_increment_with_initial_by_key(ptr, key, key_length, key, key_length, offset, initial, expiration, value); @@ -302,27 +289,34 @@ memcached_return_t memcached_increment_with_initial_by_key(memcached_st *ptr, } memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) + if (memcached_failed(rc= initialize_query(ptr, true))) { return rc; } - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) + if (memcached_failed(rc= memcached_key_test(*ptr, (const char **)&key, &key_length, 1))) { - return rc; + return memcached_set_error(*ptr, rc, MEMCACHED_AT); } + uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); + memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key); + + bool reply= memcached_is_replying(instance->root); + LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START(); - if (ptr->flags.binary_protocol) + if (memcached_is_binary(ptr)) { - rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT, - group_key, group_key_length, key, key_length, - offset, initial, (uint32_t)expiration, + rc= binary_incr_decr(instance, PROTOCOL_BINARY_CMD_INCREMENT, + key, key_length, + offset, initial, uint32_t(expiration), + reply, value); } else { - rc= MEMCACHED_PROTOCOL_ERROR; + rc= memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, + memcached_literal_param("memcached_increment_with_initial_by_key() is not supported via the ASCII protocol")); } LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END(); @@ -338,12 +332,6 @@ memcached_return_t memcached_decrement_with_initial(memcached_st *ptr, time_t expiration, uint64_t *value) { - uint64_t local_value; - if (value == NULL) - { - value= &local_value; - } - return memcached_decrement_with_initial_by_key(ptr, key, key_length, key, key_length, offset, initial, expiration, value); @@ -366,32 +354,38 @@ memcached_return_t memcached_decrement_with_initial_by_key(memcached_st *ptr, } memcached_return_t rc; - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) + if (memcached_failed(rc= initialize_query(ptr, true))) { return rc; } - if (memcached_failed(rc= initialize_query(ptr))) + if (memcached_failed(rc= memcached_key_test(*ptr, (const char **)&key, &key_length, 1))) { - return rc; + return memcached_set_error(*ptr, rc, MEMCACHED_AT); } + uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); + memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key); + + bool reply= memcached_is_replying(instance->root); + LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START(); - if (ptr->flags.binary_protocol) + if (memcached_is_binary(ptr)) { - rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_DECREMENT, - group_key, group_key_length, key, key_length, - offset, initial, (uint32_t)expiration, + rc= binary_incr_decr(instance, PROTOCOL_BINARY_CMD_DECREMENT, + key, key_length, + offset, initial, uint32_t(expiration), + reply, value); } else { - rc= MEMCACHED_PROTOCOL_ERROR; + rc= memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, + memcached_literal_param("memcached_decrement_with_initial_by_key() is not supported via the ASCII protocol")); } LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END(); return rc; } -