X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=libmemcached%2Fauto.cc;h=517e5b96fb8faf96f23ee1c50a7ad2544206baad;hb=06d0eaed5e274bc0ba93a3a61788a4bab480adf2;hp=d7289f066a91bf225a6f14822237906d56dcbe03;hpb=a6c3e3a3d04f379b1480c8c88a8eae17e54b1449;p=awesomized%2Flibmemcached diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc index d7289f06..517e5b96 100644 --- a/libmemcached/auto.cc +++ b/libmemcached/auto.cc @@ -38,69 +38,58 @@ #include static memcached_return_t text_incr_decr(memcached_st *ptr, - const char *verb, + const bool is_incr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, uint64_t offset, - uint64_t *value) + 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; + + // Invert the logic to make it simpler to read the code + bool reply= (ptr->flags.no_reply) ? false : true; - if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) + if (memcached_failed(memcached_key_test(*ptr, (const char **)&key, &key_length, 1))) + { 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); - int send_length; - send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "%s %.*s%.*s %" PRIu64 "%s\r\n", verb, - memcached_print_array(ptr->prefix_key), - (int)key_length, key, - offset, no_reply ? " noreply" : ""); + int send_length= snprintf(buffer, sizeof(buffer), " %" PRIu64, offset); 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)")); } - 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); - - /* - 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"))) + struct libmemcached_io_vector_st vector[]= { - *value= 0; - rc= MEMCACHED_PROTOCOL_ERROR; - } - else if (not strncmp(buffer, memcached_literal_param("NOT_FOUND\r\n"))) + { memcached_literal_param("incr ") }, + { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, + { key, key_length }, + { buffer, send_length }, + { " noreply", reply ? 0 : memcached_literal_param_size(" noreply") }, + { memcached_literal_param("\r\n") } + }; + + if (is_incr == false) { - *value= 0; - rc= MEMCACHED_NOTFOUND; + vector[0].buffer= "decr "; } - else + + memcached_return_t rc= memcached_vdo(instance, vector, 6, true); + if (reply == false or 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); } @@ -111,15 +100,10 @@ static memcached_return_t binary_incr_decr(memcached_st *ptr, uint8_t cmd, uint32_t expiration, uint64_t *value) { - uint32_t server_key; - memcached_server_write_instance_st instance; bool no_reply= ptr->flags.no_reply; - if (memcached_server_count(ptr) == 0) - return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT); - - server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - instance= memcached_server_instance_fetch(ptr, server_key); + 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) { @@ -133,30 +117,32 @@ static memcached_return_t binary_incr_decr(memcached_st *ptr, uint8_t cmd, 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->prefix_key))); + request.message.header.request.keylen= htons((uint16_t)(key_length + memcached_array_size(ptr->_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->prefix_key) +request.message.header.request.extlen)); - request.message.body.delta= htonll(offset); - request.message.body.initial= htonll(initial); + request.message.header.request.bodylen= htonl((uint32_t)(key_length + memcached_array_size(ptr->_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[]= { - { sizeof(request.bytes), request.bytes }, - { memcached_array_size(ptr->prefix_key), ptr->prefix_key }, - { key_length, key } + { request.bytes, sizeof(request.bytes) }, + { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, + { key, key_length } }; memcached_return_t rc; - if ((rc= memcached_vdo(instance, vector, 3, true)) != MEMCACHED_SUCCESS) + 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); } @@ -166,10 +152,6 @@ memcached_return_t memcached_increment(memcached_st *ptr, uint32_t offset, uint64_t *value) { - uint64_t local_value; - if (! value) - value= &local_value; - return memcached_increment_by_key(ptr, key, key_length, key, key_length, offset, value); } @@ -178,10 +160,6 @@ memcached_return_t memcached_decrement(memcached_st *ptr, uint32_t offset, uint64_t *value) { - uint64_t local_value; - if (! value) - value= &local_value; - return memcached_decrement_by_key(ptr, key, key_length, key, key_length, offset, value); } @@ -193,8 +171,10 @@ 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))) { @@ -216,7 +196,7 @@ memcached_return_t memcached_increment_by_key(memcached_st *ptr, } else { - rc= text_incr_decr(ptr, "incr", group_key, group_key_length, key, key_length, offset, value); + rc= text_incr_decr(ptr, true, group_key, group_key_length, key, key_length, offset, *value); } LIBMEMCACHED_MEMCACHED_INCREMENT_END(); @@ -231,8 +211,10 @@ 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))) @@ -256,7 +238,7 @@ memcached_return_t memcached_decrement_by_key(memcached_st *ptr, } else { - rc= text_incr_decr(ptr, "decr", group_key, group_key_length, key, key_length, offset, value); + rc= text_incr_decr(ptr, false, group_key, group_key_length, key, key_length, offset, *value); } LIBMEMCACHED_MEMCACHED_DECREMENT_END(); @@ -273,8 +255,10 @@ memcached_return_t memcached_increment_with_initial(memcached_st *ptr, uint64_t *value) { uint64_t local_value; - if (! value) + if (value == NULL) + { value= &local_value; + } return memcached_increment_with_initial_by_key(ptr, key, key_length, key, key_length, @@ -292,8 +276,10 @@ 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))) @@ -308,12 +294,16 @@ memcached_return_t memcached_increment_with_initial_by_key(memcached_st *ptr, 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; + } LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END(); @@ -329,8 +319,10 @@ memcached_return_t memcached_decrement_with_initial(memcached_st *ptr, uint64_t *value) { uint64_t local_value; - if (! value) + if (value == NULL) + { value= &local_value; + } return memcached_decrement_with_initial_by_key(ptr, key, key_length, key, key_length, @@ -348,8 +340,10 @@ 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)))