X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fdelete.cc;h=f5a60e33e0eb0b919927147a0796bd72f2d00c2a;hb=5ba025a6fda8479e8f38ab690b0f89d4d1c4ffc3;hp=7ef05b07aef8f756945bc3e179e6aa1e52c1d8f2;hpb=3a1352a68657a7506f37eab1f91057912063aa69;p=m6w6%2Flibmemcached diff --git a/libmemcached/delete.cc b/libmemcached/delete.cc index 7ef05b07..f5a60e33 100644 --- a/libmemcached/delete.cc +++ b/libmemcached/delete.cc @@ -41,192 +41,87 @@ memcached_return_t memcached_delete(memcached_st *ptr, const char *key, size_t key_length, time_t expiration) { - return memcached_delete_by_key(ptr, key, key_length, - key, key_length, expiration); + return memcached_delete_by_key(ptr, key, key_length, key, key_length, expiration); } -static inline memcached_return_t binary_delete(memcached_st *ptr, - uint32_t server_key, - const char *key, - size_t key_length, - bool flush); - -memcached_return_t memcached_delete_by_key(memcached_st *ptr, - const char *group_key, size_t group_key_length, - const char *key, size_t key_length, - time_t expiration) +static inline memcached_return_t ascii_delete(memcached_st *ptr, + memcached_server_write_instance_st instance, + uint32_t , + const char *key, + size_t key_length, + bool& reply, + bool& flush) { - bool to_write; - char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; - memcached_server_write_instance_st instance; - - LIBMEMCACHED_MEMCACHED_DELETE_START(); - - memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) + struct libmemcached_io_vector_st vector[]= { - return rc; - } - - rc= memcached_validate_key_length(key_length, - ptr->flags.binary_protocol); - - unlikely (memcached_failed(rc)) - return rc; - - unlikely (memcached_server_count(ptr) == 0) - return MEMCACHED_NO_SERVERS; - - uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - instance= memcached_server_instance_fetch(ptr, server_key); - - to_write= (ptr->flags.buffer_requests) ? false : true; + { memcached_literal_param("delete ") }, + { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, + { key, key_length }, + { " noreply", reply ? 0 : memcached_literal_param_size(" noreply") }, + { memcached_literal_param("\r\n") } + }; - bool no_reply= (ptr->flags.no_reply); + size_t send_length= io_vector_total_size(vector, 5); - if (ptr->flags.binary_protocol) - { - likely (! expiration) - { - rc= binary_delete(ptr, server_key, key, key_length, to_write); - } - else - { - rc= MEMCACHED_INVALID_ARGUMENTS; - } - } - else + if (ptr->flags.use_udp and flush == false) { - int send_length; - - unlikely (expiration) - { - if ((instance->major_version == 1 && - instance->minor_version > 2) || - instance->major_version > 1) - { - rc= MEMCACHED_INVALID_ARGUMENTS; - goto error; - } - else - { - /* ensure that we are connected, otherwise we might bump the - * command counter before connection */ - if ((rc= memcached_connect(instance)) != MEMCACHED_SUCCESS) - { - WATCHPOINT_ERROR(rc); - return rc; - } - - if (instance->minor_version == 0) - { - 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= true; - if (no_reply) - memcached_server_response_increment(instance); - no_reply= false; - } - } - send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "delete %.*s%.*s %u%s\r\n", - memcached_print_array(ptr->_namespace), - (int) key_length, key, - (uint32_t)expiration, - no_reply ? " noreply" :"" ); - } - } - else + if (send_length > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH) { - send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, - "delete %.*s%.*s%s\r\n", - memcached_print_array(ptr->_namespace), - (int)key_length, key, no_reply ? " noreply" :""); - } - - if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE || send_length < 0) - { - rc= MEMCACHED_WRITE_FAILURE; - goto error; + return MEMCACHED_WRITE_FAILURE; } - if (ptr->flags.use_udp && ! to_write) + if (send_length +instance->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) { - 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, true); + memcached_io_write(instance, NULL, 0, true); } - - rc= memcached_do(instance, buffer, (size_t)send_length, to_write); } - if (rc != MEMCACHED_SUCCESS) - goto error; - - if (! to_write) - { - rc= MEMCACHED_BUFFERED; - } - else if (!no_reply) - { - rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); - if (rc == MEMCACHED_DELETED) - rc= MEMCACHED_SUCCESS; - } - - if (rc == MEMCACHED_SUCCESS && ptr->delete_trigger) - ptr->delete_trigger(ptr, key, key_length); - -error: - LIBMEMCACHED_MEMCACHED_DELETE_END(); - return rc; + /* Send command header */ + return memcached_vdo(instance, vector, 5, flush); } static inline memcached_return_t binary_delete(memcached_st *ptr, + memcached_server_write_instance_st instance, uint32_t server_key, const char *key, size_t key_length, - bool flush) + bool& reply, + bool& flush) { - memcached_server_write_instance_st instance; protocol_binary_request_delete request= {}; - instance= memcached_server_instance_fetch(ptr, server_key); - request.message.header.request.magic= PROTOCOL_BINARY_REQ; - if (ptr->flags.no_reply) + if (reply) { - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ; + request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETE; } else { - request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETE; + request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ; } request.message.header.request.keylen= htons((uint16_t)(key_length + memcached_array_size(ptr->_namespace))); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; request.message.header.request.bodylen= htonl((uint32_t)(key_length + memcached_array_size(ptr->_namespace))); - if (ptr->flags.use_udp && ! flush) + if (ptr->flags.use_udp and flush == false) { 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) + if (cmd_size +instance->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) + { memcached_io_write(instance, NULL, 0, true); + } } struct libmemcached_io_vector_st vector[]= { - { sizeof(request.bytes), request.bytes}, - { memcached_array_size(ptr->_namespace), memcached_array_string(ptr->_namespace) }, - { 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= MEMCACHED_SUCCESS; @@ -234,10 +129,9 @@ static inline memcached_return_t binary_delete(memcached_st *ptr, if ((rc= memcached_vdo(instance, vector, 3, flush)) != MEMCACHED_SUCCESS) { memcached_io_reset(instance); - rc= (rc == MEMCACHED_SUCCESS) ? MEMCACHED_WRITE_FAILURE : rc; } - unlikely (ptr->number_of_replicas > 0) + if (ptr->number_of_replicas > 0) { request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ; @@ -264,3 +158,88 @@ static inline memcached_return_t binary_delete(memcached_st *ptr, return rc; } + +memcached_return_t memcached_delete_by_key(memcached_st *ptr, + const char *group_key, size_t group_key_length, + const char *key, size_t key_length, + time_t expiration) +{ + LIBMEMCACHED_MEMCACHED_DELETE_START(); + + memcached_return_t rc; + if (memcached_failed(rc= initialize_query(ptr))) + { + return rc; + } + + rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol); + if (memcached_failed(rc)) + { + return rc; + } + + if (expiration) + { + return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, + memcached_literal_param("Memcached server version does not allow expiration of deleted items")); + } + + // If a delete trigger exists, we need a response, so no buffering/noreply + if (ptr->delete_trigger) + { + if (ptr->flags.buffer_requests) + { + return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, + memcached_literal_param("Delete triggers cannot be used if buffering is enabled")); + } + + if (ptr->flags.no_reply) + { + return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, + memcached_literal_param("Delete triggers cannot be used if MEMCACHED_BEHAVIOR_NOREPLY is set")); + } + } + + + 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 to_write= (ptr->flags.buffer_requests) ? false : true; + + // Invert the logic to make it simpler to read the code + bool reply= (ptr->flags.no_reply) ? false : true; + + if (ptr->flags.binary_protocol) + { + rc= binary_delete(ptr, instance, server_key, key, key_length, reply, to_write); + } + else + { + rc= ascii_delete(ptr, instance, server_key, key, key_length, reply, to_write); + } + + if (rc == MEMCACHED_SUCCESS) + { + if (to_write == false) + { + rc= MEMCACHED_BUFFERED; + } + else if (reply) + { + char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; + rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); + if (rc == MEMCACHED_DELETED) + { + rc= MEMCACHED_SUCCESS; + } + } + + if (rc == MEMCACHED_SUCCESS and ptr->delete_trigger) + { + ptr->delete_trigger(ptr, key, key_length); + } + } + + LIBMEMCACHED_MEMCACHED_DELETE_END(); + return rc; +}