// async
bool RedisClientPool::ReconnectAsync(redisAsyncContext* rc, aeEventLoop *loop)
{
DestroyAsync(rc);
try
{
rc = redisAsyncConnect(address_.c_str(), port_);
//fprintf(stderr, "connect redisContext->err: %d\n", rc->err);
if (rc != NULL && rc->err != 0)
{
stringstream stream;
stream << "reconnect Error: " << rc->errstr;
LOG(ERROR, stream.str());
// 建立错误直接返回NULL
// FIXME: no need to free?
// redisFree(rc);
return false;
}
redisAsyncSetDisconnectCallback(rc, redisAsyncDisconnectCallback);
// 在重连成功后做Attach操作
redisAeAttach(loop, rc);
} catch (std::exception &e)
{
stringstream stream;
stream << "reconnect server faild!!";
LOG(ERROR, stream.str());
return false;
}
return true;
}
// async
redisAsyncContext* RedisClientPool::createAsync(aeEventLoop *loop)
{
try
{
redisAsyncContext * ret = redisAsyncConnect(address_.c_str(), port_);
if (ret != NULL && ret->err)
{
stringstream stream;
stream << "reconnect Error: " << ret->err;
LOG(ERROR, stream.str());
// FIXME: no need to free
// redisFree(ret);
// 建立错误直接返回NULL
ret = NULL;
return ret;
}
// 设置连接断开的回调函数
redisAsyncSetDisconnectCallback(ret, redisAsyncDisconnectCallback);
// 在第一次创建链接的时候做Attach操作
redisAeAttach(loop, ret);
return ret;
} catch (std::exception &e)
{
return NULL;
}
}
static client createClient(void) {
client c = zmalloc(sizeof(struct _client));
c->context = redisAsyncConnect(config.hostip,config.hostport);
c->context->data = c;
redisAsyncSetDisconnectCallback(c->context,clientDisconnected);
if (c->context->err) {
fprintf(stderr,"Connect: %s\n",c->context->errstr);
exit(1);
}
redisAeAttach(config.el,c->context);
listAddNodeTail(config.clients,c);
issueRequest(c);
return c;
}
int main (int argc, char **argv) {
signal(SIGPIPE, SIG_IGN);
redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
loop = aeCreateEventLoop();
redisAeAttach(loop, c);
redisAsyncSetConnectCallback(c,connectCallback);
redisAsyncSetDisconnectCallback(c,disconnectCallback);
redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
aeMain(loop);
return 0;
}
int GatewayDataMgr::startRedisCliProcLoop() {
int iRet = 0;
//init redis script sha1
sha1sumScript();
mPtRedisAC = redisAsyncConnect(mRedisSvrIPAddr.c_str(), mPort);
if (mPtRedisAC->err) {
/* Let *c leak for now... */
LOG(ERROR)<<"Error: "<<mPtRedisAC->errstr;
iRet = -1;
return iRet;
}
mPtEventLoop = aeCreateEventLoop(64);
mPtRedisAC->data = mPtEventLoop;//used on connect/disconnect callback
redisAeAttach(mPtEventLoop, mPtRedisAC);
redisAsyncSetConnectCallback(mPtRedisAC, connectCallback);
redisAsyncSetDisconnectCallback(mPtRedisAC,disconnectCallback);
std::thread loopThread(std::mem_fn(&GatewayDataMgr::loopThread), this);
loopThread.detach();
return iRet;
}
static int dispatch_data_thread_init(dispatch_data_thread *ddt, char *test_target_groups, int connections)
{
int i, j, k;
ddt->id = 0;
ddt->thread_id = 0;
ddt->el = NULL;
ddt->hz = 10;
ddt->cronloops = 0;
ddt->datas = NULL;
ddt->rdatas = NULL;
ddt->abgs = NULL;
ddt->pause = 0;
ddt->count_wait_for_reply = 0;
ddt->reply_total_count_per_cycle = 0;
ddt->reply_type_err_count_per_cycle = 0;
ddt->el = aeCreateEventLoop(200);
if (ddt->el == NULL) {
return VRT_ERROR;
}
ddt->datas = dmtqueue_create();
if (ddt->datas == NULL) {
return VRT_ERROR;
}
if (dmtqueue_init_with_lockqueue(ddt->datas, NULL) != 0) {
return VRT_ERROR;
}
ddt->rdatas = dlistCreate();
if (ddt->rdatas == NULL) {
return VRT_ERROR;
}
ddt->abgs = abtest_groups_create(test_target_groups);
if (ddt->abgs == NULL) {
return VRT_ERROR;
}
/* Init connection context for each server */
for (i = 0; i < darray_n(ddt->abgs); i ++) {
abtest_group *abg = darray_get(ddt->abgs, i);
for (j = 0; j < darray_n(&abg->abtest_servers); j ++) {
abtest_server *abs = darray_get(&abg->abtest_servers, j);
abs->conn_contexts = darray_create(connections, sizeof(conn_context));
for (k = 0; k < connections; k ++) {
conn_context *cc = darray_push(abs->conn_contexts);
if (dispatch_conn_context_init(cc,abs->host,abs->port) != VRT_OK) {
return VRT_ERROR;
}
cc->actx->data = ddt;
redisAeAttach(ddt->el, cc->actx);
redisAsyncSetConnectCallback(cc->actx,connect_callback);
redisAsyncSetDisconnectCallback(cc->actx,disconnect_callback);
}
}
}
if (aeCreateTimeEvent(ddt->el, 1, dispatch_data_thread_cron, ddt, NULL) == AE_ERR) {
return VRT_ERROR;
}
return VRT_OK;
}
