2 * Copyright (C) 2006-2010 Brian Aker
5 * Use and distribution licensed under the BSD license. See
6 * the COPYING file in the parent directory for full text.
14 static const memcached_st global_copy
= {
17 .is_processing_input
= false,
18 .is_time_for_rebuild
= false,
21 .auto_eject_hosts
= false,
22 .binary_protocol
= false,
23 .buffer_requests
= false,
25 .hash_with_prefix_key
= false,
26 .ketama_weighted
= false,
29 .randomize_replica_read
= false,
33 .use_cache_lookups
= false,
34 .use_sort_hosts
= false,
37 .tcp_keepalive
= false,
42 static inline bool _memcached_init(memcached_st
*self
)
44 self
->state
= global_copy
.state
;
45 self
->flags
= global_copy
.flags
;
47 self
->distribution
= MEMCACHED_DISTRIBUTION_MODULA
;
50 hash_ptr
= hashkit_create(&self
->hashkit
);
54 self
->ketama
.continuum_points_counter
= 0;
56 self
->number_of_hosts
= 0;
58 self
->last_disconnected_server
= NULL
;
62 self
->server_failure_limit
= 0;
64 /* TODO, Document why we picked these defaults */
65 self
->io_msg_watermark
= 500;
66 self
->io_bytes_watermark
= 65 * 1024;
68 self
->tcp_keepidle
= 0;
70 self
->io_key_prefetch
= 0;
71 self
->cached_errno
= 0;
72 self
->poll_timeout
= MEMCACHED_DEFAULT_TIMEOUT
;
73 self
->connect_timeout
= MEMCACHED_DEFAULT_CONNECT_TIMEOUT
;
74 self
->retry_timeout
= 0;
75 self
->ketama
.continuum_count
= 0;
80 self
->user_data
= NULL
;
81 self
->ketama
.next_distribution_rebuild
= 0;
82 self
->number_of_replicas
= 0;
83 hash_ptr
= hashkit_create(&self
->distribution_hashkit
);
86 self
->ketama
.continuum
= NULL
;
88 self
->allocators
= memcached_allocators_return_default();
91 self
->on_cleanup
= NULL
;
92 self
->get_key_failure
= NULL
;
93 self
->delete_trigger
= NULL
;
94 self
->callbacks
= NULL
;
95 self
->sasl
.callbacks
= NULL
;
96 self
->sasl
.is_allocated
= false;
98 self
->error_messages
= NULL
;
99 self
->prefix_key
= NULL
;
100 self
->configure
.filename
= NULL
;
105 static void _free(memcached_st
*ptr
, bool release_st
)
107 /* If we have anything open, lets close it now */
109 memcached_server_list_free(memcached_server_list(ptr
));
110 memcached_result_free(&ptr
->result
);
112 if (ptr
->last_disconnected_server
)
113 memcached_server_free(ptr
->last_disconnected_server
);
116 ptr
->on_cleanup(ptr
);
118 if (ptr
->ketama
.continuum
)
119 libmemcached_free(ptr
, ptr
->ketama
.continuum
);
121 memcached_array_free(ptr
->prefix_key
);
122 ptr
->prefix_key
= NULL
;
124 memcached_error_free(ptr
);
126 if (ptr
->sasl
.callbacks
)
128 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
129 memcached_destroy_sasl_auth_data(ptr
);
135 memcached_array_free(ptr
->configure
.filename
);
136 ptr
->configure
.filename
= NULL
;
139 if (memcached_is_allocated(ptr
) && release_st
)
141 libmemcached_free(ptr
, ptr
);
145 memcached_st
*memcached_create(memcached_st
*ptr
)
149 ptr
= (memcached_st
*)malloc(sizeof(memcached_st
));
153 return NULL
; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
156 ptr
->options
.is_allocated
= true;
160 ptr
->options
.is_allocated
= false;
164 memcached_set_purging(ptr
, false);
165 memcached_set_processing_input(ptr
, false);
168 if (! _memcached_init(ptr
))
174 if (! memcached_result_create(ptr
, &ptr
->result
))
180 WATCHPOINT_ASSERT_INITIALIZED(&ptr
->result
);
185 memcached_st
*memcached_create_with_options(const char *string
, size_t length
)
187 memcached_st
*self
= memcached_create(NULL
);
192 memcached_return_t rc
;
193 if ((rc
= memcached_parse_configuration(self
, string
, length
)) != MEMCACHED_SUCCESS
)
198 if (memcached_parse_filename(self
))
200 rc
= memcached_parse_configure_file(self
, memcached_parse_filename(self
), memcached_parse_filename_length(self
));
206 memcached_return_t
memcached_reset(memcached_st
*ptr
)
208 WATCHPOINT_ASSERT(ptr
);
210 return MEMCACHED_INVALID_ARGUMENTS
;
212 bool stored_is_allocated
= memcached_is_allocated(ptr
);
214 memcached_create(ptr
);
215 memcached_set_allocated(ptr
, stored_is_allocated
);
217 if (ptr
->configure
.filename
)
219 return memcached_parse_configure_file(ptr
, memcached_param_array(ptr
->configure
.filename
));
222 return MEMCACHED_SUCCESS
;
225 void memcached_servers_reset(memcached_st
*ptr
)
227 memcached_server_list_free(memcached_server_list(ptr
));
229 memcached_server_list_set(ptr
, NULL
);
230 ptr
->number_of_hosts
= 0;
231 if (ptr
->last_disconnected_server
)
233 memcached_server_free(ptr
->last_disconnected_server
);
235 ptr
->last_disconnected_server
= NULL
;
236 ptr
->server_failure_limit
= 0;
239 void memcached_reset_last_disconnected_server(memcached_st
*ptr
)
241 if (ptr
->last_disconnected_server
)
243 memcached_server_free(ptr
->last_disconnected_server
);
244 ptr
->last_disconnected_server
= NULL
;
248 void memcached_free(memcached_st
*ptr
)
254 clone is the destination, while source is the structure to clone.
255 If source is NULL the call is the same as if a memcached_create() was
258 memcached_st
*memcached_clone(memcached_st
*clone
, const memcached_st
*source
)
260 memcached_return_t rc
= MEMCACHED_SUCCESS
;
261 memcached_st
*new_clone
;
264 return memcached_create(clone
);
266 if (clone
&& memcached_is_allocated(clone
))
271 new_clone
= memcached_create(clone
);
273 if (new_clone
== NULL
)
276 new_clone
->flags
= source
->flags
;
277 new_clone
->send_size
= source
->send_size
;
278 new_clone
->recv_size
= source
->recv_size
;
279 new_clone
->poll_timeout
= source
->poll_timeout
;
280 new_clone
->connect_timeout
= source
->connect_timeout
;
281 new_clone
->retry_timeout
= source
->retry_timeout
;
282 new_clone
->distribution
= source
->distribution
;
284 hashkit_st
*hash_ptr
;
286 hash_ptr
= hashkit_clone(&new_clone
->hashkit
, &source
->hashkit
);
289 memcached_free(new_clone
);
293 hash_ptr
= hashkit_clone(&new_clone
->distribution_hashkit
, &source
->distribution_hashkit
);
296 memcached_free(new_clone
);
300 new_clone
->user_data
= source
->user_data
;
302 new_clone
->snd_timeout
= source
->snd_timeout
;
303 new_clone
->rcv_timeout
= source
->rcv_timeout
;
305 new_clone
->on_clone
= source
->on_clone
;
306 new_clone
->on_cleanup
= source
->on_cleanup
;
308 new_clone
->allocators
= source
->allocators
;
310 new_clone
->get_key_failure
= source
->get_key_failure
;
311 new_clone
->delete_trigger
= source
->delete_trigger
;
312 new_clone
->server_failure_limit
= source
->server_failure_limit
;
313 new_clone
->io_msg_watermark
= source
->io_msg_watermark
;
314 new_clone
->io_bytes_watermark
= source
->io_bytes_watermark
;
315 new_clone
->io_key_prefetch
= source
->io_key_prefetch
;
316 new_clone
->number_of_replicas
= source
->number_of_replicas
;
317 new_clone
->tcp_keepidle
= source
->tcp_keepidle
;
319 if (memcached_server_count(source
))
320 rc
= memcached_push(new_clone
, source
);
322 if (rc
!= MEMCACHED_SUCCESS
)
324 memcached_free(new_clone
);
330 new_clone
->prefix_key
= memcached_array_clone(new_clone
, source
->prefix_key
);
332 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
333 if (source
->sasl
.callbacks
)
335 if (memcached_clone_sasl(new_clone
, source
) != MEMCACHED_SUCCESS
)
337 memcached_free(new_clone
);
343 rc
= run_distribution(new_clone
);
345 if (rc
!= MEMCACHED_SUCCESS
)
347 memcached_free(new_clone
);
352 if (source
->on_clone
)
353 source
->on_clone(new_clone
, source
);
358 void *memcached_get_user_data(const memcached_st
*ptr
)
360 return ptr
->user_data
;
363 void *memcached_set_user_data(memcached_st
*ptr
, void *data
)
365 void *ret
= ptr
->user_data
;
366 ptr
->user_data
= data
;
371 memcached_return_t
memcached_push(memcached_st
*destination
, const memcached_st
*source
)
373 return memcached_server_push(destination
, source
->servers
);
376 memcached_server_write_instance_st
memcached_server_instance_fetch(memcached_st
*ptr
, uint32_t server_key
)
378 return &ptr
->servers
[server_key
];
381 memcached_server_instance_st
memcached_server_instance_by_position(const memcached_st
*ptr
, uint32_t server_key
)
383 return &ptr
->servers
[server_key
];