void Cache::flush() {
SysUtility::IgnorePipe ignorePipe;
memcached_return rc = memcached_flush( m_pimpl->memc.get(), 0 );
throwOnFail( rc, m_pimpl->memc.get(), "Couldn't flush" );
}
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."));
}
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 */
}
static int cdb_clear(knot_db_t *db)
{
struct memcached_cli *cli = db;
memcached_return_t ret = memcached_flush(cli->handle, 0);
if (ret != 0) {
return kr_error(EIO);
}
return 0;
}
/**
* @function memcached.flush
*
* ### Synopsis
*
* var rc = memcached.flush(handle);
* var rc = memcached.flush(handle, expiration);
*
* Wipe clean the contents of memcached servers. It will either do this immediately or expire the content based on the expiration time passed to the method (a value of zero causes an immediate flush). The operation is not atomic to multiple servers, just atomic to a single server. That is, it will flush the servers in the order that they were added.
*
* @param {object} handle - handle to memcached connection.
* @param {int} expiration - length of time value is valid (after this it will be removed from memcached automatically).
* @return {int} rc - result code; 0 if no error, otherwise the error code.
*/
JSVAL _memcached_flush (JSARGS args) {
HandleScope scope;
M *handle = HANDLE(args[0]);
time_t expiration = 0;
if (args.Length() > 1) {
expiration = args[1]->IntegerValue();
}
return scope.Close(Integer::New(memcached_flush(handle, expiration)));
}
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;
}
static int
exec_flush(memcached_st *mcd, time_t expire)
{
memcached_return_t error = memcached_flush(mcd, expire);
if (error == MEMCACHED_SUCCESS)
printf("flush: expire=%lu\n", expire);
else
printf("flush: expire=%lu error=%s\n",
expire, memcached_strerror(mcd, error));
return 0;
}
static mrb_value mrb_memcached_flush(mrb_state *mrb, mrb_value self)
{
memcached_return mrt;
mrb_memcached_data *data = DATA_PTR(self);
mrb_int expr = 0;
mrb_get_args(mrb, "|i", &expr);
mrt = memcached_flush(data->mst, expr);
if (mrt != MEMCACHED_SUCCESS) {
return mrb_nil_value();
}
return mrb_fixnum_value(mrt);
}
static test_return_t udp_flush_test(memcached_st *memc)
{
memcached_return_t rc;
uint16_t *expected_ids= get_udp_request_ids(memc);
for (size_t x= 0; x < memcached_server_count(memc); x++)
{
increment_request_id(&expected_ids[x]);
}
rc= memcached_flush(memc,0);
test_true(rc == MEMCACHED_SUCCESS);
return post_udp_op_check(memc,expected_ids);
}
int32_t CVDCMemcache::MemcacheFlush(memcached_st* memc, time_t expiration)
{
DB_MUTEX_GUARD(cf_mutex, m_dbcrit);
memcached_return rc;
rc = memcached_flush(memc, expiration);
if(rc != MEMCACHED_SUCCESS)
{
WRITE_WARNING_LOG( "wipe clean the contents of memcached servers failed! errorcode=%d, errordesc=%s\n", rc, memcached_strerror(memc, rc));
return E_MEMCACHE_FLUSH;
}
WRITE_DEBUG_LOG( "wipe clean the contents of memcached servers!\n");
return S_OK;
}
Memcache_Res CMemcache:: Memcac_Free()
{
Memcache_Res mRes = MEMCACHED_SUCCESS;
if(NULL == m_hMc)
return static_cast<Memcache_Res>(MEMCACHED_SERVER_ERROR);
// lock and free
pthread_mutex_lock(&m_hmc_mutex);
mRes = memcached_flush(m_hMc, 0);
m_hMc = NULL;
pthread_mutex_unlock(&m_hmc_mutex);
return mRes;
}
void
test_memcached_flush(void)
{
uint32_t flags;
memcached_return rc;
rc = memcached_set(memc, "key", 3, "to be flushed", 13, 0, 0xdeadbeefU);
cut_set_message("memcached set failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
memcached_flush(memc, 0);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
cut_set_message("memcached get succeeded.");
cut_assert_equal_int(MEMCACHED_NOTFOUND, rc);
}
VALUE mc_flush_all(int argc, VALUE *argv, VALUE self) {
memcached_st *mc;
VALUE delay;
static memcached_return_t result;
Data_Get_Struct(self, memcached_st, mc);
rb_scan_args(argc, argv, "01", &delay);
result = memcached_flush(mc, RTEST(delay) ? NUM2UINT(delay) : 0);
if (result == MEMCACHED_SUCCESS) {
return Qnil;
} else {
return throw_error(&result);
}
}
/// Wipe the contents of all the memcached servers immediately, if we can
/// get a connection. If not, does nothing.
void MemcachedStore::flush_all()
{
memcached_return_t rc;
// Try to get a connection
struct timespec wait_time;
wait_time.tv_sec = 0;
wait_time.tv_nsec = 100 * 1000 * 1000;
memcached_st* st = memcached_pool_fetch(_pool, &wait_time, &rc);
if (st != NULL)
{
// Got one: use it to wipe out the contents of the servers immediately.
rc = memcached_flush(st, 0);
memcached_pool_release(_pool, st);
}
}
void
cut_setup(void)
{
GError *error = NULL;
memc = NULL;
servers = NULL;
server = grn_test_server_new();
grn_test_server_start(server, &error);
gcut_assert_error(error);
memc = memcached_create(NULL);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
servers =
memcached_servers_parse(grn_test_server_get_memcached_address(server));
grn_test_memcached_assert(memcached_server_push(memc, servers),
cut_message("memcached server connect failed."));
memcached_flush(memc, 0); /* flush immediately for debug daemon */
}
bool c_Memcache::t_flush(int expire /*= 0*/) {
return memcached_flush(&m_memcache, expire) == MEMCACHED_SUCCESS;
}
int main()
{
memcached_st *local_memc;
memcached_return rc;
local_memc = memcached_create(NULL);
unsigned int set= 1;
//memcached_behavior_set(local_memc, MEMCACHED_DISTRIBUTION_CONSISTENT, set);
memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, set);
//memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_KETAMA, set);
//memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, set);
rc = memcached_server_add(local_memc, "127.0.0.1", 11211);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11212);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11213);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11214);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
rc = memcached_server_add(local_memc, "127.0.0.1", 11215);
if(rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcached_server_add error.");
}
uint32_t num = memcached_server_count(local_memc);
printf("num:%d\n", num);
rc= memcached_flush(local_memc, 0);
if (!(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED))
{
fprintf(stderr, "memcached_flush:%d rc:%d\n", MEMCACHED_SUCCESS, rc);
char const *retVal = memcached_strerror(NULL, rc);
fprintf(stderr, "error memcached_flush:%s rc:%d\n", retVal, rc);
goto ERROR;
}
int i = 0;
//for(i = 0; i < 1; i++)
for(i = 0; i < 100000; i++)
{
char key[64];
char value[64];
snprintf(key, sizeof(key), "tkey_%05d", i);
snprintf(value, sizeof(value), "tvalue_%05d", i);
rc= memcached_set(local_memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0);
if (!(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED))
{
char const *retVal = memcached_strerror(NULL, rc);
fprintf(stderr, "error memcached_set .%s\n", retVal);
goto ERROR;
}
}
memcached_free(local_memc);
printf("success \n");
return 0;
ERROR:
printf("error \n");
return 1;
}
static int
exec_simple_bench(memcached_st *mcd, double scale)
{
char kbuf[256];
char vbuf[1024 * 1024];
int klen, vlen;
int i, n, count;
int num_gets = 0;
int num_adds = 0;
long total = 0;
long interval;
struct timeval tv1, tv2;
if (scale < 100.0)
scale = 100.0;
n = (int)(scale * 64);
count = (int)(scale * 512);
srand(count);
gettimeofday(&tv1, NULL);
memcached_flush(mcd, 0);
while (count-- > 0)
{
memcached_return_t error;
uint32_t flags;
char *value;
size_t value_length;
i = rand() % n;
klen = sprintf(kbuf, "mcdbench_key%06u", i);
value = memcached_get(mcd, kbuf, klen, &value_length, &flags, &error);
if (value == NULL)
{
if (error != MEMCACHED_NOTFOUND)
{
printf("key=%s error=%s\n", kbuf, memcached_strerror(mcd, error));
continue;
}
make_pseudo_value(i, vbuf, &vlen);
error = memcached_add(mcd, kbuf, klen, vbuf, vlen, 0, 0);
if (error != MEMCACHED_SUCCESS)
{
printf("key=%s error=%s\n", kbuf, memcached_strerror(mcd, error));
continue;
}
num_adds++;
total += vlen;
}
else
{
num_gets++;
total += value_length;
free(value);
}
}
gettimeofday(&tv2, NULL);
interval = (tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
printf("time: %.2f adds: %u gets: %u transfer: %lubytes\n",
((double)interval) / 1000000.0,
num_adds, num_gets, total);
return 0;
}
/**
* Wipe the contents of memcached servers.
*
* @param[in] expiration time to wait until wiping contents of
* memcached servers
* @return true on success; false otherwise
*/
bool flush(time_t expiration)
{
memcached_return rc= memcached_flush(&memc, expiration);
return (rc == MEMCACHED_SUCCESS);
}
void flush_all(memcached_st *memc)
{
memcached_flush(memc, 0);
}
/*doc Memcached flushAll([expiration])
Asks memcached to invalidate all existing items immediately (by default)
or after the expiration specified.
Always returns true.
*/
IoObject *IoMemcached_flushAll(IoMemcached *self, IoObject *locals, IoMessage *m)
{
time_t expiration = IoMessage_argCount(m) == 1 ? IoMessage_locals_intArgAt_(m, locals, 0) : 0;
memcached_flush(DATA(self)->mc, expiration); // always returns ok
return self;
}
void ESPMemCached::flush(unsigned when)
{
//NOTE: memcached_flush is the actual cache flush/clear/delete and not an io buffer flush.
assertOnError(memcached_flush(connection, (time_t)(when)), "'Clear' request failed - ");
}
