1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
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
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
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.
38 #include <libmemcached/common.h>
39 #include <libmemcached/virtual_bucket.h>
42 static const memcached_st global_copy
= {
44 .is_purging
= false, // .is_purging
45 .is_processing_input
= false, // is_processing_input
46 .is_time_for_rebuild
= false,
49 .auto_eject_hosts
= false,
50 .binary_protocol
= false,
51 .buffer_requests
= false,
52 .hash_with_prefix_key
= false,
55 .randomize_replica_read
= false,
58 .use_sort_hosts
= false,
61 .tcp_keepalive
= false,
66 static inline bool _memcached_init(memcached_st
*self
)
68 self
->state
.is_purging
= false;
69 self
->state
.is_processing_input
= false;
70 self
->state
.is_time_for_rebuild
= false;
72 self
->flags
.auto_eject_hosts
= false;
73 self
->flags
.binary_protocol
= false;
74 self
->flags
.buffer_requests
= false;
75 self
->flags
.hash_with_prefix_key
= false;
76 self
->flags
.no_block
= false;
77 self
->flags
.no_reply
= false;
78 self
->flags
.randomize_replica_read
= false;
79 self
->flags
.support_cas
= false;
80 self
->flags
.tcp_nodelay
= false;
81 self
->flags
.use_sort_hosts
= false;
82 self
->flags
.use_udp
= false;
83 self
->flags
.verify_key
= false;
84 self
->flags
.tcp_keepalive
= false;
86 self
->virtual_bucket
= NULL
;
88 self
->distribution
= MEMCACHED_DISTRIBUTION_MODULA
;
91 hash_ptr
= hashkit_create(&self
->hashkit
);
95 self
->ketama
.continuum
= NULL
;
96 self
->ketama
.continuum_count
= 0;
97 self
->ketama
.continuum_points_counter
= 0;
98 self
->ketama
.next_distribution_rebuild
= 0;
99 self
->ketama
.weighted
= false;
101 self
->number_of_hosts
= 0;
103 self
->last_disconnected_server
= NULL
;
105 self
->snd_timeout
= 0;
106 self
->rcv_timeout
= 0;
107 self
->server_failure_limit
= 0;
108 self
->query_id
= 1; // 0 is considered invalid
110 /* TODO, Document why we picked these defaults */
111 self
->io_msg_watermark
= 500;
112 self
->io_bytes_watermark
= 65 * 1024;
114 self
->tcp_keepidle
= 0;
116 self
->io_key_prefetch
= 0;
117 self
->poll_timeout
= MEMCACHED_DEFAULT_TIMEOUT
;
118 self
->connect_timeout
= MEMCACHED_DEFAULT_CONNECT_TIMEOUT
;
119 self
->retry_timeout
= 0;
124 self
->user_data
= NULL
;
125 self
->number_of_replicas
= 0;
126 hash_ptr
= hashkit_create(&self
->distribution_hashkit
);
130 self
->allocators
= memcached_allocators_return_default();
132 self
->on_clone
= NULL
;
133 self
->on_cleanup
= NULL
;
134 self
->get_key_failure
= NULL
;
135 self
->delete_trigger
= NULL
;
136 self
->callbacks
= NULL
;
137 self
->sasl
.callbacks
= NULL
;
138 self
->sasl
.is_allocated
= false;
140 self
->error_messages
= NULL
;
141 self
->prefix_key
= NULL
;
142 self
->configure
.initial_pool_size
= 1;
143 self
->configure
.max_pool_size
= 1;
144 self
->configure
.version
= -1;
145 self
->configure
.filename
= NULL
;
150 static void _free(memcached_st
*ptr
, bool release_st
)
152 /* If we have anything open, lets close it now */
154 memcached_server_list_free(memcached_server_list(ptr
));
155 memcached_result_free(&ptr
->result
);
157 memcached_virtual_bucket_free(ptr
);
159 if (ptr
->last_disconnected_server
)
160 memcached_server_free(ptr
->last_disconnected_server
);
163 ptr
->on_cleanup(ptr
);
165 if (ptr
->ketama
.continuum
)
166 libmemcached_free(ptr
, ptr
->ketama
.continuum
);
168 memcached_array_free(ptr
->prefix_key
);
169 ptr
->prefix_key
= NULL
;
171 memcached_error_free(ptr
);
173 if (ptr
->sasl
.callbacks
)
175 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
176 memcached_destroy_sasl_auth_data(ptr
);
182 memcached_array_free(ptr
->configure
.filename
);
183 ptr
->configure
.filename
= NULL
;
186 if (memcached_is_allocated(ptr
) && release_st
)
188 libmemcached_free(ptr
, ptr
);
192 memcached_st
*memcached_create(memcached_st
*ptr
)
196 ptr
= (memcached_st
*)malloc(sizeof(memcached_st
));
200 return NULL
; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
203 ptr
->options
.is_allocated
= true;
207 ptr
->options
.is_allocated
= false;
211 memcached_set_purging(ptr
, false);
212 memcached_set_processing_input(ptr
, false);
215 if (! _memcached_init(ptr
))
221 if (! memcached_result_create(ptr
, &ptr
->result
))
227 WATCHPOINT_ASSERT_INITIALIZED(&ptr
->result
);
232 memcached_st
*memcached(const char *string
, size_t length
)
234 if (! length
|| ! string
)
240 memcached_st
*self
= memcached_create(NULL
);
247 memcached_return_t rc
;
248 rc
= memcached_parse_configuration(self
, string
, length
);
250 if (rc
== MEMCACHED_SUCCESS
&& memcached_parse_filename(self
))
252 rc
= memcached_parse_configure_file(self
, memcached_parse_filename(self
), memcached_parse_filename_length(self
));
255 if (rc
!= MEMCACHED_SUCCESS
)
257 memcached_free(self
);
267 memcached_return_t
memcached_reset(memcached_st
*ptr
)
269 WATCHPOINT_ASSERT(ptr
);
271 return MEMCACHED_INVALID_ARGUMENTS
;
273 bool stored_is_allocated
= memcached_is_allocated(ptr
);
274 uint64_t query_id
= ptr
->query_id
;
276 memcached_create(ptr
);
277 memcached_set_allocated(ptr
, stored_is_allocated
);
278 ptr
->query_id
= query_id
;
280 if (ptr
->configure
.filename
)
282 return memcached_parse_configure_file(ptr
, memcached_param_array(ptr
->configure
.filename
));
285 return MEMCACHED_SUCCESS
;
288 void memcached_servers_reset(memcached_st
*ptr
)
293 memcached_server_list_free(memcached_server_list(ptr
));
295 memcached_server_list_set(ptr
, NULL
);
296 ptr
->number_of_hosts
= 0;
297 if (ptr
->last_disconnected_server
)
299 memcached_server_free(ptr
->last_disconnected_server
);
301 ptr
->last_disconnected_server
= NULL
;
302 ptr
->server_failure_limit
= 0;
305 void memcached_reset_last_disconnected_server(memcached_st
*ptr
)
310 if (ptr
->last_disconnected_server
)
312 memcached_server_free(ptr
->last_disconnected_server
);
313 ptr
->last_disconnected_server
= NULL
;
317 void memcached_free(memcached_st
*ptr
)
326 clone is the destination, while source is the structure to clone.
327 If source is NULL the call is the same as if a memcached_create() was
330 memcached_st
*memcached_clone(memcached_st
*clone
, const memcached_st
*source
)
332 memcached_return_t rc
= MEMCACHED_SUCCESS
;
333 memcached_st
*new_clone
;
336 return memcached_create(clone
);
338 if (clone
&& memcached_is_allocated(clone
))
343 new_clone
= memcached_create(clone
);
345 if (new_clone
== NULL
)
348 new_clone
->flags
= source
->flags
;
349 new_clone
->send_size
= source
->send_size
;
350 new_clone
->recv_size
= source
->recv_size
;
351 new_clone
->poll_timeout
= source
->poll_timeout
;
352 new_clone
->connect_timeout
= source
->connect_timeout
;
353 new_clone
->retry_timeout
= source
->retry_timeout
;
354 new_clone
->distribution
= source
->distribution
;
356 hashkit_st
*hash_ptr
;
358 hash_ptr
= hashkit_clone(&new_clone
->hashkit
, &source
->hashkit
);
361 memcached_free(new_clone
);
365 hash_ptr
= hashkit_clone(&new_clone
->distribution_hashkit
, &source
->distribution_hashkit
);
368 memcached_free(new_clone
);
372 new_clone
->user_data
= source
->user_data
;
374 new_clone
->snd_timeout
= source
->snd_timeout
;
375 new_clone
->rcv_timeout
= source
->rcv_timeout
;
377 new_clone
->on_clone
= source
->on_clone
;
378 new_clone
->on_cleanup
= source
->on_cleanup
;
380 new_clone
->allocators
= source
->allocators
;
382 new_clone
->get_key_failure
= source
->get_key_failure
;
383 new_clone
->delete_trigger
= source
->delete_trigger
;
384 new_clone
->server_failure_limit
= source
->server_failure_limit
;
385 new_clone
->io_msg_watermark
= source
->io_msg_watermark
;
386 new_clone
->io_bytes_watermark
= source
->io_bytes_watermark
;
387 new_clone
->io_key_prefetch
= source
->io_key_prefetch
;
388 new_clone
->number_of_replicas
= source
->number_of_replicas
;
389 new_clone
->tcp_keepidle
= source
->tcp_keepidle
;
391 if (memcached_server_count(source
))
392 rc
= memcached_push(new_clone
, source
);
394 if (rc
!= MEMCACHED_SUCCESS
)
396 memcached_free(new_clone
);
402 new_clone
->prefix_key
= memcached_array_clone(new_clone
, source
->prefix_key
);
404 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
405 if (source
->sasl
.callbacks
)
407 if (memcached_clone_sasl(new_clone
, source
) != MEMCACHED_SUCCESS
)
409 memcached_free(new_clone
);
415 rc
= run_distribution(new_clone
);
417 if (rc
!= MEMCACHED_SUCCESS
)
419 memcached_free(new_clone
);
424 if (source
->on_clone
)
425 source
->on_clone(new_clone
, source
);
430 void *memcached_get_user_data(const memcached_st
*ptr
)
432 return ptr
->user_data
;
435 void *memcached_set_user_data(memcached_st
*ptr
, void *data
)
437 void *ret
= ptr
->user_data
;
438 ptr
->user_data
= data
;
443 memcached_return_t
memcached_push(memcached_st
*destination
, const memcached_st
*source
)
445 return memcached_server_push(destination
, source
->servers
);
448 memcached_server_write_instance_st
memcached_server_instance_fetch(memcached_st
*ptr
, uint32_t server_key
)
450 return &ptr
->servers
[server_key
];
453 memcached_server_instance_st
memcached_server_instance_by_position(const memcached_st
*ptr
, uint32_t server_key
)
455 return &ptr
->servers
[server_key
];
458 uint64_t memcached_query_id(const memcached_st
*self
)
463 return self
->query_id
;