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"
40 #include "libmemcached/options.hpp"
41 #include "libmemcached/virtual_bucket.h"
43 static inline bool _memcached_init(Memcached
*self
)
45 self
->state
.is_purging
= false;
46 self
->state
.is_processing_input
= false;
47 self
->state
.is_time_for_rebuild
= false;
48 self
->state
.is_parsing
= false;
50 self
->flags
.auto_eject_hosts
= false;
51 self
->flags
.binary_protocol
= false;
52 self
->flags
.buffer_requests
= false;
53 self
->flags
.hash_with_namespace
= false;
54 self
->flags
.no_block
= false;
55 self
->flags
.reply
= true;
56 self
->flags
.randomize_replica_read
= false;
57 self
->flags
.support_cas
= false;
58 self
->flags
.tcp_nodelay
= false;
59 self
->flags
.use_sort_hosts
= false;
60 self
->flags
.use_udp
= false;
61 self
->flags
.verify_key
= false;
62 self
->flags
.tcp_keepalive
= false;
63 self
->flags
.is_aes
= false;
64 self
->flags
.is_fetching_version
= false;
66 self
->virtual_bucket
= NULL
;
68 self
->distribution
= MEMCACHED_DISTRIBUTION_MODULA
;
70 if (hashkit_create(&self
->hashkit
) == NULL
)
75 self
->server_info
.version
= 0;
77 self
->ketama
.continuum
= NULL
;
78 self
->ketama
.continuum_count
= 0;
79 self
->ketama
.continuum_points_counter
= 0;
80 self
->ketama
.next_distribution_rebuild
= 0;
81 self
->ketama
.weighted_
= false;
83 self
->number_of_hosts
= 0;
85 self
->last_disconnected_server
= NULL
;
89 self
->server_failure_limit
= MEMCACHED_SERVER_FAILURE_LIMIT
;
90 self
->server_timeout_limit
= MEMCACHED_SERVER_TIMEOUT_LIMIT
;
91 self
->query_id
= 1; // 0 is considered invalid
93 /* TODO, Document why we picked these defaults */
94 self
->io_msg_watermark
= 500;
95 self
->io_bytes_watermark
= 65 * 1024;
97 self
->tcp_keepidle
= 0;
99 self
->io_key_prefetch
= 0;
100 self
->poll_timeout
= MEMCACHED_DEFAULT_TIMEOUT
;
101 self
->connect_timeout
= MEMCACHED_DEFAULT_CONNECT_TIMEOUT
;
102 self
->retry_timeout
= MEMCACHED_SERVER_FAILURE_RETRY_TIMEOUT
;
103 self
->dead_timeout
= MEMCACHED_SERVER_FAILURE_DEAD_TIMEOUT
;
108 self
->user_data
= NULL
;
109 self
->number_of_replicas
= 0;
111 self
->allocators
= memcached_allocators_return_default();
113 self
->on_clone
= NULL
;
114 self
->on_cleanup
= NULL
;
115 self
->get_key_failure
= NULL
;
116 self
->delete_trigger
= NULL
;
117 self
->callbacks
= NULL
;
118 self
->sasl
.callbacks
= NULL
;
119 self
->sasl
.is_allocated
= false;
121 self
->error_messages
= NULL
;
122 self
->_namespace
= NULL
;
123 self
->configure
.initial_pool_size
= 1;
124 self
->configure
.max_pool_size
= 1;
125 self
->configure
.version
= -1;
126 self
->configure
.filename
= NULL
;
131 static void __memcached_free(Memcached
*ptr
, bool release_st
)
133 /* If we have anything open, lets close it now */
135 memcached_instance_list_free(memcached_instance_list(ptr
), memcached_instance_list_count(ptr
));
136 memcached_result_free(&ptr
->result
);
138 memcached_virtual_bucket_free(ptr
);
140 memcached_instance_free((memcached_instance_st
*)ptr
->last_disconnected_server
);
144 ptr
->on_cleanup(ptr
);
147 libmemcached_free(ptr
, ptr
->ketama
.continuum
);
148 ptr
->ketama
.continuum
= NULL
;
150 memcached_array_free(ptr
->_namespace
);
151 ptr
->_namespace
= NULL
;
153 memcached_error_free(*ptr
);
155 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and ptr
->sasl
.callbacks
)
157 memcached_destroy_sasl_auth_data(ptr
);
162 memcached_array_free(ptr
->configure
.filename
);
163 ptr
->configure
.filename
= NULL
;
166 hashkit_free(&ptr
->hashkit
);
168 if (memcached_is_allocated(ptr
) and release_st
)
170 libmemcached_free(ptr
, ptr
);
174 memcached_st
*memcached_create(memcached_st
*shell
)
178 shell
->options
.is_allocated
= false;
182 shell
= (memcached_st
*)libmemcached_xmalloc(NULL
, memcached_st
);
186 return NULL
; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
189 shell
->options
.is_allocated
= true;
192 if (_memcached_init(shell
) == false)
194 memcached_free(shell
);
198 Memcached
* memc
= memcached2Memcached(shell
);
199 if (memcached_result_create(shell
, &memc
->result
) == NULL
)
201 memcached_free(shell
);
205 WATCHPOINT_ASSERT_INITIALIZED(&memc
->result
);
210 memcached_st
*memcached(const char *string
, size_t length
)
212 if (length
== 0 and string
)
217 if (length
and string
== NULL
)
224 if (bool(getenv("LIBMEMCACHED")))
226 string
= getenv("LIBMEMCACHED");
227 length
= string
? strlen(string
) : 0;
231 memcached_st
*memc
= memcached_create(NULL
);
237 if (length
== 0 or string
== NULL
)
242 memcached_return_t rc
= memcached_parse_configuration(memc
, string
, length
);
243 if (memcached_success(rc
) and memcached_parse_filename(memc
))
245 rc
= memcached_parse_configure_file(*memc
, memcached_parse_filename(memc
), memcached_parse_filename_length(memc
));
248 if (memcached_failed(rc
))
250 memcached_free(memc
);
257 memcached_return_t
memcached_reset(memcached_st
*shell
)
259 Memcached
* ptr
= memcached2Memcached(shell
);
260 WATCHPOINT_ASSERT(ptr
);
263 return MEMCACHED_INVALID_ARGUMENTS
;
266 bool stored_is_allocated
= memcached_is_allocated(ptr
);
267 uint64_t query_id
= ptr
->query_id
;
268 __memcached_free(ptr
, false);
269 memcached_create(ptr
);
270 memcached_set_allocated(ptr
, stored_is_allocated
);
271 ptr
->query_id
= query_id
;
273 if (ptr
->configure
.filename
)
275 return memcached_parse_configure_file(*ptr
, memcached_param_array(ptr
->configure
.filename
));
278 return MEMCACHED_SUCCESS
;
281 void memcached_servers_reset(memcached_st
*shell
)
283 Memcached
* self
= memcached2Memcached(shell
);
286 libmemcached_free(self
, self
->ketama
.continuum
);
287 self
->ketama
.continuum
= NULL
;
288 self
->ketama
.continuum_count
= 0;
289 self
->ketama
.continuum_points_counter
= 0;
291 memcached_instance_list_free(memcached_instance_list(self
), self
->number_of_hosts
);
292 memcached_instance_set(self
, NULL
, 0);
294 memcached_reset_last_disconnected_server(self
);
298 void memcached_reset_last_disconnected_server(memcached_st
*shell
)
300 Memcached
* self
= memcached2Memcached(shell
);
303 memcached_instance_free((memcached_instance_st
*)self
->last_disconnected_server
);
304 self
->last_disconnected_server
= NULL
;
308 void memcached_free(memcached_st
*ptr
)
312 __memcached_free(ptr
, true);
317 clone is the destination, while source is the structure to clone.
318 If source is NULL the call is the same as if a memcached_create() was
321 memcached_st
*memcached_clone(memcached_st
*clone
, const memcached_st
*source
)
325 return memcached_create(clone
);
328 if (clone
and memcached_is_allocated(clone
))
333 memcached_st
*new_clone
= memcached_create(clone
);
335 if (new_clone
== NULL
)
340 new_clone
->flags
= source
->flags
;
341 new_clone
->send_size
= source
->send_size
;
342 new_clone
->recv_size
= source
->recv_size
;
343 new_clone
->poll_timeout
= source
->poll_timeout
;
344 new_clone
->connect_timeout
= source
->connect_timeout
;
345 new_clone
->retry_timeout
= source
->retry_timeout
;
346 new_clone
->dead_timeout
= source
->dead_timeout
;
347 new_clone
->distribution
= source
->distribution
;
349 if (hashkit_clone(&new_clone
->hashkit
, &source
->hashkit
) == NULL
)
351 memcached_free(new_clone
);
355 new_clone
->user_data
= source
->user_data
;
357 new_clone
->snd_timeout
= source
->snd_timeout
;
358 new_clone
->rcv_timeout
= source
->rcv_timeout
;
360 new_clone
->on_clone
= source
->on_clone
;
361 new_clone
->on_cleanup
= source
->on_cleanup
;
363 new_clone
->allocators
= source
->allocators
;
365 new_clone
->get_key_failure
= source
->get_key_failure
;
366 new_clone
->delete_trigger
= source
->delete_trigger
;
367 new_clone
->server_failure_limit
= source
->server_failure_limit
;
368 new_clone
->server_timeout_limit
= source
->server_timeout_limit
;
369 new_clone
->io_msg_watermark
= source
->io_msg_watermark
;
370 new_clone
->io_bytes_watermark
= source
->io_bytes_watermark
;
371 new_clone
->io_key_prefetch
= source
->io_key_prefetch
;
372 new_clone
->number_of_replicas
= source
->number_of_replicas
;
373 new_clone
->tcp_keepidle
= source
->tcp_keepidle
;
375 if (memcached_server_count(source
))
377 if (memcached_failed(memcached_push(new_clone
, source
)))
384 new_clone
->_namespace
= memcached_array_clone(new_clone
, source
->_namespace
);
385 new_clone
->configure
.filename
= memcached_array_clone(new_clone
, source
->_namespace
);
386 new_clone
->configure
.version
= source
->configure
.version
;
388 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and source
->sasl
.callbacks
)
390 if (memcached_failed(memcached_clone_sasl(new_clone
, source
)))
392 memcached_free(new_clone
);
397 if (memcached_failed(run_distribution(new_clone
)))
399 memcached_free(new_clone
);
404 if (source
->on_clone
)
406 source
->on_clone(new_clone
, source
);
412 void *memcached_get_user_data(const memcached_st
*shell
)
414 const Memcached
* memc
= memcached2Memcached(shell
);
417 return memc
->user_data
;
423 void *memcached_set_user_data(memcached_st
*shell
, void *data
)
425 Memcached
* memc
= memcached2Memcached(shell
);
428 void *ret
= memc
->user_data
;
429 memc
->user_data
= data
;
437 memcached_return_t
memcached_push(memcached_st
*destination
, const memcached_st
*source
)
439 return memcached_instance_push(destination
, (memcached_instance_st
*)source
->servers
, source
->number_of_hosts
);
442 memcached_instance_st
* memcached_instance_fetch(Memcached
*ptr
, uint32_t server_key
)
449 return &ptr
->servers
[server_key
];
452 const memcached_instance_st
* memcached_server_instance_by_position(const memcached_st
*shell
, uint32_t server_key
)
454 const Memcached
* memc
= memcached2Memcached(shell
);
457 return &memc
->servers
[server_key
];
463 memcached_instance_st
* memcached_instance_by_position(const memcached_st
*shell
, uint32_t server_key
)
465 const Memcached
* memc
= memcached2Memcached(shell
);
468 return &memc
->servers
[server_key
];
474 uint64_t memcached_query_id(const memcached_st
*shell
)
476 const Memcached
* memc
= memcached2Memcached(shell
);
479 return memc
->query_id
;
485 memcached_instance_st
* memcached_instance_list(const memcached_st
*shell
)
487 const Memcached
* memc
= memcached2Memcached(shell
);
490 return (memcached_instance_st
*)memc
->servers
;