Refactor test framework to run pre/post just once.
[m6w6/libmemcached] / libmemcached / delete.c
1 #include "common.h"
2 #include "memcached/protocol_binary.h"
3
4 memcached_return_t memcached_delete(memcached_st *ptr, const char *key, size_t key_length,
5 time_t expiration)
6 {
7 return memcached_delete_by_key(ptr, key, key_length,
8 key, key_length, expiration);
9 }
10
11 static inline memcached_return_t binary_delete(memcached_st *ptr,
12 uint32_t server_key,
13 const char *key,
14 size_t key_length,
15 uint8_t flush);
16
17 memcached_return_t memcached_delete_by_key(memcached_st *ptr,
18 const char *master_key, size_t master_key_length,
19 const char *key, size_t key_length,
20 time_t expiration)
21 {
22 uint8_t to_write;
23 size_t send_length;
24 memcached_return_t rc;
25 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
26 uint32_t server_key;
27 memcached_server_instance_st *instance;
28
29 LIBMEMCACHED_MEMCACHED_DELETE_START();
30
31 rc= memcached_validate_key_length(key_length,
32 ptr->flags.binary_protocol);
33 unlikely (rc != MEMCACHED_SUCCESS)
34 return rc;
35
36 unlikely (memcached_server_count(ptr) == 0)
37 return MEMCACHED_NO_SERVERS;
38
39 server_key= memcached_generate_hash(ptr, master_key, master_key_length);
40 instance= memcached_server_instance_fetch(ptr, server_key);
41
42 to_write= (uint8_t)((ptr->flags.buffer_requests) ? 0 : 1);
43
44 bool no_reply= (ptr->flags.no_reply);
45
46 if (ptr->flags.binary_protocol)
47 {
48 likely (!expiration)
49 {
50 rc= binary_delete(ptr, server_key, key, key_length, to_write);
51 }
52 else
53 {
54 rc= MEMCACHED_INVALID_ARGUMENTS;
55 }
56 }
57 else
58 {
59 unlikely (expiration)
60 {
61 if ((instance->major_version == 1 &&
62 instance->minor_version > 2) ||
63 instance->major_version > 1)
64 {
65 rc= MEMCACHED_INVALID_ARGUMENTS;
66 goto error;
67 }
68 else
69 {
70 /* ensure that we are connected, otherwise we might bump the
71 * command counter before connection */
72 if ((rc= memcached_connect(instance)) != MEMCACHED_SUCCESS)
73 {
74 WATCHPOINT_ERROR(rc);
75 return rc;
76 }
77
78 if (instance->minor_version == 0)
79 {
80 if (no_reply || !to_write)
81 {
82 /* We might get out of sync with the server if we
83 * send this command to a server newer than 1.2.x..
84 * disable no_reply and buffered mode.
85 */
86 to_write= 1;
87 if (no_reply)
88 memcached_server_response_increment(instance);
89 no_reply= false;
90 }
91 }
92 send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
93 "delete %s%.*s %u%s\r\n",
94 ptr->prefix_key,
95 (int) key_length, key,
96 (uint32_t)expiration,
97 no_reply ? " noreply" :"" );
98 }
99 }
100 else
101 send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
102 "delete %s%.*s%s\r\n",
103 ptr->prefix_key,
104 (int)key_length, key, no_reply ? " noreply" :"");
105
106 if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
107 {
108 rc= MEMCACHED_WRITE_FAILURE;
109 goto error;
110 }
111
112 if (ptr->flags.use_udp && !to_write)
113 {
114 if (send_length > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH)
115 return MEMCACHED_WRITE_FAILURE;
116 if (send_length + instance->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH)
117 memcached_io_write(instance, NULL, 0, 1);
118 }
119
120 rc= memcached_do(instance, buffer, send_length, to_write);
121 }
122
123 if (rc != MEMCACHED_SUCCESS)
124 goto error;
125
126 if (!to_write)
127 rc= MEMCACHED_BUFFERED;
128 else if (!no_reply)
129 {
130 rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
131 if (rc == MEMCACHED_DELETED)
132 rc= MEMCACHED_SUCCESS;
133 }
134
135 if (rc == MEMCACHED_SUCCESS && ptr->delete_trigger)
136 ptr->delete_trigger(ptr, key, key_length);
137
138 error:
139 LIBMEMCACHED_MEMCACHED_DELETE_END();
140 return rc;
141 }
142
143 static inline memcached_return_t binary_delete(memcached_st *ptr,
144 uint32_t server_key,
145 const char *key,
146 size_t key_length,
147 uint8_t flush)
148 {
149 memcached_server_instance_st *instance;
150 protocol_binary_request_delete request= {.bytes= {0}};
151
152 instance= memcached_server_instance_fetch(ptr, server_key);
153
154 request.message.header.request.magic= PROTOCOL_BINARY_REQ;
155 if (ptr->flags.no_reply)
156 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ;
157 else
158 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETE;
159 request.message.header.request.keylen= htons((uint16_t)key_length);
160 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
161 request.message.header.request.bodylen= htonl((uint32_t) key_length);
162
163 if (ptr->flags.use_udp && !flush)
164 {
165 size_t cmd_size= sizeof(request.bytes) + key_length;
166 if (cmd_size > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH)
167 return MEMCACHED_WRITE_FAILURE;
168 if (cmd_size + instance->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH)
169 memcached_io_write(instance, NULL, 0, 1);
170 }
171
172 memcached_return_t rc= MEMCACHED_SUCCESS;
173
174 if ((memcached_do(instance, request.bytes,
175 sizeof(request.bytes), 0) != MEMCACHED_SUCCESS) ||
176 (memcached_io_write(instance, key,
177 key_length, (char) flush) == -1))
178 {
179 memcached_io_reset(instance);
180 rc= MEMCACHED_WRITE_FAILURE;
181 }
182
183 unlikely (ptr->number_of_replicas > 0)
184 {
185 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ;
186
187 for (uint32_t x= 0; x < ptr->number_of_replicas; ++x)
188 {
189 memcached_server_instance_st *replica;
190
191 ++server_key;
192 if (server_key == memcached_server_count(ptr))
193 server_key= 0;
194
195 replica= memcached_server_instance_fetch(ptr, server_key);
196
197 if ((memcached_do(replica, (const char*)request.bytes,
198 sizeof(request.bytes), 0) != MEMCACHED_SUCCESS) ||
199 (memcached_io_write(replica, key, key_length, (char) flush) == -1))
200 {
201 memcached_io_reset(replica);
202 }
203 else
204 {
205 memcached_server_response_decrement(replica);
206 }
207 }
208 }
209
210 return rc;
211 }