mrb_value mrb_redis_basic_zrange(mrb_state *mrb, mrb_value self, const char *cmd)
{
int i;
mrb_value list, array;
mrb_int arg1, arg2;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oii", &list, &arg1, &arg2);
mrb_value arg1_str = mrb_fixnum_to_str(mrb, mrb_fixnum_value(arg1), 10);
mrb_value arg2_str = mrb_fixnum_to_str(mrb, mrb_fixnum_value(arg2), 10);
const char *argv[] = {"ZADD", RSTRING_PTR(list), RSTRING_PTR(arg1_str), RSTRING_PTR(arg2_str)};
size_t lens[] = {4, RSTRING_LEN(list), RSTRING_LEN(arg1_str), RSTRING_LEN(arg2_str)};
redisReply *rr = redisCommandArgv(rc, 4, argv, lens);
if (rr->type == REDIS_REPLY_ARRAY) {
array = mrb_ary_new(mrb);
for (i = 0; i < rr->elements; i++) {
mrb_ary_push(mrb, array, mrb_str_new(mrb, rr->element[i]->str, rr->element[i]->len));
}
} else {
freeReplyObject(rr);
return mrb_nil_value();
}
freeReplyObject(rr);
return array;
}
static int lconn_command(lua_State * L)
{
redisContext * pContext = check_connection(L, 1);
const char * argv[LUAHIREDIS_MAXARGS];
size_t argvlen[LUAHIREDIS_MAXARGS];
int nargs = load_args(L, pContext, 2, argv, argvlen);
int nret = 0;
redisReply * pReply = (redisReply *)redisCommandArgv(
pContext, nargs, argv, argvlen
);
if (pReply == NULL)
{
/* TODO: Shouldn't we clear the context error state somehow after this? */
return push_error(L, pContext);
}
nret = push_reply(L, pReply);
/*
* TODO: Not entirely safe: if above code throws error, reply object is leaked.
*/
freeReplyObject(pReply);
pReply = NULL;
return nret;
}
/* issuue one command with one key paratemer and return the result */
SEXP cr_cmd(SEXP sc, SEXP sArgs) {
rconn_t *c;
const char **argv = argbuf;
int n, i;
redisReply *reply;
SEXP res;
if (!Rf_inherits(sc, "redisConnection")) Rf_error("invalid connection");
c = (rconn_t*) EXTPTR_PTR(sc);
if (!c) Rf_error("invalid connection (NULL)");
rc_validate_connection(c, 0);
if (TYPEOF(sArgs) != STRSXP || LENGTH(sArgs) < 1)
Rf_error("invalid command - must be a string");
n = LENGTH(sArgs);
if (n + 1 > NARGBUF) {
argv = malloc(sizeof(const char*) * (n + 2));
if (!argv)
Rf_error("out of memory");
}
for (i = 0; i < n; i++)
argv[i] = CHAR(STRING_ELT(sArgs, i));
/* we use strings only, so no need to supply argvlen */
reply = redisCommandArgv(c->rc, n, argv, 0);
if (!reply && (c->flags & RCF_RETRY)) {
SEXP es = Rf_mkChar(c->rc->errstr);
rc_close(c);
rc_validate_connection(c, 1);
if (c->rc)
reply = redisCommandArgv(c->rc, 2, argv, 0);
else {
if (argv != argbuf)
free(argv);
Rf_error("%s error: %s and re-connect failed", argv[0], CHAR(es));
}
}
if (argv != argbuf)
free(argv);
if (!reply) {
SEXP es = Rf_mkChar(c->rc->errstr);
rc_close(c);
Rf_error("%s error: %s", argv[0], CHAR(es));
}
/* Rprintf("reply, type=%d\n", reply->type); */
res = rc_reply2R(reply);
freeReplyObject(reply);
return res;
}
SEXP cr_del(SEXP sc, SEXP keys) {
rconn_t *c;
int n, i;
const char **argv = argbuf;
redisReply *reply;
if (!Rf_inherits(sc, "redisConnection")) Rf_error("invalid connection");
c = (rconn_t*) EXTPTR_PTR(sc);
if (!c) Rf_error("invalid connection (NULL)");
rc_validate_connection(c, 0);
if (TYPEOF(keys) != STRSXP)
Rf_error("invalid keys");
n = LENGTH(keys);
if (n + 1 > NARGBUF) {
argv = malloc(sizeof(const char*) * (n + 2));
if (!argv)
Rf_error("out of memory");
}
argv[0] = "DEL";
for (i = 0; i < n; i++)
argv[i + 1] = CHAR(STRING_ELT(keys, i));
/* we use strings only, so no need to supply argvlen */
reply = redisCommandArgv(c->rc, n + 1, argv, 0);
if (!reply && (c->flags & RCF_RETRY)) {
SEXP es = Rf_mkChar(c->rc->errstr);
rc_close(c);
rc_validate_connection(c, 1);
if (c->rc)
reply = redisCommandArgv(c->rc, n + 1, argv, 0);
else {
if (argv != argbuf)
free(argv);
Rf_error("DEL error: %s and re-connect failed", CHAR(es));
}
}
if (argv != argbuf)
free(argv);
if (!reply) {
SEXP es = Rf_mkChar(c->rc->errstr);
rc_close(c);
Rf_error("DEL error: %s", CHAR(es));
}
/* Rprintf("reply, type=%d\n", reply->type); */
freeReplyObject(reply);
return R_NilValue;
}
/**
* Executes a redis command.
* Command is coded using a vector of strings, and a vector of lenghts.
*
* @param rsrv Pointer to a redis_server_t structure.
* @param argc number of elements in the command vector.
* @param argv vector of zero terminated strings forming the command.
* @param argvlen vector of command string lenghts or NULL.
* @return redisReply structure or NULL if there was an error.
*/
void * redisc_exec_argv(redisc_server_t *rsrv, int argc, const char **argv, const size_t *argvlen)
{
redisReply *res=NULL;
if(rsrv==NULL || rsrv->ctxRedis==NULL)
{
LM_ERR("no redis context found for server %.*s\n",
rsrv->sname->len, rsrv->sname->s);
return NULL;
}
if(argc<=0)
{
LM_ERR("invalid parameters\n");
return NULL;
}
if(argv==NULL || *argv==NULL)
{
LM_ERR("invalid parameters\n");
return NULL;
}
res = redisCommandArgv(rsrv->ctxRedis, argc, argv, argvlen);
if(res)
{
return res;
}
/* null reply, reconnect and try again */
if(rsrv->ctxRedis->err)
{
LM_ERR("Redis error: %s\n", rsrv->ctxRedis->errstr);
}
if(redisc_reconnect_server(rsrv)==0)
{
res = redisCommandArgv(rsrv->ctxRedis, argc, argv, argvlen);
}
else
{
LM_ERR("Unable to reconnect to server: %.*s\n",
rsrv->sname->len, rsrv->sname->s);
return NULL;
}
return res;
}
static JSVAL command(JSARGS args) {
redisContext *c = (redisContext *)JSOPAQUE(args[0]);
String::Utf8Value _query(args[1]->ToString());
char *argstr = strdup(*_query);
char *in = argstr;
int n = 0;
while (*in) {
while (isspace(*in)) in++;
if (*in) {
n++;
if (*in == '"') {
in++;
while (*in && *in != '"') in++;
if (*in == '"') in++;
}
else {
while (*in && !isspace(*in)) in++;
}
}
}
in = argstr;
int argc = n;
char *argv[n];
n = 0;
while (*in) {
while (isspace(*in)) in++;
if (*in) {
if (*in == '"') {
in++;
argv[n++] = in;
while (*in && *in != '"') in++;
if (*in == '"') {
*in = '\0';
in++;
}
}
else {
argv[n++] = in;
while (*in && !isspace(*in)) {
in++;
}
if (*in != '\0') {
*in++ = '\0';
}
}
}
}
// printf("%s\n", *_query);
// redisReply *reply = (redisReply *)redisCommand(c, *_query);
redisReply *reply = (redisReply *)redisCommandArgv(c, argc, (const char **)argv, NULL);
free(argstr);
return Opaque::New(reply);
}
long long _do_redis_command( const char ** args,const size_t * argvlen, size_t arg_count) {
pthread_mutex_lock(&sredisContext_mutex);
redisContext *c = NULL;
redisReply *reply;
c = (redisContext*)_redis_context_init();
if (!c) {
info_print("_redis_context_init return null, connect failed\n");
pthread_mutex_unlock(&sredisContext_mutex);
return -1;
}
debug_print("%s %s %s\n",args[0] ,args[1],args[2]);
reply = redisCommandArgv(c,arg_count,args,argvlen);
if(!reply) {
c = (redisContext*)_redis_context_reinit();
if (!c) {
info_print("_do_redis_command, Cannot reconnect to redis\n ");
pthread_mutex_unlock(&sredisContext_mutex);
return -1;
}
reply = redisCommandArgv(c,arg_count,args,argvlen);
if (!reply) {
info_print("_do_redis_command, reconnect to redis and re-execute redisCommandArgv failed\n ");
pthread_mutex_unlock(&sredisContext_mutex);
return -1;
}
}
if(reply) {
freeReplyObject(reply);
}
pthread_mutex_unlock(&sredisContext_mutex);
return 0;
}
/*
* Query the redis database
*/
int rlm_redis_query(REDISSOCK **dissocket_p, REDIS_INST *inst,
const char *query, REQUEST *request)
{
REDISSOCK *dissocket;
int argc;
const char *argv[MAX_REDIS_ARGS];
char argv_buf[MAX_QUERY_LEN];
if (!query || !*query || !inst || !dissocket_p) {
return -1;
}
argc = rad_expand_xlat(request, query, MAX_REDIS_ARGS, argv, 0,
sizeof(argv_buf), argv_buf);
if (argc <= 0)
return -1;
dissocket = *dissocket_p;
DEBUG2("executing %s ...", argv[0]);
dissocket->reply = redisCommandArgv(dissocket->conn, argc, argv, NULL);
if (!dissocket->reply) {
radlog(L_ERR, "rlm_redis: (%s) REDIS error: %s",
inst->xlat_name, dissocket->conn->errstr);
dissocket = fr_connection_reconnect(inst->pool, dissocket);
if (!dissocket) {
error:
*dissocket_p = NULL;
return -1;
}
dissocket->reply = redisCommand(dissocket->conn, query);
if (!dissocket->reply) {
radlog(L_ERR, "rlm_redis (%s): failed after re-connect",
inst->xlat_name);
fr_connection_del(inst->pool, dissocket);
goto error;
}
*dissocket_p = dissocket;
}
if (dissocket->reply->type == REDIS_REPLY_ERROR) {
radlog(L_ERR, "rlm_redis (%s): query failed, %s",
inst->xlat_name, query);
return -1;
}
return 0;
}
mrb_value mrb_redis_pub(mrb_state *mrb, mrb_value self)
{
mrb_value channel, msg;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oo", &channel, &msg);
const char *argv[] = {"PUBLISH", RSTRING_PTR(channel), RSTRING_PTR(msg)};
size_t lens[] = {7, RSTRING_LEN(channel), RSTRING_LEN(msg)};
redisReply *rr = redisCommandArgv(rc, 3, argv, lens);
freeReplyObject(rr);
return self;
}
mrb_value mrb_redis_del(mrb_state *mrb, mrb_value self)
{
mrb_value key;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "o", &key);
const char *argv[] = {"DEL", RSTRING_PTR(key)};
size_t lens[] = {3, RSTRING_LEN(key)};
redisReply *rs = redisCommandArgv(rc, 2, argv, lens);
freeReplyObject(rs);
return self;
}
mrb_value mrb_redis_hset(mrb_state *mrb, mrb_value self) {
mrb_value key, field, val;
redisContext *rc = DATA_PTR(self);
mrb_int integer;
mrb_get_args(mrb, "ooo", &key, &field, &val);
const char *argv[] = {"HSET", RSTRING_PTR(key), RSTRING_PTR(field), RSTRING_PTR(val)};
size_t lens[] = {4, RSTRING_LEN(key), RSTRING_LEN(field), RSTRING_LEN(val)};
redisReply *rs = redisCommandArgv(rc, 4, argv, lens);
integer = rs->integer;
freeReplyObject(rs);
return integer ? mrb_true_value() : mrb_false_value();
}
static int lmset(lua_State *L){
int i;
struct redisContext *c = lua_touserdata(L, 1);
if(c == NULL){
LOG_ERROR("userdata is null");
return 0;
}
int argc = lua_gettop(L);
if(redis_argc < argc){
if(redis_argv != NULL){
redis_argc = 0;
free(redis_argv);
}
if(redis_argvlen != NULL){
redis_argc = 0;
free(redis_argvlen);
}
redis_argv = (char **)malloc(argc * sizeof(char *));
redis_argvlen = (size_t *)malloc(argc * sizeof(size_t));
if(!redis_argv || !redis_argvlen){
redis_argv = 0;
if(redis_argv)free(redis_argv);
if(redis_argvlen)free(redis_argvlen);
LOG_ERROR("malloc fail");
return 0;
}
redis_argc = argc;
}
redis_argv[0] = s_mset_cmd;
redis_argvlen[0] = 4;
for(i = 0; i < (argc - 1)/2; i++){
size_t k_len = 0;
size_t v_len = 0;
const char *k = (const char *)lua_tolstring(L, (i*2) + 2, &k_len);
const char *v = (const char *)lua_tolstring(L, (i*2) + 3, &v_len);
redis_argv[(2*i)+1] = (char *)k;
redis_argvlen[(2*i)+1] = k_len;
redis_argv[(2*i)+2] = (char *)v;
redis_argvlen[(2*i)+2] = v_len;
}
redisReply * reply = (redisReply *)redisCommandArgv(c, argc, (const char **)redis_argv, redis_argvlen);
if(reply == NULL){
LOG_ERROR("MSET FAIL");
return 0;
}
getCallback_push_reply(L, reply);
freeReplyObject(reply);
return 1;
}
mrb_value mrb_redis_zscore(mrb_state *mrb, mrb_value self)
{
mrb_value key, member, score;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oo", &key, &member);
const char *argv[] = {"ZSCORE", RSTRING_PTR(key), RSTRING_PTR(member)};
size_t lens[] = {6, RSTRING_LEN(key), RSTRING_LEN(member)};
redisReply *rr = redisCommandArgv(rc, 3, argv, lens);
score = mrb_str_new(mrb, rr->str, rr->len);
freeReplyObject(rr);
return score;
}
mrb_value mrb_redis_hdel(mrb_state *mrb, mrb_value self) {
mrb_value key, val;
mrb_int integer;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oo", &key, &val);
const char *argv[] = {"HDEL", RSTRING_PTR(key), RSTRING_PTR(val)};
size_t lens[] = {4, RSTRING_LEN(key), RSTRING_LEN(val)};
redisReply *rr = redisCommandArgv(rc, 3, argv, lens);
integer = rr->integer;
freeReplyObject(rr);
return mrb_fixnum_value(integer);
}
mrb_value mrb_redis_set(mrb_state *mrb, mrb_value self)
{
mrb_value key, val;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oo", &key, &val);
const char *argv[] = {"SET", RSTRING_PTR(key), RSTRING_PTR(val)};
size_t lens[] = {3, RSTRING_LEN(key), RSTRING_LEN(val)};
redisReply *rs = redisCommandArgv(rc, 3, argv, lens);
freeReplyObject(rs);
return self;
}
mrb_value mrb_redis_zadd(mrb_state *mrb, mrb_value self)
{
mrb_value key, member;
mrb_float score;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "ofo", &key, &score, &member);
mrb_value score_str = mrb_float_to_str(mrb, mrb_float_value(mrb, score), "%f");
const char *argv[] = {"ZADD", RSTRING_PTR(key), RSTRING_PTR(score_str), RSTRING_PTR(member)};
size_t lens[] = {4, RSTRING_LEN(key), RSTRING_LEN(score_str), RSTRING_LEN(member)};
redisReply *rs = redisCommandArgv(rc, 4, argv, lens);
freeReplyObject(rs);
return self;
}
mrb_value mrb_redis_ttl(mrb_state *mrb, mrb_value self)
{
mrb_value key;
redisContext *rc = DATA_PTR(self);
mrb_int integer;
mrb_get_args(mrb, "o", &key);
const char *argv[] = {"TTL", RSTRING_PTR(key)};
size_t lens[] = {3, RSTRING_LEN(key)};
redisReply *rr = redisCommandArgv(rc, 2, argv, lens);
integer = rr->integer;
freeReplyObject(rr);
return mrb_fixnum_value(integer);
}
mrb_value mrb_redis_exists(mrb_state *mrb, mrb_value self)
{
mrb_value key;
mrb_int counter;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "o", &key);
const char *argv[] = {"EXISTS", RSTRING_PTR(key)};
size_t lens[] = {6, RSTRING_LEN(key)};
redisReply *rr = redisCommandArgv(rc, 2, argv, lens);
counter = rr->integer;
freeReplyObject(rr);
return counter ? mrb_true_value() : mrb_false_value();
}
mrb_value mrb_redis_basic_zrank(mrb_state *mrb, mrb_value self, const char* cmd)
{
mrb_value key, member;
mrb_int rank;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oo", &key, &member);
const char *argv[] = {cmd, RSTRING_PTR(key), RSTRING_PTR(member)};
size_t lens[] = {strlen(cmd), RSTRING_LEN(key), RSTRING_LEN(member)};
redisReply *rr = redisCommandArgv(rc, 3, argv, lens);
rank = rr->integer;
freeReplyObject(rr);
return mrb_fixnum_value(rank);
}
mrb_value mrb_redis_expire(mrb_state *mrb, mrb_value self)
{
mrb_value key;
mrb_int expire, counter;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oi", &key, &expire);
mrb_value val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(expire), 10);
const char *argv[] = {"EXPIRE", RSTRING_PTR(key), RSTRING_PTR(val)};
size_t lens[] = {6, RSTRING_LEN(key), RSTRING_LEN(val)};
redisReply *rr = redisCommandArgv(rc, 3, argv, lens);
counter = rr->integer;
freeReplyObject(rr);
return mrb_bool_value(counter == 1);
}
mrb_value mrb_redis_decrby(mrb_state *mrb, mrb_value self)
{
mrb_value key;
mrb_int val, counter;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oi", &key, &val);
mrb_value val_str = mrb_fixnum_to_str(mrb, mrb_fixnum_value(val), 10);
const char *argv[] = {"DECRBY", RSTRING_PTR(key), RSTRING_PTR(val_str)};
size_t lens[] = {6, RSTRING_LEN(key), RSTRING_LEN(val_str)};
redisReply *rr = redisCommandArgv(rc, 3, argv, lens);
counter = rr->integer;
freeReplyObject(rr);
return mrb_fixnum_value(counter);
}
SEXP redux_redis_unsubscribe(SEXP extPtr, SEXP channel, SEXP pattern) {
redisContext *context = redis_get_context(extPtr, CLOSED_ERROR);
// Issue the unsubscribe command:
const int p = INTEGER(pattern)[0];
SEXP cmd = PROTECT(allocVector(VECSXP, 2));
SET_VECTOR_ELT(cmd, 0, mkString(p ? "PUNSUBSCRIBE" : "UNSUBSCRIBE"));
SET_VECTOR_ELT(cmd, 1, channel);
cmd = PROTECT(redis_check_command(cmd));
// Arrange the command:
const char **argv = NULL;
size_t *argvlen = NULL;
const size_t argc = sexp_to_redis(cmd, &argv, &argvlen);
// Issue the unsubscribe request:
redisReply *reply = redisCommandArgv(context, argc, argv, argvlen);
// Then loop until the reply looks correct.
int n_discarded = 0;
while (1) {
if (reply == NULL) {
// Here, we probably should consider destroying the client as
// there is no API way of ensuring that the responses are dealt
// with.
//
// This needs testing with toxiproxy.
error("Redis connection error: client likely in awkward spot");
}
// This is possibly over-cautious, but it doesn't really hurt.
if (reply->type == REDIS_REPLY_ARRAY && reply->elements == 3) {
redisReply *reply0 = reply->element[0];
if (reply0->type == REDIS_REPLY_STRING &&
strcmp(reply0->str, p ? "punsubscribe" : "unsubscribe") == 0) {
break;
}
}
freeReplyObject(reply);
reply = NULL;
n_discarded++;
redisGetReply(context, (void*)&reply);
}
SEXP ret = PROTECT(redis_reply_to_sexp(reply, REPLY_ERROR_THROW));
freeReplyObject(reply);
if (n_discarded > 0) {
setAttrib(ret, mkString("n_discarded"), ScalarInteger(n_discarded));
}
UNPROTECT(3);
return ret;
}
mrb_value mrb_redis_ltrim(mrb_state *mrb, mrb_value self)
{
mrb_value list;
mrb_int arg1, arg2, integer;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oii", &list, &arg1, &arg2);
mrb_value val_str1 = mrb_fixnum_to_str(mrb, mrb_fixnum_value(arg1), 10);
mrb_value val_str2 = mrb_fixnum_to_str(mrb, mrb_fixnum_value(arg2), 10);
const char *argv[] = {"LTRIM", RSTRING_PTR(list), RSTRING_PTR(val_str1), RSTRING_PTR(val_str2)};
size_t lens[] = {6, RSTRING_LEN(list), RSTRING_LEN(val_str1), RSTRING_LEN(val_str2)};
redisReply *rr = redisCommandArgv(rc, 4, argv, lens);
integer = rr->integer;
freeReplyObject(rr);
return mrb_fixnum_value(integer);
}
mrb_value mrb_redis_hget(mrb_state *mrb, mrb_value self) {
mrb_value key, field;
char *val;
int len;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "oo", &key, &field);
const char *argv[] = {"HGET", RSTRING_PTR(key), RSTRING_PTR(field)};
size_t lens[] = {4, RSTRING_LEN(key), RSTRING_LEN(field)};
redisReply *rs = redisCommandArgv(rc, 3, argv, lens);
if (rs->type == REDIS_REPLY_STRING) {
val = malloc((rs->len + 1) * sizeof(char));
memcpy(val, rs->str, (rs->len + 1) * sizeof(char));
len = rs->len;
freeReplyObject(rs);
return mrb_str_new(mrb, val, len);
} else {
freeReplyObject(rs);
return mrb_nil_value();
}
}
int RedisCli::_doExeCmdNoReconnect(Replyer &rpler, int argc, const char **argv,
const size_t *argvLen)
{
redisReply *tmpReply = (redisReply *)redisCommandArgv(m_c, argc, argv, argvLen);
if (tmpReply == NULL) {
disconnect();
return -1;
}
if (m_c->err) {
disconnect();
return -3;
}
//logic error, do not disconnect it!
if (tmpReply->type == REDIS_REPLY_ERROR) {
freeReplyObject(tmpReply);
return -4;
}
rpler.setReply(tmpReply);
return 0;
}
mrb_value mrb_redis_hkeys(mrb_state *mrb, mrb_value self)
{
mrb_value key, array = mrb_nil_value();
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "o", &key);
const char *argv[] = {"HKEYS", RSTRING_PTR(key)};
size_t lens[] = {5, RSTRING_LEN(key)};
redisReply *rr = redisCommandArgv(rc, 2, argv, lens);
if (rr->type == REDIS_REPLY_ARRAY) {
if (rr->elements > 0) {
int i;
array = mrb_ary_new(mrb);
for (i = 0; i < rr->elements; i++) {
mrb_ary_push(mrb, array, mrb_str_new(mrb, rr->element[i]->str, rr->element[i]->len));
}
}
}
freeReplyObject(rr);
return array;
}
mrb_value mrb_redis_lpop(mrb_state *mrb, mrb_value self)
{
char *val;
int len;
mrb_value key;
redisContext *rc = DATA_PTR(self);
mrb_get_args(mrb, "o", &key);
const char *argv[] = {"LPOP", RSTRING_PTR(key)};
size_t lens[] = {4, RSTRING_LEN(key)};
redisReply *rr = redisCommandArgv(rc, 2, argv, lens);
if (rr->type == REDIS_REPLY_STRING) {
val = malloc((rr->len + 1) * sizeof(char));
memcpy(val, rr->str, (rr->len + 1) * sizeof(char));
len = rr->len;
freeReplyObject(rr);
return mrb_str_new(mrb, val, len);
} else {
freeReplyObject(rr);
return mrb_nil_value();
}
}
bool cmd(int _argc,const char**_argv,listStr & _list)
{
_list.clear();
size_t *_argv_len=new size_t[_argc+1];
for(int i=0;i<_argc;i++)
_argv_len[i]=strlen(_argv[i]);
this->_reply = (redisReply*)redisCommandArgv(this->_connect,_argc+1,_argv,_argv_len);
delete []_argv_len;
do
{
if(this->_reply)
{
if(REDIS_REPLY_ERROR == _reply->type)
break;
parse_reply(this->_reply,_list);
freeReplyObject(this->_reply);
this->_reply=NULL;
return true;
}
}while(0);
std::cout<<"ERR::"<<_connect->err<<std::endl;
false;;
}
void rddRedisDelete(redisContext*rd,char*rdd)
{ u32 nb=0;
char **keys = rddGetAllKeys(rdd,&nb);
int argnb = nb+1;
const char ** cargv = (const char**) malloc( argnb*(sizeof(char*)) );
size_t *cargl = (size_t*)malloc( argnb*(sizeof(size_t*)) );
cargv[0] = "DEL";
cargl[0] = 3;
for(u32 c=0; c<nb; c++)
{ char*n = (keys[c])+12;
cargv[c+1] = n;
cargl[c+1] = strlen(n);
}
redisReply * reply = redisCommandArgv(rd, argnb, cargv, cargl);
//printf("%i keys where removed from redis.\n",reply->integer);
free(cargv);
free(cargl);
free(keys);
}
void *db_redis_command_argv(km_redis_con_t *con, redis_key_t *query) {
char **argv = NULL;
int argc;
print_query(query);
argc = db_redis_key_list2arr(query, &argv);
if (argc < 0) {
LM_ERR("Failed to allocate memory for query array\n");
return NULL;
}
LM_DBG("query has %d args\n", argc);
redisReply *reply = redisCommandArgv(con->con, argc, (const char**)argv, NULL);
if (con->con->err == REDIS_ERR_EOF) {
if (db_redis_connect(con) != 0) {
LM_ERR("Failed to reconnect to redis db\n");
pkg_free(argv);
if (con->con) {
redisFree(con->con);
con->con = NULL;
}
return NULL;
}
reply = redisCommandArgv(con->con, argc, (const char**)argv, NULL);
}
pkg_free(argv);
return reply;
}