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;
}
QStore::~QStore()
{
if (need_url_seen_db) {
memcached_free(url_seen_memc);
}
if (need_html_db) {
memcached_free(html_memc);
}
if (need_record_db) {
if(!tcrdbclose(record_db)){
int ecode = tcrdbecode(record_db);
fprintf(stderr, "close record db error: %s\n", tcrdberrmsg(ecode));
}
tcrdbdel(record_db);
}
if (need_media_db) {
if(!tcrdbclose(media_db)){
int ecode = tcrdbecode(media_db);
fprintf(stderr, "close media db error: %s\n", tcrdberrmsg(ecode));
}
tcrdbdel(media_db);
}
}
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 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;
}
// 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;
}
ESPMemCached::~ESPMemCached()
{
if (pool)
{
memcached_pool_release(pool, connection);
connection = nullptr;//For safety (from changing this destructor) as not implicit in either the above or below.
memcached_st *memc = memcached_pool_destroy(pool);
if (memc)
memcached_free(memc);
}
else if (connection)//This should never be needed but just in case.
{
memcached_free(connection);
}
}
/**
@note This should be testing to see if the server really supports the binary protocol.
*/
static test_return_t pre_binary(memcached_st *memc)
{
memcached_return_t rc= MEMCACHED_FAILURE;
memcached_st *memc_clone;
memcached_server_instance_st instance;
memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
// The memcached_version needs to be done on a clone, because the server
// will not toggle protocol on an connection.
memcached_version(memc_clone);
instance= memcached_server_instance_by_position(memc_clone, 0);
if (instance->major_version >= 1 && instance->minor_version > 2)
{
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
test_true(rc == MEMCACHED_SUCCESS);
test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
}
memcached_free(memc_clone);
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
/*
* mmc_cleanup()
*/
void mmc_cleanup (void)
{
if (pmmc)
memcached_free(pmmc);
pmmc = NULL;
}
/** Create a new memcached handle
*
* @param ctx to allocate handle in.
* @param instance data.
*/
static void *mod_conn_create(TALLOC_CTX *ctx, void *instance)
{
rlm_cache_t *inst = instance;
rlm_cache_memcached_t *driver = inst->driver;
rlm_cache_memcached_handle_t *mandle;
memcached_st *sandle;
memcached_return_t ret;
sandle = memcached(driver->options, talloc_array_length(driver->options) -1);
if (!sandle) {
ERROR("rlm_cache_memcached: Failed creating memcached connection");
return NULL;
}
ret = memcached_version(sandle);
if (ret != MEMCACHED_SUCCESS) {
ERROR("rlm_cache_memcached: Failed getting server info: %s: %s", memcached_strerror(sandle, ret),
memcached_last_error_message(sandle));
memcached_free(sandle);
return NULL;
}
mandle = talloc_zero(ctx, rlm_cache_memcached_handle_t);
mandle->handle = sandle;
talloc_set_destructor(mandle, _mod_conn_free);
return mandle;
}
static int cdb_init(knot_db_t **db, struct kr_cdb_opts *opts, knot_mm_t *pool)
{
if (!db || !opts) {
return kr_error(EINVAL);
}
struct memcached_cli *cli = malloc(sizeof(*cli));
if (!cli) {
return kr_error(ENOMEM);
}
memset(cli, 0, sizeof(*cli));
/* Make sure we're running on binary protocol, as the
* textual protocol is broken for binary keys. */
auto_free char *config_str = kr_strcatdup(2, opts->path, " --BINARY-PROTOCOL");
cli->handle = memcached(config_str, strlen(config_str));
if (!cli->handle) {
free(cli);
return kr_error(EIO);
}
/* Create result set */
memcached_result_st *res = memcached_result_create(cli->handle, &cli->res);
if (!res) {
memcached_free(cli->handle);
free(cli);
return kr_error(ENOMEM);
}
*db = cli;
return 0;
}
int32_t CVDCMemcache::init_m_memc()
{
//如果m_memc对象不为空则先清空
if(NULL != m_memc)
{
memcached_free(m_memc);
m_memc = NULL;
}
//重新创建m_memc对象
m_memc = memcached_create(NULL);
//创建失败则返回错误
if(NULL == m_memc)
{
g_FrameLogEngine.WriteBaseLog( enmLogLevel_Error, "[%s:%d]Error: initialize m_memc failed! errorcode=0x%08X\n",
__FILE__, __LINE__, E_DBPROXY_MALLOC_MEMC);
// g_bMemcacheConnected = false;
return E_DBPROXY_MALLOC_MEMC;
}
g_FrameLogEngine.WriteBaseLog( enmLogLevel_Notice, "[%s:%d]initialize m_memc success!\n", __FILE__, __LINE__);
//设置为非阻塞
memcached_behavior_set(m_memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
return S_OK;
}
int main(void)
{
memcached_st *memc= memcached_create(NULL);
memcached_free(memc);
return EXIT_SUCCESS;
}
static void cdb_deinit(knot_db_t *db)
{
struct memcached_cli *cli = db;
memcached_result_free(&cli->res);
memcached_free(cli->handle);
free(cli);
}
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);
}
}
static int memcached_init (void)
{
memcached_t *st;
int status;
if (memcached_have_instances)
return (0);
/* No instances were configured, lets start a default instance. */
st = malloc (sizeof (*st));
if (st == NULL)
return (ENOMEM);
memset (st, 0, sizeof (*st));
st->name = sstrdup ("__legacy__");
st->socket = NULL;
st->host = NULL;
st->port = NULL;
st->use_global_hostn = NULL;
status = memcached_add_read_callback (st);
if (status == 0)
memcached_have_instances = 1;
else
memcached_free (st);
return (status);
} /* int memcached_init */
static void lmd_restart_ev(const void *event_data, void *user_data) {
if(memcached_deny_blacklist_mmc){
memcached_free(memcached_deny_blacklist_mmc);
memcached_deny_blacklist_mmc = NULL;
}
/* restartの前にmodule-unloadが呼ばれるのかな? */
pr_log_debug(DEBUG5, "%s at core.module-unload", MODULE_NAME);
}
void ProxyConnPool::Push(memcached_st * memc) {
IceUtil::Mutex::Lock lock(mutex_);
if (!reseting && memc_pool_.size() < kMaxPoolSize) {
memc_pool_.push_back(memc);
} else {
memcached_free(memc);
}
}
Memcached::~Memcached()
{
if (NULL != m_pMemc)
{
memcached_free(m_pMemc);
m_pMemc = NULL;
}
}
FriendOfFriendMemcache::~FriendOfFriendMemcache()
{
if (this->handle_ != NULL) {
memcached_free(this->handle_);
}
this->handle_ = NULL;
pthread_mutex_destroy(&this->memcache_lock_);
}
/*!
* \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);
}
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;
}
static test_return_t post_allocate(memcached_st *memc)
{
(void)memc;
for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
{
if (benchmark_state.create_init)
memcached_free(&benchmark_state.create[x]);
if (benchmark_state.clone_init)
memcached_free(&benchmark_state.clone[x]);
}
free(benchmark_state.create);
free(benchmark_state.clone);
return TEST_SUCCESS;
}
void memcached_free_connection(cachedb_pool_con *con)
{
memcached_con * c;
if (!con) return;
c = (memcached_con *)con;
memcached_free(c->memc);
}
void lmc_free_data(mcs_st *ptr) {
assert(ptr->kind == MCS_KIND_LIBMEMCACHED);
if (ptr->data != NULL) {
memcached_free((memcached_st *) ptr->data);
}
ptr->data = NULL;
}
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;
}
BeatBoard::SearchApiService::~SearchApiService()
{
delete client;
client = NULL;
delete parser;
parser = NULL;
delete logger;
logger = NULL;
memcached_free(memc);
}
void IoMemcached_free(IoMemcached *self)
{
if (DATA(self) != NULL) {
if (DATA(self)->mc != NULL) {
memcached_free(DATA(self)->mc);
}
free(DATA(self));
}
}
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;
}
/// Called to clean up the thread local data for a thread using the MemcachedStore class.
void MemcachedStore::cleanup_connection(void* p)
{
MemcachedStore::connection* conn = (MemcachedStore::connection*)p;
for (size_t ii = 0; ii < conn->st.size(); ++ii)
{
memcached_free(conn->st[ii]);
}
delete conn;
}
inline void
sstack_memcache_destroy(memcached_st *memc, log_ctx_t *ctx)
{
if (NULL == memc) {
sfs_log(ctx, SFS_ERR, "%s: memc is NULL \n", __FUNCTION__);
return;
}
memcached_free(memc);
sfs_log(ctx, SFS_INFO, "%s: Memcached database destroyed \n", __FUNCTION__);
}
