Merge doc update.
[awesomized/libmemcached] / libmemcached / memcached.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011 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 #include <libmemcached/options.hpp>
41 #include <libmemcached/virtual_bucket.h>
42
43 static inline bool _memcached_init(memcached_st *self)
44 {
45 self->state.is_purging= false;
46 self->state.is_processing_input= false;
47 self->state.is_time_for_rebuild= false;
48
49 self->flags.auto_eject_hosts= false;
50 self->flags.binary_protocol= false;
51 self->flags.buffer_requests= false;
52 self->flags.hash_with_namespace= false;
53 self->flags.no_block= false;
54 self->flags.reply= true;
55 self->flags.randomize_replica_read= false;
56 self->flags.support_cas= false;
57 self->flags.tcp_nodelay= false;
58 self->flags.use_sort_hosts= false;
59 self->flags.use_udp= false;
60 self->flags.verify_key= false;
61 self->flags.tcp_keepalive= false;
62 self->flags.is_aes= false;
63 self->flags.is_fetching_version= false;
64
65 self->virtual_bucket= NULL;
66
67 self->distribution= MEMCACHED_DISTRIBUTION_MODULA;
68
69 if (hashkit_create(&self->hashkit) == NULL)
70 {
71 return false;
72 }
73
74 self->server_info.version= 0;
75
76 self->ketama.continuum= NULL;
77 self->ketama.continuum_count= 0;
78 self->ketama.continuum_points_counter= 0;
79 self->ketama.next_distribution_rebuild= 0;
80 self->ketama.weighted_= false;
81
82 self->number_of_hosts= 0;
83 self->servers= NULL;
84 self->last_disconnected_server= NULL;
85
86 self->snd_timeout= 0;
87 self->rcv_timeout= 0;
88 self->server_failure_limit= MEMCACHED_SERVER_FAILURE_LIMIT;
89 self->query_id= 1; // 0 is considered invalid
90
91 /* TODO, Document why we picked these defaults */
92 self->io_msg_watermark= 500;
93 self->io_bytes_watermark= 65 * 1024;
94
95 self->tcp_keepidle= 0;
96
97 self->io_key_prefetch= 0;
98 self->poll_timeout= MEMCACHED_DEFAULT_TIMEOUT;
99 self->connect_timeout= MEMCACHED_DEFAULT_CONNECT_TIMEOUT;
100 self->retry_timeout= MEMCACHED_SERVER_FAILURE_RETRY_TIMEOUT;
101 self->dead_timeout= MEMCACHED_SERVER_FAILURE_DEAD_TIMEOUT;
102
103 self->send_size= -1;
104 self->recv_size= -1;
105
106 self->user_data= NULL;
107 self->number_of_replicas= 0;
108
109 self->allocators= memcached_allocators_return_default();
110
111 self->on_clone= NULL;
112 self->on_cleanup= NULL;
113 self->get_key_failure= NULL;
114 self->delete_trigger= NULL;
115 self->callbacks= NULL;
116 self->sasl.callbacks= NULL;
117 self->sasl.is_allocated= false;
118
119 self->error_messages= NULL;
120 self->_namespace= NULL;
121 self->configure.initial_pool_size= 1;
122 self->configure.max_pool_size= 1;
123 self->configure.version= -1;
124 self->configure.filename= NULL;
125
126 return true;
127 }
128
129 static void __memcached_free(memcached_st *ptr, bool release_st)
130 {
131 /* If we have anything open, lets close it now */
132 send_quit(ptr);
133 memcached_instance_list_free(memcached_instance_list(ptr), memcached_instance_list_count(ptr));
134 memcached_result_free(&ptr->result);
135
136 memcached_virtual_bucket_free(ptr);
137
138 memcached_instance_free((org::libmemcached::Instance*)ptr->last_disconnected_server);
139
140 if (ptr->on_cleanup)
141 {
142 ptr->on_cleanup(ptr);
143 }
144
145 libmemcached_free(ptr, ptr->ketama.continuum);
146
147 memcached_array_free(ptr->_namespace);
148 ptr->_namespace= NULL;
149
150 memcached_error_free(*ptr);
151
152 if (LIBMEMCACHED_WITH_SASL_SUPPORT and ptr->sasl.callbacks)
153 {
154 memcached_destroy_sasl_auth_data(ptr);
155 }
156
157 if (release_st)
158 {
159 memcached_array_free(ptr->configure.filename);
160 ptr->configure.filename= NULL;
161 }
162
163 hashkit_free(&ptr->hashkit);
164
165 if (memcached_is_allocated(ptr) and release_st)
166 {
167 libmemcached_free(ptr, ptr);
168 }
169 }
170
171 memcached_st *memcached_create(memcached_st *ptr)
172 {
173 if (ptr)
174 {
175 ptr->options.is_allocated= false;
176 }
177 else
178 {
179 ptr= (memcached_st *)libmemcached_xmalloc(NULL, memcached_st);
180
181 if (ptr == NULL)
182 {
183 return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
184 }
185
186 ptr->options.is_allocated= true;
187 }
188
189 if (_memcached_init(ptr) == false)
190 {
191 memcached_free(ptr);
192 return NULL;
193 }
194
195 if (memcached_result_create(ptr, &ptr->result) == NULL)
196 {
197 memcached_free(ptr);
198 return NULL;
199 }
200
201 WATCHPOINT_ASSERT_INITIALIZED(&ptr->result);
202
203 return ptr;
204 }
205
206 memcached_st *memcached(const char *string, size_t length)
207 {
208 if (length == 0 and string)
209 {
210 return NULL;
211 }
212
213 if (length and string == NULL)
214 {
215 return NULL;
216 }
217
218 if (length == 0)
219 {
220 if (bool(getenv("LIBMEMCACHED")))
221 {
222 string= getenv("LIBMEMCACHED");
223 length= string ? strlen(string) : 0;
224 }
225 }
226
227 memcached_st *memc= memcached_create(NULL);
228 if (memc == NULL)
229 {
230 return NULL;
231 }
232
233 if (length == 0 or string == NULL)
234 {
235 return memc;
236 }
237
238 memcached_return_t rc= memcached_parse_configuration(memc, string, length);
239 if (memcached_success(rc) and memcached_parse_filename(memc))
240 {
241 rc= memcached_parse_configure_file(*memc, memcached_parse_filename(memc), memcached_parse_filename_length(memc));
242 }
243
244 if (memcached_failed(rc))
245 {
246 memcached_free(memc);
247 return NULL;
248 }
249
250 return memc;
251 }
252
253 memcached_return_t memcached_reset(memcached_st *ptr)
254 {
255 WATCHPOINT_ASSERT(ptr);
256 if (ptr == NULL)
257 {
258 return MEMCACHED_INVALID_ARGUMENTS;
259 }
260
261 bool stored_is_allocated= memcached_is_allocated(ptr);
262 uint64_t query_id= ptr->query_id;
263 __memcached_free(ptr, false);
264 memcached_create(ptr);
265 memcached_set_allocated(ptr, stored_is_allocated);
266 ptr->query_id= query_id;
267
268 if (ptr->configure.filename)
269 {
270 return memcached_parse_configure_file(*ptr, memcached_param_array(ptr->configure.filename));
271 }
272
273 return MEMCACHED_SUCCESS;
274 }
275
276 void memcached_servers_reset(memcached_st *self)
277 {
278 if (self)
279 {
280 memcached_instance_list_free(memcached_instance_list(self), self->number_of_hosts);
281
282 memcached_instance_set(self, NULL);
283 self->number_of_hosts= 0;
284 memcached_instance_free((org::libmemcached::Instance*)self->last_disconnected_server);
285 self->last_disconnected_server= NULL;
286 }
287 }
288
289 void memcached_reset_last_disconnected_server(memcached_st *self)
290 {
291 if (self)
292 {
293 memcached_instance_free((org::libmemcached::Instance*)self->last_disconnected_server);
294 self->last_disconnected_server= NULL;
295 }
296 }
297
298 void memcached_free(memcached_st *ptr)
299 {
300 if (ptr)
301 {
302 __memcached_free(ptr, true);
303 }
304 }
305
306 /*
307 clone is the destination, while source is the structure to clone.
308 If source is NULL the call is the same as if a memcached_create() was
309 called.
310 */
311 memcached_st *memcached_clone(memcached_st *clone, const memcached_st *source)
312 {
313 if (source == NULL)
314 {
315 return memcached_create(clone);
316 }
317
318 if (clone and memcached_is_allocated(clone))
319 {
320 return NULL;
321 }
322
323 memcached_st *new_clone= memcached_create(clone);
324
325 if (new_clone == NULL)
326 {
327 return NULL;
328 }
329
330 new_clone->flags= source->flags;
331 new_clone->send_size= source->send_size;
332 new_clone->recv_size= source->recv_size;
333 new_clone->poll_timeout= source->poll_timeout;
334 new_clone->connect_timeout= source->connect_timeout;
335 new_clone->retry_timeout= source->retry_timeout;
336 new_clone->dead_timeout= source->dead_timeout;
337 new_clone->distribution= source->distribution;
338
339 if (hashkit_clone(&new_clone->hashkit, &source->hashkit) == NULL)
340 {
341 memcached_free(new_clone);
342 return NULL;
343 }
344
345 new_clone->user_data= source->user_data;
346
347 new_clone->snd_timeout= source->snd_timeout;
348 new_clone->rcv_timeout= source->rcv_timeout;
349
350 new_clone->on_clone= source->on_clone;
351 new_clone->on_cleanup= source->on_cleanup;
352
353 new_clone->allocators= source->allocators;
354
355 new_clone->get_key_failure= source->get_key_failure;
356 new_clone->delete_trigger= source->delete_trigger;
357 new_clone->server_failure_limit= source->server_failure_limit;
358 new_clone->io_msg_watermark= source->io_msg_watermark;
359 new_clone->io_bytes_watermark= source->io_bytes_watermark;
360 new_clone->io_key_prefetch= source->io_key_prefetch;
361 new_clone->number_of_replicas= source->number_of_replicas;
362 new_clone->tcp_keepidle= source->tcp_keepidle;
363
364 if (memcached_server_count(source))
365 {
366 if (memcached_failed(memcached_push(new_clone, source)))
367 {
368 return NULL;
369 }
370 }
371
372
373 new_clone->_namespace= memcached_array_clone(new_clone, source->_namespace);
374 new_clone->configure.filename= memcached_array_clone(new_clone, source->_namespace);
375 new_clone->configure.version= source->configure.version;
376
377 if (LIBMEMCACHED_WITH_SASL_SUPPORT and source->sasl.callbacks)
378 {
379 if (memcached_failed(memcached_clone_sasl(new_clone, source)))
380 {
381 memcached_free(new_clone);
382 return NULL;
383 }
384 }
385
386 if (memcached_failed(run_distribution(new_clone)))
387 {
388 memcached_free(new_clone);
389
390 return NULL;
391 }
392
393 if (source->on_clone)
394 {
395 source->on_clone(new_clone, source);
396 }
397
398 return new_clone;
399 }
400
401 void *memcached_get_user_data(const memcached_st *ptr)
402 {
403 if (ptr == NULL)
404 {
405 return NULL;
406 }
407
408 return ptr->user_data;
409 }
410
411 void *memcached_set_user_data(memcached_st *ptr, void *data)
412 {
413 if (ptr == NULL)
414 {
415 return NULL;
416 }
417
418 void *ret= ptr->user_data;
419 ptr->user_data= data;
420
421 return ret;
422 }
423
424 memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source)
425 {
426 return memcached_instance_push(destination, (org::libmemcached::Instance*)source->servers, source->number_of_hosts);
427 }
428
429 org::libmemcached::Instance* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key)
430 {
431 if (ptr == NULL)
432 {
433 return NULL;
434 }
435
436 return &ptr->servers[server_key];
437 }
438
439 memcached_server_instance_st memcached_server_instance_by_position(const memcached_st *ptr, uint32_t server_key)
440 {
441 if (ptr == NULL)
442 {
443 return NULL;
444 }
445
446 return &ptr->servers[server_key];
447 }
448
449 org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key)
450 {
451 if (ptr == NULL)
452 {
453 return NULL;
454 }
455
456 return &ptr->servers[server_key];
457 }
458
459 uint64_t memcached_query_id(const memcached_st *self)
460 {
461 if (self == NULL)
462 {
463 return 0;
464 }
465
466 return self->query_id;
467 }
468
469 org::libmemcached::Instance* memcached_instance_list(const memcached_st *self)
470 {
471 if (self)
472 {
473 return (org::libmemcached::Instance*)self->servers;
474 }
475
476 return NULL;
477 }
478