int split_mc_set(struct memcached_st *mc, char *key, size_t key_len, void *val,
size_t bytes, time_t expire, uint32_t flags)
{
char chunk_key[250];
int i, retval;
size_t chunk_bytes;
/* assert bytes > CHUNK_SIZE */
if (key_len > 200 || bytes > CHUNK_SIZE * 10) return -1;
for (i=0; bytes>0; i++) {
retval = snprintf(chunk_key, 250, "~%.*s/%d", key_len, key, i);
if (retval < 0 || retval >= 250) {
return -1;
}
chunk_bytes = bytes > CHUNK_SIZE ? CHUNK_SIZE : bytes;
retval = memcached_set(mc, chunk_key, retval, val, chunk_bytes,
expire, flags);
if (retval != 0 && retval != 31) {
return retval;
}
val += CHUNK_SIZE;
bytes -= chunk_bytes;
}
sprintf(chunk_key, "%d", i); /* re-use chunk_key as value buffer */
retval = memcached_set(mc, key, key_len, chunk_key, strlen(chunk_key)+1,
expire, flags|FLAG_CHUNKED);
return retval;
}
static int cdb_writev(knot_db_t *db, knot_db_val_t *key, knot_db_val_t *val, int maxcount)
{
if (!db || !key || !val) {
return kr_error(EINVAL);
}
struct memcached_cli *cli = db;
/* @warning This expects usage only for recursor cache, if anyone
* desires to port this somewhere else, TTL shouldn't be interpreted.
*/
memcached_return_t ret = 0;
for (int i = 0; i < maxcount; ++i) {
if (val->len < 2) {
/* @note Special values/namespaces, not a RR entry with TTL. */
ret = memcached_set(cli->handle, key[i].data, key[i].len, val[i].data, val[i].len, 0, 0);
} else {
struct kr_cache_entry *entry = val[i].data;
ret = memcached_set(cli->handle, key[i].data, key[i].len, val[i].data, val[i].len, entry->ttl, 0);
}
if (ret != 0) {
break;
}
}
return ret;
}
int main(int argc, char **argv)
{
if(argc < 2) {
fprintf(stderr, "usage: %s 'script.k'\n", argv[0]);
return 1;
}
memcached_st *mc = memcached_create(NULL);
memcached_server_list_st servers;
memcached_return_t rc;
servers = memcached_server_list_append(NULL, "127.0.0.1", 11211, &rc);
if(rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "memcached_server_list_append failed\n");
}
rc = memcached_server_Push(mc, servers);
memcached_server_list_Free(servers);
logpool_t *logpool = logpool_open_client(NULL, "0.0.0.0", 14801);
size_t script_len;
char *script = loadFile(argv[1], &script_len);
memcached_set(mc, "dump_Init", strlen("dump_Init"), script, script_len, 0, 0);
logpool_procedure(logpool, "dump", strlen("dump"));
struct Log *logbuf = alloca(sizeof(struct Log) + 256);
while(1) {
if(logpool_client_get(logpool, logbuf, 256) == NULL) {
break;
}
log_dump(stderr, "log=(", logbuf, ")\n", 1);
usleep(1);
}
logpool_close(logpool);
free(script);
return 0;
}
/*
Set the value, then quit to make sure it is flushed.
Come back in and test that add fails.
*/
static test_return_t add_test(memcached_st *memc)
{
memcached_return_t rc;
const char *key= "foo";
const char *value= "when we sanitize";
unsigned long long setting_value;
setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
memcached_quit(memc);
rc= memcached_add(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
/* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
if (setting_value)
{
test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
}
else
{
test_true(rc == MEMCACHED_NOTSTORED);
}
return 0;
}
//原型：memcached_return memcached_set(memcached_st* ptr, const char* ptr, size_t key_length, const char* value, size_t value_length, time_t expiration, uint32_t flags);
int32_t CVDCMemcache::MemcacheSet(memcached_st* memc, const char* szKey, const size_t keyLen, const char* szValue, const size_t valueLen, const time_t expiration)
{
DB_MUTEX_GUARD(cf_mutex, m_dbcrit);
memcached_return rc;
rc = memcached_set(memc, szKey, keyLen, szValue, valueLen, expiration, (uint32_t)0);
if(rc != MEMCACHED_SUCCESS)
{
//16号错误码：NOT FOUND 46号错误码：operation in process
if(16 == rc || 46==rc)
{
WRITE_WARNING_LOG( "warning: operation is in process! szKey=%s, keylen=%d, expiration=%d, errorcode=%d, errordesc=%s\n",
szKey,
(int32_t)keyLen,
(int32_t)expiration,
rc,
memcached_strerror(m_memc,rc));
return S_OK;
}
WRITE_ERROR_LOG( "Error: set memcache failed! szKey=%s, keyLen=%d, szValue=%s, valuelen=%d, expirtation=%d, errorcode=%d, errordesc=%s\n",
szKey,
(int32_t)keyLen,
szValue,
(int32_t)valueLen,
(int32_t)expiration,
rc,
memcached_strerror(memc, rc));
return E_MEMCACHED_SET;
}
//WRITE_DEBUG_LOG( "set memcached success! szKey=%s, keylen=%d\n", szKey, (int32_t)keyLen);
return S_OK;
}
/*doc Memcached set(key, value[, expiration])
Asks memcached to store the value identified by the key.
Returns true on success, otherwise raises an exception.
*/
IoObject *IoMemcached_set(IoMemcached *self, IoObject *locals, IoMessage *m)
{
IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0);
IoObject *value = IoMessage_locals_quickValueArgAt_(m, locals, 1);
time_t expiration = IoMessage_argCount(m) == 3 ? IoMessage_locals_intArgAt_(m, locals, 2) : 0;
uint32_t flags;
size_t size;
char *cvalue = IoMemcached_serialize(self, locals, value, &size, &flags);
memcached_return_t rc;
rc = memcached_set(DATA(self)->mc,
CSTRING(key), IOSEQ_LENGTH(key),
cvalue, size,
expiration, flags
);
free(cvalue);
if(rc != MEMCACHED_SUCCESS)
IoState_error_(IOSTATE, m, memcached_strerror(DATA(self)->mc, rc));
return IOSTATE->ioTrue;
}
void MemcachedCache::setValue(const QString& key, const CacheEntry& entry)
{
QWriteLocker lock(&m_lock);
// Binary key
const QByteArray rawKey(fullKey(key));
// Binary data
const quint64 dateTime(qToLittleEndian(static_cast<quint64>(entry.timeStamp().toTime_t())));
QByteArray rawData(reinterpret_cast<const char*>(&dateTime), sizeof(quint64));
rawData.append(entry.data());
// Store in memcached
memcached_return rt;
rt = memcached_set(
m_memcached,
rawKey.constData(),
rawKey.length(),
rawData.constData(),
rawData.length(),
0, // expire
0 // flags
);
if(rt != MEMCACHED_SUCCESS)
{
qFatal("Memcached error: %s", memcached_strerror(m_memcached, rt));
}
}
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;
}
/* Ready to send data to the server. */
debug_msg("carbon proxy:: %s is ready to receive",gmetad_config.carbon_server);
nbytes = write (carbon_socket, graphite_msg, strlen(graphite_msg) + 1);
if (nbytes < 0) {
err_msg("write: %s", strerror(errno));
close(carbon_socket);
return EXIT_FAILURE;
}
} else if ( carbon_struct_poll.revents & POLLHUP ) {
debug_msg("carbon proxy:: Recvd an RST from %s during transmission",gmetad_config.carbon_server);
close(carbon_socket);
return EXIT_FAILURE;
} else if ( carbon_struct_poll.revents & POLLERR ) {
debug_msg("carbon proxy:: Recvd an POLLERR from %s during transmission",gmetad_config.carbon_server);
close(carbon_socket);
return EXIT_FAILURE;
}
}
close (carbon_socket);
return EXIT_SUCCESS;
}
#ifdef WITH_MEMCACHED
#define MEMCACHED_MAX_KEY_LENGTH 250 /* Maximum allowed by memcached */
int
write_data_to_memcached ( const char *cluster, const char *host, const char *metric,
const char *sum, unsigned int process_time, unsigned int expiry )
{
time_t expiry_time;
char s_path[MEMCACHED_MAX_KEY_LENGTH];
if (strlen(cluster) + strlen(host) + strlen(metric) + 3 > MEMCACHED_MAX_KEY_LENGTH) {
debug_msg("Cluster + host + metric + 3 > %d", MEMCACHED_MAX_KEY_LENGTH);
return EXIT_FAILURE;
}
sprintf(s_path, "%s/%s/%s", cluster, host, metric);
if (expiry != 0) {
expiry_time = expiry;
} else {
expiry_time = (time_t) 0;
}
memcached_return_t rc;
memcached_st *memc = memcached_pool_pop(memcached_connection_pool, false, &rc);
if (rc != MEMCACHED_SUCCESS) {
debug_msg("Unable to retrieve a memcached connection from the pool");
return EXIT_FAILURE;
}
rc = memcached_set(memc, s_path, strlen(s_path), sum, strlen(sum), expiry_time, (uint32_t)0);
if (rc != MEMCACHED_SUCCESS) {
debug_msg("Unable to push %s value %s to the memcached server(s) - %s", s_path, sum, memcached_strerror(memc, rc));
memcached_pool_push(memcached_connection_pool, memc);
return EXIT_FAILURE;
} else {
debug_msg("Pushed %s value %s to the memcached server(s)", s_path, sum);
memcached_pool_push(memcached_connection_pool, memc);
return EXIT_SUCCESS;
}
}
bool
Server::cache_set(const string &key,const char *value,size_t valuelen)
{
if(m_memcached_conn.number_of_hosts == 0){
return false;
}
/*
vector<char> vv;
for(size_t i=0;i<valuelen;i++){
vv.push_back(value[i]);
}
*/
pthread_mutex_lock(&m_cache_lock);
string cachekey = cache_hash(key);
memcached_return_t rc= memcached_set(&m_memcached_conn,
cachekey.c_str(), cachekey.size(),
value, valuelen,
86400, 0);
pthread_mutex_unlock(&m_cache_lock);
if(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED){
TB_INFO("cache set ok: key="<<cachekey);
return true;
}else{
TB_ERROR("cache set failed: error="<<memcached_strerror(NULL, rc)<<",key="<<cachekey<<", valuelen="<<valuelen);
return false;
}
}
static bool HHVM_METHOD(Memcache, set, const String& key, const Variant& var,
int flag /*= 0*/, int expire /*= 0*/) {
if (key.empty()) {
raise_warning("Key cannot be empty");
return false;
}
auto data = Native::data<MemcacheData>(this_);
if (!hasAvailableServers(data)) {
return false;
}
String serializedKey = memcache_prepare_key(key);
std::vector<char> serializedVar =
memcache_prepare_for_storage(data, var, flag);
memcached_return_t ret = memcached_set(&data->m_memcache,
serializedKey.c_str(),
serializedKey.length(),
serializedVar.data(),
serializedVar.size(), expire, flag);
if (ret == MEMCACHED_SUCCESS) {
return true;
}
return false;
}
/**
* @brief set_cache_bin Set a new BINARY value of a key.
*
* @param thr_arg The arg of thread.
* @param key The key.
* @param value A char * buffer you want to set.
* @param len The length of the buffer above,
*
* @return 1 for success and -1 for fial.
*/
int set_cache_bin(thr_arg_t *thr_arg, const char *key, const char *value, const size_t len)
{
int rst = -1;
if(settings.cache_on == false)
return rst;
if(thr_arg->cache_conn == NULL)
return rst;
memcached_st *memc = thr_arg->cache_conn;
memcached_return rc;
rc = memcached_set(memc, key, strlen(key), value, len, 0, 0);
if (rc == MEMCACHED_SUCCESS)
{
LOG_PRINT(LOG_DEBUG, "Binary Cache Set Successfully. Key[%s] Len: %d.", key, len);
rst = 1;
}
else if(rc == MEMCACHED_CONNECTION_FAILURE)
{
LOG_PRINT(LOG_DEBUG, "Cache Conn Failed!");
//retry_cache(thr_arg);
}
else
{
LOG_PRINT(LOG_DEBUG, "Binary Cache Set Key[%s] Failed!", key);
const char *str_rc = memcached_strerror(memc, rc);
LOG_PRINT(LOG_DEBUG, "Cache Result: %s", str_rc);
rst = -1;
}
return rst;
}
/** Insert a new entry into the data store
*
* @param inst main rlm_cache instance.
* @param request The current request.
* @param handle Pointer to memcached handle.
* @param c entry to insert.
* @return CACHE_OK on success else CACHE_ERROR on error.
*/
static cache_status_t cache_entry_insert(UNUSED rlm_cache_t *inst, REQUEST *request, rlm_cache_handle_t **handle,
rlm_cache_entry_t *c)
{
rlm_cache_memcached_handle_t *mandle = *handle;
memcached_return_t ret;
TALLOC_CTX *pool;
char *to_store;
pool = talloc_pool(NULL, 1024);
if (!pool) return CACHE_ERROR;
if (cache_serialize(pool, &to_store, c) < 0) {
talloc_free(pool);
return CACHE_ERROR;
}
ret = memcached_set(mandle->handle, c->key, talloc_array_length(c->key) - 1,
to_store ? to_store : "",
to_store ? talloc_array_length(to_store) - 1 : 0, c->expires, 0);
talloc_free(pool);
if (ret != MEMCACHED_SUCCESS) {
RERROR("Failed storing entry with key \"%s\": %s: %s", c->key,
memcached_strerror(mandle->handle, ret),
memcached_last_error_message(mandle->handle));
return CACHE_ERROR;
}
return CACHE_OK;
}
static bool kv_put(kv_data* c,
const void* key, size_t keylen,
const void* val, size_t vallen)
{
return (c->err = memcached_set(c->st, key, keylen, val, vallen, 0, 0))
== MEMCACHED_SUCCESS;
}
/**
* @brief save_img_beansdb Set a new BINARY value of a key in beansdb.
*
* @param memc The connection to beansdb.
* @param key The key.
* @param value A char * buffer you want to set.
* @param len The length of the buffer above,
*
* @return 1 for success and -1 for fial.
*/
int save_img_beansdb(memcached_st *memc, const char *key, const char *value, const size_t len)
{
int rst = -1;
if(memc == NULL)
return rst;
memcached_return rc;
rc = memcached_set(memc, key, strlen(key), value, len, 0, 0);
if (rc == MEMCACHED_SUCCESS)
{
LOG_PRINT(LOG_DEBUG, "Binary Beansdb Set Successfully. Key[%s] Len: %d.", key, len);
rst = 1;
}
else
{
LOG_PRINT(LOG_DEBUG, "Binary beansdb Set Key: [%s] Failed!", key);
const char *str_rc = memcached_strerror(memc, rc);
LOG_PRINT(LOG_DEBUG, "Beansdb Result: %s", str_rc);
rst = -1;
}
return rst;
}
/**
* @brief set_beansdb Set a key with the value input.
*
* @param memc The connection to beansdb.
* @param key The key you want to set a new value.
* @param value The value of the key.
*
* @return 1 for success and -1 for fail.
*/
int set_beansdb(memcached_st *memc, const char *key, const char *value)
{
int rst = -1;
if(memc == NULL)
return rst;
memcached_return rc;
rc = memcached_set(memc, key, strlen(key), value, strlen(value), 0, 0);
if (rc == MEMCACHED_SUCCESS)
{
LOG_PRINT(LOG_DEBUG, "Beansdb Set Successfully. Key[%s] Value: %s", key, value);
rst = 1;
}
else
{
LOG_PRINT(LOG_DEBUG, "Beansdb Set(Key: %s Value: %s) Failed!", key, value);
const char *str_rc = memcached_strerror(memc, rc);
LOG_PRINT(LOG_DEBUG, "Beansdb Result: %s", str_rc);
rst = -1;
}
return rst;
}
void
test_memcached_flush_with_time(void)
{
const int sleep_time = 1;
uint32_t flags;
memcached_return rc;
grn_test_memcached_assert(
memcached_set(memc, "key", 3, "to be flushed", 13, 0, 0xdeadbeefU),
cut_message("memcached set failed."));
memcached_flush(memc, sleep_time);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
grn_test_memcached_assert(rc, cut_message("memcached get failed."));
cut_assert_equal_string("to be flushed", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
sleep(sleep_time + 1);
val2 = memcached_get(memc, "key", 3, &val2_len, &flags, &rc);
grn_test_memcached_assert_equal_rc(
MEMCACHED_NOTFOUND, rc,
cut_message("memcached get succeeded."));
}
int
sstack_memcache_store(memcached_st *memc,
const char *key,
const char *value,
size_t valuelen,
log_ctx_t *ctx)
{
memcached_return_t rc = -1;
if (NULL == key || NULL == value || valuelen <= 0 || NULL == memc) {
sfs_log(ctx, SFS_ERR, "%s: Invalid parameters specified \n",
__FUNCTION__);
return -1;
}
rc = memcached_set(memc, key, strlen(key), value, valuelen,
(time_t)0, (uint32_t) 0);
if (rc != MEMCACHED_SUCCESS) {
sfs_log(ctx, SFS_ERR, "%s: Storing key %s n memcahced db failed with"
" error %d\n", __FUNCTION__, key, rc);
return -rc;
} else {
sfs_log(ctx, SFS_INFO, "%s: stored key %s into memcached db \n",
__FUNCTION__, key);
return 0;
}
}
void setearValor(char operacion, const char *path, char* buffer) {
if (cache != 0) {
extern t_log *loguear;
extern memcached_st *memcached;
extern pthread_mutex_t bloquearCache;
char *key = malloc(sizeof(char) + strlen(path) + 1);
size_t tamkey = 0;
size_t tamBuff = 0;
memcached_return resultado;
key = armarKey(operacion, path);
tamkey = strlen(key);
tamBuff = strlen(buffer);
pthread_mutex_lock(&bloquearCache);
resultado = memcached_set(memcached, key, tamkey, buffer, tamBuff,
(time_t) 0, (uint32_t) 0);
log_debug(loguear,
"Solicitud de almacenamiento en cache para la key: %s", key);
if (resultado == MEMCACHED_SUCCESS)
printf("Se seteo %s en la Memcached\n", key);
free(key);
pthread_mutex_unlock(&bloquearCache);
}
}
static mrb_value mrb_memcached_set(mrb_state *mrb, mrb_value self)
{
mrb_value key, val;
mrb_int expr = 0;
mrb_memcached_data *data = DATA_PTR(self);
memcached_return mrt;
mrb_get_args(mrb, "oo|i", &key, &val, &expr);
switch (mrb_type(key)) {
case MRB_TT_STRING:
break;
case MRB_TT_SYMBOL:
key = mrb_obj_as_string(mrb, key);
break;
default:
mrb_raise(mrb, E_RUNTIME_ERROR, "memcached key type is string or symbol");
}
val = mrb_obj_as_string(mrb, val);
mrt = memcached_set(data->mst, RSTRING_PTR(key), RSTRING_LEN(key), RSTRING_PTR(val), RSTRING_LEN(val), (time_t)expr, (uint32_t)0);
if (mrt != MEMCACHED_SUCCESS && mrt != MEMCACHED_BUFFERED) {
// set failed
return mrb_nil_value();
}
return mrb_fixnum_value(mrt);
}
static int memcached_metatile_write(struct storage_backend * store, const char *xmlconfig, const char *options, int x, int y, int z, const char *buf, int sz) {
char meta_path[PATH_MAX];
char tmp[PATH_MAX];
struct stat_info tile_stat;
int sz2 = sz + sizeof(struct stat_info);
char * buf2 = malloc(sz2);
memcached_return_t rc;
if (buf2 == NULL) {
return -2;
}
tile_stat.expired = 0;
tile_stat.size = sz;
tile_stat.mtime = time(NULL);
tile_stat.atime = tile_stat.mtime;
tile_stat.ctime = tile_stat.mtime;
memcpy(buf2, &tile_stat, sizeof(tile_stat));
memcpy(buf2 + sizeof(tile_stat), buf, sz);
log_message(STORE_LOGLVL_DEBUG, "Trying to create and write a metatile to %s\n", memcached_tile_storage_id(store, xmlconfig, options, x, y, z, tmp));
snprintf(meta_path,PATH_MAX - 1, "%s/%d/%d/%d.meta", xmlconfig, x, y, z);
rc = memcached_set(store->storage_ctx, meta_path, strlen(meta_path), buf2, sz2, (time_t)0, (uint32_t)0);
free(buf2);
if (rc != MEMCACHED_SUCCESS) {
return -1;
}
memcached_flush_buffers(store->storage_ctx);
return sz;
}
int main(int argc, char* argv[])
{
if(argc < 4) { usage(); }
char* host = argv[1];
unsigned short port = atoi(argv[2]);
if(port == 0) { usage(); }
uint32_t num = atoi(argv[3]);
if(num == 0) { usage(); }
memcached_st* mc = memcached_create(NULL);
if(mc == NULL) { pexit("memcached_create"); }
memcached_server_add(mc, host, port);
// memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
char kbuf[strlen(KEY_PREFIX) + 11];
char vbuf[strlen(VAL_PREFIX) + 11];
while(1) {
uint32_t i;
for(i=0; i < num; ++i) {
int klen = sprintf(kbuf, KEY_PREFIX "%d", i);
int vlen = sprintf(vbuf, VAL_PREFIX "%d", i);
printf("set '%s' = '%s'\n", kbuf, vbuf);
memcached_set(mc, kbuf, klen, vbuf, vlen, 0, 0);
}
for(i=0; i < num; ++i) {
int klen = sprintf(kbuf, KEY_PREFIX "%d", i);
int vlen = sprintf(vbuf, VAL_PREFIX "%d", i);
size_t vallen;
uint32_t flags;
memcached_return rc;
char* val = memcached_get(mc, kbuf, klen, &vallen, &flags, &rc);
if(!val) {
fprintf(stderr, "** key '%s' not found **\n", kbuf);
} else if(vallen != vlen || memcmp(val, vbuf, vlen) != 0) {
fprintf(stderr, "** key '%s' not match ** '", kbuf);
fwrite(val, vallen, 1, stderr);
fprintf(stderr, "'\n");
} else {
printf("get '%s' = '", kbuf);
fwrite(val, vallen, 1, stdout);
printf("'\n");
}
}
for(i=0; i < num; ++i) {
int klen = sprintf(kbuf, KEY_PREFIX "%d", i);
printf("delete '%s'\n", kbuf);
memcached_delete(mc, kbuf, klen, 0);
}
}
return 0;
}
bool FriendOfFriendMemcache::Set(const char *key, const char *value, size_t value_len)
{
bool result = true;
pthread_mutex_lock(&this->memcache_lock_);
if (this->handle_ == NULL) {
MCE_FATAL("There isnot a connection!");
result = false;
goto _exit;
}
memcached_return_t ret;
ret = memcached_set(this->handle_, key, strlen(key), value, value_len, this->expiration_, 0);
if (ret == MEMCACHED_SUCCESS) {
result = true;
goto _exit;
} else {
MCE_FATAL("Unable to store the data with the key `" << key << "' of " << value_len << " bytes: "
<< memcached_strerror(this->handle_, ret));
result = false;
goto _exit;
}
_exit:
pthread_mutex_unlock(&this->memcache_lock_);
return result;
}
/**
* @brief set_cache Set a key with the value input.
*
* @param memc The connection to beansdb.
* @param key The key you want to set a new value.
* @param value The value of the key.
*
* @return 1 for success and -1 for fail.
*/
int set_cache(memcached_st *memc, const char *key, const char *value)
{
int rst = -1;
if(memc == NULL)
return rst;
memcached_return rc;
rc = memcached_set(memc, key, strlen(key), value, strlen(value), 0, 0);
if (rc == MEMCACHED_SUCCESS)
{
LOG_PRINT(LOG_DEBUG, "Cache Set Successfully. Key[%s] Value: %s", key, value);
rst = 1;
}
else if(rc == MEMCACHED_CONNECTION_FAILURE)
{
LOG_PRINT(LOG_DEBUG, "Cache Connection Failed!");
}
else
{
LOG_PRINT(LOG_DEBUG, "Cache Set(Key: %s Value: %s) Failed!", key, value);
const char *str_rc = memcached_strerror(memc, rc);
LOG_PRINT(LOG_DEBUG, "Cache Result: %s", str_rc);
rst = -1;
}
return rst;
}
/* wrapper of set command */
static int memc_put(memcached_st *memc, char *key, char *val) {
memcached_return_t rc;
rc = memcached_set(memc, key, key_len, val, val_len, (time_t) 0, (uint32_t) 0);
if (rc != MEMCACHED_SUCCESS) {
return 1;
}
return 0;
}
bool MemcClient::SetMemcached(const char * key, const string & value, int32_t flag) {
pair<int, memcached_st *> memc_pair = GetMemc();
memcached_st * memc = memc_pair.second;
memcached_return rc = memcached_set(memc, key, strlen(key), value.data(),
value.size(), (time_t)0, flag);
return ReturnMemc(rc == MEMCACHED_SUCCESS, memc_pair);
}
static void perform_ping_test(struct ping_test_recipe recipe,
memcached_st *mst,
struct moxi_stats *out, int *failures)
{
double *timing_results = calloc(recipe.iterations, sizeof(double));
assert(timing_results);
struct timeval timing = { 0, 0 };
char *key = calloc(recipe.keysize, sizeof(char));
assert(key);
char *value = calloc(recipe.valsize, sizeof(char));
assert(value);
/* Key is all 't's...just because */
memset(key, 't', recipe.keysize);
/* Value is a random bunch of stuff */
for (int i = 0; i < recipe.valsize; i++) {
value[i] = random() & 0xff;
}
if (memcached_set(mst,
key, recipe.keysize,
value, recipe.valsize,
0, 0) != MEMCACHED_SUCCESS) {
/* XXX: Failure */
}
for (int i = 0 ; i < recipe.iterations; i++) {
struct timeval tv_pre = { 0, 0 } , tv_post = { 0, 0 };
size_t retrieved_len = 0;
uint32_t flags = 0;
memcached_return error;
gettimeofday(&tv_pre, NULL);
char *retrieved = memcached_get(mst,
key, recipe.keysize,
&retrieved_len, &flags,
&error);
gettimeofday(&tv_post, NULL);
timeval_subtract(&timing, &tv_post, &tv_pre);
timing_results[i] = timeval_to_double(timing);
if (retrieved) {
free(retrieved);
} else {
(*failures)++;
}
}
compute_stats(out, timing_results, recipe.iterations);
free(timing_results);
free(key);
free(value);
}
static void do_memcached_set(memcached_st *memc, const char *key,
size_t key_length, const char *value, size_t value_length)
{
memcached_return ret;
ret = memcached_set(memc, key, key_length, value, value_length, 0, 0);
if (ret != MEMCACHED_SUCCESS)
warnx("memcached_set: %s", memcached_strerror(memc, ret));
}
void
vmod_set(struct sess *sp, struct vmod_priv *priv, const char *key, const char *value, int expiration, int flags)
{
memcached_return rc;
memcached_st *mc = get_memcached(priv->priv);
if (!mc) return;
rc = memcached_set(mc, key, strlen(key), value, strlen(value), expiration, flags);
}
static void memcached_setValue(memcached_st *memc, const char *key, const char *val)
{
memcached_return rc = memcached_set(memc, key, strlen(key), val, strlen(val), (time_t)0, (uint32_t)0);
if (rc != MEMCACHED_SUCCESS) {// && rc != MEMCACHED_STORED && rc != MEMCACHED_NOTSTORED) {
//fprintf(stderr, "%s\n", memcached_strerror(memc, rc));
return;
}
//fprintf(stderr, "[set] : [%s] : [%s]\n", key, val);
}
