HiredisAdapter.cpp

Go to the documentation of this file.

#include <stdexcept>
 
#include "HiredisAdapter.hpp"
 
HiredisAdapter::~HiredisAdapter()
{
    if (is_connected()) {
        disconnect();
    }
}
 
void HiredisAdapter::connect()
{
    if (is_connected()) {
        return;
    }
 
    ctx = redisConnect(server_ip.c_str(), port);
 
    if (ctx == nullptr) {
        throw HiredisException("HiredisAdapter::connect(): Couldn't allocate redis context");
    }
 
    if (ctx->err) {
        throw HiredisException(std::string("HiredisAdapter::connect(): Error: ") + ctx->errstr);
    }
}
 
void HiredisAdapter::disconnect()
{
    if (is_connected()) {
        redisFree(ctx);
    }
 
    ctx = nullptr;
}
 
HiredisAdapter::set_reply_t HiredisAdapter::set(const std::string& key, const std::string& value,
                                                const timeout_t expire_timeout)
{
    redisReply* reply = generic_set("SET", key, value);
    expire(key, expire_timeout);
 
    return set_reply_t{reply, freeReplyObject};
}
 
HiredisAdapter::sadd_reply_t HiredisAdapter::sadd(const std::string& key, const std::string& value,
                                                  const timeout_t expire_timeout)
{
    redisReply* reply = generic_set("SADD", key, value);
    expire(key, expire_timeout);
 
    return sadd_reply_t{reply, freeReplyObject};
}
 
void HiredisAdapter::expire(const std::string& key, const timeout_t expire)
{
    if (expire == 0) {
        return;
    }
 
    assert_connected();
 
    void* reply = redisCommand(ctx, "EXPIRE %s %lld", key.c_str(), expire);
 
    last_expire_failed = (reply == nullptr);
    freeReplyObject(reply);
}
 
HiredisAdapter::get_reply_t HiredisAdapter::get(const std::string& key)
{
    redisReply* reply = generic_read("GET", key);
 
    return get_reply_t{reply, freeReplyObject};
}
 
HiredisAdapter::smembers_reply_t HiredisAdapter::smembers(const std::string& key)
{
    redisReply* reply = generic_read("SMEMBERS", key);
 
    return get_reply_t{reply, freeReplyObject};
}
 
inline redisReply* HiredisAdapter::generic_set(const std::string& command, const std::string& key,
                                               const std::string& value)
{
    assert_connected();
 
    void* raw_reply = redisCommand(ctx, (command + " %s %s").c_str(), key.c_str(), value.c_str());
    assert_valid_redis_reply(raw_reply, command);
 
    return static_cast<redisReply*>(raw_reply);
}
 
inline redisReply* HiredisAdapter::generic_read(const std::string& command, const std::string& key)
{
    assert_connected();
 
    void* raw_reply = redisCommand(ctx, (command + " %s").c_str(), key.c_str());
    assert_valid_redis_reply(raw_reply, command);
 
    return static_cast<redisReply*>(raw_reply);
}
 
inline void HiredisAdapter::assert_connected() const
{
    if (!is_connected()) {
        throw HiredisException("HiredisAdapter::assert_connected(): Not connected");
    }
}
 
inline void HiredisAdapter::assert_valid_redis_reply(const void* reply, const std::string& command)
{
    if (reply != nullptr) {
        return;
    }
 
    std::string errstr = ctx->errstr;
    disconnect();
    throw HiredisException("HiredisAdapter::assert_valid_redis_reply(): " + command
                           + " failed due to error: " + errstr);
}