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; }