mcs_st *lmc_create(mcs_st *ptr, const char *config) {
assert(ptr);
memset(ptr, 0, sizeof(*ptr));
ptr->kind = MCS_KIND_LIBMEMCACHED;
memcached_st *mst = memcached_create(NULL);
if (mst != NULL) {
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_KETAMA, 1);
memcached_behavior_set(mst, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
memcached_server_st *mservers;
mservers = memcached_servers_parse(config);
if (mservers != NULL) {
memcached_server_push(mst, mservers);
ptr->data = mst;
ptr->nservers = (int) memcached_server_list_count(mservers);
if (ptr->nservers > 0) {
ptr->servers = calloc(sizeof(mcs_server_st), ptr->nservers);
if (ptr->servers != NULL) {
for (int i = 0; i < ptr->nservers; i++) {
ptr->servers[i].fd = -1;
}
int j = 0;
for (; j < ptr->nservers; j++) {
strncpy(ptr->servers[j].hostname,
memcached_server_name(mservers + j),
sizeof(ptr->servers[j].hostname) - 1);
ptr->servers[j].port = (int) memcached_server_port(mservers + j);
if (ptr->servers[j].port <= 0) {
moxi_log_write("lmc_create failed, could not parse port: %s\n",
config);
break;
}
}
if (j >= ptr->nservers) {
memcached_server_list_free(mservers);
return ptr;
}
}
}
memcached_server_list_free(mservers);
}
}
mcs_free(ptr);
return NULL;
}
void init_thread(evhtp_t *htp, evthr_t *thread, void *arg)
{
thr_arg_t *thr_args;
thr_args = calloc(1, sizeof(thr_arg_t));
thr_args->thread = thread;
char mserver[32];
if(settings.cache_on == true)
{
memcached_st *memc = memcached_create(NULL);
snprintf(mserver, 32, "%s:%d", settings.cache_ip, settings.cache_port);
memcached_server_st *servers = memcached_servers_parse(mserver);
memcached_server_push(memc, servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, 1);
thr_args->cache_conn = memc;
LOG_PRINT(LOG_DEBUG, "Memcached Connection Init Finished.");
memcached_server_list_free(servers);
}
if(settings.mode == 2)
{
memcached_st *beans = memcached_create(NULL);
snprintf(mserver, 32, "%s:%d", settings.beansdb_ip, settings.beansdb_port);
memcached_server_st *servers = memcached_servers_parse(mserver);
servers = memcached_servers_parse(mserver);
memcached_server_push(beans, servers);
memcached_behavior_set(beans, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0);
memcached_behavior_set(beans, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(beans, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, 1);
thr_args->beansdb_conn = beans;
LOG_PRINT(LOG_DEBUG, "beansdb Connection Init Finished.");
memcached_server_list_free(servers);
}
else if(settings.mode == 3)
{
redisContext* c = redisConnect(settings.ssdb_ip, settings.ssdb_port);
if(c->err)
{
redisFree(c);
LOG_PRINT(LOG_DEBUG, "Connect to ssdb server faile");
}
else
{
thr_args->ssdb_conn = c;
LOG_PRINT(LOG_DEBUG, "Connect to ssdb server Success");
}
}
evthr_set_aux(thread, thr_args);
}
/**
* @function memcached.connect
*
* ### Synopsis
*
* var handle = memcached.connect(servers);
*
* Create a connection to the specified memcached servers.
*
* The servers argument is a comma separated list of memcached servers. The server names are of the form <code>hostname[:port]</code>.
*
* @param {string} servers - comma separated list of servers
* @return {object} handle - opaque handle used for other memcached methods, or false if an error occurred.
*/
JSVAL _memcached_connect (JSARGS args) {
HandleScope scope;
String::Utf8Value options(args[0]);
M *handle = memcached_create(NULL);
S *servers = memcached_servers_parse(*options);
if (memcached_server_push(handle, servers) != MEMCACHED_SUCCESS) {
memcached_server_list_free(servers);
memcached_free(handle);
return scope.Close(False());
}
memcached_server_list_free(servers);
return scope.Close(External::New(handle));
}
void
BeatBoard::ApiMemcached::setUpMemcached( const std::string& memcached_host,
const int memcached_port )
{
memcached_server_st *servers;
memcached_return rc;
memcached_status = false;
memc = memcached_create(NULL);
servers = memcached_server_list_append(NULL, memcached_host.c_str(),
memcached_port, &rc);
if (rc != MEMCACHED_SUCCESS) {
std::cerr << memcached_strerror(memc, rc) << std::endl;
return;
}
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS) {
std::cerr << memcached_strerror(memc, rc) << std::endl;
return;
}
memcached_server_list_free(servers);
memcached_status = true;
}
Memcache_Res CMemcache:: Memcac_Create(string strIp, unsigned int uPort)
{
Memcache_Res mRes = MEMCACHED_SUCCESS;
Memcache_Handler htMc = NULL;
memcached_server_st* pServ = NULL;
char pMem_Server_Addr[MEM_SERV_ADDR_SIZE] = {0};
if(strIp.empty() || 0 == uPort)
return static_cast<Memcache_Res>(MEMCACHED_INVALID_ARGUMENTS);
// create memcache server address
sprintf(pMem_Server_Addr, "%s:%d", strIp.c_str(), uPort);
// create memcache
htMc = memcached_create(NULL);
pServ = memcached_servers_parse(pMem_Server_Addr);
if((mRes = memcached_server_push(htMc, pServ)) != MEMCACHED_SUCCESS)
return mRes;
memcached_server_list_free(pServ);
if((mRes = memcached_behavior_set(htMc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0)) != MEMCACHED_SUCCESS)
return mRes;
// return
if(NULL != m_hMc)
Memcac_Free();
pthread_mutex_lock(&m_hmc_mutex);
m_hMc = htMc;
pthread_mutex_unlock(&m_hmc_mutex);
return MEMCACHED_SUCCESS;
}
void *logpool_memcache_init(logpool_t *ctx, logpool_param_t *p)
{
struct logpool_param_memcache *args = cast(struct logpool_param_memcache *, p);
const char *host = args->host;
long port = args->port;
mc_t *mc = cast(mc_t *, logpool_string_init(ctx, p));
memcached_return_t rc;
memcached_server_list_st servers;
mc->st = memcached_create(NULL);
#if 0
memcached_behavior_set (mc->st, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
#endif
#ifdef USE_BUFFER_REQ
memcached_behavior_set (mc->st, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
#endif
if (unlikely(mc->st == NULL)) {
/* TODO Error */
abort();
}
servers = memcached_server_list_append(NULL, host, port, &rc);
if (unlikely(rc != MEMCACHED_SUCCESS)) {
/* TODO Error */
fprintf(stderr, "Error!! '%s'\n", memcached_strerror(mc->st, rc));
abort();
}
rc = memcached_server_push(mc->st, servers);
if (unlikely(rc != MEMCACHED_SUCCESS)) {
/* TODO Error */
fprintf(stderr, "Error!! '%s'\n", memcached_strerror(mc->st, rc));
abort();
}
memcached_server_list_free(servers);
return cast(void *, mc);
}
/*
* mmc_init()
*/
int mmc_init (char *server_list)
{
memcached_server_st *servers;
memcached_return ret;
pmmc = memcached_create(NULL);
if (!pmmc) {
printf("Cannot create mmc object.\n");
return -1;
}
/*
* Add server.
*/
servers = memcached_servers_parse(server_list);
ret = memcached_server_push(pmmc, servers);
if (ret != MEMCACHED_SUCCESS) {
printf("Cannot push the mmc server list. [%s]\n",
memcached_strerror(pmmc, ret));
return -1;
}
/*
* Set options.
*/
memcached_behavior_set(pmmc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 5000);
memcached_behavior_set(pmmc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 5000);
memcached_behavior_set(pmmc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_server_list_free(servers);
return 0;
}
/* added by Wakamori */
static void opt_logcached(int mode, const char *optstr)
{
#if defined(HAVE_LIBMEMCACHED)
knh_syslog = memcached_syslog;
knh_vsyslog = memcached_vsyslog;
kbytes_t host_port = B(optstr);
kbytes_t host = knh_bytes_head(host_port, ':');
kint_t port;
if (!knh_bytes_parseint(knh_bytes_next(host_port, ':'), &port)) {
KNH_DIE("konoha: invalid arguments.");
}
memc = memcached_create(NULL);
char tmp = host.buf[host.len];
host.buf[host.len] = '\0';
memcached_return rc;
memcached_server_list_st servers;
servers = memcached_server_list_append(NULL, host.text, port, &rc);
if (rc != MEMCACHED_SUCCESS) {
KNH_DIE("konoha: cannot append a memcached server.");
}
host.buf[host.len] = tmp;
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS) {
KNH_DIE("konoha: cannot push a memcached server.");
}
memcached_server_list_free(servers);
#else
KNH_DIE("konoha: memcached library is not installed.");
#endif /* defined(HAVE_LIBMEMCACHED) */
}
void
cut_teardown(void)
{
if (val1) {
free(val1);
val1 = NULL;
}
if (val2) {
free(val2);
val2 = NULL;
}
if (egg) {
g_object_unref(egg);
}
cut_remove_path(tmp_directory, NULL);
if (servers) {
memcached_server_list_free(servers);
}
if (memc) {
memcached_free(memc);
}
}
int32_t CVDCMemcache::init_m_servers()
{
//重置 m_servers， 如果不为空，则先释放，置空，保证m_servers为空
if(NULL != m_servers)
{
memcached_server_list_free(m_servers);
m_servers = NULL;
}
//重新创建m_servers对象
m_servers = memcached_servers_parse(GET_MEMCACHECONFIG_INSTANCE().GetMemcacheIPAndPort());
memcached_server_push(m_memc, m_servers);
//创建m_servers对象失败，返回错误
if(NULL == m_servers)
{
g_FrameLogEngine.WriteBaseLog( enmLogLevel_Error, "[%s:%d]ERROR: allocate memcached server failed! errorcode=0x%08X\n",
__FILE__, __LINE__, E_DBPROXY_MALLOC_MEMCACHE_SERVERS);
// g_bMemcacheConnected = false;
return E_DBPROXY_MALLOC_MEMCACHE_SERVERS;
}
g_FrameLogEngine.WriteBaseLog( enmLogLevel_Notice, "[%s:%d]initialize m_servers success!\n", __FILE__, __LINE__);
return S_OK;
}
static mrb_value mrb_memcached_init(mrb_state *mrb, mrb_value self)
{
mrb_memcached_data *data;
memcached_server_st *msv;
memcached_st *mst;
memcached_return mrt;
const char *servers;
data = (mrb_memcached_data *)DATA_PTR(self);
if (data) {
mrb_free(mrb, data);
}
DATA_TYPE(self) = &mrb_memcached_data_type;
DATA_PTR(self) = NULL;
mrb_get_args(mrb, "z", &servers);
mst = memcached_create(NULL);
msv = memcached_servers_parse(servers);
mrt = memcached_server_push(mst, msv);
if (mrt != MEMCACHED_SUCCESS) {
mrb_raisef(mrb, E_RUNTIME_ERROR, "libmemcached error: %S"
, mrb_str_new_cstr(mrb, memcached_strerror(mst, mrt)));
}
memcached_server_list_free(msv);
data = (mrb_memcached_data *)mrb_malloc(mrb, sizeof(mrb_memcached_data));
data->mst = mst;
DATA_PTR(self) = data;
return self;
}
/*!
* \brief Module shutdown function
*/
static void mod_destroy(void) {
if (servers != NULL)
memcached_server_list_free(servers);
/* Crash on shutdown with internal memory manager, even if we disable the mm callbacks */
if (mcd_memory != 1 && memcached_h != NULL)
memcached_free(memcached_h);
}
void world_destroy(void *p)
{
server_startup_st *construct= (server_startup_st *)p;
memcached_server_st *servers= (memcached_server_st *)construct->servers;
memcached_server_list_free(servers);
server_shutdown(construct);
free(construct);
}
int main(int argc, char *argv[])
{
memcached_st *memc;
memcached_return rc;
memcached_server_st *servers;
options_parse(argc, argv);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
while (optind < argc)
{
if (opt_verbose)
printf("key: %s\nexpires: %llu\n", argv[optind], (unsigned long long)opt_expire);
rc = memcached_delete(memc, argv[optind], strlen(argv[optind]), opt_expire);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memrm: %s: memcache error %s",
argv[optind], memcached_strerror(memc, rc));
if (memc->cached_errno)
fprintf(stderr, " system error %s", strerror(memc->cached_errno));
fprintf(stderr, "\n");
}
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
return 0;
}
static const char* append_server(cmd_parms* parms, void* _conf, const char* w1, const char* w2)
{
memcached_return r;
resize_conf* conf = (resize_conf*)_conf;
memcached_server_st* servers;
int port = atoi(w2);
if(port<=0 || port>65535) return "Bad port number.";
servers = memcached_server_list_append(NULL, w1, port, &r);
if(r!=MEMCACHED_SUCCESS) return "memcached_server_list_append() failed.";
r = memcached_server_push(conf->memc, servers);
if(r!=MEMCACHED_SUCCESS) {
memcached_server_list_free(servers);
return "memcached_server_push() failed.";
}
memcached_server_list_free(servers);
return NULL;
}
/*doc Memcached addServer(address)
Adds a memcached server. address is a "host:port" string, e.g., "127.0.0.1:11211"
Returns self.
*/
IoObject *IoMemcached_addServer(IoMemcached *self, IoObject *locals, IoMessage *m)
{
memcached_server_list_st server;
server = memcached_servers_parse(IoMessage_locals_cStringArgAt_(m, locals, 0));
memcached_server_push(DATA(self)->mc, server);
memcached_server_list_free(server);
return self;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
memcached_return_t rc;
memcached_server_st *servers;
options_parse(argc, argv);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
memc= memcached_create(NULL);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t) opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return 1;
}
rc = memcached_flush(memc, opt_expire);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memflush: memcache error %s",
memcached_strerror(memc, rc));
if (memc->cached_errno)
fprintf(stderr, " system error %s", strerror(memc->cached_errno));
fprintf(stderr, "\n");
}
memcached_free(memc);
free(opt_servers);
shutdown_sasl();
return 0;
}
bool libkv_libmemcached_add_list(libkv_t* x,
const char* server_strings)
{
kv_data* c = x->data;
memcached_server_st* list = memcached_servers_parse(server_strings);
if(list == NULL) {
return false;
}
c->err = memcached_server_push(c->st, list);
memcached_server_list_free(list);
return c->err == MEMCACHED_SUCCESS;
}
// return:
// 0:succ 1:fail
int get_to_mc(char *mc_ip, int mc_port, char *mc_key, char *mc_value, size_t mc_value_size)
{
size_t nval = 0;
uint32_t flag = 0;
char *result = NULL;
int ret = 0;
memcached_st *memc = memcached_create(NULL);
memcached_return mrc;
memcached_server_st *mc_servers;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, mc_timeout);
mc_servers= memcached_server_list_append(NULL, mc_ip, atoi(mc_port), &mrc);
log_debug("memcached_server_list_append[%d]:%s:%d", mrc, mc_ip, mc_port);
if (MEMCACHED_SUCCESS == mrc) {
mrc= memcached_server_push(memc, mc_servers);
memcached_server_list_free(mc_servers);
if (MEMCACHED_SUCCESS == mrc) {
result = memcached_get(memc, mc_key, strlen(mc_key), (size_t *)&nval, &flag, &mrc);
if (MEMCACHED_SUCCESS == mrc) {
log_debug("get mc key:%s val:%s succ", mc_key, result);
snprintf(mc_value, mc_value_size, "%s", result);
ret = 0;
} else {
log_error("get mc key:%s val:%s failed:%s", mc_key, mc_value, memcached_strerror(memc, mrc));
ret = 1;
}
if (result != NULL) {
free(result);
result = NULL;
}
memcached_free(memc);
return ret;
}
}
log_error("set_to_mc:%s:%d connect fail:%s", mc_ip, mc_port, memcached_strerror(memc, mrc));
memcached_free(memc);
return 1;
}
int main(int argc, char **argv)
{
struct memcached_st *memc;
struct memcached_server_st *servers;
memcached_return rc;
uint32_t flags;
size_t reslen;
char *server = argv[1];
char *key = argv[2];
char *filename = argv[3];
int fd;
char *res;
if (argc < 4) {
fprintf(stderr, "more args required\n");
return -1;
}
memc = memcached_create(NULL);
servers = memcached_servers_parse(server);
rc = memcached_server_push(memc, servers);
if (rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "memcached_server_push err:%d\n", rc);
goto out;
}
res = memcached_get(memc, key, strlen(key), &reslen, &flags, &rc);
if (rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "memcached_get err:%d\n", rc);
goto out;
}
fd = open(filename, O_RDWR|O_CREAT);
if (fd < 0) {
perror("open");
rc = fd;
goto out;
}
if ((rc = write(fd, res, reslen)) != reslen) {
printf("write:%d\n", rc);
goto out;
}
close(fd);
out:
free(res);
memcached_server_list_free(servers);
memcached_free(memc);
return rc;
}
CVDCMemcache::~CVDCMemcache()
{
if(m_memc != NULL)
{
memcached_free(m_memc);
m_memc = NULL;
}
if(NULL != m_servers)
{
memcached_server_list_free(m_servers);
m_servers = NULL;
}
}
Cache::Cache( const MC2String& hosts )
: m_pimpl( new Implementation ) {
m_pimpl->memc.reset( memcached_create( NULL ) );
if ( m_pimpl->memc.get() == NULL ) {
throw MemcachedException( "Couldn't create memcached_st structure" );
}
// Enable asynchronous IO mode
memcached_return rc =
memcached_behavior_set( m_pimpl->memc.get(),
MEMCACHED_BEHAVIOR_NO_BLOCK,
1 /* 1 = enable */ );
throwOnFail( rc, m_pimpl->memc.get(), "Couldn't set asynchronous IO mode" );
uint32 timeout = Properties::getUint32Property( "MEMCACHED_TIMEOUT",
1000 // default, ms
);
// Set poll timeout
rc = memcached_behavior_set( m_pimpl->memc.get(),
MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
timeout );
throwOnFail( rc, m_pimpl->memc.get(), "Couldn't set poll timeout" );
// Set connect timeout
rc = memcached_behavior_set( m_pimpl->memc.get(),
MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT,
timeout );
throwOnFail( rc, m_pimpl->memc.get(), "Couldn't set connect timeout" );
// work around the fact that memcached_servers_parse
// doesn't take a const char*
char* hostsDup = strdup( hosts.c_str() );
memcached_server_st* serverList = memcached_servers_parse( hostsDup );
free( hostsDup );
if ( serverList == NULL ) {
throw MemcachedException( "Couldn't parse server string" );
}
rc = memcached_server_push( m_pimpl->memc.get(),
serverList );
memcached_server_list_free( serverList );
throwOnFail( rc, m_pimpl->memc.get(), "Couldn't add servers" );
}
static int cmc_page_init_memc(web_page_t *wp) /* {{{ */
{
memcached_server_st *server;
wp->memc = memcached_create(NULL);
if (wp->memc == NULL) {
ERROR("memcachec plugin: memcached_create failed.");
return (-1);
}
server = memcached_servers_parse(wp->server);
memcached_server_push(wp->memc, server);
memcached_server_list_free(server);
return (0);
} /* }}} int cmc_page_init_memc */
void
cut_teardown(void)
{
if (val1) { free(val1); val1 = NULL; }
if (val2) { free(val2); val2 = NULL; }
if (servers) {
memcached_server_list_free(servers);
}
if (memc) {
memcached_free(memc);
}
if (server) {
g_object_unref(server);
}
}
static memcached_st *new_memcached(const char *host)
{
int port = 11211;
memcached_return rc;
memcached_st *memc = memcached_create(NULL);
memcached_server_st *servers = memcached_server_list_append(NULL, host, port, &rc);
if (rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "%s\n", memcached_strerror(memc, rc));
return 0;
}
rc = memcached_server_push(memc, servers);//servers ==> memc
if (rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "%s\n", memcached_strerror(memc, rc));
return 0;
}
memcached_server_list_free(servers);
return memc;
}
int main(int argc, char *argv[])
{
conclusions_st conclusion;
memcached_server_st *servers;
memset(&conclusion, 0, sizeof(conclusions_st));
srandom(time(NULL));
options_parse(argc, argv);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
servers= memcached_servers_parse(opt_servers);
pthread_mutex_init(&counter_mutex, NULL);
pthread_cond_init(&count_threshhold, NULL);
pthread_mutex_init(&sleeper_mutex, NULL);
pthread_cond_init(&sleep_threshhold, NULL);
scheduler(servers, &conclusion);
free(opt_servers);
(void)pthread_mutex_destroy(&counter_mutex);
(void)pthread_cond_destroy(&count_threshhold);
(void)pthread_mutex_destroy(&sleeper_mutex);
(void)pthread_cond_destroy(&sleep_threshhold);
conclusions_print(&conclusion);
memcached_server_list_free(servers);
return 0;
}
static void run(const int id, const char *server, const int value_length,
const int requests, const int command)
{
char key[20];
char *value;
struct memcached_st memc;
struct memcached_server_st *servers;
memcached_return ret;
int i;
value = xmalloc(value_length);
memset(value, '*', value_length);
memcached_create(&memc);
servers = memcached_servers_parse(server);
ret = memcached_server_push(&memc, servers);
if (ret != MEMCACHED_SUCCESS)
die("memcached_server_push: %d", ret);
if (tcp_nodelay) {
ret = memcached_behavior_set(&memc,
MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
if (ret != MEMCACHED_SUCCESS)
die("memcached_behavior_set: %d", ret);
}
for (i = 0; i < requests; i++) {
sprintf(key, "%04d-%011d", id, i);
if (command == 'w')
do_memcached_set(&memc, key, 16, value, value_length);
else
do_memcached_get(&memc, key, 16);
}
memcached_server_list_free(servers);
memcached_free(&memc);
free(value);
}
void init_memcached()
{
memcached_return rc;
memcached_server_st *server_pool;
memc = memcached_create(NULL);
assert(memc);
server_pool = memcached_servers_parse(settings.memcached_pool);
assert(server_pool);
rc = memcached_server_push(memc, server_pool);
assert(rc == MEMCACHED_SUCCESS);
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, settings.memcached_binary);
assert(rc == MEMCACHED_SUCCESS);
if (settings.verbose > 0)
fprintf(stderr, "connected to Memcached server pool: %s. Total hosts: %d. Binary setting: %d\n", settings.memcached_pool, memc->number_of_hosts, settings.memcached_binary);
memcached_server_list_free(server_pool);
}
rate_limiter::rate_limiter(const boost::program_options::variables_map &options)
{
if (options.count("memcache") &&
(ptr = memcached_create(NULL)) != NULL)
{
memcached_server_st *server_list;
memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
// memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
server_list = memcached_servers_parse(options["memcache"].as<std::string>().c_str());
memcached_server_push(ptr, server_list);
memcached_server_list_free(server_list);
}
else
{
ptr = NULL;
}
if (options.count("ratelimit"))
{
bytes_per_sec = options["ratelimit"].as<int>();
}
else
{
bytes_per_sec = 100 * 1024;
}
if (options.count("maxdebt"))
{
max_bytes = options["maxdebt"].as<int>() * 1024 * 1024;
}
else
{
max_bytes = 250 * 1024 * 1024;
}
}
memcached_st *
get_memcached(void *server_list)
{
memcached_st *mc = pthread_getspecific(thread_key);
if (!mc)
{
#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX > 0x00049000
if (strstr(server_list, "--SERVER")) {
mc = memcached(server_list, strlen(server_list));
} else {
#endif
memcached_server_st *servers = memcached_servers_parse(server_list);
mc = memcached_create(NULL);
memcached_server_push(mc, (memcached_server_st *)servers);
memcached_server_list_free(servers);
#if defined(LIBMEMCACHED_VERSION_HEX) && LIBMEMCACHED_VERSION_HEX > 0x00049000
}
#endif
pthread_setspecific(thread_key, mc);
}
return mc;
}