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); }
memcached_st * sstack_memcache_init(const char *config, int num_servers, log_ctx_t *ctx) { memcached_server_st *servers = NULL; memcached_st *memc = NULL; memcached_return_t rc; memc = memcached_create(NULL); if (NULL == memc) { sfs_log(ctx, SFS_ERR, "%s: Unable to create memcached connection\n", __FUNCTION__); return NULL; } if (num_servers > 1) { char *buf = strdup(config); char **ptr = (char **) &buf; char *server_name = NULL; while((server_name = strsep(ptr, SEPERATOR)) != NULL) { if (strlen(server_name) == 0) continue; servers = memcached_server_list_append(servers, server_name, MEMCACHED_PORT, &rc); rc = memcached_server_push(memc, servers); if (rc != MEMCACHED_SUCCESS) { sfs_log(ctx, SFS_ERR, "%s: memcached_server_push failed\n", __FUNCTION__); return NULL; } } free(buf); } else { servers = memcached_server_list_append(servers, config, MEMCACHED_PORT, &rc); rc = memcached_server_push(memc, servers); if (rc != MEMCACHED_SUCCESS) { sfs_log(ctx, SFS_ERR, "%s: memcached_server_push failed\n", __FUNCTION__); return NULL; } } sfs_log(ctx, SFS_INFO, "%s: memcached init succeeded\n", __FUNCTION__); return memc; }
int main(int argc, char **argv) { memcached_server_st *servers = NULL; memcached_st *memc; memcached_return rc; char *key, *value; size_t value_length; memc = memcached_create(NULL); servers = memcached_server_list_append(servers, "localhost", 11211, &rc); rc = memcached_server_push(memc, servers); if (rc != MEMCACHED_SUCCESS) { fprintf(stderr, "memcache: error: couldn't add server: %s\n.", memcached_strerror(memc, rc)); memcached_free(memc); return 1; } if (argc == 3) // Insert (key, value) pair { key = argv[1]; value = argv[2]; rc = memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); if (rc != MEMCACHED_SUCCESS) { fprintf(stderr, "memcache: error: couldn't store key: %s\n.", memcached_strerror(memc, rc)); memcached_free(memc); return 2; } } else if (argc == 2) // Get value given key { key = argv[1]; value = memcached_get(memc, key, strlen(key), &value_length, (uint32_t)0, &rc); if (rc != MEMCACHED_SUCCESS) { fprintf(stderr, "memcache: error: couldn't get key: %s.\n", memcached_strerror(memc, rc)); memcached_free(memc); return 3; } printf("%s\n", value); } else { fprintf(stderr, "usage: memcache <key> [<value>]\n"); } memcached_free(memc); return 0; }
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; }
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; }
void cut_setup(void) { GError *error = NULL; memcached_return rc; tmp_directory = g_build_filename(grn_test_get_base_dir(), "tmp", NULL); cut_remove_path(tmp_directory, NULL); if (g_mkdir_with_parents(tmp_directory, 0700) == -1) { cut_assert_errno(); } egg = gcut_egg_new(GROONGA, "-s", "-p", GROONGA_TEST_PORT, cut_take_printf("%s%s%s", tmp_directory, G_DIR_SEPARATOR_S, "memcached.db"), NULL); gcut_egg_hatch(egg, &error); gcut_assert_error(error); sleep(1); /* wait for groonga daemon */ memc = memcached_create(NULL); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); servers = memcached_servers_parse("localhost:" GROONGA_TEST_PORT); rc = memcached_server_push(memc, servers); cut_set_message("memcached server connect failed."); cut_assert_equal_int(MEMCACHED_SUCCESS, rc); memcached_flush(memc, 0); /* flush immediately for debug daemon */ }
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 }
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; }
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; }
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; }
/* 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) */ }
static memcached_st *s_init_mod_data (const memcached_server_list_st servers, zend_bool is_persistent) { void *buffer; php_memcached_user_data *user_data; memcached_st *memc; buffer = pecalloc(1, sizeof(memcached_st), is_persistent); memc = memcached_create (buffer); if (!memc) { php_error_docref(NULL, E_ERROR, "failed to allocate memcached structure"); /* not reached */ } memcached_set_memory_allocators(memc, s_pemalloc_fn, s_pefree_fn, s_perealloc_fn, s_pecalloc_fn, NULL); user_data = pecalloc(1, sizeof(php_memcached_user_data), is_persistent); user_data->is_persistent = is_persistent; user_data->has_sasl_data = 0; user_data->lock_key = NULL; user_data->is_locked = 0; memcached_set_user_data(memc, user_data); memcached_server_push (memc, servers); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1); return memc; }
/* create a memcached structure */ static memcached_st *memc_new() { char config_string[1024]; memcached_st *memc = NULL; memcached_server_st *servers = NULL; unsigned long long getter; memcached_return_t rc; pthread_mutex_lock (&printmutex); sprintf(config_string, "--SERVER=%s --BINARY-PROTOCOL", serverip); printf("config_string = %s\n", config_string); //memc = memcached(config_string, strlen(config_string)); memc = memcached_create(NULL); servers = memcached_server_list_append(servers, serverip, 11211, &rc); rc = memcached_server_push(memc, servers); if (rc == MEMCACHED_SUCCESS) fprintf(stderr, "Added server successfully\n"); else fprintf(stderr, "Couldnt add server: %s\n", serverip); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); printf("No block: %lld\n", getter); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE); printf("Socket send size: %lld\n", getter); getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE); printf("Socket recv size: %lld\n", getter); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); pthread_mutex_unlock (&printmutex); return memc; }
MODRET add_lmd_memcached_host(cmd_rec *cmd) { int i; memcached_return rc; memcached_server_st *server = NULL; if(cmd->argc < 2 ) CONF_ERROR(cmd, "argument missing"); CHECK_CONF(cmd, CONF_ROOT|CONF_GLOBAL); /* NOTICE: i = 1 */ for(i=1; i < cmd->argc; i++) { const char *arg = cmd->argv[i]; server = memcached_servers_parse(arg); rc = memcached_server_push(memcached_deny_blacklist_mmc, server); if(rc != MEMCACHED_SUCCESS){ pr_log_auth(PR_LOG_ERR, "Fatal %s: failed memcached_strerror(): %s", MODULE_NAME, memcached_strerror(memcached_deny_blacklist_mmc, rc)); exit(1); } pr_log_debug(DEBUG2, "%s: add memcached server %s", MODULE_NAME, arg); } is_set_server = true; return PR_HANDLED(cmd); }
static VALUE mc_initialize(VALUE self, VALUE opts) { memcached_st *mc; VALUE servers_aryv, prefixv, hashv, distributionv; Data_Get_Struct(self, memcached_st, mc); hashv = rb_hash_aref(opts, sym_hash); distributionv = rb_hash_aref(opts, sym_distribution); prefixv = rb_hash_aref(opts, sym_prefix); servers_aryv = rb_hash_aref(opts, sym_servers); if (!NIL_P(hashv)) { memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_HASH, hash_behavior(hashv)); memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_KETAMA_HASH, hash_behavior(hashv)); } if (!NIL_P(distributionv)) memcached_behavior_set_distribution(mc, distribution_behavior(distributionv)); if (RTEST( rb_hash_aref(opts, sym_ketama) )) memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_KETAMA, true); if (RTEST( rb_hash_aref(opts, sym_ketama_weighted) )) memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true); if (RTEST( rb_hash_aref(opts, sym_hash_with_prefix) )) memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY, true); if (RTEST( rb_hash_aref(opts, sym_binary) )) memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true); if (!NIL_P(prefixv)) memcached_callback_set(mc, MEMCACHED_CALLBACK_PREFIX_KEY, StringValuePtr(prefixv)); if (!NIL_P(servers_aryv)) { char* server; int i; for (i = 0; i < RARRAY_LEN(servers_aryv); i++) { server = StringValuePtr(RARRAY_PTR(servers_aryv)[i]); memcached_server_push(mc, memcached_servers_parse(server)); } } else { VALUE hostv, portv, weightv; char* host; int port, weight; hostv = rb_hash_aref(opts, sym_host); portv = rb_hash_aref(opts, sym_port); weightv = rb_hash_aref(opts, sym_weight); host = StringValuePtr(hostv); port = NIL_P(portv) ? MEMCACHED_DEFAULT_PORT : NUM2INT(portv); weight = NIL_P(weightv) ? 0 : NUM2INT(weightv); memcached_server_add_with_weight(mc, StringValuePtr(hostv), port, weight); } return self; }
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; }
bool ProxyConnPool::Reset() { MCE_WARN("ProxyConnPool Reset(). index=" << proxy_index_); { IceUtil::Mutex::Lock lock(mutex_); if (reseting) { return true; } reseting = true; while (!memc_pool_.empty()) { memcached_free(memc_pool_.back()); memc_pool_.pop_back(); } } string endpoint; try { endpoint = MemcProxyAdapter::instance().GetEndpoint(proxy_index_); } catch(Ice::Exception& e) { MCE_WARN("MemcProxyAdapter::GetEndpoint Ice error : " << e); } catch (...) { MCE_WARN("MemcProxyAdapter::GetEndpoint error."); } size_t pos = endpoint.find(':'); if (pos != string::npos) { proxy_addr_ = endpoint.substr(0, pos); proxy_port_ = boost::lexical_cast<unsigned short>(endpoint.c_str() + pos + 1); } MCE_INFO("MemcProxy " << proxy_index_ << " endpoint : " << endpoint); if (proxy_addr_.empty() || proxy_port_ <= 0) { reseting = false; return false; } memcached_return rc; memcached_server_st * servers = NULL; servers = memcached_server_list_append(servers, proxy_addr_.c_str(), proxy_port_, &rc); memcached_st * memc = memcached_create(NULL); rc = memcached_server_push(memc, servers); // 向服务集群添加server list if (rc != MEMCACHED_SUCCESS) { reseting = false; return false; } { IceUtil::Mutex::Lock lock(mutex_); memc_pool_.push_back(memc); reseting = false; } error_count_ = 0; return true; }
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; }
int memcached_connect_to_server(char *hostname, int port) { memc = memcached_create(NULL); servers = memcached_server_list_append(NULL, hostname, port, NULL); memcached_return rc; rc = memcached_server_push(memc, servers); memcached_connected = 0; if (rc == MEMCACHED_SUCCESS) return 0; return -1; }
/*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; }
FRAME_DBPROXY_NAMESPACE_BEGIN CVDCMemcache::CVDCMemcache() { m_memc = memcached_create(NULL); m_servers = memcached_servers_parse(GET_MEMCACHECONFIG_INSTANCE().GetMemcacheIPAndPort()); memcached_server_push(m_memc, m_servers); //设置为非阻塞 memcached_behavior_set(m_memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1); }
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; }
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; }
int db_module_init() { memcached_return rc; //memcached_server_st *memcached_servers_parse (char *server_strings); internal_memc= memcached_create(NULL); syslog(LOG_INFO, "creating memcached server\n"); internal_servers= memcached_server_list_append(internal_servers, "localhost"/* server name */, 11211/* port */, &rc); rc= memcached_server_push(internal_memc, internal_servers); if (rc == MEMCACHED_SUCCESS) syslog(LOG_INFO, "Added server successfully\n"); else syslog(LOG_ERR, "Couldn't add server: %s\n",memcached_strerror(internal_memc, rc)); return 0; }
/** * @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)); }
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; }
// 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; }
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" ); }
int iSetupAndTestMemcached(void) { memcached_server_st *servers = NULL; memcached_return rc; char *key= "unxsLoadFromSPS"; char *value= "svn ID removed //memcached_server_st *memcached_servers_parse(const char *server_strings); gsMemc=memcached_create(NULL); servers=memcached_server_list_append(servers,"localhost",11211,&rc); rc=memcached_server_push(gsMemc, servers); if(rc!=MEMCACHED_SUCCESS) { sprintf(gcQuery,"couldn't add server: %s",memcached_strerror(gsMemc, rc)); logfileLine("iSetupAndTestMemcached",gcQuery); return(-1); } rc=memcached_set(gsMemc,key,strlen(key),value,strlen(value),(time_t)0,(uint32_t)0); if(rc!=MEMCACHED_SUCCESS) { sprintf(gcQuery,"couldn't store test key: %s",memcached_strerror(gsMemc, rc)); logfileLine("iSetupAndTestMemcached",gcQuery); return(-1); } char cValue[100]={""}; size_t size=100; uint32_t flags=0; sprintf(cValue,"%.99s",memcached_get(gsMemc,key,strlen(key),&size,&flags,&rc)); if(rc!=MEMCACHED_SUCCESS) { sprintf(gcQuery,"couldn't retrieve test key: %s",memcached_strerror(gsMemc, rc)); logfileLine("iSetupAndTestMemcached",gcQuery); return(-1); } if(strncmp(cValue,value,size)) { sprintf(gcQuery,"keys differ: (%s) (%s)",cValue,value); logfileLine("iSetupAndTestMemcached",gcQuery); return(-1); } logfileLine("iSetupAndTestMemcached","memcached running"); return(0); }//int iSetupAndTestMemcached(void)