static ERL_NIF_TERM
put(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
redisContext *c;
redisReply *reply = NULL;
ErlNifBinary bucket, key, uid, world, val;
if (!enif_inspect_binary(env, argv[0], &bucket)) return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[1], &key)) return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[2], &world)) return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[3], &uid)) return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[4], &val)) return enif_make_badarg(env);
c = redisConnectUnix((const char*)"/tmp/redis.sock");
if (c->err) {
return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "redis_connection_error"));
}
redisAppendCommand(c, "MULTI");
redisAppendCommand(c, "SET %b %b", uid.data, uid.size, val.data, val.size);
redisAppendCommand(c, "SADD %b %b", bucket.data, bucket.size, key.data, key.size);
redisAppendCommand(c, "SADD %b %b", world.data, world.size, bucket.data, bucket.size);
redisAppendCommand(c, "EXEC");
for (int i=0; i<6; i++) {
redisReply *reply = NULL;
redisGetReply(c, (void **) &reply);
free(reply);
}
redisFree(c);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_atom(env, "put"));
}
void cm_dig(evhtp_request_t *req, void *arg) {
enum {
err_param = -1,
err_db = -2,
};
int err = 0;
int x = kvs_find_int32(&err, req->uri->query, "x");
int y = kvs_find_int32(&err, req->uri->query, "y");
if (err) {
return cm_send_error(err_param, req);
}
if (x < 0 || x >= CELL_MAX || y < 0 || y >= CELL_MAX) {
return cm_send_error(err_param, req);
}
int undig = kvs_find_int32(&err, req->uri->query, "undig");
int blockX = x/CELLS_PER_BLOCK_SIDE;
int blockY = y/CELLS_PER_BLOCK_SIDE;
int idx = (y%CELLS_PER_BLOCK_SIDE)*CELLS_PER_BLOCK_SIDE+(x%CELLS_PER_BLOCK_SIDE);
redisContext *redis = cm_get_context()->redis;
if (redis->err) {
return cm_send_error(err_db, req);
}
if (undig)
redisAppendCommand(redis, "SETBIT block:%u,%u %u 0", blockX, blockY, idx);
else
redisAppendCommand(redis, "SETBIT block:%u,%u %u 1", blockX, blockY, idx);
redisAppendCommand(redis, "GET block:%u,%u", blockX, blockY);
redisReply *reply;
redisGetReply(redis, (void**)&reply);
freeReplyObject(reply);
redisGetReply(redis, (void**)&reply);
char buf[CELLS_PER_BLOCK_SIDE*CELLS_PER_BLOCK_SIDE/8] = {0};
if (reply->type == REDIS_REPLY_STRING && reply->len <= (int)sizeof(buf)) {
memcpy(buf, reply->str, reply->len);
char *b64 = base64_cf(buf, sizeof(buf));
evbuffer_add_printf(req->buffer_out, "{\"error\":0, \"data\":\"%s\"}", b64);
evhtp_send_reply(req, EVHTP_RES_OK);
free(b64);
} else {
cm_send_error(err_db, req);
}
freeReplyObject(reply);
}
static int redis_push(char *redisqueuename,
void *buf, int num, size_t len, const char *cmd)
{
assert(rctx);
for (int i=0; i < num; i++) {
void* load = (void*)((intptr_t)buf + i*len);
int rc = redisAppendCommand(rctx, "%s %s %b",
cmd, redisqueuename, load, len);
if (rc != REDIS_OK || rctx->err) {
log_fatal("redis", "%s", rctx->errstr);
return -1;
}
}
redisReply *reply;
for (int i=0; i < num; i++) {
if (redisGetReply(rctx, (void**) &reply) != REDIS_OK
|| rctx->err) {
log_fatal("redis","%s", rctx->errstr);
return -1;
}
if (reply->type == REDIS_REPLY_ERROR) {
log_fatal("redis", "%s", rctx->errstr);
return -1;
}
freeReplyObject(reply);
}
return 0;
}
int send_commands(std::vector<std::string> cmds, std::vector<std::string> times, Json::Value &json_data) {
redisContext *rc = redisConnect("localhost", 6379);
for(size_t i=0;i<cmds.size();i++) {
redisAppendCommand(rc, cmds[i].c_str());
}
for(size_t i=0;i<cmds.size();i++) {
redisReply *reply;
redisGetReply(rc, (void **)&reply);
if(reply->type == REDIS_REPLY_ERROR) {
LOG_WARN("redis return error which msg:%s", reply->str);
continue;
}
int pv_value = reply->type == REDIS_REPLY_NIL ? 0 : atoi(reply->str);
Json::ArrayIndex index = (Json::ArrayIndex) i;
json_data[index]["unit"] = times[i];
json_data[index]["value"] = pv_value;
LOG_DEBUG("start_time:%s, pv:%d", times[i].c_str(), pv_value);
if(reply != NULL) {
freeReplyObject(reply);
}
}
redisFree(rc);
return 0;
}
int AdRedisCli::AdRedisArrayHGetAll( vector<string>& vStr, vector<map<int, int> > & vValue)
{
unsigned int i = 0;
unsigned int j = 0;
redisReply *reply = NULL;
vector<string>::iterator iter;
//append cmd
for(iter = vStr.begin(); iter != vStr.end(); iter ++)
{
if (REDIS_OK != redisAppendCommand( m_pGtCli, "HGETALL %s", (*iter).c_str() ))
return AD_FAILURE;
}
for(j = 0; j < vStr.size(); j ++)
{
if (REDIS_OK != redisGetReply(m_pGtCli, (void**)&reply))
{
return AD_FAILURE;
}
if ( reply->type == REDIS_REPLY_ARRAY )
{
for ( i = 0; i < reply->elements; i+=2 )
{
vValue[j][atoi(reply->element[i]->str)] = atoi(reply->element[i + 1]->str) ;
}
}
freeReplyObject(reply);
}
return AD_SUCCESS;
}
static int redis_push_strings(redisContext* rctx, char *redisqueuename,
char **buf, int num, const char *cmd)
{
assert(rctx);
for (int i = 0; i < num; i++) {
int rc = redisAppendCommand(rctx, "%s %s %s", cmd, redisqueuename, buf[i]);
if (rc != REDIS_OK || rctx->err) {
log_error("redis", "%s", rctx->errstr);
return ZMAP_REDIS_ERROR;
}
}
redisReply *reply = NULL;
for (int i = 0; i < num; i++) {
if (redisGetReply(rctx, (void**) &reply) != REDIS_OK || rctx->err) {
log_error("redis", "%s", rctx->errstr);
if (reply) {
freeReplyObject(reply);
}
return ZMAP_REDIS_ERROR;
}
if (reply->type == REDIS_REPLY_ERROR) {
log_error("redis", "%s", rctx->errstr);
freeReplyObject(reply);
return ZMAP_REDIS_ERROR;
}
freeReplyObject(reply);
}
return ZMAP_REDIS_SUCCESS;
}
static int redis_push(redisContext* rctx, char *redisqueuename,
void *buf, int num, size_t len, const char *cmd)
{
assert(rctx);
for (int i=0; i < num; i++) {
void* load = (void*)((intptr_t)buf + i*len);
int rc = redisAppendCommand(rctx, "%s %s %b",
cmd, redisqueuename, load, len);
if (rc != REDIS_OK || rctx->err) {
log_error("redis", "%s", rctx->errstr);
return ZMAP_REDIS_ERROR;
}
}
redisReply *reply = NULL;
for (int i = 0; i < num; i++) {
int rc = redisGetReply(rctx, (void**) &reply);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
if (rc != REDIS_OK || reply == NULL) {
if (reply) {
freeReplyObject(reply);
}
return ZMAP_REDIS_ERROR;
}
if (reply->type == REDIS_REPLY_ERROR) {
log_error("redis", "%s", rctx->errstr);
freeReplyObject(reply);
return ZMAP_REDIS_ERROR;
}
freeReplyObject(reply);
}
return ZMAP_REDIS_SUCCESS;
}
int check(pyrebloomctxt * ctxt, const char * data, uint32_t len) {
uint32_t i;
for (i = 0; i < ctxt->hashes; ++i) {
redisAppendCommand(ctxt->ctxt, "GETBIT %s %d", ctxt->key, hash(data, len, ctxt->seeds[i], ctxt->bits));
}
return 1;
}
void setCacheNumKeyMixedValueQuad(const char *prefix,
u_int16_t id,
const u_int32_t key0, const char* value0,
const u_int32_t key1, const char* value1,
const u_int32_t key2, const u_int32_t value2,
const u_int32_t key3, const u_int32_t value3) {
#ifdef HAVE_REDIS
if(readOnlyGlobals.redis.use_nutcracker) {
setCacheKeyValueNumberString(prefix, id, key0, value0);
setCacheKeyValueNumberString(prefix, id, key1, value1);
setCacheKeyValueNumberNumber(prefix, id, key2, value2);
setCacheKeyValueNumberNumber(prefix, id, key3, value3);
} else {
if(readOnlyGlobals.redis.write_context[id]) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug))
traceEvent(TRACE_NORMAL, "[Redis] MSET %s%u %s %s%u %s %s%u %u %s%u %u",
prefix, key0, value0, prefix, key1, value1,
prefix, key2, value2, prefix, key3, value3);
redisAppendCommand(readOnlyGlobals.redis.write_context[id],
"MSET %s%u \"%s\" %s%u \"%s\" %s%u %u %s%u %u",
prefix, key0, value0, prefix, key1, value1,
prefix, key2, value2, prefix, key3, value3);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
}
#endif
}
int main () {
printf("Connecting...\n");
redisContext *redis = redisConnect("localhost", 6379);
if(redis->err) {
puts(redis->errstr);
char *p = redis->errstr;
while(*p) {
printf("%x ", (int) (*p++));
}
printf("\n");
} else {
puts("Connected!");
// void *redisCommand(redisContext *c, const char *format, ...);
for(int i = 0; i < N; i++) {
redisAppendCommand(redis,"SET foo bar");
}
for(int i = 0; i < N; i++) {
redisReply *reply;
redisGetReply(redis, (void**) &reply); // reply for SET
freeReplyObject(reply);
}
puts("Done");
}
}
int DRedisConnection::append_cmd(const char* cmd) {
if(!redis_context) {
ERROR("REDIS append cmd '%s': not connected",cmd);
return DB_E_CONNECTION;
}
return redisAppendCommand(redis_context, cmd) == REDIS_OK ?
DB_E_OK : DB_E_CONNECTION;
}
int add(pyrebloomctxt * ctxt, const char * data, uint32_t len) {
uint32_t i;
for (i = 0; i < ctxt->hashes; ++i) {
uint32_t d = hash(data, len, ctxt->seeds[i], ctxt->bits);
redisAppendCommand(ctxt->ctxt, "SETBIT %s %d 1", ctxt->key, d);
}
return 1;
}
int deleteCacheNumKey(const char *prefix, u_int16_t id, const u_int32_t key, const u_int32_t delete_delay_sec) {
#ifdef HAVE_REDIS
if(readOnlyGlobals.redis.write_context[id]) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug)) traceEvent(TRACE_NORMAL, "[Redis] EXPIRE %s%u %d", prefix, key, delete_delay_sec);
if(delete_delay_sec > 0)
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "EXPIRE %s%u %d", prefix, key, delete_delay_sec);
else
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "DEL %s%u", prefix, key);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
#endif
return(0);
}
void RedisCon::append(const std::string& cmd)
{
int ret = redisAppendCommand(connect_.get(), cmd.c_str());
if (ret != REDIS_OK) {
throw redis_transport_except(connect_->errstr);
}
}
std::vector<RedisReply> RedisCon::pipelining(const std::vector<std::string> cmds)
{
//send all commands
for (auto& i: cmds) {
redisAppendCommand(connect_.get(), i.c_str());
}
return std::move(getReply(cmds.size()));
}
void Server::doOfflineGroupMsg(shared_ptr<IMChat::MsgData> ptrMsg , const string& serializaStr)
{
m_mutex.lock();
//未读消息长度;
int nGroupMsgLen = 0;
auto ptrContext = m_redis.GetContext();
redisReply* ptrReply = NULL;
string keyGroupMsgList("groupMsg:");
keyGroupMsgList += ptrMsg->toid();
//从左边入列表存储二进制数据;
ptrReply = static_cast<redisReply*>(redisCommand(ptrContext, "LPUSH %s %b", keyGroupMsgList.c_str(), serializaStr.c_str(), serializaStr.size()));
if (NULL != ptrReply && REDIS_REPLY_INTEGER == ptrReply->type)
{
nGroupMsgLen = ptrReply->integer;
}
freeReplyObject(ptrReply);
//只保存99条消息;如果超过截取后面99条;
if (nGroupMsgLen > 99)
{
ptrReply = static_cast<redisReply*>(redisCommand(ptrContext, "LTRIM %s %d %d", keyGroupMsgList.c_str(), 0, 99));
freeReplyObject(ptrReply);
}
//对于没有在线的用户, Key unread:groupid:userid +1;
string onlineKey("onlineGroup:");
string groupMemberKey("groupMember:");
onlineKey += ptrMsg->toid();
groupMemberKey += ptrMsg->toid();
//返回一个集合的全部成员，该集合是所有给定集合之间的差集。;第一个集合与其他集合的差集;
vector<string> vecRes;
ptrReply = static_cast<redisReply*>(redisCommand(ptrContext, "SDIFF %s %s", groupMemberKey.c_str(), onlineKey.c_str()));
if (NULL != ptrReply && REDIS_REPLY_ARRAY == ptrReply->type && 0 != ptrReply->elements)
{
for (size_t i = 0; i < ptrReply->elements; i++)
vecRes.push_back(ptrReply->element[i]->str);
}
freeReplyObject(ptrReply);
//pipeline
//Key unreadNumber : userid : groupid ;+ 1;方便查询数据;
for (size_t i = 0; i < vecRes.size(); i++)
{
string key("unreadNumber:");
key += vecRes[i];
key += ':';
key += ptrMsg->toid();
redisAppendCommand(ptrContext, "INCR %s", key.c_str());
}
for (size_t i = 0; i < vecRes.size(); i++)
{
redisGetReply(ptrContext, reinterpret_cast<void**>(&ptrReply)); // reply for SET
freeReplyObject(ptrReply);
}
m_mutex.unlock();
}
int check(pyrebloomctxt *ctxt, const char *data, uint32_t data_size)
{
for (uint32_t i = 0; i < ctxt->hashes; ++i) {
uint64_t d = hash(data, data_size, ctxt->seeds[i], ctxt->bits);
redisAppendCommand(ctxt->ctxt, "GETBIT %s %lu",
ctxt->keys[d / max_bits_per_key], d % max_bits_per_key);
}
return PYREBLOOM_OK;
}
void setCacheKeyValueNumberNumber(const char *prefix, u_int16_t id, const u_int32_t key, const u_int32_t value) {
#ifdef HAVE_REDIS
if(readOnlyGlobals.redis.write_context[id]) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug)) traceEvent(TRACE_NORMAL, "[Redis] SET %s%u %u", prefix, key, value);
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "SET %s%u %u", prefix, key, value);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
#endif
}
bool RedisDriver::AppendQuery(const char* pCmd, uint16_t& nCmdCount)
{
assert(m_pContext != NULL);
if (redisAppendCommand(m_pContext, pCmd) != REDIS_OK)
{
DumpReplyErr();
return false;
}
nCmdCount++;
return true;
}
void expireCacheKey(const char *prefix, u_int16_t id, const char *key, u_int32_t duration_sec) {
#ifdef HAVE_REDIS
if(readOnlyGlobals.redis.write_context[id]) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug)) traceEvent(TRACE_NORMAL, "[Redis] EXPIRE %s%s %u", prefix, key, duration_sec);
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "EXPIRE %s%s %u", prefix, key, duration_sec);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
#endif
}
void setCacheHashKeyValueString(const char *element, u_int16_t id, const char *key, const char *value) {
#ifdef HAVE_REDIS
if(readOnlyGlobals.redis.write_context[id]) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug)) traceEvent(TRACE_NORMAL, "[Redis] HSET %s %s %s", element, key, value);
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "HSET %s %s %s", element, key, value);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
#endif
}
void zIncrCacheHashKeyValueNumber(const char *set_name,
u_int16_t id, const char *key, const u_int64_t value) {
#ifdef HAVE_REDIS
if(readOnlyGlobals.redis.write_context[id] && (value > 0)) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug)) traceEvent(TRACE_NORMAL, "[Redis] ZINCRBY %s %llu %s", set_name, value, key);
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "ZINCRBY %s %llu %s", set_name, value, key);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
#endif
}
void publishKeyValueString(const char *prefix, u_int16_t id, const char *key, const char *value) {
#ifdef HAVE_REDIS
if(!readOnlyGlobals.redis.use_nutcracker) {
if(readOnlyGlobals.redis.write_context[id]) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug)) traceEvent(TRACE_NORMAL, "[Redis] PUBLISH %s%s %s", prefix, key, value);
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "PUBLISH %s%s %s", prefix, key, value);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
}
#endif
}
/* Redis does not accept expire time */
int deleteCacheStrKeyTwin(const char *prefix, u_int16_t id, const char *key1, const char *key2) {
#ifdef HAVE_REDIS
if(readOnlyGlobals.redis.write_context[id]) {
pthread_rwlock_wrlock(&readOnlyGlobals.redis.lock_set_delete[id]);
if(unlikely(readOnlyGlobals.enable_debug)) traceEvent(TRACE_NORMAL, "[Redis] DEL %s%s %s%s", prefix, key1, prefix, key2);
redisAppendCommand(readOnlyGlobals.redis.write_context[id], "DEL %s%s %s%s", prefix, key1, prefix, key2);
incrementQueueStats(id);
pthread_rwlock_unlock(&readOnlyGlobals.redis.lock_set_delete[id]);
}
#endif
return(0);
}
int RedisGetExecRowId(redisContext *c, char* Channel,int Multi)
{
char RedisCommandBuffer[REDISCOMMAND_MAX_LEN];
redisReply *reply;
int ExecRowId;
sprintf(RedisCommandBuffer,"INCRBY %s:nextid %i",Channel,Multi);
redisAppendCommand(c,RedisCommandBuffer);
redisGetReply(c,(void**)&reply);
if ( reply->type != REDIS_REPLY_INTEGER )
{
fprintf(stderr,"Error during fetching next Redis ID\n%s\n",c->errstr);
exit(1);
}
ExecRowId = reply->integer;
freeReplyObject(reply);
return (ExecRowId);
}
int redis_pull(redisContext* rctx, char *redisqueuename, void *buf,
int maxload, size_t obj_size, int *numloaded, const char* cmd)
{
assert(rctx);
long elems_in_redis = redis_get_sizeof_list(rctx, redisqueuename);
long num_to_add = MIN(elems_in_redis, maxload);
log_debug("redis", "redis load called on %s. Transferring %li of %li elements "
"to in-memory queue.",
redisqueuename, num_to_add, elems_in_redis);
for (int i = 0; i < num_to_add; i++) {
redisAppendCommand(rctx, "%s %s", cmd, redisqueuename);
}
for (int i = 0; i < num_to_add; i++) {
redisReply *reply = NULL;
int rc = redisGetReply(rctx, (void **) &reply);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
if (rc != REDIS_OK || reply == NULL) {
log_error("redis", "unknown error, could not get reply");
if (reply) {
freeReplyObject(reply);
}
return ZMAP_REDIS_ERROR;
}
if (reply->type != REDIS_REPLY_STRING) {
log_error("redis", "unxpected reply type from redis");
freeReplyObject(reply);
return ZMAP_REDIS_ERROR;
}
if ((size_t) reply->len != obj_size) {
freeReplyObject(reply);
log_error("redis", "response object length mismatch");
return ZMAP_REDIS_ERROR;
}
memcpy((void*)((intptr_t)buf+i*obj_size), reply->str, obj_size);
freeReplyObject(reply);
*numloaded = i + 1;
}
return ZMAP_REDIS_SUCCESS;
}
int redis_pull(char *redisqueuename, void *buf,
int maxload, size_t obj_size, int *numloaded, const char* cmd)
{
assert(rctx);
long elems_in_redis = redis_get_sizeof_list(redisqueuename);
long num_to_add = MIN(elems_in_redis, maxload);
log_info("redis", "INFO: redis load called on %s. Transfering %li "
"of %li elements to in-memory queue.",
redisqueuename,
num_to_add, elems_in_redis);
for(int i=0; i < num_to_add; i++) {
redisAppendCommand(rctx, "%s %s", cmd, redisqueuename);
}
for(int i=0; i < num_to_add; i++) {
redisReply *reply;
int rc = redisGetReply(rctx, (void**) &reply);
if (rc != REDIS_OK) {
log_fatal("redis", "response from redis != REDIS_OK");
return -1;
}
if (!reply) {
log_fatal("redis", "no reply provided by redis.");
return -1;
}
if (reply->type != REDIS_REPLY_STRING) {
log_fatal("redis",
"unxpected reply type from redis.");
return -1;
}
if ((size_t)reply->len != obj_size) {
log_fatal("redis", "ERROR: unexpected lengthed "
"object provided by redis.\n");
return -1;
}
memcpy((void*)((intptr_t)buf+i*obj_size), reply->str, obj_size);
freeReplyObject(reply);
}
*numloaded = num_to_add;
return 0;
}
int add_one(pyrebloomctxt *ctxt, const char *data, uint32_t data_size)
{
uint32_t ct = 0, total = 0, count = 1;
redisReply *reply = NULL;
for (uint32_t i = 0; i < ctxt->hashes; ++i) {
uint64_t hashed_data = hash(data, data_size, ctxt->seeds[i], ctxt->bits);
redisAppendCommand(ctxt->ctxt, "SETBIT %s %lu 1",
ctxt->keys[hashed_data / max_bits_per_key], hashed_data % max_bits_per_key);
}
for (uint32_t i = 0, ct = 0; i < ctxt->hashes; ++i) {
/* Make sure that we were able to read a reply. Otherwise, provide
* an error response */
if (redisGetReply(ctxt->ctxt, (void**)(&reply)) == REDIS_ERR) {
strncpy(ctxt->ctxt->errstr, "No pending replies", errstr_size);
ctxt->ctxt->err = PYREBLOOM_ERROR;
return PYREBLOOM_ERROR;
}
/* Consume and read the response */
if (reply->type == REDIS_REPLY_ERROR) {
ctxt->ctxt->err = PYREBLOOM_ERROR;
strncpy(ctxt->ctxt->errstr, reply->str, errstr_size);
} else {
ct += reply->integer;
}
freeReplyObject(reply);
}
if (ct == ctxt->hashes) {
total = 1;
}
if (ctxt->ctxt->err == PYREBLOOM_ERROR) {
return PYREBLOOM_ERROR;
}
return count - total;
}
/** Change the state of a connection to READONLY execute a command and switch to READWRITE
*
* @param[out] status_out Where to write the status from the command.
* @param[out] reply_out Where to write the reply associated with the highest priority status.
* @param[in] request The current request.
* @param[in] conn to issue commands with.
* @param[in] argc Redis command argument count.
* @param[in] argv Redis command arguments.
* @return
* - 0 success.
* - -1 normal failure.
* - -2 failure that may leave the connection in a READONLY state.
*/
static int redis_command_read_only(fr_redis_rcode_t *status_out, redisReply **reply_out,
REQUEST *request, fr_redis_conn_t *conn, int argc, char const **argv)
{
bool maybe_more = false;
redisReply *reply;
fr_redis_rcode_t status;
*reply_out = NULL;
redisAppendCommand(conn->handle, "READONLY");
redisAppendCommandArgv(conn->handle, argc, argv, NULL);
redisAppendCommand(conn->handle, "READWRITE");
/*
* Process the response for READONLY
*/
reply = NULL; /* Doesn't set reply to NULL on error *sigh* */
if (redisGetReply(conn->handle, (void **)&reply) == REDIS_OK) maybe_more = true;
status = fr_redis_command_status(conn, reply);
if (status != REDIS_RCODE_SUCCESS) {
REDEBUG("Setting READONLY failed");
*reply_out = reply;
*status_out = status;
if (maybe_more) {
if (redisGetReply(conn->handle, (void **)&reply) != REDIS_OK) return -1;
fr_redis_reply_free(reply);
if (redisGetReply(conn->handle, (void **)&reply) != REDIS_OK) return -1;
fr_redis_reply_free(reply);
}
return -1;
}
fr_redis_reply_free(reply);
/*
* Process the response for the command
*/
reply = NULL;
if (redisGetReply(conn->handle, (void **)&reply) == REDIS_OK) maybe_more = true;
status = fr_redis_command_status(conn, reply);
if (status != REDIS_RCODE_SUCCESS) {
*reply_out = reply;
*status_out = status;
if (maybe_more) {
if (redisGetReply(conn->handle, (void **)&reply) != REDIS_OK) return -1;
fr_redis_reply_free(reply);
}
return -1;
}
*reply_out = reply;
*status_out = status;
/*
* Process the response for READWRITE
*/
reply = NULL;
status = fr_redis_command_status(conn, reply);
if ((redisGetReply(conn->handle, (void **)&reply) != REDIS_OK) || (status != REDIS_RCODE_SUCCESS)) {
REDEBUG("Setting READWRITE failed");
fr_redis_reply_free(*reply_out);
*reply_out = reply;
*status_out = status;
return -2;
}
return 0;
}
bool QTSServerInterface::RedisInit()//连接redis成功之后调用该函数执行一些初始化的工作
{
//每一次与redis连接后，都应该清除上一次的数据存储，使用覆盖或者直接清除的方式,串行命令使用管线更加高效
char chTemp[128]={0};
char chPassword[]="~ziguangwulian~iguangwulian~guangwulian~uangwulian";
do
{
//1,redis密码认证
sprintf(chTemp,"auth %s",chPassword);
if(redisAppendCommand(fRedisCon,chTemp)!=REDIS_OK)
break;
//2,CMS唯一信息存储(覆盖上一次的存储)
sprintf(chTemp,"sadd CMSName %s:%d",fCMSIP.c_str(),fCMSPort);
if(redisAppendCommand(fRedisCon,chTemp)!=REDIS_OK)
break;
//3,CMS属性存储,设置多个filed使用hmset，单个使用hset(覆盖上一次的存储)
sprintf(chTemp,"hmset %s:%d_Info IP %s PORT %d",fCMSIP.c_str(),fCMSPort,fCMSIP.c_str(),fCMSPort);
if(redisAppendCommand(fRedisCon,chTemp)!=REDIS_OK)
break;
//4,清除设备名称存储，因为连接之前和连接之后的设备可能一斤该发生了变化，因此必须先执行清楚操作
sprintf(chTemp,"del %s:%d_DevName",fCMSIP.c_str(),fCMSPort);
if(redisAppendCommand(fRedisCon,chTemp)!=REDIS_OK)
break;
OSMutex *mutexMap=fDeviceMap.GetMutex();
OSHashMap *deviceMap=fDeviceMap.GetMap();
OSRefIt itRef;
string strAllDevices;
mutexMap->Lock();
for(itRef = deviceMap->begin();itRef != deviceMap->end();itRef++)
{
strDevice *deviceInfo=(((HTTPSessionInterface*)(itRef->second->GetObjectPtr()))->GetDeviceInfo());
strAllDevices=strAllDevices+' '+deviceInfo->serial_;
}
mutexMap->Unlock();
char *chNewTemp=new char[strAllDevices.size()+128];//注意，这里不能再使用chTemp，因为长度不确定，可能导致缓冲区溢出
//5,设备名称存储
sprintf(chNewTemp,"sadd %s:%d_DevName%s",fCMSIP.c_str(),fCMSPort,strAllDevices.c_str());
if(redisAppendCommand(fRedisCon,chNewTemp)!=REDIS_OK)
{
delete[] chNewTemp;
break;
}
delete[] chNewTemp;
//6,保活，设置15秒，这之后当前CMS已经开始提供服务了
sprintf(chTemp,"setex %s:%d_Live 15 1",fCMSIP.c_str(),fCMSPort);
if(redisAppendCommand(fRedisCon,chTemp)!=REDIS_OK)
break;
bool bBreak=false;
redisReply* reply = NULL;
for(int i=0;i<6;i++)
{
if(REDIS_OK != redisGetReply(fRedisCon,(void**)&reply))
{
bBreak=true;
freeReplyObject(reply);
break;
}
freeReplyObject(reply);
}
if(bBreak)//说明redisGetReply出现了错误
break;
return true;
} while (0);
//走到这说明出现了错误，需要进行重连,重连操作再下一次执行命令时进行,在这仅仅是置标志位
redisFree(fRedisCon);
fIfConSucess=false;
return false;
}
