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