int borrarDir(const char *path) {
int exit = 0;
char key[255] = "LC";
char* fatherPath = getFatherPath(path);
strcat(key, fatherPath);
memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools);
memcached_delete(memcached, (const char*) key, strlen(key), (time_t) 0);
char mensajeCacheActualizarEntradaDir[255];
sprintf(mensajeCacheActualizarEntradaDir,
"Operacion: Actualizar Cache - path:%s", path);
log_debug(teLogueo, mensajeCacheActualizarEntradaDir);
char key2[255] = "AC";
strcat(key2, path);
memcached_delete(memcached, (const char*) key2, strlen(key2), (time_t) 0);
char mensajeCacheActualizarAtributos[255];
sprintf(mensajeCacheActualizarAtributos,
"Operacion: Actualizar Cache - path:%s", path);
log_debug(teLogueo, mensajeCacheActualizarAtributos);
//memcached_finishHer(memcached, &servers);
connectionPool_depositeAvaibleMemcached(pools, memcached);
t_stream *stream = serializar_pedido_nombre(BORRAR_DIR, path);
int descriptor = connectionPool_extractAvaibleSocket(pools);
enviar_paquete(descriptor, stream->data, stream->length);
char mensaje[255];
sprintf(mensaje, "Operacion: Borrar Directorio - path:%s", path);
log_debug(teLogueo, mensaje);
char *mensaje_recibido = recibir_paquete(descriptor, 3);
t_header *header = deserializadorHeader(mensaje_recibido);
if (header->type == NO_EXISTE) {
connectionPool_depositeAvaibleSocket(pools, descriptor);
perror("No existe el directorio");
return -ENOENT;
}
if (header->type == NAME_TOO_LONG) {
connectionPool_depositeAvaibleSocket(pools, descriptor);
perror("El nombre es demasiado largo");
return -ENAMETOOLONG;
}
if (header->type == NO_ESTA_VACIO) {
connectionPool_depositeAvaibleSocket(pools, descriptor);
perror("El dir no esta vacio");
return -ENOTEMPTY;
}
free(header);
free(mensaje_recibido);
free(stream);
connectionPool_depositeAvaibleSocket(pools, descriptor);
return exit;
}
/**
* @brief del_beansdb This function delete a key and its value in beansdb.
*
* @param memc The connection to beansdb.
* @param key The key.
*
* @return 1 for success and -1 for fail.
*/
int del_beansdb(memcached_st *memc, const char *key)
{
int rst = -1;
if(memc == NULL)
return rst;
memcached_return rc;
rc = memcached_delete(memc, key, strlen(key), 0);
if (rc == MEMCACHED_SUCCESS)
{
LOG_PRINT(LOG_DEBUG, "Beansdb Key[%s] Delete Successfully.", key);
rst = 1;
}
else
{
LOG_PRINT(LOG_DEBUG, "Beansdb Key[%s] Delete Failed!", key);
const char *str_rc = memcached_strerror(memc, rc);
LOG_PRINT(LOG_DEBUG, "Beansdb Result: %s", str_rc);
rst = -1;
}
return rst;
}
bool FriendOfFriendMemcache::Erase(const char *key)
{
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_delete(this->handle_, key, strlen(key), 0);
if (ret == MEMCACHED_SUCCESS) {
result = true;
goto _exit;
} else {
if (ret != MEMCACHED_NOTFOUND) {
MCE_FATAL("Unable to delete the key `" << key
<< "': " << memcached_strerror(this->handle_, ret));
}
result = false;
goto _exit;
}
_exit:
pthread_mutex_unlock(&this->memcache_lock_);
return result;
}
static test_return_t udp_delete_test(memcached_st *memc)
{
unsigned int num_iters= 1025; //request id rolls over at 1024
for (size_t x= 0; x < num_iters; x++)
{
memcached_return_t rc;
const char *key= "foo";
uint16_t *expected_ids=get_udp_request_ids(memc);
unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
memcached_server_instance_st instance=
memcached_server_instance_by_position(memc, server_key);
size_t init_offset= instance->write_buffer_offset;
rc= memcached_delete(memc, key, strlen(key), 0);
test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
if (rc == MEMCACHED_SUCCESS || instance->write_buffer_offset < init_offset)
increment_request_id(&expected_ids[server_key]);
if (rc == MEMCACHED_SUCCESS)
{
test_true(instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
}
else
{
test_true(instance->write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
test_true(instance->write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
}
test_true(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
}
return TEST_SUCCESS;
}
virtual void remove(const char *key, size_t key_size) {
memcached_return_t _error = memcached_delete(&memcached, key, key_size, 0);
if(_error != MEMCACHED_SUCCESS) {
fprintf(stderr, "Error performing delete operation (%d)\n", _error);
exit(-1);
}
}
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;
}
void BaseMemcachedStore::delete_without_tombstone(const std::string& fqkey,
const std::vector<memcached_st*>& replicas,
SAS::TrailId trail)
{
if (trail != 0)
{
SAS::Event event(trail, SASEvent::MEMCACHED_DELETE, 0);
event.add_var_param(fqkey);
SAS::report_event(event);
}
const char* key_ptr = fqkey.data();
const size_t key_len = fqkey.length();
for (size_t ii = 0; ii < replicas.size(); ++ii)
{
TRC_DEBUG("Attempt delete to replica %d (connection %p)",
ii,
replicas[ii]);
memcached_return_t rc = memcached_delete(replicas[ii],
key_ptr,
key_len,
0);
if (!memcached_success(rc))
{
log_delete_failure(fqkey, ii, replicas.size(), trail, 0);
}
}
}
/**
* @brief del_cache This function delete a key and its value in memcached.
*
* @param thr_arg The arg of thread.
* @param key The key.
*
* @return 1 for success and -1 for fail.
*/
int del_cache(thr_arg_t *thr_arg, const char *key)
{
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_delete(memc, key, strlen(key), 0);
if (rc == MEMCACHED_SUCCESS)
{
LOG_PRINT(LOG_DEBUG, "Cache Key[%s] Delete Successfully.", key);
rst = 1;
}
else if(rc == MEMCACHED_CONNECTION_FAILURE)
{
LOG_PRINT(LOG_DEBUG, "Cache Conn Failed!");
//retry_cache(thr_arg);
}
else
{
LOG_PRINT(LOG_DEBUG, "Cache Key[%s] Delete Failed!", key);
const char *str_rc = memcached_strerror(memc, rc);
LOG_PRINT(LOG_DEBUG, "Cache Result: %s", str_rc);
rst = -1;
}
return rst;
}
int
sstack_memcache_remove(memcached_st *memc, const char *key, log_ctx_t *ctx)
{
int rc = -1;
// Parameter validation
if (NULL == key || NULL == memc) {
sfs_log(ctx, SFS_ERR, "%s: Invalid parameters specified \n",
__FUNCTION__);
return -1;
}
rc = memcached_delete(memc, key, strlen(key), 0);
if (rc != MEMCACHED_SUCCESS) {
sfs_log(ctx, SFS_ERR, "%s: memcached_delete for key %s failed with "
"error %d \n", __FUNCTION__, key, rc);
return -rc;
} else {
sfs_log(ctx, SFS_INFO, "%s: Key %s deleted from memcached db \n",
__FUNCTION__, key);
return 0;
}
}
void eliminarValor(char operacion, const char *path) {
if (cache != 0) {
extern pthread_mutex_t bloquearCache;
char *key = malloc(sizeof(char) + strlen(path) + 1);
extern memcached_st *memcached;
size_t tamkey = 0;
memcached_return resultado;
key = armarKey(operacion, path);
tamkey = strlen(key);
pthread_mutex_lock(&bloquearCache);
resultado = memcached_delete(memcached, key, tamkey, (time_t) 0);
if (resultado == MEMCACHED_SUCCESS)
printf("Se elimino %s en la Memcached\n", key);
else
printf("Error al eliminar %s en la Memcached\n", key);
free(key);
pthread_mutex_unlock(&bloquearCache);
}
}
static void php_memc_sess_unlock(memcached_st *memc)
{
if (MEMC_G(sess_locked)) {
memcached_delete(memc, MEMC_G(sess_lock_key), MEMC_G(sess_lock_key_len), 0);
MEMC_G(sess_locked) = 0;
efree(MEMC_G(sess_lock_key));
MEMC_G(sess_lock_key_len) = 0;
}
}
void MemcachedSessionManager::delete_session(Session &session)
{
memcached_return rc;
std::string const &sessionid = session.sessionid();
rc = memcached_delete(memcached_conn, sessionid.data(),
sessionid.length(), 0);
if (rc != MEMCACHED_SUCCESS)
throw MemcacheError(memcached_conn, rc);
}
/**
* Delete an object from the server specified by the key given.
*
* @param[in] key key of object to delete
* @return true on success; false otherwise
*/
bool remove(const std::string &key)
{
if (key.empty())
{
return false;
}
memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
return (rc == MEMCACHED_SUCCESS);
}
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;
}
void Cache::remove( const MC2String& key ) {
SysUtility::IgnorePipe ignorePipe;
memcached_return rc = memcached_delete( m_pimpl->memc.get(),
key.c_str(),
strlen( key.c_str() ),
0 );
throwOnFail( rc, m_pimpl->memc.get(), "Couldn't delete a value" );
}
/**
* @function memcached.remove
*
* ### Synopsis
*
* var rc = memcached.remove(handle, key);
*
* Remove an item from memcached by key.
*
* @param {object} handle - handle to memcached connection.
* @param {string} key - key of data to set in memcached.
* @return {int} rc - result code; 0 if no error, otherwise the error code.
*/
JSVAL _memcached_remove (JSARGS args) {
HandleScope scope;
M *handle = HANDLE(args[0]);
String::Utf8Value key(args[1]);
time_t expiration = 0;
if (args.Length() > 2) {
expiration = args[2]->IntegerValue();
}
return scope.Close(Integer::New(memcached_delete(handle, *key, strlen(*key), expiration)));
}
void ESPMemCached::remove(const char* groupID, const char* cacheID)
{
memcached_return_t rc;
size_t groupIDLength = strlen(groupID);
if (groupIDLength)
rc = memcached_delete_by_key(connection, groupID, groupIDLength, cacheID, strlen(cacheID), (time_t)0);
else
rc = memcached_delete(connection, cacheID, strlen(cacheID), (time_t)0);
assertOnError(rc, "'Delete' request failed - ");
}
bool c_Memcache::t_delete(CStrRef key, int expire /*= 0*/) {
if (key.empty()) {
raise_warning("Key cannot be empty");
return false;
}
memcached_return_t ret = memcached_delete(&m_memcache,
key.c_str(), key.length(),
expire);
return (ret == MEMCACHED_SUCCESS);
}
void wrap_memcached_remove(str* attr,void * memc)
{
memcached_return rc;
rc = memcached_delete((memcached_st*)memc,attr->s,attr->len,0);
if( rc != MEMCACHED_SUCCESS && rc != MEMCACHED_NOTFOUND)
{
LM_ERR("Failed to remove: %s\n",memcached_strerror(memc,rc));
}
}
static
void s_unlock_session(memcached_st *memc)
{
php_memcached_user_data *user_data = memcached_get_user_data(memc);
if (user_data->is_locked) {
memcached_delete(memc, user_data->lock_key->val, user_data->lock_key->len, 0);
user_data->is_locked = 0;
zend_string_release (user_data->lock_key);
}
}
static int
exec_delete(memcached_st *mcd, const char *key, time_t expire)
{
memcached_return_t error = memcached_delete(mcd, key, strlen(key),
expire);
if (error == MEMCACHED_SUCCESS)
printf("delete: key=%s expire=%lu\n", key, expire);
else
printf("delete: key=%s expire=%lu error=%s\n",
key, expire, memcached_strerror(mcd, error));
return 0;
}
void delete_memcached(memcached_st *cache, const char* path, enum tipo_nipc nipc_type) {
char *key = key_for_memcached(path, nipc_type);
memcached_return_t memcached_response = memcached_delete(cache, key,
strlen(key), (time_t) 0);
if (memcached_response == MEMCACHED_SUCCESS) {
log_info(memcached_logger, "Se borro la clave %s", key);
} else {
log_error(memcached_logger, "Error borrando la clave %s: %s", key,
memcached_strerror(cache, memcached_response));
}
}
/**
* Data uma resposta, verifica se ela é válida para a requisição corrente.
*/
ngx_int_t verifica_captcha(ngx_http_request_t *r, ngx_str_t *resposta) {
char captcha_key_buf[100];
ngx_str_t captcha_key = ngx_string(captcha_key_buf);
ngx_str_t cookie_name = ngx_string("CAPTCHA");
if (resposta == NULL || resposta->len == 0) {
return 0;
}
if (!le_cookie(r, &cookie_name, &captcha_key)) {
return 0;
}
ngx_log_debug1( NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "request captcha key cookie is %s", captcha_key.data);
// char * memcached_get(memcached_st *ptr, const char *key, size_t key_length, size_t *value_length, uint32_t *flags, memcached_return_t *error);
// memcached_return_t mc_rc = memcached_set(memc, (char*) ngx_chave.data, ngx_chave.len, (char*)resposta, strlen((char*)resposta), (time_t) 10000, (uint32_t)0);
// if (mc_rc != MEMCACHED_SUCCESS) {
// ngx_log_error(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
// "Problemas ao escrever no memcached");
// return NGX_HTTP_INTERNAL_SERVER_ERROR;
// }
memcached_return_t mc_error;
ngx_str_t resposta_correta;
size_t tam = 0;
uint32_t flags;
resposta_correta.data = (u_char*) memcached_get(memc, (char*) captcha_key.data, captcha_key.len, &tam, &flags, &mc_error);
if (mc_error != MEMCACHED_SUCCESS) {
// FIXME diferenciar chave inexistente de conexao inexistente
return 0;
}
resposta_correta.len = tam;
if (resposta_correta.len != resposta->len) {
ngx_log_debug2( NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "diferença no tamanho dos captchas: enviado->'%d' == '%d'<-correto", resposta->len, resposta_correta.len);
return 0;
}
ngx_log_debug2( NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "comparando captcha: enviado->'%s' == '%s'<-correto", resposta->data, resposta_correta.data);
int cmp = ngx_strncmp(resposta->data, resposta_correta.data, resposta_correta.len);
if (cmp ==0) {
// resposta correta
time_t t = 0;
memcached_delete(memc, (char*) captcha_key.data, captcha_key.len, t);
return 1;
}
return 0;
}
Memcache_Res CMemcache:: Memcac_Delete(string strKey)
{
Memcache_Res mRes = MEMCACHED_SUCCESS;
if(strKey.empty())
return static_cast<Memcache_Res>(MEMCACHED_INVALID_ARGUMENTS);
// lock and delete
pthread_mutex_lock(&m_hmc_mutex);
mRes = memcached_delete(m_hMc, strKey.c_str(), strKey.length(), 0);
pthread_mutex_unlock(&m_hmc_mutex);
return mRes;
}
static int memcached_metatile_delete(struct storage_backend * store, const char *xmlconfig, int x, int y, int z) {
char meta_path[PATH_MAX];
memcached_return_t rc;
memcached_xyz_to_storagekey(xmlconfig, x, y, z, meta_path);
rc = memcached_delete(store->storage_ctx, meta_path, strlen(meta_path), 0);
if (rc != MEMCACHED_SUCCESS) {
return -1;
}
return 0;
}
/// Delete the data for the specified namespace and key. Writes the data
/// unconditionally, so CAS is not needed.
Store::Status MemcachedStore::delete_data(const std::string& table,
const std::string& key,
SAS::TrailId trail)
{
Store::Status status = Store::Status::OK;
LOG_DEBUG("Deleting key %s from table %s", key.c_str(), table.c_str());
// Construct the fully qualified key.
std::string fqkey = table + "\\\\" + key;
const char* key_ptr = fqkey.data();
const size_t key_len = fqkey.length();
// Delete from the read replicas - read replicas are a superset of the write replicas
const std::vector<memcached_st*>& replicas = get_replicas(fqkey, Op::READ);
if (trail != 0)
{
SAS::Event start(trail, SASEvent::MEMCACHED_DELETE, 0);
start.add_var_param(fqkey);
SAS::report_event(start);
}
LOG_DEBUG("Deleting from the %d read replicas for key %s", replicas.size(), fqkey.c_str());
// First try to write the primary data record to the first responding
// server.
memcached_return_t rc = MEMCACHED_ERROR;
size_t ii;
for (ii = 0; ii < replicas.size(); ++ii)
{
LOG_DEBUG("Attempt delete to replica %d (connection %p)",
ii,
replicas[ii]);
rc = memcached_delete(replicas[ii],
key_ptr,
key_len,
0);
if (!memcached_success(rc))
{
// Deletes are unconditional so this should never happen
LOG_ERROR("Delete failed to replica %d", ii);
}
}
return status;
}
void MemcachedCache::remove(const QString& key)
{
QWriteLocker lock(&m_lock);
const QByteArray rawKey(fullKey(key));
const memcached_return rt = memcached_delete(
m_memcached,
rawKey.constData(),
rawKey.length(),
0
);
if(rt != MEMCACHED_SUCCESS)
{
qFatal("Memcached error: %s", memcached_strerror(m_memcached, rt));
}
}
static void rush_delete(int nr, char *buf, char seed, uint32_t key_len, memcached_st *memc)
{
int i;
memcached_return_t rc;
char *key, *value;
for(i=0; i<nr; i++) {
generate_key_value(i,buf,seed,&key,key_len,NULL,0);
rc=memcached_delete(memc,key,key_len,(time_t)0);
if(memcached_failed(rc)) {
printf("memcached_delete() failed: %s\n",memcached_strerror(memc,rc));
}
PRINTF("i=%d, key_len=%ld\n",i,key_len);
}
}
static int cdb_remove(knot_db_t *db, knot_db_val_t *key, int maxcount)
{
if (!db || !key) {
return kr_error(EINVAL);
}
struct memcached_cli *cli = db;
memcached_return_t ret = 0;
for (int i = 0; i < maxcount; ++i) {
memcached_return_t ret = memcached_delete(cli->handle, key[i].data, key[i].len, 0);
if (ret != 0) {
break;
}
}
return ret;
}
bool Memcached::Delete(const std::string& sKey, time_t tOverTime)
{
if (m_pMemc == NULL)
{
return false;
}
m_rc = memcached_delete(m_pMemc, sKey.c_str(), sKey.length(), tOverTime);
if (MEMCACHED_SUCCESS != m_rc)
{
m_sErrMsg = "memcached_delete failed.";
return false;
}
return true;
}