minetest/src/database-redis.cpp

160 lines
4.5 KiB
C++
Raw Normal View History

2014-04-08 21:39:21 +02:00
/*
Minetest
Copyright (C) 2014 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#if USE_REDIS
#include "database-redis.h"
#include "settings.h"
#include "log.h"
#include "exceptions.h"
#include "util/string.h"
#include <hiredis.h>
#include <cassert>
2014-04-08 21:39:21 +02:00
Database_Redis::Database_Redis(Settings &conf)
2014-04-08 21:39:21 +02:00
{
std::string tmp;
try {
tmp = conf.get("redis_address");
hash = conf.get("redis_hash");
} catch (SettingNotFoundException) {
throw SettingNotFoundException("Set redis_address and "
"redis_hash in world.mt to use the redis backend");
2014-04-08 21:39:21 +02:00
}
const char *addr = tmp.c_str();
int port = conf.exists("redis_port") ? conf.getU16("redis_port") : 6379;
ctx = redisConnect(addr, port);
if (!ctx) {
2014-04-08 21:39:21 +02:00
throw FileNotGoodException("Cannot allocate redis context");
} else if(ctx->err) {
2014-04-08 21:39:21 +02:00
std::string err = std::string("Connection error: ") + ctx->errstr;
redisFree(ctx);
throw FileNotGoodException(err);
}
}
Database_Redis::~Database_Redis()
2014-04-08 21:39:21 +02:00
{
redisFree(ctx);
2014-04-08 21:39:21 +02:00
}
void Database_Redis::beginSave() {
redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "MULTI"));
if (!reply) {
throw FileNotGoodException(std::string(
"Redis command 'MULTI' failed: ") + ctx->errstr);
}
2014-04-08 21:39:21 +02:00
freeReplyObject(reply);
}
void Database_Redis::endSave() {
redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "EXEC"));
if (!reply) {
throw FileNotGoodException(std::string(
"Redis command 'EXEC' failed: ") + ctx->errstr);
}
2014-04-08 21:39:21 +02:00
freeReplyObject(reply);
}
bool Database_Redis::saveBlock(const v3s16 &pos, const std::string &data)
2014-04-08 21:39:21 +02:00
{
std::string tmp = i64tos(getBlockAsInteger(pos));
2014-04-08 21:39:21 +02:00
redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "HSET %s %s %b",
hash.c_str(), tmp.c_str(), data.c_str(), data.size()));
if (!reply) {
errorstream << "WARNING: saveBlock: redis command 'HSET' failed on "
"block " << PP(pos) << ": " << ctx->errstr << std::endl;
freeReplyObject(reply);
return false;
}
if (reply->type == REDIS_REPLY_ERROR) {
errorstream << "WARNING: saveBlock: saving block " << PP(pos)
<< "failed" << std::endl;
freeReplyObject(reply);
return false;
}
2014-04-08 21:39:21 +02:00
freeReplyObject(reply);
return true;
2014-04-08 21:39:21 +02:00
}
std::string Database_Redis::loadBlock(const v3s16 &pos)
2014-04-08 21:39:21 +02:00
{
std::string tmp = i64tos(getBlockAsInteger(pos));
redisReply *reply = static_cast<redisReply *>(redisCommand(ctx,
"HGET %s %s", hash.c_str(), tmp.c_str()));
if (!reply) {
throw FileNotGoodException(std::string(
"Redis command 'HGET %s %s' failed: ") + ctx->errstr);
} else if (reply->type != REDIS_REPLY_STRING) {
return "";
}
2014-04-08 21:39:21 +02:00
std::string str(reply->str, reply->len);
freeReplyObject(reply); // std::string copies the memory so this won't cause any problems
return str;
2014-04-08 21:39:21 +02:00
}
bool Database_Redis::deleteBlock(const v3s16 &pos)
{
std::string tmp = i64tos(getBlockAsInteger(pos));
redisReply *reply = static_cast<redisReply *>(redisCommand(ctx,
"HDEL %s %s", hash.c_str(), tmp.c_str()));
if (!reply) {
throw FileNotGoodException(std::string(
"Redis command 'HDEL %s %s' failed: ") + ctx->errstr);
} else if (reply->type == REDIS_REPLY_ERROR) {
errorstream << "WARNING: deleteBlock: deleting block " << PP(pos)
<< " failed" << std::endl;
freeReplyObject(reply);
return false;
}
freeReplyObject(reply);
return true;
}
void Database_Redis::listAllLoadableBlocks(std::vector<v3s16> &dst)
2014-04-08 21:39:21 +02:00
{
redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "HKEYS %s", hash.c_str()));
if (!reply) {
throw FileNotGoodException(std::string(
"Redis command 'HKEYS %s' failed: ") + ctx->errstr);
} else if (reply->type != REDIS_REPLY_ARRAY) {
2014-04-08 21:39:21 +02:00
throw FileNotGoodException("Failed to get keys from database");
}
for (size_t i = 0; i < reply->elements; i++) {
2014-04-08 21:39:21 +02:00
assert(reply->element[i]->type == REDIS_REPLY_STRING);
dst.push_back(getIntegerAsBlock(stoi64(reply->element[i]->str)));
}
freeReplyObject(reply);
}
#endif // USE_REDIS