memcached_st *php_memc_create_str (const char *str, size_t str_len)
{
#ifdef HAVE_LIBMEMCACHED_MEMCACHED
return memcached (str, str_len);
#else
memcached_return rc;
memcached_st *memc;
memcached_server_st *servers;
memc = memcached_create(NULL);
if (!memc) {
return NULL;
}
servers = memcached_servers_parse (str);
if (!servers) {
memcached_free (memc);
return NULL;
}
rc = memcached_server_push (memc, servers);
memcached_server_free (servers);
if (rc != MEMCACHED_SUCCESS) {
memcached_free (memc);
return NULL;
}
return memc;
#endif
}
int db_module_deinit() {
if(internal_memc != NULL)
memcached_free(internal_memc);
internal_memc = NULL;
if(internal_servers != NULL)
memcached_server_free(internal_servers);
internal_servers = NULL;
}
bool
Server::init()
{
if(m_server_type == SERVER_TYPE_USER){
m_com_contacts = new CompanyContactsKeeper(m_mongodb_addr,m_company_list_filename);
if(m_com_contacts->init()==false){
return false;
}
}
if(m_server_type == SERVER_TYPE_JOB){
m_com_score = new CompanyScoreKeeper(m_company_score_filename);
if(m_com_score->init()==false){
return false;
}
}
m_tag_scorer = new TagScorer(1.0);
memcached_create(&m_memcached_conn);
memcached_behavior_set(&m_memcached_conn,MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,1);
//memcached_behavior_set(&m_memcached_conn, MEMCACHED_BEHAVIOR_USE_UDP,1);
if(m_memcache_addr!=""){
memcached_server_st *servers;
servers= memcached_servers_parse(m_memcache_addr.c_str());
memcached_return_t rc = memcached_server_push(&m_memcached_conn, servers);
memcached_server_free(servers);
if(rc!=MEMCACHED_SUCCESS){
TB_ERROR("connect to memcached failed, error="<<memcached_strerror(NULL, rc));
return false;
}else{
TB_INFO("connected to memcached on "<<m_memcache_addr);
}
}
pthread_mutex_init(&m_cache_lock,0);
pthread_mutex_init(&m_db_lock,0);
pthread_cond_init(&m_db_cond,0);
for(size_t i=0;i<db_pool_size;i++){
m_dbs.push_back(new Xapian::Database(m_index_dir));
m_dbs_busy.push_back(false);
m_dbs_last_reload_ts.push_back(time(0));
}
TB_INFO("database doccount: "<<m_dbs[0]->get_doccount());
Session* new_session = create_session();
new_session->init();
acceptor_.async_accept(new_session->socket(),
boost::bind(&Server::handle_accept, this, new_session,
boost::asio::placeholders::error));
return true;
}
static inline void set_last_disconnected_host(memcached_server_write_instance_st self)
{
assert(self->root);
if (self->root == NULL)
{
return;
}
if (self->root->last_disconnected_server and self->root->last_disconnected_server->version == self->version)
{
return;
}
// const_cast
memcached_st *root= (memcached_st *)self->root;
memcached_server_free(root->last_disconnected_server);
root->last_disconnected_server= memcached_server_clone(NULL, self);
root->last_disconnected_server->version= self->version;
}
bool FriendOfFriendMemcache::SetServers(const char *servers_string)
{
bool result = true;
pthread_mutex_lock(&this->memcache_lock_);
if (this->handle_ == NULL) {
this->handle_ = memcached_create(NULL);
} else {
memcached_servers_reset(this->handle_);
}
memcached_return_t ret;
memcached_server_list_st servers = memcached_servers_parse(servers_string);
if (servers == NULL) {
MCE_FATAL("Invalid servers_string: `" << servers_string);
result = false;
goto _exit;
}
ret = memcached_server_push(this->handle_, servers);
memcached_server_free(servers);
if (ret != MEMCACHED_SUCCESS) {
MCE_FATAL("Unable to push servers info memcached handler: " << memcached_strerror(this->handle_, ret));
result = false;
goto _exit;
}
ret = memcached_behavior_set(this->handle_, MEMCACHED_BEHAVIOR_KETAMA, 1);
if (ret != MEMCACHED_SUCCESS) {
MCE_FATAL("Unable to switch to the consistent hashing: " << memcached_strerror(this->handle_, ret));
result = false;
goto _exit;
}
_exit:
pthread_mutex_unlock(&memcache_lock_);
return result;
}
/**
* 从字符串创建memcacheq的实例
* params:
* addr: eg. 127.0.0.1:22201
* return memcacheq instance
**/
static memcached_st * create_memcacheq_from_str(const char *addr)
{
if (addr == NULL)
return NULL;
memcached_return rc;
memcached_st* ret = memcached_create(NULL);
memcached_server_st *servers = NULL;
int port;
char *ip;
get_addr_from_str(addr, &ip, &port);
fprintf(stderr, "addr:port is %s-> %s:%d\n", addr, ip, port);
servers = memcached_server_list_append(NULL, ip, port, &rc);
free(ip);
if (rc != MEMCACHED_SUCCESS)
{
memcached_free(ret);
return NULL;
}
memcached_server_push(ret, servers);
memcached_server_free(servers);
return ret;
}
/*
** There is a little bit of a hack here, instead of removing
** the servers, I just set num host to 0 and them add then new udp servers
**/
static test_return_t init_udp(memcached_st *memc)
{
memcached_version(memc);
#if 0
memcached_server_instance_st instance=
memcached_server_instance_by_position(memc, 0);
/* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
if (instance->major_version != 1 || instance->minor_version != 2
|| instance->micro_version < 6)
return TEST_SKIPPED;
uint32_t num_hosts= memcached_server_count(memc);
memcached_server_st servers[num_hosts];
memcpy(servers, memcached_server_list(memc), sizeof(memcached_server_st) * num_hosts);
for (uint32_t x= 0; x < num_hosts; x++)
{
memcached_server_instance_st set_instance=
memcached_server_instance_by_position(memc, x);
memcached_server_free(((memcached_server_write_instance_st)set_instance));
}
memc->number_of_hosts= 0;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
for (uint32_t x= 0; x < num_hosts; x++)
{
memcached_server_instance_st set_instance=
memcached_server_instance_by_position(memc, x);
test_true(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
test_true(set_instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
}
#endif
return TEST_SKIPPED;
}
int main() {
//memcached_t 时client handle
//memcached_return_t 返回的消息类型
memcached_st *memcli = NULL;
//EE create a connect
memcli = memcached_create(NULL); //NULL 为你分配空间
if (memcli == NULL) {
perror("memcached_create failed");
exit(1);
}
memcached_return_t rtmsg ;
//EE connecting to server
//memcached_server_st server handle
//connect memcache server
//加入serverlist
//port
memcached_server_st * memser = memcached_server_list_append(NULL, "127.0.0.1", 11211, &rtmsg);
if (memser == NULL || rtmsg != MEMCACHED_SUCCESS) {
perror("memcached_server_list_append failed");
exit(1);
}
//connect client and server
rtmsg = memcached_server_push(memcli, memser);
if (rtmsg != MEMCACHED_SUCCESS) {
printf(" memcached_server_push faled: %s\n",
memcached_strerror(memcli, rtmsg));
exit(1);
}
//Add v-k to server
char *key = "foll";
char value[] ="hello";
//EE 所有的设置操作
//都是相同的 最后时时间和flags
//len 不包括'\0'结尾
rtmsg = memcached_set(memcli, //client
key, strlen(key), //key and keylen
value, strlen(value), //value, valuelen
(time_t)0, //Experimental time
0); //flags
//EE check rtmsg
if (rtmsg != MEMCACHED_SUCCESS) {
printf(" memcached_set faled: %s\n",
memcached_strerror(memcli, rtmsg));
exit(1);
}
char buf[1024];
//EE get v-k
size_t valuelen=0;
uint32_t flags=0;
char *v = memcached_get(memcli,
key, strlen(key),
&valuelen,
&flags,
&rtmsg);
memcpy(buf, v, valuelen);
buf[valuelen]='\0';
printf("vlen:%ld, flags:%u, value:%s\n", valuelen, flags, buf);
// memcached_return_t //
// memcached_mget (memcached_st *ptr,
// const char * const *keys,
// const size_t *key_length,
// size_t number_of_keys);
//EE free server
memcached_server_free(memser);
//EE free client
memcached_free(memcli);
return 0;
}
//destory memcache
int ssMemcached::destory() {
memcached_free(memc_);
memcached_server_free(servers_);
return 0;
}
