BOOST_FIXTURE_TEST_CASE(test_error, ParserFixture)
{
RedisValue value = parse("-Error message\r\n");
BOOST_CHECK_EQUAL(value.toString(), "Error message");
BOOST_CHECK_EQUAL(value.isError(), true);
BOOST_CHECK_EQUAL(value.isOk(), false);
}
TEST(ReadRedisValue, Null) {
RedisValue val;
StringReader reader;
reader.input = "$-1\r\n";
ReadRedisValue(&reader, &val);
EXPECT_EQ(REDIS_NULL, val.which());
}
void redisworker::onSet(const RedisValue& value)
{
if(value.toString() == "OK")
{
std::cout<<"SET: success"<<std::endl;
}
else
{
std::cerr<<"SET: "<<value.toString()<<std::endl;
}
}
void redisworker::task(const RedisValue& value)
{
if(value.isOk())
{
std::cout<<value.toArray()[0].toString()<<std::endl;
std::cout<<value.toArray()[1].toString()<<std::endl;
m_taskcb(value);
m_redis.command("BRPOP",m_para.task_title,"push:test2",0,boost::bind(&redisworker::onBrpop,this,_1));
if(value.toArray()[1].toString() == m_para.quitcmd)
m_ioService.stop();
}
else
{
std::cerr<<"BRPOP: error"<<value.toString()<<std::endl;
}
}
void RedisClientImpl::onRedisError(const RedisValue &v)
{
if( errorHandler )
{
std::string message = v.toString();
errorHandler(message);
}
}
//need argument for the cb
void redisworker::onLpush(const RedisValue& value)
{
if(value.toInt()>0)
{
}
else
{
}
}
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 RedisClientImpl::doProcessMessage(const RedisValue &v)
{
if( state == RedisClientImpl::Subscribed )
{
std::vector<RedisValue> result = v.toArray();
if( result.size() == 3 )
{
const RedisValue &command = result[0];
const RedisValue &queue = result[1];
const RedisValue &value = result[2];
const std::string &cmd = command.toString();
if( cmd == "message" )
{
SingleShotHandlersMap::iterator it = singleShotMsgHandlers.find(queue.toString());
if( it != singleShotMsgHandlers.end() )
{
strand.post(boost::bind(it->second, value.toString()));
singleShotMsgHandlers.erase(it);
}
std::pair<MsgHandlersMap::iterator, MsgHandlersMap::iterator> pair =
msgHandlers.equal_range(queue.toString());
for(MsgHandlersMap::iterator it = pair.first; it != pair.second; ++it)
strand.post(boost::bind(it->second.second, value.toString()));
}
else if( cmd == "subscribe" && handlers.empty() == false )
{
handlers.front()(v);
handlers.pop();
}
else if(cmd == "unsubscribe" && handlers.empty() == false )
{
handlers.front()(v);
handlers.pop();
}
else
{
std::stringstream ss;
ss << "[RedisClient] invalid command: "
<< command.toString();
onError(ss.str());
return;
}
}
else
{
onError("[RedisClient] Protocol error");
return;
}
}
else
{
if( handlers.empty() == false )
{
handlers.front()(v);
handlers.pop();
}
else
{
std::stringstream ss;
ss << "[RedisClient] unexpected message: "
<< v.inspect();
onError(ss.str());
return;
}
}
}
void redisworker::onGet(const RedisValue& value)
{
std::cout<<value.toString()<<std::endl;
}
void defTaskFunc(const RedisValue& value)
{
std::cout<<value.toString()<<std::endl;
}
