bool xRedisClient::commandargv_array(const RedisDBIdx& dbi, const VDATA& vDataIn, VALUES& array){
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
std::vector<const char*> argv( vDataIn.size() );
std::vector<size_t> argvlen( vDataIn.size() );
uint32_t j = 0;
for ( VDATA::const_iterator i = vDataIn.begin(); i != vDataIn.end(); ++i, ++j ) {
argv[j] = i->c_str(), argvlen[j] = i->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
for (size_t i = 0; i<reply->elements; i++) {
std::string str(reply->element[i]->str, reply->element[i]->len);
array.push_back(str);
}
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::commandargv_integer(const RedisDBIdx& dbi, const VDATA& vDataIn, int64_t& retval){
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
std::vector<const char*> argv( vDataIn.size() );
std::vector<size_t> argvlen( vDataIn.size() );
uint32_t j = 0;
for ( VDATA::const_iterator iter = vDataIn.begin(); iter != vDataIn.end(); ++iter, ++j ) {
argv[j] = iter->c_str(), argvlen[j] = iter->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
retval = reply->integer;
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
void xRedisClient::FreexRedisContext(xRedisContext* ctx)
{
RedisConn *pRedisConn = static_cast<RedisConn *>(ctx->conn);
redisReply *reply = static_cast<redisReply *>(redisCommand(pRedisConn->getCtx(), "unsubscribe"));
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection((RedisConn*)ctx->conn);
}
bool xRedisClient::commandargv_status(const RedisDBIdx& dbi, const VDATA& vData) {
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return bRet;
}
std::vector<const char *> argv( vData.size() );
std::vector<size_t> argvlen( vData.size() );
uint32_t j = 0;
for ( VDATA::const_iterator i = vData.begin(); i != vData.end(); ++i, ++j ) {
argv[j] = i->c_str(), argvlen[j] = i->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
// Assume good reply until further inspection
bRet = true;
if (REDIS_REPLY_STRING == reply->type) {
if (!reply->len || !reply->str || strcasecmp(reply->str, "OK") != 0) {
bRet = false;
}
}
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::command_array(const RedisDBIdx& dbi, ArrayReply& array, const char* cmd, ...){
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
va_list args;
va_start(args, cmd);
redisReply *reply = static_cast<redisReply *>(redisvCommand(pRedisConn->getCtx(), cmd, args));
va_end(args);
if (RedisPool::CheckReply(reply)) {
for (size_t i = 0; i<reply->elements; i++) {
DataItem item;
item.type = reply->element[i]->type;
item.str.assign(reply->element[i]->str, reply->element[i]->len);
array.push_back(item);
}
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::command_status(const RedisDBIdx& dbi, const char* cmd, ...) {
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
va_list args;
va_start(args, cmd);
redisReply *reply = static_cast<redisReply *>(redisvCommand(pRedisConn->getCtx(), cmd, args));
va_end(args);
if (RedisPool::CheckReply(reply)) {
// Assume good reply until further inspection
bRet = true;
if (REDIS_REPLY_STRING == reply->type) {
if (!reply->len || !reply->str || strcasecmp(reply->str, "OK") != 0) {
bRet = false;
}
}
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::command_bool(const RedisDBIdx& dbi, const char *cmd, ...) {
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
va_list args;
va_start(args, cmd);
redisReply *reply = static_cast<redisReply *>(redisvCommand(pRedisConn->getCtx(), cmd, args));
va_end(args);
if (RedisPool::CheckReply(reply)) {
if (REDIS_REPLY_STATUS==reply->type) {
bRet = true;
} else {
bRet = (reply->integer == 1) ? true : false;
}
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool xRedisClient::ScanFun(const char* cmd, const RedisDBIdx& dbi, const std::string *key,
int64_t &cursor, const char* pattern, uint32_t count, ArrayReply& array, xRedisContext& ctx)
{
SETDEFAULTIOTYPE(MASTER);
VDATA vCmdData;
vCmdData.push_back(cmd);
if (NULL != key) {
vCmdData.push_back(*key);
}
vCmdData.push_back(toString(cursor));
if (NULL != pattern) {
vCmdData.push_back("MATCH");
vCmdData.push_back(pattern);
}
if (0 != count) {
vCmdData.push_back("COUNT");
vCmdData.push_back(toString(count));
}
bool bRet = false;
RedisConn *pRedisConn = static_cast<RedisConn *>(ctx.conn);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
std::vector<const char*> argv(vCmdData.size());
std::vector<size_t> argvlen(vCmdData.size());
uint32_t j = 0;
for (VDATA::const_iterator i = vCmdData.begin(); i != vCmdData.end(); ++i, ++j) {
argv[j] = i->c_str(), argvlen[j] = i->size();
}
redisReply *reply = static_cast<redisReply *>(redisCommandArgv(pRedisConn->getCtx(), argv.size(), &(argv[0]), &(argvlen[0])));
if (RedisPool::CheckReply(reply)) {
if (0 == reply->elements){
cursor = 0;
} else {
cursor = atoi(reply->element[0]->str);
redisReply **replyData = reply->element[1]->element;
for (size_t i = 0; i < reply->element[1]->elements; i++) {
DataItem item;
item.type = replyData[i]->type;
item.str.assign(replyData[i]->str, replyData[i]->len);
array.push_back(item);
}
}
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
return bRet;
}
rReply *xRedisClient::command(const RedisDBIdx& dbi, const char* cmd)
{
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return NULL;
}
rReply *reply = static_cast<rReply *>(redisCommand(pRedisConn->getCtx(), cmd));
mRedisPool->FreeConnection(pRedisConn);
return reply;
}
int32_t xRedisClient::GetReply(xRedisContext* ctx, ReplyData& vData)
{
//vData.clear();
//ReplyData(vData).swap(vData);
redisReply *reply;
RedisConn *pRedisConn = static_cast<RedisConn *>(ctx->conn);
int32_t ret = redisGetReply(pRedisConn->getCtx(), (void**)&reply);
if (0==ret) {
for (size_t i = 0; i < reply->elements; i++) {
DataItem item;
item.type = reply->element[i]->type;
item.str.assign(reply->element[i]->str, reply->element[i]->len);
vData.push_back(item);
}
}
RedisPool::FreeReply(reply);
return ret;
}
bool xRedisClient::hincrbyfloat(const RedisDBIdx& dbi, const string& key, const string& field, float increment, float& value ) {
SETDEFAULTIOTYPE(MASTER);
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex);
if (NULL==pRedisConn) {
return false;
}
redisReply *reply = static_cast<redisReply *>(redisCommand(pRedisConn->getCtx(), "HINCRBYFLOAT %s %s %f", key.c_str(), field.c_str(), increment));
if (RedisPool::CheckReply(reply)) {
value = atof(reply->str);
bRet = true;
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
bool RedisDBSlice::ConnectRedisNodes(unsigned int cahcetype, unsigned int dbindex, const std::string& host, unsigned int port, const std::string& passwd, unsigned int poolsize, unsigned int timeout, int role)
{
bool bRet = false;
if ((host.empty())
|| (cahcetype > MAX_REDIS_CACHE_TYPE)
|| (dbindex > MAX_REDIS_DB_HASHBASE)
|| (poolsize > MAX_REDIS_CONN_POOLSIZE)) {
return false;
}
try {
if (MASTER == role) {
XLOCK(mSliceConn.MasterLock);
for (unsigned int i = 0; i < poolsize; ++i) {
RedisConn *pRedisconn = new RedisConn;
if (NULL == pRedisconn) {
continue;
}
pRedisconn->Init(cahcetype, dbindex, host.c_str(), port, passwd.c_str(), poolsize, timeout, role, 0);
if (pRedisconn->RedisConnect()) {
mSliceConn.RedisMasterConn.push_back(pRedisconn);
mStatus = REDISDB_WORKING;
} else {
delete pRedisconn;
}
}
bRet = true;
} else if (SLAVE == role) {
XLOCK(mSliceConn.SlaveLock);
RedisConnPool *pSlaveNode = new RedisConnPool;
int slave_idx = mSliceConn.RedisSlaveConn.size();
for (unsigned int i = 0; i < poolsize; ++i) {
RedisConn *pRedisconn = new RedisConn;
if (NULL == pRedisconn) {
continue;
}
pRedisconn->Init(cahcetype, dbindex, host.c_str(), port, passwd.c_str(), poolsize, timeout, role, slave_idx);
if (pRedisconn->RedisConnect()) {
pSlaveNode->push_back(pRedisconn);
} else {
delete pRedisconn;
}
}
mSliceConn.RedisSlaveConn.push_back(pSlaveNode);
bRet = true;
mHaveSlave = true;
} else {
bRet = false;
}
} catch (...) {
return false;
}
return bRet;
}
bool xRedisClient::command_string(const RedisDBIdx& dbi, std::string &data, const char* cmd, ...) {
bool bRet = false;
RedisConn *pRedisConn = mRedisPool->GetConnection(dbi.mType, dbi.mIndex, dbi.mIOtype);
if (NULL == pRedisConn) {
SetErrString(dbi, GET_CONNECT_ERROR, ::strlen(GET_CONNECT_ERROR));
return false;
}
va_list args;
va_start(args, cmd);
redisReply *reply = static_cast<redisReply *>(redisvCommand(pRedisConn->getCtx(), cmd, args));
va_end(args);
if (RedisPool::CheckReply(reply)) {
data.assign(reply->str, reply->len);
bRet = true;
} else {
SetErrInfo(dbi, reply);
}
RedisPool::FreeReply(reply);
mRedisPool->FreeConnection(pRedisConn);
return bRet;
}
int redis_conns_init()
{
if(redis_load_conf() != OK)
{
printf("\nredis_load_conf failed!\n");
return FAIL;
}
int ret;
ret = redis_conn.initConn(redis_conf.redis_conf);
if(OK != ret)
{
printf("redis conn init error.ip=[%s], port=[%d]",redis_conf.redis_conf.ip,redis_conf.redis_conf.port);
return FAIL;
}
return OK;
}
