void memcached_free(memcached_st *ptr)
{
if (!ptr) return;
/* If we have anything open, lets close it now */
memcached_quit(ptr);
server_list_free(ptr, ptr->hosts);
memcached_result_free(&ptr->result);
if (ptr->on_cleanup)
ptr->on_cleanup(ptr);
if (ptr->continuum)
{
if (ptr->call_free)
ptr->call_free(ptr, ptr->continuum);
else
free(ptr->continuum);
}
if (ptr->is_allocated)
{
if (ptr->call_free)
ptr->call_free(ptr, ptr);
else
free(ptr);
}
else
memset(ptr, 0, sizeof(memcached_st));
}
/*
Set the value, then quit to make sure it is flushed.
Come back in and test that add fails.
*/
static test_return_t add_test(memcached_st *memc)
{
memcached_return_t rc;
const char *key= "foo";
const char *value= "when we sanitize";
unsigned long long setting_value;
setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
memcached_quit(memc);
rc= memcached_add(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
/* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
if (setting_value)
{
test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
}
else
{
test_true(rc == MEMCACHED_NOTSTORED);
}
return 0;
}
void do_set(memcached_st *mc, int key_num)
{
int i;
char key[12];
for (i=0; i<key_num; i++) {
sprintf(key, "%d_%d", i, pid);
TRACE2("%s : %s", key, data[i]);
memcached_set(mc, key, strlen(key), data[i], strlen(data[i]), 0, 0);
if (! do_one_connection)
memcached_quit(mc);
}
printf("last set: key:%s val:%s\n", key, data[i-1]);
}
void memcached_free(memcached_st *ptr)
{
/* If we have anything open, lets close it now */
memcached_quit(ptr);
server_list_free(ptr, memcached_server_list(ptr));
memcached_result_free(&ptr->result);
if (ptr->on_cleanup)
ptr->on_cleanup(ptr);
if (ptr->continuum)
libmemcached_free(ptr, ptr->continuum);
if (memcached_is_allocated(ptr))
{
libmemcached_free(ptr, ptr);
}
}
static test_return_t set_udp_behavior_test(memcached_st *memc)
{
memcached_quit(memc);
memc->number_of_hosts= 0;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, memc->distribution);
test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
test_true(memc->flags.use_udp);
test_true(memc->flags.no_reply);
test_true(memcached_server_count(memc) == 0);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
test_true(! (memc->flags.use_udp));
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
test_true(! (memc->flags.no_reply));
return TEST_SUCCESS;
}
void do_get(memcached_st *mc, int key_num)
{
int i;
char key[12];
char *val = '\0';
size_t value_length;
uint32_t flags;
memcached_return rc;
for (i=0; i<key_num; i++) {
sprintf(key, "%d_%d", i, pid);
val = memcached_get(mc, key, strlen(key), &value_length, &flags, &rc);
TRACE2("%s : %s", key, val);
if (! do_one_connection)
memcached_quit(mc);
#if DEBUG
if (strcmp(val, data[i])) {
printf("[ERROR] mismatch: [%d] <%s>vs<%s>\n", i, data[i], val);
}
#endif
}
printf("last get: key:%s val:%s\n", key, val);
}
int pr_memcache_conn_clone(pool *p, pr_memcache_t *mcache) {
memcached_st *old_mc = NULL, *new_mc = NULL;
if (p == NULL ||
mcache == NULL) {
errno = EINVAL;
return -1;
}
memcached_quit(mcache->mc);
old_mc = mcache->mc;
new_mc = memcached_clone(NULL, old_mc);
if (new_mc == NULL) {
errno = ENOMEM;
return -1;
}
/* Now free up the previous context; we don't need it anymore. */
memcached_free(old_mc);
mcache->mc = new_mc;
return 0;
}
bool c_Memcache::t_close() {
memcached_quit(&m_memcache);
return true;
}
memcached_return_t memcached_behavior_set(memcached_st *ptr,
const memcached_behavior_t flag,
uint64_t data)
{
switch (flag)
{
case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
ptr->number_of_replicas= (uint32_t)data;
break;
case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
ptr->io_msg_watermark= (uint32_t) data;
break;
case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
ptr->io_bytes_watermark= (uint32_t)data;
break;
case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
ptr->io_key_prefetch = (uint32_t)data;
break;
case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
ptr->snd_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
ptr->rcv_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
ptr->server_failure_limit= (uint32_t)data;
break;
case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
memcached_quit(ptr); // We need t shutdown all of the connections to make sure we do the correct protocol
if (data)
{
ptr->flags.verify_key= false;
}
ptr->flags.binary_protocol= set_flag(data);
break;
case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
ptr->flags.support_cas= set_flag(data);
break;
case MEMCACHED_BEHAVIOR_NO_BLOCK:
ptr->flags.no_block= set_flag(data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
ptr->flags.buffer_requests= set_flag(data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_USE_UDP:
if (memcached_server_count(ptr))
{
return MEMCACHED_FAILURE;
}
ptr->flags.use_udp= set_flag(data);
if (data)
{
ptr->flags.no_reply= set_flag(data);
}
break;
case MEMCACHED_BEHAVIOR_TCP_NODELAY:
ptr->flags.tcp_nodelay= set_flag(data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE:
ptr->flags.tcp_keepalive= set_flag(data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_DISTRIBUTION:
return memcached_behavior_set_distribution(ptr, (memcached_server_distribution_t)data);
case MEMCACHED_BEHAVIOR_KETAMA:
{
if (data)
{
(void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
(void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
(void)memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
}
else
{
(void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_DEFAULT);
(void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_DEFAULT);
(void)memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_MODULA);
}
break;
}
case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
{
(void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
(void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
ptr->flags.ketama_weighted= set_flag(data);
/**
@note We try to keep the same distribution going. This should be deprecated and rewritten.
*/
return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
}
case MEMCACHED_BEHAVIOR_HASH:
return memcached_behavior_set_key_hash(ptr, (memcached_hash_t)(data));
case MEMCACHED_BEHAVIOR_KETAMA_HASH:
return memcached_behavior_set_distribution_hash(ptr, (memcached_hash_t)(data));
case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
ptr->flags.use_cache_lookups= set_flag(data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_VERIFY_KEY:
if (ptr->flags.binary_protocol)
return MEMCACHED_FAILURE;
ptr->flags.verify_key= set_flag(data);
break;
case MEMCACHED_BEHAVIOR_SORT_HOSTS:
{
ptr->flags.use_sort_hosts= set_flag(data);
run_distribution(ptr);
break;
}
case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
ptr->poll_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
ptr->connect_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
ptr->retry_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
ptr->send_size= (int32_t)data;
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
ptr->recv_size= (int32_t)data;
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE:
ptr->tcp_keepidle= (uint32_t)data;
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_USER_DATA:
return MEMCACHED_FAILURE;
case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
ptr->flags.hash_with_prefix_key= set_flag(data);
break;
case MEMCACHED_BEHAVIOR_NOREPLY:
ptr->flags.no_reply= set_flag(data);
break;
case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
ptr->flags.auto_eject_hosts= set_flag(data);
break;
case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
srandom((uint32_t) time(NULL));
ptr->flags.randomize_replica_read= set_flag(data);
break;
case MEMCACHED_BEHAVIOR_CORK:
{
memcached_server_write_instance_st instance;
bool action= set_flag(data);
if (action == false)
{
ptr->flags.cork= set_flag(false);
return MEMCACHED_SUCCESS;
}
instance= memcached_server_instance_fetch(ptr, 0);
if (! instance)
return MEMCACHED_NO_SERVERS;
/* We just try the first host, and if it is down we return zero */
memcached_return_t rc;
rc= memcached_connect(instance);
if (rc != MEMCACHED_SUCCESS)
{
return rc;
}
/* Now we test! */
memcached_ternary_t enabled;
enabled= test_cork(instance, true);
switch (enabled)
{
case MEM_FALSE:
return ptr->cached_errno ? MEMCACHED_ERRNO : MEMCACHED_FAILURE ;
case MEM_TRUE:
{
enabled= test_cork(instance, false);
if (enabled == false) // Possible bug in OS?
{
memcached_quit_server(instance, false); // We should reset everything on this error.
return MEMCACHED_ERRNO; // Errno will be true because we will have already set it.
}
ptr->flags.cork= true;
ptr->flags.tcp_nodelay= true;
memcached_quit(ptr); // We go on and reset the connections.
}
break;
case MEM_NOT:
default:
return MEMCACHED_NOT_SUPPORTED;
}
}
break;
case MEMCACHED_BEHAVIOR_MAX:
default:
/* Shouldn't get here */
WATCHPOINT_ASSERT(0);
return MEMCACHED_FAILURE;
}
return MEMCACHED_SUCCESS;
}
memcached_return memcached_behavior_set(memcached_st *ptr,
memcached_behavior flag,
uint64_t data)
{
switch (flag)
{
case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
ptr->io_msg_watermark= (uint32_t) data;
break;
case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
ptr->io_bytes_watermark= (uint32_t)data;
break;
case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
ptr->io_key_prefetch = (uint32_t)data;
break;
case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
ptr->snd_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
ptr->rcv_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
ptr->server_failure_limit= (uint32_t)data;
break;
case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
if (data)
set_behavior_flag(ptr, MEM_VERIFY_KEY, 0);
set_behavior_flag(ptr, MEM_BINARY_PROTOCOL, data);
break;
case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
set_behavior_flag(ptr, MEM_SUPPORT_CAS, data);
break;
case MEMCACHED_BEHAVIOR_NO_BLOCK:
set_behavior_flag(ptr, MEM_NO_BLOCK, data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
set_behavior_flag(ptr, MEM_BUFFER_REQUESTS, data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_USE_UDP:
if (ptr->number_of_hosts)
return MEMCACHED_FAILURE;
set_behavior_flag(ptr, MEM_USE_UDP, data);
if (data)
set_behavior_flag(ptr,MEM_NOREPLY,data);
break;
case MEMCACHED_BEHAVIOR_TCP_NODELAY:
set_behavior_flag(ptr, MEM_TCP_NODELAY, data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_DISTRIBUTION:
{
ptr->distribution= (memcached_server_distribution)(data);
if (ptr->distribution == MEMCACHED_DISTRIBUTION_RANDOM)
{
srandom((uint32_t) time(NULL));
}
run_distribution(ptr);
break;
}
case MEMCACHED_BEHAVIOR_KETAMA:
{
if (data)
{
ptr->hash= MEMCACHED_HASH_MD5;
ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
}
else
{
ptr->hash= 0;
ptr->distribution= 0;
}
run_distribution(ptr);
break;
}
case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
{
ptr->hash= MEMCACHED_HASH_MD5;
ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
set_behavior_flag(ptr, MEM_KETAMA_WEIGHTED, data);
run_distribution(ptr);
break;
}
case MEMCACHED_BEHAVIOR_HASH:
#ifndef HAVE_HSIEH_HASH
if ((memcached_hash)(data) == MEMCACHED_HASH_HSIEH)
return MEMCACHED_FAILURE;
#endif
ptr->hash= (memcached_hash)(data);
break;
case MEMCACHED_BEHAVIOR_KETAMA_HASH:
ptr->hash_continuum= (memcached_hash)(data);
run_distribution(ptr);
break;
case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
set_behavior_flag(ptr, MEM_USE_CACHE_LOOKUPS, data);
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_VERIFY_KEY:
if (ptr->flags & MEM_BINARY_PROTOCOL)
break;
set_behavior_flag(ptr, MEM_VERIFY_KEY, data);
break;
case MEMCACHED_BEHAVIOR_SORT_HOSTS:
{
set_behavior_flag(ptr, MEM_USE_SORT_HOSTS, data);
run_distribution(ptr);
break;
}
case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
ptr->poll_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_POLL_MAX_RETRIES:
ptr->poll_max_retries= (uint32_t) data;
break;
case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
ptr->connect_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
ptr->retry_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
ptr->send_size= (int32_t)data;
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
ptr->recv_size= (int32_t)data;
memcached_quit(ptr);
break;
case MEMCACHED_BEHAVIOR_USER_DATA:
return MEMCACHED_FAILURE;
case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
set_behavior_flag(ptr, MEM_HASH_WITH_PREFIX_KEY, data);
break;
case MEMCACHED_BEHAVIOR_NOREPLY:
set_behavior_flag(ptr, MEM_NOREPLY, data);
break;
case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
set_behavior_flag(ptr, MEM_AUTO_EJECT_HOSTS, data);
break;
default:
/* Shouldn't get here */
WATCHPOINT_ASSERT(flag);
break;
}
return MEMCACHED_SUCCESS;
}
static test_return_t udp_quit_test(memcached_st *memc)
{
uint16_t *expected_ids= get_udp_request_ids(memc);
memcached_quit(memc);
return post_udp_op_check(memc, expected_ids);
}
VALUE mc_close(VALUE self) {
memcached_st *mc;
Data_Get_Struct(self, memcached_st, mc);
memcached_quit(mc);
return Qnil;
}
