projects / m6w6 / libmemcached / blob
? search:


1f7e775c3cc57a258eb47d554b263782bf604e26
[m6w6/libmemcached] / libmemcached / get.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
10 * met:
11 *
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
22 * written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 */
37
38 #include <libmemcached/common.h>
39
40 /*
41 What happens if no servers exist?
42 */
43 char *memcached_get(memcached_st *ptr, const char *key,
44 size_t key_length,
45 size_t *value_length,
46 uint32_t *flags,
47 memcached_return_t *error)
48 {
49 return memcached_get_by_key(ptr, NULL, 0, key, key_length, value_length,
50 flags, error);
51 }
52
53 static memcached_return_t __mget_by_key_real(memcached_st *ptr,
54 const char *group_key,
55 size_t group_key_length,
56 const char * const *keys,
57 const size_t *key_length,
58 size_t number_of_keys,
59 const bool mget_mode);
60 char *memcached_get_by_key(memcached_st *shell,
61 const char *group_key,
62 size_t group_key_length,
63 const char *key, size_t key_length,
64 size_t *value_length,
65 uint32_t *flags,
66 memcached_return_t *error)
67 {
68 Memcached* ptr= memcached2Memcached(shell);
69 memcached_return_t unused;
70 if (error == NULL)
71 {
72 error= &unused;
73 }
74
75 uint64_t query_id= 0;
76 if (ptr)
77 {
78 query_id= ptr->query_id;
79 }
80
81 /* Request the key */
82 *error= __mget_by_key_real(ptr, group_key, group_key_length,
83 (const char * const *)&key, &key_length,
84 1, false);
85 if (ptr)
86 {
87 assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
88 }
89
90 if (memcached_failed(*error))
91 {
92 if (ptr)
93 {
94 if (memcached_has_current_error(*ptr)) // Find the most accurate error
95 {
96 *error= memcached_last_error(ptr);
97 }
98 }
99
100 if (value_length)
101 {
102 *value_length= 0;
103 }
104
105 return NULL;
106 }
107
108 char *value= memcached_fetch(ptr, NULL, NULL,
109 value_length, flags, error);
110 assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
111
112 /* This is for historical reasons */
113 if (*error == MEMCACHED_END)
114 {
115 *error= MEMCACHED_NOTFOUND;
116 }
117
118 if (value == NULL)
119 {
120 if (ptr->get_key_failure and *error == MEMCACHED_NOTFOUND)
121 {
122 memcached_result_st key_failure_result;
123 memcached_result_st* result_ptr= memcached_result_create(ptr, &key_failure_result);
124 memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, result_ptr);
125
126 /* On all failure drop to returning NULL */
127 if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED)
128 {
129 if (rc == MEMCACHED_BUFFERED)
130 {
131 uint64_t latch; /* We use latch to track the state of the original socket */
132 latch= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS);
133 if (latch == 0)
134 {
135 memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
136 }
137
138 rc= memcached_set(ptr, key, key_length,
139 (memcached_result_value(result_ptr)),
140 (memcached_result_length(result_ptr)),
141 0,
142 (memcached_result_flags(result_ptr)));
143
144 if (rc == MEMCACHED_BUFFERED and latch == 0)
145 {
146 memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0);
147 }
148 }
149 else
150 {
151 rc= memcached_set(ptr, key, key_length,
152 (memcached_result_value(result_ptr)),
153 (memcached_result_length(result_ptr)),
154 0,
155 (memcached_result_flags(result_ptr)));
156 }
157
158 if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED)
159 {
160 *error= rc;
161 *value_length= memcached_result_length(result_ptr);
162 *flags= memcached_result_flags(result_ptr);
163 char *result_value= memcached_string_take_value(&result_ptr->value);
164 memcached_result_free(result_ptr);
165
166 return result_value;
167 }
168 }
169
170 memcached_result_free(result_ptr);
171 }
172 assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
173
174 return NULL;
175 }
176
177 return value;
178 }
179
180 memcached_return_t memcached_mget(memcached_st *ptr,
181 const char * const *keys,
182 const size_t *key_length,
183 size_t number_of_keys)
184 {
185 return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys);
186 }
187
188 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
189 const uint32_t master_server_key,
190 const bool is_group_key_set,
191 const char * const *keys,
192 const size_t *key_length,
193 const size_t number_of_keys,
194 const bool mget_mode);
195
196 static memcached_return_t __mget_by_key_real(memcached_st *ptr,
197 const char *group_key,
198 const size_t group_key_length,
199 const char * const *keys,
200 const size_t *key_length,
201 size_t number_of_keys,
202 const bool mget_mode)
203 {
204 bool failures_occured_in_sending= false;
205 const char *get_command= "get";
206 uint8_t get_command_length= 3;
207 unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
208
209 memcached_return_t rc;
210 if (memcached_failed(rc= initialize_query(ptr, true)))
211 {
212 return rc;
213 }
214
215 if (memcached_is_udp(ptr))
216 {
217 return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
218 }
219
220 LIBMEMCACHED_MEMCACHED_MGET_START();
221
222 if (number_of_keys == 0)
223 {
224 return memcached_set_error(*ptr, MEMCACHED_NOTFOUND, MEMCACHED_AT, memcached_literal_param("number_of_keys was zero"));
225 }
226
227 if (memcached_failed(memcached_key_test(*ptr, keys, key_length, number_of_keys)))
228 {
229 return memcached_last_error(ptr);
230 }
231
232 bool is_group_key_set= false;
233 if (group_key and group_key_length)
234 {
235 master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
236 is_group_key_set= true;
237 }
238
239 /*
240 Here is where we pay for the non-block API. We need to remove any data sitting
241 in the queue before we start our get.
242
243 It might be optimum to bounce the connection if count > some number.
244 */
245 for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
246 {
247 memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
248
249 if (instance->response_count())
250 {
251 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
252
253 if (ptr->flags.no_block)
254 {
255 memcached_io_write(instance);
256 }
257
258 while(instance->response_count())
259 {
260 (void)memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result);
261 }
262 }
263 }
264
265 if (memcached_is_binary(ptr))
266 {
267 return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys,
268 key_length, number_of_keys, mget_mode);
269 }
270
271 if (ptr->flags.support_cas)
272 {
273 get_command= "gets";
274 get_command_length= 4;
275 }
276
277 /*
278 If a server fails we warn about errors and start all over with sending keys
279 to the server.
280 */
281 WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS);
282 size_t hosts_connected= 0;
283 for (uint32_t x= 0; x < number_of_keys; x++)
284 {
285 uint32_t server_key;
286
287 if (is_group_key_set)
288 {
289 server_key= master_server_key;
290 }
291 else
292 {
293 server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
294 }
295
296 memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
297
298 libmemcached_io_vector_st vector[]=
299 {
300 { get_command, get_command_length },
301 { memcached_literal_param(" ") },
302 { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
303 { keys[x], key_length[x] }
304 };
305
306
307 if (instance->response_count() == 0)
308 {
309 rc= memcached_connect(instance);
310
311 if (memcached_failed(rc))
312 {
313 memcached_set_error(*instance, rc, MEMCACHED_AT);
314 continue;
315 }
316 hosts_connected++;
317
318 if ((memcached_io_writev(instance, vector, 1, false)) == false)
319 {
320 failures_occured_in_sending= true;
321 continue;
322 }
323 WATCHPOINT_ASSERT(instance->cursor_active_ == 0);
324 memcached_instance_response_increment(instance);
325 WATCHPOINT_ASSERT(instance->cursor_active_ == 1);
326 }
327
328 {
329 if ((memcached_io_writev(instance, (vector + 1), 3, false)) == false)
330 {
331 memcached_instance_response_reset(instance);
332 failures_occured_in_sending= true;
333 continue;
334 }
335 }
336 }
337
338 if (hosts_connected == 0)
339 {
340 LIBMEMCACHED_MEMCACHED_MGET_END();
341
342 if (memcached_failed(rc))
343 {
344 return rc;
345 }
346
347 return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT);
348 }
349
350
351 /*
352 Should we muddle on if some servers are dead?
353 */
354 bool success_happened= false;
355 for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
356 {
357 memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
358
359 if (instance->response_count())
360 {
361 /* We need to do something about non-connnected hosts in the future */
362 if ((memcached_io_write(instance, "\r\n", 2, true)) == -1)
363 {
364 failures_occured_in_sending= true;
365 }
366 else
367 {
368 success_happened= true;
369 }
370 }
371 }
372
373 LIBMEMCACHED_MEMCACHED_MGET_END();
374
375 if (failures_occured_in_sending and success_happened)
376 {
377 return MEMCACHED_SOME_ERRORS;
378 }
379
380 if (success_happened)
381 {
382 return MEMCACHED_SUCCESS;
383 }
384
385 return MEMCACHED_FAILURE; // Complete failure occurred
386 }
387
388 memcached_return_t memcached_mget_by_key(memcached_st *shell,
389 const char *group_key,
390 size_t group_key_length,
391 const char * const *keys,
392 const size_t *key_length,
393 size_t number_of_keys)
394 {
395 Memcached* ptr= memcached2Memcached(shell);
396 return __mget_by_key_real(ptr, group_key, group_key_length, keys, key_length, number_of_keys, true);
397 }
398
399 memcached_return_t memcached_mget_execute(memcached_st *ptr,
400 const char * const *keys,
401 const size_t *key_length,
402 size_t number_of_keys,
403 memcached_execute_fn *callback,
404 void *context,
405 unsigned int number_of_callbacks)
406 {
407 return memcached_mget_execute_by_key(ptr, NULL, 0, keys, key_length,
408 number_of_keys, callback,
409 context, number_of_callbacks);
410 }
411
412 memcached_return_t memcached_mget_execute_by_key(memcached_st *shell,
413 const char *group_key,
414 size_t group_key_length,
415 const char * const *keys,
416 const size_t *key_length,
417 size_t number_of_keys,
418 memcached_execute_fn *callback,
419 void *context,
420 unsigned int number_of_callbacks)
421 {
422 Memcached* ptr= memcached2Memcached(shell);
423 memcached_return_t rc;
424 if (memcached_failed(rc= initialize_query(ptr, false)))
425 {
426 return rc;
427 }
428
429 if (memcached_is_udp(ptr))
430 {
431 return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
432 }
433
434 if (memcached_is_binary(ptr) == false)
435 {
436 return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT,
437 memcached_literal_param("ASCII protocol is not supported for memcached_mget_execute_by_key()"));
438 }
439
440 memcached_callback_st *original_callbacks= ptr->callbacks;
441 memcached_callback_st cb= {
442 callback,
443 context,
444 number_of_callbacks
445 };
446
447 ptr->callbacks= &cb;
448 rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys,
449 key_length, number_of_keys);
450 ptr->callbacks= original_callbacks;
451
452 return rc;
453 }
454
455 static memcached_return_t simple_binary_mget(memcached_st *ptr,
456 const uint32_t master_server_key,
457 bool is_group_key_set,
458 const char * const *keys,
459 const size_t *key_length,
460 const size_t number_of_keys, const bool mget_mode)
461 {
462 memcached_return_t rc= MEMCACHED_NOTFOUND;
463
464 bool flush= (number_of_keys == 1);
465
466 /*
467 If a server fails we warn about errors and start all over with sending keys
468 to the server.
469 */
470 for (uint32_t x= 0; x < number_of_keys; ++x)
471 {
472 uint32_t server_key;
473
474 if (is_group_key_set)
475 {
476 server_key= master_server_key;
477 }
478 else
479 {
480 server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
481 }
482
483 memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
484
485 if (instance->response_count() == 0)
486 {
487 rc= memcached_connect(instance);
488 if (memcached_failed(rc))
489 {
490 continue;
491 }
492 }
493
494 protocol_binary_request_getk request= { }; //= {.bytes= {0}};
495 initialize_binary_request(instance, request.message.header);
496 if (mget_mode)
497 {
498 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
499 }
500 else
501 {
502 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
503 }
504
505 {
506 memcached_return_t vk= memcached_validate_key_length(key_length[x], ptr->flags.binary_protocol);
507 if (vk != MEMCACHED_SUCCESS)
508 {
509 if (x > 0)
510 {
511 memcached_io_reset(instance);
512 }
513
514 return vk;
515 }
516 }
517
518 request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
519 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
520 request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->_namespace)));
521
522 libmemcached_io_vector_st vector[]=
523 {
524 { request.bytes, sizeof(request.bytes) },
525 { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
526 { keys[x], key_length[x] }
527 };
528
529 if (memcached_io_writev(instance, vector, 3, flush) == false)
530 {
531 memcached_server_response_reset(instance);
532 rc= MEMCACHED_SOME_ERRORS;
533 continue;
534 }
535
536 /* We just want one pending response per server */
537 memcached_server_response_reset(instance);
538 memcached_server_response_increment(instance);
539 if ((x > 0 and x == ptr->io_key_prefetch) and memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
540 {
541 rc= MEMCACHED_SOME_ERRORS;
542 }
543 }
544
545 if (mget_mode)
546 {
547 /*
548 Send a noop command to flush the buffers
549 */
550 protocol_binary_request_noop request= {}; //= {.bytes= {0}};
551 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP;
552 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
553
554 for (uint32_t x= 0; x < memcached_server_count(ptr); ++x)
555 {
556 memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
557
558 if (instance->response_count())
559 {
560 initialize_binary_request(instance, request.message.header);
561 if ((memcached_io_write(instance) == false) or
562 (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1))
563 {
564 memcached_instance_response_reset(instance);
565 memcached_io_reset(instance);
566 rc= MEMCACHED_SOME_ERRORS;
567 }
568 }
569 }
570 }
571
572 return rc;
573 }
574
575 static memcached_return_t replication_binary_mget(memcached_st *ptr,
576 uint32_t* hash,
577 bool* dead_servers,
578 const char *const *keys,
579 const size_t *key_length,
580 const size_t number_of_keys)
581 {
582 memcached_return_t rc= MEMCACHED_NOTFOUND;
583 uint32_t start= 0;
584 uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
585
586 if (randomize_read)
587 {
588 start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1);
589 }
590
591 /* Loop for each replica */
592 for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica)
593 {
594 bool success= true;
595
596 for (uint32_t x= 0; x < number_of_keys; ++x)
597 {
598 if (hash[x] == memcached_server_count(ptr))
599 {
600 continue; /* Already successfully sent */
601 }
602
603 uint32_t server= hash[x] +replica;
604
605 /* In case of randomized reads */
606 if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas)))
607 {
608 server+= start;
609 }
610
611 while (server >= memcached_server_count(ptr))
612 {
613 server -= memcached_server_count(ptr);
614 }
615
616 if (dead_servers[server])
617 {
618 continue;
619 }
620
621 memcached_instance_st* instance= memcached_instance_fetch(ptr, server);
622
623 if (instance->response_count() == 0)
624 {
625 rc= memcached_connect(instance);
626
627 if (memcached_failed(rc))
628 {
629 memcached_io_reset(instance);
630 dead_servers[server]= true;
631 success= false;
632 continue;
633 }
634 }
635
636 protocol_binary_request_getk request= {};
637 initialize_binary_request(instance, request.message.header);
638 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
639 request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
640 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
641 request.message.header.request.bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
642
643 /*
644 * We need to disable buffering to actually know that the request was
645 * successfully sent to the server (so that we should expect a result
646 * back). It would be nice to do this in buffered mode, but then it
647 * would be complex to handle all error situations if we got to send
648 * some of the messages, and then we failed on writing out some others
649 * and we used the callback interface from memcached_mget_execute so
650 * that we might have processed some of the responses etc. For now,
651 * just make sure we work _correctly_
652 */
653 libmemcached_io_vector_st vector[]=
654 {
655 { request.bytes, sizeof(request.bytes) },
656 { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
657 { keys[x], key_length[x] }
658 };
659
660 if (memcached_io_writev(instance, vector, 3, true) == false)
661 {
662 memcached_io_reset(instance);
663 dead_servers[server]= true;
664 success= false;
665 continue;
666 }
667
668 memcached_server_response_increment(instance);
669 hash[x]= memcached_server_count(ptr);
670 }
671
672 if (success)
673 {
674 break;
675 }
676 }
677
678 return rc;
679 }
680
681 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
682 const uint32_t master_server_key,
683 bool is_group_key_set,
684 const char * const *keys,
685 const size_t *key_length,
686 const size_t number_of_keys,
687 const bool mget_mode)
688 {
689 if (ptr->number_of_replicas == 0)
690 {
691 return simple_binary_mget(ptr, master_server_key, is_group_key_set,
692 keys, key_length, number_of_keys, mget_mode);
693 }
694
695 uint32_t* hash= libmemcached_xvalloc(ptr, number_of_keys, uint32_t);
696 bool* dead_servers= libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool);
697
698 if (hash == NULL or dead_servers == NULL)
699 {
700 libmemcached_free(ptr, hash);
701 libmemcached_free(ptr, dead_servers);
702 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
703 }
704
705 if (is_group_key_set)
706 {
707 for (size_t x= 0; x < number_of_keys; x++)
708 {
709 hash[x]= master_server_key;
710 }
711 }
712 else
713 {
714 for (size_t x= 0; x < number_of_keys; x++)
715 {
716 hash[x]= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
717 }
718 }
719
720 memcached_return_t rc= replication_binary_mget(ptr, hash, dead_servers, keys,
721 key_length, number_of_keys);
722
723 WATCHPOINT_IFERROR(rc);
724 libmemcached_free(ptr, hash);
725 libmemcached_free(ptr, dead_servers);
726
727 return MEMCACHED_SUCCESS;
728 }
Resurrection of libmemcached https://launchpad.net/libmemcached