void test_set()
{
for (int i = 0; i < MAX_USER_NUM; i++)
{
std::ostringstream oss;
oss << "user:"******"fuckyou!\0...";
std::string key = oss.str();
std::string value(data, sizeof(data));
RedisConnectionByKey redis(key);
if (redis)
{
RedisReply::Map kvs;
kvs["value"] = value;
kvs["flag"] = boost::lexical_cast<std::string>(0);
kvs["touchtime"] = boost::lexical_cast<std::string>(time(0));
if (redis->hmset(key, kvs))
{
LOG4CXX_INFO(logger, "set " << key << " " << value.size() << " [OK]");
}
else
{
LOG4CXX_INFO(logger, "set " << key << " " << value.size() << " [FAILED]");
}
}
}
}
void redis_cmdump::get_nodes(std::vector<acl::string>& addrs)
{
acl::redis_client client(addr_, conn_timeout_, rw_timeout_);
acl::redis redis(&client);
std::vector<acl::redis_node*> nodes;
redis_util::get_nodes(redis, prefer_master_, nodes);
if (nodes.empty())
{
logger_error("nodes NULL!");
return;
}
for (std::vector<acl::redis_node*>::const_iterator cit
= nodes.begin(); cit != nodes.end(); ++cit)
{
const char* addr = (*cit)->get_addr();
if (addr == NULL || *addr == 0)
{
logger_error("addr null");
continue;
}
addrs.push_back(addr);
}
}
void* run(void)
{
acl::redis_client client(addr_, conn_timeout_, rw_timeout_);
acl::redis redis(&client);
if (redis.monitor() == false)
{
logger_error("redis monitor error: %s, addr: %s",
redis.result_error(), addr_.c_str());
return NULL;
}
acl::string buf;
while (!stopped_)
{
if (redis.get_command(buf) == false)
{
logger_error("redis get_command error: %s",
redis.result_error());
break;
}
qitem* item = new qitem(addr_, buf);
queue_.push(item);
buf.clear();
}
return NULL;
}
void redis_thread::do_win_mission(unsigned int uid)
{
myredis_helper redis(myredis_pool::instance(),
config_manager::instance()->redis_win_ip(),
config_manager::instance()->redis_win_port(),
config_manager::instance()->redis_win_db());
if(redis.is_null())
{
LOG_ERROR("%s %d", __FILE__, __LINE__);
return;
}
char key[32];
sprintf(key, "win%d_%d", config_manager::instance()->server_type(), uid);
if(redis->exists(key))
{
int out = 0;
redis->hincrby(key, "wincount", 1, &out);
}
else
{
pptr_buffer<128, 4> field;
pptr_buffer<128, 4> val;
field.add("wincount");
field.add("giftcount");
val.add("1");
val.add("0");
redis->hmset(key, field.pptr, val.pptr);
}
redis->expire(key, get_wincount_expire_time());
}
void redis_thread::do_update_count_box(unsigned int uid, int level, int seconds)
{
myredis_helper redis(myredis_pool::instance(), config_manager::instance()->redis_count_box_ip(),
config_manager::instance()->redis_count_box_port(),
config_manager::instance()->redis_count_box_db());
if(redis.is_null())
return;
char key[64];
sprintf(key, "cb_%d_%d", config_manager::instance()->server_type(), uid);
pptr_buffer<128, 4> field;
field.add("second");
field.add("level");
if(redis->exists(key))
{
pptr_buffer<128, 4> value;
char sz_seconds[64];
char sz_level[64];
sprintf(sz_seconds, "%d", seconds);
value.add(sz_seconds);
sprintf(sz_level, "%d", level);
value.add(sz_level);
redis->hmset(key, field.pptr, value.pptr);
}
}
bool redis_builder::build_master(acl::redis_node& master)
{
acl::redis_client client(master.get_addr());
acl::redis redis(&client);
if (master_set_slots(redis, master) == false)
return false;
acl::string id;
if (redis_util::get_node_id(redis, id) == false)
{
printf("%s: null id, master addr: %s\r\n",
__FUNCTION__, master.get_addr());
return false;
}
master.set_id(id.c_str());
printf("Build master: %s, %s\r\n", id.c_str(), master.get_addr());
const std::vector<acl::redis_node*>* slaves = master.get_slaves();
std::vector<acl::redis_node*>::const_iterator cit;
for (cit = slaves->begin(); cit != slaves->end(); ++cit)
{
if (add_slave(master, **cit) == false)
return false;
}
printf("Build master OK\r\n");
return true;
}
bool doMsg(std::string& reply, const std::string& msg)
{
Cmd::Set setmsg;
if (setmsg.ParseFromString(msg))
{
const std::string& key = setmsg.key();
const std::string& value = setmsg.value();
LOG4CXX_INFO(logger, "<" << pthread_self() << "> set : " << setmsg.key() << ", " << setmsg.value().size());
RedisConnectionByKey redis(key, worker->cachePool());
if (redis)
{
redis->hmset("%s value %b flag %u touchtime %u", key.c_str(),
value.data(), value.size(), 0, (unsigned int)time(0));
}
else
{
LOG4CXX_WARN(logger, "set " << key << " .. redis is not ready");
}
if (0 == s_cacheonly)
{
MySqlConnectionByKey mysql(key, worker->dbPool());
if (mysql)
{
try {
mysqlpp::Query query = mysql->query();
query.reset();
query << "replace into "
<< getKVSTableName(key)
<< "(`key`, value, flag, touchtime) values("
<< mysqlpp::quote << key << ","
<< mysqlpp::quote << value << ","
<< 0 << ","
<< time(0) << ")";
query.execute();
LOG4CXX_INFO(logger, "mysql " << key << "," << mysql->shard() << "," << getKVSTableName(key));
}
catch (std::exception& err)
{
LOG4CXX_WARN(logger, "set " << key << " .. mysql error:" << err.what());
return false;
}
}
else
{
LOG4CXX_WARN(logger, "set " << key << " .. mysql is not ready");
}
}
}
reply = "OK";
return true;
}
bool redis_builder::add_node(const char* addr,
const char* new_node_addr, bool slave)
{
acl::redis_client client(new_node_addr);
acl::redis redis(&client);
acl::string buf(addr);
const std::vector<acl::string>& tokens = buf.split2(":");
if (tokens.size() != 2)
{
printf("%s: invalid addr: %s\r\n", __FUNCTION__, addr);
return false;
}
// CLUSTER MEET master node
if (!redis.cluster_meet(tokens[0].c_str(), atoi(tokens[1].c_str())))
{
printf("%s: cluster meet %s %s error: %s\r\n", __FUNCTION__,
tokens[0].c_str(), tokens[1].c_str(),
redis.result_error());
return false;
}
// wait for the master recognizing the slave
while (true)
{
if (cluster_meeting(redis, addr) == true)
break;
acl_doze(meet_wait_);
}
if (!slave)
return true;
acl::string node_id;
if (redis_util::get_node_id(addr, node_id) == false)
{
printf("%s: can't get master(%s)'s node_id\r\n",
__FUNCTION__, addr);
return false;
}
if (redis.cluster_replicate(node_id.c_str()) == false)
{
printf("%s: cluster replicate id: %s, error: %s, "
"master_addr: %s, slave_addr: %s\r\n",
__FUNCTION__, node_id.c_str(), redis.result_error(),
addr, new_node_addr);
return false;
}
return true;
}
/**
* @brief Redis Main process
*
* @param -
*
*/
int main(int argc, char *argv[])
{
//mtrace();
int result =1;
/*Sinyal yakalama*/
signal(SIGINT, RedisSig);
redis();
return result;
}
bool redis_builder::del_node(const char* addr, const char* node_id)
{
acl::redis_client client(addr);
acl::redis redis(&client);
if (redis.cluster_forget(node_id) == false)
{
printf("%s: del node: %s error: %s, addr: %s\r\n",
__FUNCTION__, node_id, redis.result_error(), addr);
return false;
}
return true;
}
bool redis_thread::init()
{
if(!ring_buffer2_thread::init(1, 10240, 10240, 1024000, 1000))
return false;
do
{
myredis_helper redis(myredis_pool::instance(),
config_manager::instance()->redis_win_ip(),
config_manager::instance()->redis_win_port(),
config_manager::instance()->redis_win_db());
if(redis.is_null())
{
LOG_ERROR("connect reids fail %s:%d:%d",
config_manager::instance()->redis_win_ip(),
config_manager::instance()->redis_win_port(),
config_manager::instance()->redis_win_db());
return false;
}
} while (false);
do
{
myredis_helper redis(myredis_pool::instance(), config_manager::instance()->redis_count_box_ip(),
config_manager::instance()->redis_count_box_port(),
config_manager::instance()->redis_count_box_db());
if(redis.is_null())
{
LOG_ERROR("connect redis fail %s:%d:%d",
config_manager::instance()->redis_count_box_ip(),
config_manager::instance()->redis_count_box_port(),
config_manager::instance()->redis_count_box_db());
return false;
}
} while (false);
return true;
}
int main(int argc, char* argv[])
{
int ch, conn_timeout = 10, rw_timeout = 10;
acl::string addr("127.0.0.1:6379");
bool slice_req = false;
while ((ch = getopt(argc, argv, "hs:C:I:S")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'I':
rw_timeout = atoi(optarg);
break;
case 'S':
slice_req = true;
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
client.set_slice_request(slice_req);
client.set_slice_respond(false);
acl::redis_transaction redis(&client);
bool ret;
ret = test_multi(redis) && test_run_cmds(redis)
&& test_exec(redis) && get_results(redis);
printf("all cmds %s\r\n", ret ? "ok" : "failed");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
int main(int, char **)
{
boost::asio::ip::address address = boost::asio::ip::address::from_string("127.0.0.1");
const unsigned short port = 6379;
boost::asio::io_service ioService;
RedisClient redis(ioService);
redis.asyncConnect(address, port,
boost::bind(&handleConnected, boost::ref(ioService), boost::ref(redis), _1, _2));
ioService.run();
return 0;
}
bool redis_builder::add_slave(const acl::redis_node& master,
const acl::redis_node& slave)
{
acl::redis_client client(slave.get_addr());
acl::redis redis(&client);
const char* master_addr = master.get_addr();
if (master_addr == NULL || *master_addr == 0)
{
printf("%s: master addr null\r\n", __FUNCTION__);
return false;
}
acl::string buf(master_addr);
const std::vector<acl::string>& tokens = buf.split2(":");
if (tokens.size() != 2)
{
printf("%s: invalid master_addr: %s\r\n",
__FUNCTION__, master_addr);
return false;
}
// CLUSTER MEET master node
if (!redis.cluster_meet(tokens[0].c_str(), atoi(tokens[1].c_str())))
{
printf("%s: cluster meet %s %s error: %s\r\n",
__FUNCTION__, tokens[0].c_str(), tokens[1].c_str(),
redis.result_error());
return false;
}
// wait for the master recognizing the slave
while (true)
{
if (cluster_meeting(redis, master_addr) == true)
break;
acl_doze(meet_wait_);
}
if (redis.cluster_replicate(master.get_id()) == false)
{
printf("%s: cluster replicate id: %s, error: %s, addr: %s\r\n",
__FUNCTION__, master.get_id(), redis.result_error(),
slave.get_addr());
return false;
}
return true;
}
int main(int argc, char** argv)
{
int conn_timeout = 10, rw_timeout = 0;
// As of now this is to choose the server to connect to
if(argc != 3){
printf("Usage: server <port> [<ip>]\n");
exit(1);
}
TCPStream* stream = NULL;
TCPAcceptor* acceptor = NULL;
acceptor = new TCPAcceptor(atoi(argv[1]), argv[2]);
// This is hard coded to the server thats running the redis server
acl::string addr("135.44.219.148:6380");
acl::acl_cpp_init();
acl::log::stdout_open(true);
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
acl::redis_pubsub redis(&client);
// Hard coded channel
acl::string channel = "channel", msg;
redis.clear();
// Have this program run continuously, and if an ip address is picked up, publish it to the redis server
if (acceptor->start() == 0) {
while (1) {
stream = acceptor->accept();
if (stream != NULL) {
printf("IP %s\n", stream->getPeerIP().c_str());
msg.format("%s", stream->getPeerIP().c_str());
redis.publish(channel, msg, msg.length());
}
}
}
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
bool doMsg(std::string& reply, const std::string& msg)
{
const std::string& key = msg;
RedisConnectionByKey redis(key, worker->cachePool());
if (redis)
{
redis->del(key);
LOG4CXX_INFO(logger, "del " << key);
}
else
{
LOG4CXX_WARN(logger, "del " << key << " .. redis is not ready");
}
if (0 == s_cacheonly)
{
MySqlConnectionByKey mysql(key, worker->dbPool());
if (mysql)
{
try {
mysqlpp::Query query = mysql->query();
query.reset();
query << "delete from " << getKVSTableName(key) << " where `key`="
<< mysqlpp::quote << key;
query.execute();
LOG4CXX_INFO(logger, "mysql: del" << key << "," << mysql->shard() << "," << getKVSTableName(key));
reply = "OK";
}
catch (std::exception& err)
{
LOG4CXX_WARN(logger, "del " << key << " .. mysql error:" << err.what());
return false;
}
}
else
{
LOG4CXX_WARN(logger, "del " << key << " .. mysql is not ready");
}
}
return true;
}
int main(int, char **)
{
boost::asio::ip::address address = boost::asio::ip::address::from_string("127.0.0.1");
const unsigned short port = 6379;
boost::asio::io_service ioService;
RedisSyncClient redis(ioService);
std::string errmsg;
if( !redis.connect(address, port, errmsg) )
{
std::cerr << "Can't connect to redis: " << errmsg << std::endl;
return EXIT_FAILURE;
}
RedisValue result;
int i = 0;
while (true) {
std::stringstream s;
s << i++;
result = redis.command("SET", "key", "value: " + s.str());
if( result.isError() )
{
std::cerr << "SET error: " << result.toString() << "\n";
return EXIT_FAILURE;
}
result = redis.command("GET", "key");
if( result.isOk() )
{
std::cout << "GET: " << result.toString() << "\n";
// return EXIT_SUCCESS;
}
else
{
std::cerr << "GET error: " << result.toString() << "\n";
// return EXIT_FAILURE;
}
}
}
void redis_monitor::status(void)
{
acl::redis_client client(addr_, conn_timeout_, rw_timeout_);
acl::redis redis(&client);
std::vector<acl::redis_node*> nodes;
redis_util::get_nodes(redis, prefer_master_, nodes);
if (nodes.empty())
{
logger_error("no redis nodes available");
return;
}
std::vector<acl::redis_client*> conns;
for (std::vector<acl::redis_node*>::const_iterator
cit = nodes.begin(); cit != nodes.end(); ++cit)
{
const char* addr = (*cit)->get_addr();
if (addr == NULL || *addr == 0)
{
logger_warn("addr NULL, skip it");
continue;
}
acl::redis_client* conn = new acl::redis_client(
addr, conn_timeout_, rw_timeout_);
conns.push_back(conn);
}
while (true)
{
show_status(conns);
sleep(1);
}
for (std::vector<acl::redis_client*>::iterator it = conns.begin();
it != conns.end(); ++it)
{
delete *it;
}
}
void redis_thread::do_load_count_box(socket_id sid, unsigned int uid)
{
myredis_helper redis(myredis_pool::instance(), config_manager::instance()->redis_count_box_ip(),
config_manager::instance()->redis_count_box_port(),
config_manager::instance()->redis_count_box_db());
if(redis.is_null())
{
LOG_ERROR("redis connect error");
return;
}
char key[64];
sprintf(key, "cb_%d_%d", config_manager::instance()->server_type(), uid);
pptr_buffer<128, 4> field;
field.add("second");
field.add("level");
int seconds = 0;
int level = 0;
if(!redis->exists(key))
{
pptr_buffer<128, 4> value;
char buf[64];
sprintf(buf, "0");
value.add(buf);
value.add(buf);
redis->hmset(key, field.pptr, value.pptr);
redis->expire(key, get_wincount_expire_time());
}
else
{
redis_bulk* out;
int n = redis->hmget(key, field.pptr, &out);
if(n == 2)
{
seconds = atoi(out[0].data);
level = atoi(out[1].data);
}
}
game_main_thread::instance()->on_count_box(sid, uid, seconds, level);
}
void redis_thread::do_get_card_mission_index(unsigned int uid)
{
myredis_helper redis(myredis_pool::instance(), config_manager::instance()->redis_count_box_ip(),
config_manager::instance()->redis_count_box_port(),
config_manager::instance()->redis_count_box_db());
int index = 0;
do
{
if(redis.is_null())
break;
char key[64];
sprintf(key, "cm_%d_%d", config_manager::instance()->server_type(), uid);
pptr_buffer<128, 4> field;
redis_bulk* out;
field.add("id");
field.add("lt");
if(!redis->exists(key))
break;
int n = redis->hmget(key, field.pptr, &out);
if(n != 2 || !out || out[0].len == 0 || out[1].len == 0)
break;
time_t t;
index = atoi(out[0].data);
t = atol(out[1].data);
int mode = cm->mode();
if(mode == CARD_MISSION_SINGLE)
{
time_t ct = time(0);
tm t1 = *localtime(&ct);
tm t2 = *localtime(&t);
if(t1.tm_yday != t2.tm_yday)
{
index = 0;
do_set_card_mission_index(uid, index);
}
}
} while (false);
game_main_thread::instance()->on_card_mission_index(uid, index);
}
void redis_thread::do_set_card_mission_index(unsigned int uid, int index)
{
myredis_helper redis(myredis_pool::instance(), config_manager::instance()->redis_count_box_ip(),
config_manager::instance()->redis_count_box_port(),
config_manager::instance()->redis_count_box_db());
if(redis.is_null())
return;
char key[64];
sprintf(key, "cm_%d_%d", config_manager::instance()->server_type(), uid);
pptr_buffer<128, 4> field;
pptr_buffer<128, 4> value;
field.add("id");
field.add("lt");
char tmp[32];
sprintf(tmp, "%d", index);
value.add(tmp);
time_t ct = time(0);
sprintf(tmp, "%lld", ct);
value.add(tmp);
redis->hmset(key, field.pptr, value.pptr);
}
bool redis_reshard::get_masters_info()
{
acl::redis_client client(addr_, 30, 30);
acl::redis redis(&client);
const std::map<acl::string, acl::redis_node*>* masters;
if ((masters = redis.cluster_nodes()) == NULL)
{
printf("%s: master nodes empty\r\n", __FUNCTION__);
return false;
}
std::map<acl::string, acl::redis_node*>::const_iterator cit;
for (cit = masters->begin(); cit != masters->end(); ++cit)
{
acl::redis_node* master = new acl::redis_node;
master->set_id(cit->second->get_id());
master->set_addr(cit->second->get_addr());
copy_slots(*cit->second, *master);
masters_.push_back(master);
}
return true;
}
void test_get()
{
for (int i = 0; i < MAX_USER_NUM; i++)
{
std::ostringstream oss;
oss << "user:"******"get " << key << " " << kvs["value"].size());
}
else
{
LOG4CXX_INFO(logger, "get " << key << " non-exists");
}
}
}
}
int main(int argc, char* argv[])
{
int ch, n = 1, conn_timeout = 10, rw_timeout = 10;
acl::string addr("127.0.0.1:6379"), cmd;
bool slice_req = false;
while ((ch = getopt(argc, argv, "hs:n:C:I:a:S")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'n':
n = atoi(optarg);
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'I':
rw_timeout = atoi(optarg);
break;
case 'a':
cmd = optarg;
break;
case 'S':
slice_req = true;
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
client.set_slice_request(slice_req);
acl::redis_hyperloglog redis(&client);
bool ret;
if (cmd == "pfadd")
ret = test_pfadd(redis, n);
else if (cmd == "pfcount")
ret = test_pfcount(redis, n);
else if (cmd == "pfmerge")
ret = test_pfmerge(redis, n);
else if (cmd == "all")
{
ret = test_pfadd(redis, n)
&& test_pfcount(redis, n)
&& test_pfmerge(redis, n);
}
else
{
printf("unknown cmd: %s\r\n", cmd.c_str());
ret = false;
}
printf("cmd: %s %s\r\n", cmd.c_str(), ret ? "ok" : "failed");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
TEST(TestConnectShared, BadPort)
{
TTR::SharedRedis redis(1234);
ASSERT_FALSE(redis.isConnected());
}
int main(int argc, char* argv[])
{
// initiation the acl library
acl::acl_cpp_init();
acl::log::stdout_open(true);
int ch;
bool add_slave = false;
acl::string addr, cmd, conf, new_addr, node_id;
while ((ch = getopt(argc, argv, "hs:a:f:N:SI:")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'a':
cmd = optarg;
break;
case 'f':
conf = optarg;
break;
case 'N':
new_addr = optarg;
break;
case 'S':
add_slave = true;
break;
case 'I':
node_id = optarg;
break;
default:
break;
}
}
int conn_timeout = 10, rw_timeout = 120;
acl::redis_client client(addr, conn_timeout, rw_timeout);
acl::redis redis(&client);
if (cmd == "nodes")
{
if (addr.empty())
{
printf("usage: %s -s ip:port -a nodes\r\n", argv[0]);
goto END;
}
redis_status status(addr, conn_timeout, rw_timeout);
status.show_nodes(redis);
}
else if (cmd == "slots")
{
if (addr.empty())
{
printf("usage: %s -a ip:port -a slots\r\n", argv[0]);
goto END;
}
redis_status status(addr, conn_timeout, rw_timeout);
status.show_slots(redis);
}
else if (cmd == "create")
{
if (conf.empty())
{
printf("usage: %s -a create -f cluster.xml\r\n", argv[0]);
goto END;
}
redis_builder builder;
builder.build(conf.c_str());
}
else if (cmd == "add_node")
{
if (addr.empty() || new_addr.empty())
{
printf("usage: %s -s ip:port -a add_node -N ip:port -S\r\n", argv[0]);
goto END;
}
redis_builder builder;
builder.add_node(addr, new_addr, add_slave);
}
else if (cmd == "del_node")
{
if (addr.empty() || node_id.empty())
{
printf("usage: %s -s ip:port -a del_node -I nod_id\r\n", argv[0]);
goto END;
}
redis_builder builder;
builder.del_node(addr, node_id);
}
else if (cmd == "node_id")
{
if (addr.empty())
{
printf("usage: %s -s ip:port -a node_id\r\n", argv[0]);
goto END;
}
node_id.clear();
redis_builder builder;
if (builder.get_node_id(addr, node_id) == false)
printf("can't get node id, addr: %s\r\n", addr.c_str());
else
printf("addr: %s, node_id: %s\r\n", addr.c_str(),
node_id.c_str());
}
else
printf("unknown cmd: %s\r\n", cmd.c_str());
END:
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
bool doMsg(std::string& reply, const std::string& msg)
{
std::string key = msg;
RedisConnectionByKey redis(key, worker->cachePool());
if (redis)
{
RedisReply::Map kvs;
if (redis->hgetall(key, kvs))
{
reply = kvs["value"];
LOG4CXX_INFO(logger, "get " << key << " .. hit");
return true;
}
}
else
{
LOG4CXX_WARN(logger, "get " << key << " .. redis is not ready");
}
if (0 == s_cacheonly)
{
MySqlConnectionByKey mysql(key, worker->dbPool());
if (mysql)
{
try {
mysqlpp::Query query = mysql->query();
query << "select * from "<< getKVSTableName(key) << " where `key`=" << mysqlpp::quote << key;
mysqlpp::StoreQueryResult res = query.store();
if (res)
{
if (res.num_rows() == 1)
{
reply.resize(res[0]["value"].size());
reply.assign(res[0]["value"].data(), res[0]["value"].size());
redis->hmset("%b value %b flag %u touchtime %u",
key.data(), key.size(),
reply.data(), reply.size(), 0, (unsigned int)time(0));
LOG4CXX_INFO(logger, "get " << key << " .. miss");
return true;
}
}
}
catch (std::exception& err)
{
LOG4CXX_WARN(logger, "get " << key << " .. mysql error:" << err.what());
return false;
}
}
else
{
LOG4CXX_WARN(logger, "get " << key << " .. mysql is not ready");
}
}
reply = "";
LOG4CXX_INFO(logger, "get " << key << " .. non-exists");
return true;
}
int main(int argc, char* argv[])
{
int ch, n = 1, conn_timeout = 10, rw_timeout = 10;
acl::string addr("127.0.0.1:6379"), cmd;
bool slice_req = false;
while ((ch = getopt(argc, argv, "hs:n:C:I:a:S")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'n':
n = atoi(optarg);
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'I':
rw_timeout = atoi(optarg);
break;
case 'a':
cmd = optarg;
break;
case 'S':
slice_req = true;
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
client.set_slice_request(slice_req);
acl::redis_hash redis(&client);
bool ret;
if (cmd == "hmset")
ret = test_hmset(redis, n);
else if (cmd == "hmget")
ret = test_hmget(redis, n);
else if (cmd == "hset")
ret = test_hset(redis, n);
else if (cmd == "hsetnx")
ret = test_hsetnx(redis, n);
else if (cmd == "hget")
ret = test_hget(redis, n);
else if (cmd == "hgetall")
ret = test_hgetall(redis, n);
else if (cmd == "hdel")
ret = test_hdel(redis, n);
else if (cmd == "hincrby")
ret = test_hincrby(redis, n);
else if (cmd == "hincrbyfloat")
ret = test_hincrbyfloat(redis, n);
else if (cmd == "hkeys")
ret = test_hkeys(redis, n);
else if (cmd == "hexists")
ret = test_hexists(redis, n);
else if (cmd == "hlen")
ret = test_hlen(redis, n);
else if (cmd == "all")
{
ret = test_hmset(redis, n)
&& test_hmget(redis, n)
&& test_hset(redis, n)
&& test_hsetnx(redis, n)
&& test_hget(redis, n)
&& test_hgetall(redis, n)
&& test_hincrby(redis, n)
&& test_hincrbyfloat(redis, n)
&& test_hkeys(redis, n)
&& test_hexists(redis, n)
&& test_hlen(redis, n)
&& test_hdel(redis, n);
}
else
{
ret = false;
printf("unknown cmd: %s\r\n", cmd.c_str());
}
if (ret == true)
printf("test OK!\r\n");
else
printf("test failed!\r\n");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
int main(int argc, char* argv[])
{
int ch, conn_timeout = 10, rw_timeout = 10;
acl::string addr("127.0.0.1:6379"), cmd, node;
while ((ch = getopt(argc, argv, "hs:n:C:T:a:i:")) > 0) {
switch (ch) {
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'T':
rw_timeout = atoi(optarg);
break;
case 'a':
cmd = optarg;
break;
case 'i':
node = optarg;
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
acl::redis_cluster redis(&client);
bool ret;
if (cmd == "slots")
ret = test_slots(redis);
else if (cmd == "preset")
ret = preset_all(addr.c_str());
else if (cmd == "nodes")
ret = test_nodes(redis);
else if (cmd == "slaves") {
if (node.empty()) {
printf("usage: %s -a slaves -i node\r\n", argv[0]);
return 1;
}
ret = test_slaves(redis, node.c_str());
} else if (cmd == "info")
ret = test_info(redis);
else {
ret = false;
printf("unknown cmd: %s\r\n", cmd.c_str());
}
if (ret == true)
printf("test OK!\r\n");
else
printf("test failed!\r\n");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
int main(int argc, char* argv[])
{
int ch, n = 50, conn_timeout = 10, rw_timeout = 10;
acl::string addr("127.0.0.1:6379"), cmd("all");
bool cluster_mode = false;
acl::log::stdout_open(true);
while ((ch = getopt(argc, argv, "hs:n:C:T:a:c")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'n':
n = atoi(optarg);
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'T':
rw_timeout = atoi(optarg);
break;
case 'a':
cmd = optarg;
break;
case 'c':
cluster_mode = true;
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
cluster.set(addr.c_str(), 100);
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
acl::redis_list redis(&client);
if (cluster_mode)
redis.set_cluster(&cluster, 100);
else
redis.set_client(&client);
bool ret;
if (cmd == "lpush")
{
ret = test_lpush(redis, n)
&& test_lpush2(redis, n)
&& test_lpush3(redis, n)
&& test_lpush4(redis, n)
&& test_lpush5(redis, n)
&& test_lpush6(redis, n);
}
else if (cmd == "rpush")
ret = test_rpush(redis, n)
&& test_rpush2(redis, n)
&& test_rpush3(redis, n)
&& test_rpush4(redis, n)
&& test_rpush5(redis, n)
&& test_rpush6(redis, n);
else if (cmd == "lpushx")
ret = test_lpushx(redis, n) && test_lpushx2(redis, n);
else if (cmd == "rpushx")
ret = test_rpushx(redis, n) && test_rpushx2(redis, n);
else if (cmd == "lrange")
ret = test_lrange(redis);
else if (cmd == "rpop")
ret = test_rpop(redis, n);
else if (cmd == "lpop")
ret = test_lpop(redis, n);
else if (cmd == "blpop")
ret = test_blpop(redis, n);
else if (cmd == "brpop")
ret = test_brpop(redis, n);
else if (cmd == "rpoplpush")
ret = test_rpoplpush(redis, n);
else if (cmd == "brpoplpush")
ret = test_brpoplpush(redis, n);
else if (cmd == "lrem")
ret = test_lrem(redis, n);
else if (cmd == "ltrim")
ret = test_ltrim(redis, n);
else if (cmd == "llen")
ret = test_llen(redis, n);
else if (cmd == "lindex")
ret = test_lindex(redis, n);
else if (cmd == "lset")
ret = test_lset(redis, n);
else if (cmd == "linsert_before")
ret = test_linsert_before(redis,1);
else if (cmd == "linsert_after")
ret = test_linsert_after(redis,1);
else
{
ret = false;
printf("unknown cmd: %s\r\n", cmd.c_str());
}
if (ret == true)
printf("test OK!\r\n");
else
printf("test failed!\r\n");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
