X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fdelete.c;h=70553d94e651112b217fea5cf535b18b0ebc17ab;hb=7202efa0916ab09b135ad93083e63ed01c854330;hp=32d946ba3888893ef7c0a5376619f4812e1c0990;hpb=c67da677fe0944d3d2d3ff46e65fc3bc775404ae;p=m6w6%2Flibmemcached diff --git a/libmemcached/delete.c b/libmemcached/delete.c index 32d946ba..70553d94 100644 --- a/libmemcached/delete.c +++ b/libmemcached/delete.c @@ -12,19 +12,19 @@ static inline memcached_return_t binary_delete(memcached_st *ptr, uint32_t server_key, const char *key, size_t key_length, - uint8_t flush); + bool flush); memcached_return_t memcached_delete_by_key(memcached_st *ptr, const char *master_key, size_t master_key_length, const char *key, size_t key_length, time_t expiration) { - uint8_t to_write; + bool to_write; size_t send_length; memcached_return_t rc; char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; uint32_t server_key; - memcached_server_instance_st *instance; + memcached_server_write_instance_st instance; LIBMEMCACHED_MEMCACHED_DELETE_START(); @@ -36,16 +36,16 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr, unlikely (memcached_server_count(ptr) == 0) return MEMCACHED_NO_SERVERS; - server_key= memcached_generate_hash(ptr, master_key, master_key_length); + server_key= memcached_generate_hash_with_redistribution(ptr, master_key, master_key_length); instance= memcached_server_instance_fetch(ptr, server_key); - to_write= (uint8_t)((ptr->flags.buffer_requests) ? 0 : 1); + to_write= (ptr->flags.buffer_requests) ? false : true; bool no_reply= (ptr->flags.no_reply); if (ptr->flags.binary_protocol) { - likely (!expiration) + likely (! expiration) { rc= binary_delete(ptr, server_key, key, key_length, to_write); } @@ -77,20 +77,21 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr, if (instance->minor_version == 0) { - if (no_reply || !to_write) + if (no_reply || ! to_write) { /* We might get out of sync with the server if we * send this command to a server newer than 1.2.x.. * disable no_reply and buffered mode. */ - to_write= 1; + to_write= true; if (no_reply) memcached_server_response_increment(instance); no_reply= false; } } send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "delete %s%.*s %u%s\r\n", + "delete %.*s%.*s %u%s\r\n", + (int)ptr->prefix_key_length, ptr->prefix_key, (int) key_length, key, (uint32_t)expiration, @@ -98,10 +99,13 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr, } } else - send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "delete %s%.*s%s\r\n", - ptr->prefix_key, - (int)key_length, key, no_reply ? " noreply" :""); + { + send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, + "delete %.*s%.*s%s\r\n", + (int)ptr->prefix_key_length, + ptr->prefix_key, + (int)key_length, key, no_reply ? " noreply" :""); + } if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE) { @@ -109,12 +113,12 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr, goto error; } - if (ptr->flags.use_udp && !to_write) + if (ptr->flags.use_udp && ! to_write) { if (send_length > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH) return MEMCACHED_WRITE_FAILURE; if (send_length + instance->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) - memcached_io_write(instance, NULL, 0, 1); + memcached_io_write(instance, NULL, 0, true); } rc= memcached_do(instance, buffer, send_length, to_write); @@ -123,8 +127,10 @@ memcached_return_t memcached_delete_by_key(memcached_st *ptr, if (rc != MEMCACHED_SUCCESS) goto error; - if (!to_write) + if (! to_write) + { rc= MEMCACHED_BUFFERED; + } else if (!no_reply) { rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); @@ -144,9 +150,9 @@ static inline memcached_return_t binary_delete(memcached_st *ptr, uint32_t server_key, const char *key, size_t key_length, - uint8_t flush) + bool flush) { - memcached_server_instance_st *instance; + memcached_server_write_instance_st instance; protocol_binary_request_delete request= {.bytes= {0}}; instance= memcached_server_instance_fetch(ptr, server_key); @@ -156,28 +162,32 @@ static inline memcached_return_t binary_delete(memcached_st *ptr, request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ; else request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETE; - request.message.header.request.keylen= htons((uint16_t)key_length); + request.message.header.request.keylen= htons((uint16_t)(key_length + ptr->prefix_key_length)); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; - request.message.header.request.bodylen= htonl((uint32_t) key_length); + request.message.header.request.bodylen= htonl((uint32_t)(key_length + ptr->prefix_key_length)); - if (ptr->flags.use_udp && !flush) + if (ptr->flags.use_udp && ! flush) { size_t cmd_size= sizeof(request.bytes) + key_length; if (cmd_size > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH) return MEMCACHED_WRITE_FAILURE; if (cmd_size + instance->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) - memcached_io_write(instance, NULL, 0, 1); + memcached_io_write(instance, NULL, 0, true); } + struct __write_vector_st vector[]= + { + { .length= sizeof(request.bytes), .buffer= request.bytes}, + { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key }, + { .length= key_length, .buffer= key }, + }; + memcached_return_t rc= MEMCACHED_SUCCESS; - if ((memcached_do(instance, request.bytes, - sizeof(request.bytes), 0) != MEMCACHED_SUCCESS) || - (memcached_io_write(instance, key, - key_length, (char) flush) == -1)) + if ((rc= memcached_vdo(instance, vector, 3, flush)) != MEMCACHED_SUCCESS) { memcached_io_reset(instance); - rc= MEMCACHED_WRITE_FAILURE; + rc= (rc == MEMCACHED_SUCCESS) ? MEMCACHED_WRITE_FAILURE : rc; } unlikely (ptr->number_of_replicas > 0) @@ -186,7 +196,7 @@ static inline memcached_return_t binary_delete(memcached_st *ptr, for (uint32_t x= 0; x < ptr->number_of_replicas; ++x) { - memcached_server_instance_st *replica; + memcached_server_write_instance_st replica; ++server_key; if (server_key == memcached_server_count(ptr)) @@ -194,9 +204,7 @@ static inline memcached_return_t binary_delete(memcached_st *ptr, replica= memcached_server_instance_fetch(ptr, server_key); - if ((memcached_do(replica, (const char*)request.bytes, - sizeof(request.bytes), 0) != MEMCACHED_SUCCESS) || - (memcached_io_write(replica, key, key_length, (char) flush) == -1)) + if (memcached_vdo(replica, vector, 3, flush) != MEMCACHED_SUCCESS) { memcached_io_reset(replica); }