void flushdb() { Redis::Context* cxt = Application::context_map()->get(Prefix::user); redisContext* rdb = redisConnect(cxt->host.c_str(),cxt->port); redisReply* r = (redisReply*) redisCommand(rdb, "select %d", cxt->db_num); freeReplyObject(r); r = (redisReply*) redisCommand(rdb,"flushdb"); freeReplyObject(r); redisFree(rdb); }
//------------------------------------------------------------------------------------- bool DBInterfaceRedis::detach() { if(pRedisContext_) { redisFree(pRedisContext_); pRedisContext_ = NULL; } return true; }
void get(char *key){ redisContext* c = redisConnect("127.0.0.1", 6379); redisReply* r = (redisReply*)redisCommand(c,"get %s",key); if(r->type == REDIS_REPLY_STRING){ printf("get value = %s",r->str); } freeReplyObject(r); redisFree(c); }
void hiredis_backend__free(git_odb_backend *_backend) { hiredis_backend *backend; assert(_backend); backend = (hiredis_backend *) _backend; redisFree(backend->db); free(backend); }
bool RedisDriver::Reconnect() { if (m_pContext != NULL) { redisFree(m_pContext); m_pContext = NULL; } XLog(LEVEL_ERROR, "[Redis]: reconnecting...\n"); return Connect(m_sIP, m_nPort, m_sPwd, m_nConnTimeout); }
int git_refdb_backend_hiredis(git_refdb_backend **backend_out, const char* prefix, const char* path, const char *host, int port, char* password) { hiredis_refdb_backend *backend; redisReply *reply; backend = calloc(1, sizeof(hiredis_refdb_backend)); if (backend == NULL) return GITERR_NOMEMORY; if (sharedConnection == NULL) { sharedConnection = redisConnect(host, port); if (sharedConnection->err) { free(backend); giterr_set_str(GITERR_REFERENCE, "Redis refdb storage couldn't connect to redis server"); return GIT_ERROR; } if (password != NULL) { reply = redisCommand(sharedConnection, "AUTH %s", password); if (reply->type == REDIS_REPLY_ERROR) { freeReplyObject(reply); redisFree(sharedConnection); free(backend); giterr_set_str(GITERR_REFERENCE, "Redis refdb storage authentication with redis server failed"); return GIT_ERROR; } freeReplyObject(reply); } } backend->db = sharedConnection; backend->prefix = strdup(prefix); backend->repo_path = strdup(path); backend->parent.exists = &hiredis_refdb_backend__exists; backend->parent.lookup = &hiredis_refdb_backend__lookup; backend->parent.iterator = &hiredis_refdb_backend__iterator; backend->parent.write = &hiredis_refdb_backend__write; backend->parent.del = &hiredis_refdb_backend__del; backend->parent.rename = &hiredis_refdb_backend__rename; backend->parent.compress = NULL; backend->parent.free = &hiredis_refdb_backend__free; backend->parent.has_log = &hiredis_refdb_backend__has_log; backend->parent.ensure_log = &hiredis_refdb_backend__ensure_log; backend->parent.reflog_read = &hiredis_refdb_backend__reflog_read; backend->parent.reflog_write = &hiredis_refdb_backend__reflog_write; backend->parent.reflog_rename = &hiredis_refdb_backend__reflog_rename; backend->parent.reflog_delete = &hiredis_refdb_backend__reflog_delete; *backend_out = (git_refdb_backend *) backend; return GIT_OK; }
static int check_contents(request_rec *req) { llzr_config *conf = ap_get_module_config (c->base_server->module_config, &llzr_module); GTable *post_data = get_post_data(req); redis = conf->redisconn; reply = conf->redisreply; /* Things of interest: request_rec->uri request_rec->useragent_ip request_rec->request_time request_rec->method */ char *request_remote_ip = recq->useragent_ip; apr_time_t request_timestamp = recq->request_time; char *request_uri = recq->uri; char *request_method = recq->method; /* @TODO: look through post request for username and password if they are included, create a token id, and insert into redis database send back a 402 payment required or 307 to /login/token ask the user to authorize login... on resubmission ony the token is passed and if exists, login is sucessful if not, the entry is logged and evaluated */ /* ... */ if (post_data) { /* ... hash the password to be secure in memory even.. */ size_t length = sizeof(post_data['USERNAME_FIELD']); unsigned char hash[SHA_DIGEST_LENGTH]; SHA1(post_data['USERNAME_FIELD'], length, hash); reply = redisCommand(redis, "HMSET %s %s %s", request_remote_ip, username, hash); } /* ... */ redisFreeReply(reply); redisFree(redis); return OK; }
SEXP cr_connect(SEXP sHost, SEXP sPort, SEXP sTimeout, SEXP sReconnect, SEXP sRetry) { const char *host = "localhost"; double tout = Rf_asReal(sTimeout); int port = Rf_asInteger(sPort), reconnect = (Rf_asInteger(sReconnect) > 0), retry = (Rf_asInteger(sRetry) > 0); redisContext *ctx; rconn_t *c; SEXP res; struct timeval tv; if (TYPEOF(sHost) == STRSXP && LENGTH(sHost) > 0) host = CHAR(STRING_ELT(sHost, 0)); tv.tv_sec = (int) tout; tv.tv_usec = (tout - (double)tv.tv_sec) * 1000000.0; if (port < 1) ctx = redisConnectUnixWithTimeout(host, tv); else ctx = redisConnectWithTimeout(host, port, tv); if (!ctx) Rf_error("connect to redis failed (NULL context)"); if (ctx->err){ SEXP es = Rf_mkChar(ctx->errstr); redisFree(ctx); Rf_error("connect to redis failed: %s", CHAR(es)); } c = malloc(sizeof(rconn_t)); if (!c) { redisFree(ctx); Rf_error("unable to allocate connection context"); } c->rc = ctx; c->flags = (reconnect ? RCF_RECONNECT : 0) | (retry ? RCF_RETRY : 0); c->host = strdup(host); c->port = port; c->timeout = tout; redisSetTimeout(ctx, tv); res = PROTECT(R_MakeExternalPtr(c, R_NilValue, R_NilValue)); Rf_setAttrib(res, R_ClassSymbol, Rf_mkString("redisConnection")); R_RegisterCFinalizer(res, rconn_fin); UNPROTECT(1); return res; }
int main() { redisContext* r {redisConnect("localhost",6379)}; freeReplyObject(redisCommand(r, "flushall")); redisFree(r); populate_users(); Test::TextOutput o(Test::TextOutput::Verbose); GMTS test {}; return test.run(o) ? EXIT_SUCCESS : EXIT_FAILURE; }
bool CRedisClient::ReConnect() { LockerGuard guard(*m_locker); if( m_pRedisContext ) { redisFree(m_pRedisContext); m_pRedisContext = NULL; } struct timeval timeout = { 0, 500000 }; // 0.5 seconds 重连 return OnConnect(&timeout); }
void init_thread(evhtp_t *htp, evthr_t *thread, void *arg) { thr_arg_t *thr_args; thr_args = calloc(1, sizeof(thr_arg_t)); thr_args->thread = thread; char mserver[32]; if(settings.cache_on == true) { memcached_st *memc = memcached_create(NULL); snprintf(mserver, 32, "%s:%d", settings.cache_ip, settings.cache_port); memcached_server_st *servers = memcached_servers_parse(mserver); memcached_server_push(memc, servers); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1); memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, 1); thr_args->cache_conn = memc; LOG_PRINT(LOG_DEBUG, "Memcached Connection Init Finished."); memcached_server_list_free(servers); } if(settings.mode == 2) { memcached_st *beans = memcached_create(NULL); snprintf(mserver, 32, "%s:%d", settings.beansdb_ip, settings.beansdb_port); memcached_server_st *servers = memcached_servers_parse(mserver); servers = memcached_servers_parse(mserver); memcached_server_push(beans, servers); memcached_behavior_set(beans, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0); memcached_behavior_set(beans, MEMCACHED_BEHAVIOR_NO_BLOCK, 1); memcached_behavior_set(beans, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, 1); thr_args->beansdb_conn = beans; LOG_PRINT(LOG_DEBUG, "beansdb Connection Init Finished."); memcached_server_list_free(servers); } else if(settings.mode == 3) { redisContext* c = redisConnect(settings.ssdb_ip, settings.ssdb_port); if(c->err) { redisFree(c); LOG_PRINT(LOG_DEBUG, "Connect to ssdb server faile"); } else { thr_args->ssdb_conn = c; LOG_PRINT(LOG_DEBUG, "Connect to ssdb server Success"); } } evthr_set_aux(thread, thr_args); }
void RedisClientPool::Destroy(redisContext* item) { if (item) { stringstream stream; stream << "free redis context"; LOG(INFO, stream.str()); redisFree(item); } }
RedisOperator::~RedisOperator() { if(this->ctx) { redisFree(this->ctx); this->ctx = NULL; } this->host.resize(0); this->port = -1; this->password.resize(0); }
HashNodeGenerator::HashNodeGenerator (const std::string& node) { redisContext* rdb = redisConnect(REDIS_HOST, REDIS_PORT); __reply = (redisReply*) redisCommand(rdb, "type %s", node.c_str()); assert(strcmp(__reply->str,"hash") == 0); freeReplyObject(__reply); __reply = (redisReply*) redisCommand(rdb, "hgetall %s", node.c_str()); redisFree(rdb); current =0; }
/* Internal methods */ static redisContext* redis_connection(struct redis_handler *handle) { redisContext* context = NULL; struct timeval timeout = { 1, 500000 }; // 1.5 seconds context = redisConnectWithTimeout((char*)handle->redis_ip, handle->redis_port, timeout); if (context == NULL || context->err) { if (context != NULL) { redisFree(context); } return NULL; } /* make keepalive connection */ if (redisEnableKeepAlive(context) != REDIS_OK){ if (context != NULL) { redisFree(context); } return NULL; } return context; }
void init_banned_syscall(){ redisContext* r= redisConnect(REDIS_IP,REDIS_PORT) ; redisReply *re = redisCommand(r,"lrange lambda:banned_syscall 0 -1") ; int i ; for(i=0;i<re->elements;i++){ int curr_sysnum = atoi(re->element[i]->str) ; syscall_white_list[curr_sysnum] = 1 ; } freeReplyObject(re); redisFree(r) ; }
static void cleanup(void) { redisContext *c = blocking_context; redisReply *reply; /* Make sure we're on DB 9 */ reply = redisCommand(c,"SELECT 9"); assert(reply != NULL); freeReplyObject(reply); reply = redisCommand(c,"FLUSHDB"); assert(reply != NULL); freeReplyObject(reply); redisFree(c); }
static int pushConnection(lua_State *L, redisContext *con) { if (con != NULL && con->err) { luaL_error(L, "Error: %s\n", con->errstr); lua_pushnil(L); lua_pushstring(L, con->errstr); redisFree(con); return 2; } lua_pushlightuserdata(L, con); return 1; };
static int _mod_conn_free(REDISSOCK *dissocket) { redisFree(dissocket->conn); if (dissocket->reply) { freeReplyObject(dissocket->reply); dissocket->reply = NULL; } return 0; }
/* Helper function to free the context. */ static void __redisAsyncFree(redisAsyncContext *ac) { redisContext *c = &(ac->c); redisCallback cb; dictIterator *it; dictEntry *de; // 执行所有等待队列中回调函数,将空回复传进去 /* Execute pending callbacks with NULL reply. */ while (__redisShiftCallback(&ac->replies,&cb) == REDIS_OK) __redisRunCallback(ac,&cb,NULL); // 执行所有等待队列中回调函数,将空回复传进去 // 这里是无效命令的回调函数 /* Execute callbacks for invalid commands */ while (__redisShiftCallback(&ac->sub.invalid,&cb) == REDIS_OK) __redisRunCallback(ac,&cb,NULL); // 执行所有等待队列中回调函数,将空回复传进去 // 这里是订阅发布的回调函数 /* Run subscription callbacks callbacks with NULL reply */ it = dictGetIterator(ac->sub.channels); while ((de = dictNext(it)) != NULL) __redisRunCallback(ac,dictGetEntryVal(de),NULL); dictReleaseIterator(it); dictRelease(ac->sub.channels); // 执行所有等待队列中回调函数,将空回复传进去 // 这里是订阅发布的回调函数 it = dictGetIterator(ac->sub.patterns); while ((de = dictNext(it)) != NULL) __redisRunCallback(ac,dictGetEntryVal(de),NULL); dictReleaseIterator(it); dictRelease(ac->sub.patterns); // 注销连接上的读写事件 /* Signal event lib to clean up */ _EL_CLEANUP(ac); // 执行连接关闭回调函数,可做一些清理工作 /* Execute disconnect callback. When redisAsyncFree() initiated destroying * this context, the status will always be REDIS_OK. */ if (ac->onDisconnect && (c->flags & REDIS_CONNECTED)) { if (c->flags & REDIS_FREEING) { ac->onDisconnect(ac,REDIS_OK); } else { ac->onDisconnect(ac,(ac->err == 0) ? REDIS_OK : REDIS_ERR); } } // 释放 redisContext 中的内存 /* Cleanup self */ redisFree(c); }
MHIREDIS_T MHiRedis::cleanUp() { // free redis resource redisFree(context_); // reset members context_ = NULL; host_ = ""; port_ = 0; password_ = ""; db_ = -1; timeout_ = 0; }
void justice_cmd::cancel() { if (!m_executor) return; redisContext *c = redisConnect("127.0.0.1", 6379); if (!c) return; if (c->err != 0) { redisFree(c); return; } void *reply = redisCommand(c, "PUBLISH %s %s", qUtf8Printable(m_info_chnl), "end"); if (reply) freeReplyObject(reply); redisFree(c); }
static void test_free_null(void) { void *redisCtx = NULL; void *reply = NULL; test("Don't fail when redisFree is passed a NULL value: "); redisFree(redisCtx); test_cond(redisCtx == NULL); test("Don't fail when freeReplyObject is passed a NULL value: "); freeReplyObject(reply); test_cond(reply == NULL); }
static void test_blocking_connection_errors(void) { redisContext *c; test("Returns error when host cannot be resolved: "); c = redisConnect((char*)"idontexist.local", 6379); test_cond(c->err == REDIS_ERR_OTHER && (strcmp(c->errstr,"Name or service not known") == 0 || strcmp(c->errstr,"Can't resolve: idontexist.local") == 0)); redisFree(c); test("Returns error when the port is not open: "); c = redisConnect((char*)"localhost", 1); test_cond(c->err == REDIS_ERR_IO && strcmp(c->errstr,"Connection refused") == 0); redisFree(c); test("Returns error when the unix socket path doesn't accept connections: "); c = redisConnectUnix((char*)"/tmp/idontexist.sock"); test_cond(c->err == REDIS_ERR_IO); /* Don't care about the message... */ redisFree(c); }
static void adjustClosedConnections( proxyContext *p, redisContext *c ) { if( c == NULL ) return; for( int i = 0; i < p->max_count; i++ ) { if( p->contexts[i] == c ) { redisFree(p->contexts[i]); p->contexts[i] = NULL; break; } } }
static void freeClient(client c) { listNode *ln; aeDeleteFileEvent(config.el,c->context->fd,AE_WRITABLE); aeDeleteFileEvent(config.el,c->context->fd,AE_READABLE); redisFree(c->context); sdsfree(c->obuf); zfree(c); config.liveclients--; ln = listSearchKey(config.clients,c); assert(ln != NULL); listDelNode(config.clients,ln); }
static void disconnectRedis(redisContext *c) { redisReply *reply; /* Make sure we're on DB 9. */ reply = redisCommand(c,"SELECT 9"); freeReplyObject(reply); reply = redisCommand(c,"FLUSHDB"); freeReplyObject(reply); /* Free the context as well. */ redisFree(c); }
void init_lang_config() { redisContext *r = redisConnect(REDIS_IP,REDIS_PORT) ; int i ; for(i=0;i<=CPP;i++){ compiler[i] = redisCommand(r,"get lambda:%s:compiler",support_language[i]); execute[i] = redisCommand(r,"get lambda:%s:execute",support_language[i]); compile_args[i] = redisCommand(r,"lrange lambda:%s:compile_args 0 -1",support_language[i]) ; execute_args[i] = redisCommand(r,"lrange lambda:%s:execute_args 0 -1",support_language[i]) ; } redisFree(r) ; }
int rs_redis_append_command(rs_slave_info_t *si, const char *fmt, ...) { va_list args; redisContext *c; int i, err; i = 0; err = 0; c = si->c; for( ;; ) { if(c == NULL) { /* retry connect*/ c = redisConnect(si->redis_addr, si->redis_port); if(c->err) { if(i % 60 == 0) { i = 0; rs_log_error(RS_LOG_ERR, rs_errno, "redisConnect(\"%s\", " "%d) failed, %s" , si->redis_addr, si->redis_port, c->errstr); } redisFree(c); c = NULL; i += RS_REDIS_CONNECT_RETRY_SLEEP_SEC; sleep(RS_REDIS_CONNECT_RETRY_SLEEP_SEC); continue; } } va_start(args, fmt); err = redisvAppendCommand(c, fmt, args); va_end(args); break; } si->c = c; if(err != REDIS_OK) { rs_log_error(RS_LOG_ERR, rs_errno, "redisvAppendCommand() failed"); return RS_ERR; } si->cmdn++; return RS_OK; }
void rs_free_slave(void *data) { int err; rs_slave_info_t *si; si = data == NULL ? rs_slave_info : (rs_slave_info_t *) data; if(si != NULL) { if(si->io_thread != 0) { if((err = pthread_cancel(si->io_thread)) != 0) { rs_log_err(err, "pthread_cancel() failed, io_thread"); } } if(si->svr_fd != -1) { rs_close(si->svr_fd); } if(si->redis_thread != 0) { if((err = pthread_cancel(si->redis_thread)) != 0) { rs_log_err(err, "pthread_cancel() failed, redis_thread"); } } if(si->c != NULL) { redisFree(si->c); } if(si->ring_buf != NULL) { rs_free_ring_buffer2(si->ring_buf); free(si->ring_buf); } /* close slave info file */ if(si->info_fd != -1) { rs_close(si->info_fd); } if((err = pthread_attr_destroy(&(si->thread_attr))) != 0) { rs_log_err(err, "pthread_attr_destroy() failed, thread_attr"); } rs_free_conf(&(si->conf)); free(si->conf.kv); free(si); } rs_slave_info = NULL; }