=head1 DESCRIPTION
memcached_delete() is used to delete a particular key. An expiration value
-can be applied so that the key is deleted after that many seconds.
-memcached_delete_by_key() works the same, but it takes a master key to
+can be applied so that the key is deleted after that many seconds, but this
+will only work if you are using a 1.2.x server. If you are using a 1.2.x
+server and you want to use the expiration value, please call memcached_version
+one time for the memcached_st instance. If you don't do this no-reply and
+buffered mode will be disabled to avoid getting out of sync with the server.
+memcached_delete_by_key() works the same, but it takes a master key to
find the given value.
=head1 RETURN
#define MEMCACHED_MAX_HOST_SORT_LENGTH 86 /* Used for Ketama */
#define MEMCACHED_POINTS_PER_SERVER 100
#define MEMCACHED_POINTS_PER_SERVER_KETAMA 160
-#define MEMCACHED_CONTINUUM_SIZE MEMCACHED_POINTS_PER_SERVER*100 /* This would then set max hosts to 100 */
+#define MEMCACHED_CONTINUUM_SIZE MEMCACHED_POINTS_PER_SERVER*100 /* This would then set max hosts to 100 */
#define MEMCACHED_STRIDE 4
#define MEMCACHED_DEFAULT_TIMEOUT 1000
#define MEMCACHED_CONTINUUM_ADDITION 10 /* How many extra slots we should build for in the continuum */
MEMCACHED_SERVER_MARKED_DEAD,
MEMCACHED_UNKNOWN_STAT_KEY,
MEMCACHED_E2BIG,
+ MEMCACHED_INVALID_ARGUMENTS,
MEMCACHED_MAXIMUM_RETURN /* Always add new error code before */
} memcached_return;
key, key_length, expiration);
}
-static inline memcached_return binary_delete(memcached_st *ptr,
+static inline memcached_return binary_delete(memcached_st *ptr,
unsigned int server_key,
- const char *key,
+ const char *key,
size_t key_length,
uint8_t flush);
-memcached_return memcached_delete_by_key(memcached_st *ptr,
+memcached_return 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)
LIBMEMCACHED_MEMCACHED_DELETE_START();
- rc= memcached_validate_key_length(key_length,
+ rc= memcached_validate_key_length(key_length,
ptr->flags & MEM_BINARY_PROTOCOL);
unlikely (rc != MEMCACHED_SUCCESS)
return rc;
server_key= memcached_generate_hash(ptr, master_key, master_key_length);
to_write= (uint8_t)((ptr->flags & MEM_BUFFER_REQUESTS) ? 0 : 1);
bool no_reply= (ptr->flags & MEM_NOREPLY);
-
- if (ptr->flags & MEM_BINARY_PROTOCOL)
- rc= binary_delete(ptr, server_key, key, key_length, to_write);
- else
+
+ if (ptr->flags & MEM_BINARY_PROTOCOL)
{
- if (expiration)
- send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
- "delete %s%.*s %u%s\r\n",
- ptr->prefix_key,
- (int) key_length, key,
- (uint32_t)expiration, no_reply ? " noreply" :"" );
+ likely (!expiration)
+ rc= binary_delete(ptr, server_key, key, key_length, to_write);
else
- send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
+ rc= MEMCACHED_INVALID_ARGUMENTS;
+ }
+ else
+ {
+ unlikely (expiration)
+ {
+ if ((ptr->hosts[server_key].major_version == 1 &&
+ ptr->hosts[server_key].minor_version > 2) ||
+ ptr->hosts[server_key].major_version > 1)
+ {
+ rc= MEMCACHED_INVALID_ARGUMENTS;
+ goto error;
+ }
+ else
+ {
+ if (ptr->hosts[server_key].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= 1;
+ if (no_reply)
+ memcached_server_response_increment(&ptr->hosts[server_key]);
+ no_reply= false;
+ }
+ }
+ send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
+ "delete %s%.*s %u%s\r\n",
+ ptr->prefix_key,
+ (int) key_length, key,
+ (uint32_t)expiration,
+ no_reply ? " noreply" :"" );
+ }
+ }
+ 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" :"");
-
- if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
+
+ if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
{
rc= MEMCACHED_WRITE_FAILURE;
goto error;
if (send_length + ptr->hosts[server_key].write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH)
memcached_io_write(&ptr->hosts[server_key], NULL, 0, 1);
}
-
+
rc= memcached_do(&ptr->hosts[server_key], buffer, send_length, to_write);
}
if (rc != MEMCACHED_SUCCESS)
goto error;
- if ((ptr->flags & MEM_BUFFER_REQUESTS))
+ if (!to_write)
rc= MEMCACHED_BUFFERED;
else if (!no_reply)
{
return rc;
}
-static inline memcached_return binary_delete(memcached_st *ptr,
+static inline memcached_return binary_delete(memcached_st *ptr,
unsigned int server_key,
- const char *key,
+ const char *key,
size_t key_length,
uint8_t flush)
{
if (cmd_size + ptr->hosts[server_key].write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH)
memcached_io_write(&ptr->hosts[server_key], NULL, 0, 1);
}
-
+
memcached_return rc= MEMCACHED_SUCCESS;
- if ((memcached_do(&ptr->hosts[server_key], request.bytes,
+ if ((memcached_do(&ptr->hosts[server_key], request.bytes,
sizeof(request.bytes), 0) != MEMCACHED_SUCCESS) ||
- (memcached_io_write(&ptr->hosts[server_key], key,
- key_length, (char) flush) == -1))
+ (memcached_io_write(&ptr->hosts[server_key], key,
+ key_length, (char) flush) == -1))
{
memcached_io_reset(&ptr->hosts[server_key]);
rc= MEMCACHED_WRITE_FAILURE;
}
- unlikely (ptr->number_of_replicas > 0)
+ unlikely (ptr->number_of_replicas > 0)
{
request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ;
++server_key;
if (server_key == ptr->number_of_hosts)
server_key= 0;
-
+
memcached_server_st* server= &ptr->hosts[server_key];
- if ((memcached_do(server, (const char*)request.bytes,
+ if ((memcached_do(server, (const char*)request.bytes,
sizeof(request.bytes), 0) != MEMCACHED_SUCCESS) ||
(memcached_io_write(server, key, key_length, (char) flush) == -1))
memcached_io_reset(server);
return "ENCOUNTERED AN UNKNOWN STAT KEY";
case MEMCACHED_E2BIG:
return "ITEM TOO BIG";
+ case MEMCACHED_INVALID_ARGUMENTS:
+ return "INVALID ARGUMENTS";
case MEMCACHED_MAXIMUM_RETURN:
return "Gibberish returned!";
default:
4269430871U, 610793021U, 527273862U, 1437122909U,
2300930706U, 2943759320U, 674306647U, 2400528935U,
54481931U, 4186304426U, 1741088401U, 2979625118U,
- 4159057246U, 3425930182U};
+ 4159057246U, 3425930182U, 2593724503U};
// You have updated the memcache_error messages but not updated docs/tests.
- assert(MEMCACHED_MAXIMUM_RETURN == 38);
+ assert(MEMCACHED_MAXIMUM_RETURN == 39);
for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
{
uint32_t hash_val;
memc->number_of_hosts= 1;
int max_keys= binary ? 20480 : 1;
-
+
char **keys= calloc((size_t)max_keys, sizeof(char*));
size_t *key_length=calloc((size_t)max_keys, sizeof(size_t));
** to do this ;-)
*/
memcached_quit(memc);
-
- /* Verify that all messages are stored, and we didn't stuff too much
+
+ /* Verify that all messages are stored, and we didn't stuff too much
* into the servers
*/
rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
return TEST_SUCCESS;
}
+static test_return_t regression_bug_463297(memcached_st *memc)
+{
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ assert(memc_clone != NULL);
+ assert(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
+
+ if (memc_clone->hosts[0].major_version > 1 ||
+ (memc_clone->hosts[0].major_version == 1 &&
+ memc_clone->hosts[0].minor_version > 2))
+ {
+ /* Binary protocol doesn't support deferred delete */
+ memcached_st *bin_clone= memcached_clone(NULL, memc);
+ assert(bin_clone != NULL);
+ assert(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
+ assert(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+ memcached_free(bin_clone);
+
+ memcached_quit(memc_clone);
+
+ /* If we know the server version, deferred delete should fail
+ * with invalid arguments */
+ assert(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+
+ /* If we don't know the server version, we should get a protocol error */
+ memcached_return rc= memcached_delete(memc, "foo", 3, 1);
+ /* but there is a bug in some of the memcached servers (1.4) that treats
+ * the counter as noreply so it doesn't send the proper error message
+ */
+ assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+
+ /* And buffered mode should be disabled and we should get protocol error */
+ assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, "foo", 3, 1);
+ assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+
+ /* Same goes for noreply... */
+ assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, "foo", 3, 1);
+ assert(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+
+ /* but a normal request should go through (and be buffered) */
+ assert((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
+ assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
+
+ assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
+ /* unbuffered noreply should be success */
+ assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
+ /* unbuffered with reply should be not found... */
+ assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
+ assert(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
+ }
+
+ memcached_free(memc_clone);
+ return TEST_SUCCESS;
+}
+
+
/* Test memcached_server_get_last_disconnect
* For a working server set, shall be NULL
* For a set of non existing server, shall not be NULL
{"lp:421108", 1, regression_bug_421108 },
{"lp:442914", 1, regression_bug_442914 },
{"lp:447342", 1, regression_bug_447342 },
+ {"lp:463297", 1, regression_bug_463297 },
{0, 0, 0}
};
projects / m6w6 / libmemcached / commitdiff
