X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fauto.cc;h=c64ccda45067d79983f9ceae6e72df5804826822;hb=ef3cb20e2967fc17cf7f1c5b6eb14e84bc88a7dc;hp=f06d9ca06242387247bfbefb42e8cad782d0685b;hpb=9cd57ce737375540f6c3b5e2e3684160e5c4bfce;p=m6w6%2Flibmemcached diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc index f06d9ca0..c64ccda4 100644 --- a/libmemcached/auto.cc +++ b/libmemcached/auto.cc @@ -37,126 +37,108 @@ #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); + libmemcached_io_vector_st vector[]= + { + { 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") } + }; - 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) + if (is_incr == false) { - return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, - memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)")); + vector[1].buffer= "decr "; } - 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); + memcached_return_t rc= memcached_vdo(instance, vector, 7, true); - /* - 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"))) - { - *value= 0; - rc= MEMCACHED_PROTOCOL_ERROR; - } - else if (not strncmp(buffer, memcached_literal_param("CLIENT_ERROR\r\n"))) + if (reply == false) { - *value= 0; - rc= MEMCACHED_PROTOCOL_ERROR; - } - else if (not strncmp(buffer, memcached_literal_param("NOT_FOUND\r\n"))) - { - *value= 0; - rc= MEMCACHED_NOTFOUND; + return MEMCACHED_SUCCESS; } - else + + if (memcached_failed(rc)) { - *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; - - 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; 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))) + 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; + } return memcached_response(instance, (char*)value, sizeof(*value), NULL); } @@ -185,30 +167,38 @@ memcached_return_t memcached_increment_by_key(memcached_st *ptr, { memcached_return_t rc; uint64_t local_value; - if (not value) + if (value == NULL) + { value= &local_value; + } - 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; } + 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(); @@ -223,32 +213,40 @@ memcached_return_t memcached_decrement_by_key(memcached_st *ptr, 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(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; } + 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(); @@ -264,10 +262,6 @@ 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, key, key_length, offset, initial, expiration, value); @@ -284,28 +278,41 @@ memcached_return_t memcached_increment_with_initial_by_key(memcached_st *ptr, 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(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; } + 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) - rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT, - group_key, group_key_length, key, key_length, - offset, initial, (uint32_t)expiration, + if (memcached_is_binary(ptr)) + { + 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(); @@ -320,10 +327,6 @@ 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, key, key_length, offset, initial, expiration, value); @@ -340,36 +343,44 @@ memcached_return_t memcached_decrement_with_initial_by_key(memcached_st *ptr, uint64_t *value) { uint64_t local_value; - if (not value) + if (value == NULL) + { value= &local_value; + } 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; } + 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; } -