X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fauto.cc;h=4196b6683deb4fc8a8affa6db2bd29ca584a4103;hb=674c7578fa870c3b57e81e765c355ce98434b310;hp=d0b7dd4813bb3116738f5713d4e048b68496954b;hpb=aa2acacce631a544d7915102b7c6c22f4ef4458d;p=m6w6%2Flibmemcached diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc index d0b7dd48..4196b668 100644 --- a/libmemcached/auto.cc +++ b/libmemcached/auto.cc @@ -37,231 +37,275 @@ #include -static memcached_return_t text_incr_decr(memcached_st *ptr, - const char *verb, - const char *group_key, size_t group_key_length, - const char *key, size_t key_length, - uint64_t offset, - uint64_t *value) +static void auto_response(org::libmemcached::Instance* instance, const bool reply, memcached_return_t& rc, uint64_t* 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))) + // If the message was successfully sent, then get the response, otherwise + // fail. + if (memcached_success(rc)) { - return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT); - } - - server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - instance= memcached_server_instance_fetch(ptr, server_key); + if (reply == false) + { + *value= UINT64_MAX; + return; + } - 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) - { - return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, - memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)")); + rc= memcached_response(instance, &instance->root->result); } - memcached_return_t rc= memcached_do(instance, buffer, (size_t)send_length, true); - if (no_reply or memcached_failed(rc)) - return rc; - - rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); - - if (rc != MEMCACHED_SUCCESS) + if (memcached_success(rc)) { - return memcached_set_error(*instance, rc, MEMCACHED_AT); + *value= instance->root->result.numeric_value; } - - /* - 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"))) + else { - *value= 0; - rc= MEMCACHED_PROTOCOL_ERROR; + *value= UINT64_MAX; } - else if (not strncmp(buffer, memcached_literal_param("CLIENT_ERROR\r\n"))) +} + +static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance, + const bool is_incr, + const char *key, size_t key_length, + const uint64_t offset, + const bool reply) +{ + char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; + + int send_length= snprintf(buffer, sizeof(buffer), " %" PRIu64, offset); + if (size_t(send_length) >= sizeof(buffer) or send_length < 0) { - *value= 0; - rc= MEMCACHED_PROTOCOL_ERROR; + return memcached_set_error(*instance, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, + memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)")); } - else if (not strncmp(buffer, memcached_literal_param("NOT_FOUND\r\n"))) + + libmemcached_io_vector_st vector[]= { - *value= 0; - rc= MEMCACHED_NOTFOUND; - } - else + { NULL, 0 }, + { memcached_literal_param("incr ") }, + { memcached_array_string(instance->root->_namespace), memcached_array_size(instance->root->_namespace) }, + { key, key_length }, + { buffer, size_t(send_length) }, + { " noreply", reply ? 0 : memcached_literal_param_size(" noreply") }, + { memcached_literal_param("\r\n") } + }; + + if (is_incr == false) { - *value= strtoull(buffer, (char **)NULL, 10); - rc= MEMCACHED_SUCCESS; + vector[1].buffer= "decr "; } - return memcached_set_error(*instance, rc, MEMCACHED_AT); + return memcached_vdo(instance, vector, 7, true); } -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, - uint64_t *value) +static memcached_return_t binary_incr_decr(org::libmemcached::Instance* 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) { - bool no_reply= ptr->flags.no_reply; - - if (memcached_server_count(ptr) == 0) - return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, 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); - - 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; + initialize_binary_request(instance, request.message.header); + 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[]= { - { sizeof(request.bytes), request.bytes }, - { memcached_array_size(ptr->_namespace), memcached_array_string(ptr->_namespace) }, - { key_length, key } + { NULL, 0 }, + { request.bytes, sizeof(request.bytes) }, + { 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))) - { - memcached_io_reset(instance); - return (rc == MEMCACHED_SUCCESS) ? MEMCACHED_WRITE_FAILURE : rc; - } - - if (no_reply) - return MEMCACHED_SUCCESS; - - return memcached_response(instance, (char*)value, sizeof(*value), NULL); -} - -memcached_return_t memcached_increment(memcached_st *ptr, - const char *key, size_t key_length, - uint32_t offset, - uint64_t *value) -{ - return memcached_increment_by_key(ptr, key, key_length, key, key_length, offset, value); + return memcached_vdo(instance, vector, 4, true); } -memcached_return_t memcached_decrement(memcached_st *ptr, +memcached_return_t memcached_increment(memcached_st *memc, const char *key, size_t key_length, uint32_t offset, uint64_t *value) { - return memcached_decrement_by_key(ptr, key, key_length, key, key_length, offset, value); + return memcached_increment_by_key(memc, key, key_length, key, key_length, offset, value); } -memcached_return_t memcached_increment_by_key(memcached_st *ptr, - const char *group_key, size_t group_key_length, - const char *key, size_t key_length, - uint64_t offset, - uint64_t *value) +static memcached_return_t increment_decrement_by_key(const protocol_binary_command command, + memcached_st *memc, + const char *group_key, size_t group_key_length, + const char *key, size_t key_length, + uint64_t offset, + uint64_t *value) { - memcached_return_t rc; uint64_t local_value; - if (not value) + if (value == NULL) + { value= &local_value; + } - if (memcached_failed(rc= initialize_query(ptr))) + memcached_return_t rc; + if (memcached_failed(rc= initialize_query(memc, true))) { return rc; } - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) + if (memcached_is_encrypted(memc)) { - return rc; + return memcached_set_error(*memc, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT, + memcached_literal_param("Operation not allowed while encyrption is enabled")); } - LIBMEMCACHED_MEMCACHED_INCREMENT_START(); - if (ptr->flags.binary_protocol) + if (memcached_failed(rc= memcached_key_test(*memc, (const char **)&key, &key_length, 1))) + { + return memcached_last_error(memc); + } + + uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length); + org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key); + + bool reply= memcached_is_replying(instance->root); + + if (memcached_is_binary(memc)) { - 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, - value); + rc= binary_incr_decr(instance, command, + key, key_length, + uint64_t(offset), 0, MEMCACHED_EXPIRATION_NOT_ADD, + reply); } else { - rc= text_incr_decr(ptr, "incr", group_key, group_key_length, key, key_length, offset, value); + rc= text_incr_decr(instance, + command == PROTOCOL_BINARY_CMD_INCREMENT ? true : false, + key, key_length, + offset, reply); } - LIBMEMCACHED_MEMCACHED_INCREMENT_END(); + auto_response(instance, reply, rc, value); return rc; } -memcached_return_t memcached_decrement_by_key(memcached_st *ptr, - const char *group_key, size_t group_key_length, - const char *key, size_t key_length, - uint64_t offset, - uint64_t *value) +static memcached_return_t increment_decrement_with_initial_by_key(const protocol_binary_command command, + memcached_st *memc, + const char *group_key, + size_t group_key_length, + const char *key, + size_t key_length, + uint64_t offset, + uint64_t initial, + time_t expiration, + uint64_t *value) { uint64_t local_value; - if (not value) + if (value == NULL) + { value= &local_value; + } memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) + if (memcached_failed(rc= initialize_query(memc, true))) { return rc; } - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) + if (memcached_is_encrypted(memc)) { - return rc; + return memcached_set_error(*memc, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT, + memcached_literal_param("Operation not allowed while encyrption is enabled")); + } + + if (memcached_failed(rc= memcached_key_test(*memc, (const char **)&key, &key_length, 1))) + { + return memcached_last_error(memc); } + uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length); + org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key); - LIBMEMCACHED_MEMCACHED_DECREMENT_START(); - if (ptr->flags.binary_protocol) + bool reply= memcached_is_replying(instance->root); + + if (memcached_is_binary(memc)) { - 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, - value); + rc= binary_incr_decr(instance, command, + key, key_length, + offset, initial, uint32_t(expiration), + reply); + } else { - rc= text_incr_decr(ptr, "decr", group_key, group_key_length, key, key_length, offset, value); + rc= memcached_set_error(*memc, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, + memcached_literal_param("memcached_increment_with_initial_by_key() is not supported via the ASCII protocol")); } + auto_response(instance, reply, rc, value); + + return rc; +} + +memcached_return_t memcached_decrement(memcached_st *memc, + const char *key, size_t key_length, + uint32_t offset, + uint64_t *value) +{ + return memcached_decrement_by_key(memc, key, key_length, key, key_length, offset, value); +} + + +memcached_return_t memcached_increment_by_key(memcached_st *memc, + const char *group_key, size_t group_key_length, + const char *key, size_t key_length, + uint64_t offset, + uint64_t *value) +{ + LIBMEMCACHED_MEMCACHED_INCREMENT_START(); + memcached_return_t rc= increment_decrement_by_key(PROTOCOL_BINARY_CMD_INCREMENT, + memc, + group_key, group_key_length, + key, key_length, + offset, value); + + LIBMEMCACHED_MEMCACHED_INCREMENT_END(); + + return rc; +} + +memcached_return_t memcached_decrement_by_key(memcached_st *memc, + const char *group_key, size_t group_key_length, + const char *key, size_t key_length, + uint64_t offset, + uint64_t *value) +{ + LIBMEMCACHED_MEMCACHED_DECREMENT_START(); + memcached_return_t rc= increment_decrement_by_key(PROTOCOL_BINARY_CMD_DECREMENT, + memc, + group_key, group_key_length, + key, key_length, + offset, value); LIBMEMCACHED_MEMCACHED_DECREMENT_END(); return rc; } -memcached_return_t memcached_increment_with_initial(memcached_st *ptr, +memcached_return_t memcached_increment_with_initial(memcached_st *memc, const char *key, size_t key_length, uint64_t offset, @@ -269,55 +313,33 @@ memcached_return_t memcached_increment_with_initial(memcached_st *ptr, time_t expiration, uint64_t *value) { - uint64_t local_value; - if (! value) - value= &local_value; - - return memcached_increment_with_initial_by_key(ptr, key, key_length, + return memcached_increment_with_initial_by_key(memc, key, key_length, key, key_length, offset, initial, expiration, value); } -memcached_return_t memcached_increment_with_initial_by_key(memcached_st *ptr, - const char *group_key, - size_t group_key_length, - const char *key, - size_t key_length, - uint64_t offset, - uint64_t initial, - time_t expiration, - uint64_t *value) +memcached_return_t memcached_increment_with_initial_by_key(memcached_st *memc, + const char *group_key, + size_t group_key_length, + const char *key, + size_t key_length, + uint64_t offset, + uint64_t initial, + time_t expiration, + uint64_t *value) { - uint64_t local_value; - if (not value) - value= &local_value; - - memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) - { - return rc; - } - - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) - { - return rc; - } - LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START(); - if (ptr->flags.binary_protocol) - rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT, - group_key, group_key_length, key, key_length, - offset, initial, (uint32_t)expiration, - value); - else - rc= MEMCACHED_PROTOCOL_ERROR; - + memcached_return_t rc= increment_decrement_with_initial_by_key(PROTOCOL_BINARY_CMD_INCREMENT, + memc, + group_key, group_key_length, + key, key_length, + offset, initial, expiration, value); LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END(); return rc; } -memcached_return_t memcached_decrement_with_initial(memcached_st *ptr, +memcached_return_t memcached_decrement_with_initial(memcached_st *memc, const char *key, size_t key_length, uint64_t offset, @@ -325,16 +347,12 @@ memcached_return_t memcached_decrement_with_initial(memcached_st *ptr, time_t expiration, uint64_t *value) { - uint64_t local_value; - if (! value) - value= &local_value; - - return memcached_decrement_with_initial_by_key(ptr, key, key_length, + return memcached_decrement_with_initial_by_key(memc, key, key_length, key, key_length, offset, initial, expiration, value); } -memcached_return_t memcached_decrement_with_initial_by_key(memcached_st *ptr, +memcached_return_t memcached_decrement_with_initial_by_key(memcached_st *memc, const char *group_key, size_t group_key_length, const char *key, @@ -344,37 +362,14 @@ memcached_return_t memcached_decrement_with_initial_by_key(memcached_st *ptr, time_t expiration, uint64_t *value) { - uint64_t local_value; - if (not value) - value= &local_value; - - memcached_return_t rc; - if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol))) - { - return rc; - } - - if (memcached_failed(rc= initialize_query(ptr))) - { - return rc; - } - - LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START(); - if (ptr->flags.binary_protocol) - { - rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_DECREMENT, - group_key, group_key_length, key, key_length, - offset, initial, (uint32_t)expiration, - value); - } - else - { - rc= MEMCACHED_PROTOCOL_ERROR; - } + memcached_return_t rc= increment_decrement_with_initial_by_key(PROTOCOL_BINARY_CMD_DECREMENT, + memc, + group_key, group_key_length, + key, key_length, + offset, initial, expiration, value); LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END(); return rc; } -