aboutsummaryrefslogtreecommitdiff
path: root/src/database/database-redis.cpp
blob: 096ea504db12c82d08094cd2ab9591c8ccfd2629 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203

/*
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>


Database_Redis::Database_Redis(Settings &conf)
{
	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");
	}
	const char *addr = tmp.c_str();
	int port = conf.exists("redis_port") ? conf.getU16("redis_port") : 6379;
	// if redis_address contains '/' assume unix socket, else hostname/ip
	ctx = tmp.find('/') != std::string::npos ? redisConnectUnix(addr) : redisConnect(addr, port);
	if (!ctx) {
		throw DatabaseException("Cannot allocate redis context");
	} else if (ctx->err) {
		std::string err = std::string("Connection error: ") + ctx->errstr;
		redisFree(ctx);
		throw DatabaseException(err);
	}
	if (conf.exists("redis_password")) {
		tmp = conf.get("redis_password");
		redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "AUTH %s", tmp.c_str()));
		if (!reply)
			throw DatabaseException("Redis authentication failed");
		if (reply->type == REDIS_REPLY_ERROR) {
			std::string err = "Redis authentication failed: " + std::string(reply->str, reply->len);
			freeReplyObject(reply);
			throw DatabaseException(err);
		}
		freeReplyObject(reply);
	}
}

Database_Redis::~Database_Redis()
{
	redisFree(ctx);
}

void Database_Redis::beginSave() {
	redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "MULTI"));
	if (!reply) {
		throw DatabaseException(std::string(
			"Redis command 'MULTI' failed: ") + ctx->errstr);
	}
	freeReplyObject(reply);
}

void Database_Redis::endSave() {
	redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "EXEC"));
	if (!reply) {
		throw DatabaseException(std::string(
			"Redis command 'EXEC' failed: ") + ctx->errstr);
	}
	freeReplyObject(reply);
}

bool Database_Redis::saveBlock(const v3s16 &pos, const std::string &data)
{
	std::string tmp = i64tos(getBlockAsInteger(pos));

	redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "HSET %s %s %b",
			hash.c_str(), tmp.c_str(), data.c_str(), data.size()));
	if (!reply) {
		warningstream << "saveBlock: redis command 'HSET' failed on "
			"block " << PP(pos) << ": " << ctx->errstr << std::endl;
		freeReplyObject(reply);
		return false;
	}

	if (reply->type == REDIS_REPLY_ERROR) {
		warningstream << "saveBlock: saving block " << PP(pos)
			<< " failed: " << std::string(reply->str, reply->len) << std::endl;
		freeReplyObject(reply);
		return false;
	}

	freeReplyObject(reply);
	return true;
}

void Database_Redis::loadBlock(const v3s16 &pos, std::string *block)
{
	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 DatabaseException(std::string(
			"Redis command 'HGET %s %s' failed: ") + ctx->errstr);
	}

	switch (reply->type) {
	case REDIS_REPLY_STRING: {
		*block = std::string(reply->str, reply->len);
		// std::string copies the memory so this won't cause any problems
		freeReplyObject(reply);
		return;
	}
	case REDIS_REPLY_ERROR: {
		std::string errstr(reply->str, reply->len);
		freeReplyObject(reply);
		errorstream << "loadBlock: loading block " << PP(pos)
			<< " failed: " << errstr << std::endl;
		throw DatabaseException(std::string(
			"Redis command 'HGET %s %s' errored: ") + errstr);
	}
	case REDIS_REPLY_NIL: {
		*block = "";
		// block not found in database
		freeReplyObject(reply);
		return;
	}
	}

	errorstream << "loadBlock: loading block " << PP(pos)
		<< " returned invalid reply type " << reply->type
		<< ": " << std::string(reply->str, reply->len) << std::endl;
	freeReplyObject(reply);
	throw DatabaseException(std::string(
		"Redis command 'HGET %s %s' gave invalid reply."));
}

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 DatabaseException(std::string(
			"Redis command 'HDEL %s %s' failed: ") + ctx->errstr);
	} else if (reply->type == REDIS_REPLY_ERROR) {
		warningstream << "deleteBlock: deleting block " << PP(pos)
			<< " failed: " << std::string(reply->str, reply->len) << std::endl;
		freeReplyObject(reply);
		return false;
	}

	freeReplyObject(reply);
	return true;
}

void Database_Redis::listAllLoadableBlocks(std::vector<v3s16> &dst)
{
	redisReply *reply = static_cast<redisReply *>(redisCommand(ctx, "HKEYS %s", hash.c_str()));
	if (!reply) {
		throw DatabaseException(std::string(
			"Redis command 'HKEYS %s' failed: ") + ctx->errstr);
	}
	switch (reply->type) {
	case REDIS_REPLY_ARRAY:
		dst.reserve(reply->elements);
		for (size_t i = 0; i < reply->elements; i++) {
			assert(reply->element[i]->type == REDIS_REPLY_STRING);
			dst.push_back(getIntegerAsBlock(stoi64(reply->element[i]->str)));
		}
		break;
	case REDIS_REPLY_ERROR:
		throw DatabaseException(std::string(
			"Failed to get keys from database: ") +
			std::string(reply->str, reply->len));
	}
	freeReplyObject(reply);
}

#endif // USE_REDIS
generated by cgit v1.2.3 (git 2.39.1) at 2025-10-10 20:28:27 +0000
kwd">c_str()) != INVALID_FILE_ATTRIBUTES); } bool IsPathAbsolute(const std::string &path) { return !PathIsRelative(path.c_str()); } bool IsDir(const std::string &path) { DWORD attr = GetFileAttributes(path.c_str()); return (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY)); } bool IsDirDelimiter(char c) { return c == '/' || c == '\\'; } bool RecursiveDelete(const std::string &path) { infostream<<"Recursively deleting \""<<path<<"\""<<std::endl; DWORD attr = GetFileAttributes(path.c_str()); bool is_directory = (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY)); if(!is_directory) { infostream<<"RecursiveDelete: Deleting file "<<path<<std::endl; //bool did = DeleteFile(path.c_str()); bool did = true; if(!did){ errorstream<<"RecursiveDelete: Failed to delete file " <<path<<std::endl; return false; } } else { infostream<<"RecursiveDelete: Deleting content of directory " <<path<<std::endl; std::vector<DirListNode> content = GetDirListing(path); for(size_t i=0; i<content.size(); i++){ const DirListNode &n = content[i]; std::string fullpath = path + DIR_DELIM + n.name; bool did = RecursiveDelete(fullpath); if(!did){ errorstream<<"RecursiveDelete: Failed to recurse to " <<fullpath<<std::endl; return false; } } infostream<<"RecursiveDelete: Deleting directory "<<path<<std::endl; //bool did = RemoveDirectory(path.c_str(); bool did = true; if(!did){ errorstream<<"Failed to recursively delete directory " <<path<<std::endl; return false; } } return true; } bool DeleteSingleFileOrEmptyDirectory(const std::string &path) { DWORD attr = GetFileAttributes(path.c_str()); bool is_directory = (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY)); if(!is_directory) { bool did = DeleteFile(path.c_str()); return did; } else { bool did = RemoveDirectory(path.c_str()); return did; } } std::string TempPath() { DWORD bufsize = GetTempPath(0, NULL); if(bufsize == 0){ errorstream<<"GetTempPath failed, error = "<<GetLastError()<<std::endl; return ""; } std::vector<char> buf(bufsize); DWORD len = GetTempPath(bufsize, &buf[0]); if(len == 0 || len > bufsize){ errorstream<<"GetTempPath failed, error = "<<GetLastError()<<std::endl; return ""; } return std::string(buf.begin(), buf.begin() + len); } #else // POSIX #include <sys/types.h> #include <dirent.h> #include <sys/stat.h> #include <sys/wait.h> #include <unistd.h> std::vector<DirListNode> GetDirListing(const std::string &pathstring) { std::vector<DirListNode> listing; DIR *dp; struct dirent *dirp; if((dp = opendir(pathstring.c_str())) == NULL) { //infostream<<"Error("<<errno<<") opening "<<pathstring<<std::endl; return listing; } while ((dirp = readdir(dp)) != NULL) { // NOTE: // Be very sure to not include '..' in the results, it will // result in an epic failure when deleting stuff. if(strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "..") == 0) continue; DirListNode node; node.name = dirp->d_name; int isdir = -1; // -1 means unknown /* POSIX doesn't define d_type member of struct dirent and certain filesystems on glibc/Linux will only return DT_UNKNOWN for the d_type member. Also we don't know whether symlinks are directories or not. */ #ifdef _DIRENT_HAVE_D_TYPE if(dirp->d_type != DT_UNKNOWN && dirp->d_type != DT_LNK) isdir = (dirp->d_type == DT_DIR); #endif /* _DIRENT_HAVE_D_TYPE */ /* Was d_type DT_UNKNOWN, DT_LNK or nonexistent? If so, try stat(). */ if(isdir == -1) { struct stat statbuf; if (stat((pathstring + "/" + node.name).c_str(), &statbuf)) continue; isdir = ((statbuf.st_mode & S_IFDIR) == S_IFDIR); } node.dir = isdir; listing.push_back(node); } closedir(dp); return listing; } bool CreateDir(const std::string &path) { int r = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); if(r == 0) { return true; } else { // If already exists, return true if(errno == EEXIST) return true; return false; } } bool PathExists(const std::string &path) { struct stat st; return (stat(path.c_str(),&st) == 0); } bool IsPathAbsolute(const std::string &path) { return path[0] == '/'; } bool IsDir(const std::string &path) { struct stat statbuf; if(stat(path.c_str(), &statbuf)) return false; // Actually error; but certainly not a directory return ((statbuf.st_mode & S_IFDIR) == S_IFDIR); } bool IsDirDelimiter(char c) { return c == '/'; } bool RecursiveDelete(const std::string &path) { /* Execute the 'rm' command directly, by fork() and execve() */ infostream<<"Removing \""<<path<<"\""<<std::endl; //return false; pid_t child_pid = fork(); if(child_pid == 0) { // Child char argv_data[3][10000]; strcpy(argv_data[0], "/bin/rm"); strcpy(argv_data[1], "-rf"); strncpy(argv_data[2], path.c_str(), 10000); char *argv[4]; argv[0] = argv_data[0]; argv[1] = argv_data[1]; argv[2] = argv_data[2]; argv[3] = NULL; verbosestream<<"Executing '"<<argv[0]<<"' '"<<argv[1]<<"' '" <<argv[2]<<"'"<<std::endl; execv(argv[0], argv); // Execv shouldn't return. Failed. _exit(1); } else { // Parent int child_status; pid_t tpid; do{ tpid = wait(&child_status); //if(tpid != child_pid) process_terminated(tpid); }while(tpid != child_pid); return (child_status == 0); } } bool DeleteSingleFileOrEmptyDirectory(const std::string &path) { if(IsDir(path)){ bool did = (rmdir(path.c_str()) == 0); if(!did) errorstream<<"rmdir errno: "<<errno<<": "<<strerror(errno) <<std::endl; return did; } else { bool did = (unlink(path.c_str()) == 0); if(!did) errorstream<<"unlink errno: "<<errno<<": "<<strerror(errno) <<std::endl; return did; } } std::string TempPath() { /* Should the environment variables TMPDIR, TMP and TEMP and the macro P_tmpdir (if defined by stdio.h) be checked before falling back on /tmp? Probably not, because this function is intended to be compatible with lua's os.tmpname which under the default configuration hardcodes mkstemp("/tmp/lua_XXXXXX"). */ #ifdef __ANDROID__ return DIR_DELIM "sdcard" DIR_DELIM PROJECT_NAME DIR_DELIM "tmp"; #else return DIR_DELIM "tmp"; #endif } #endif void GetRecursiveSubPaths(const std::string &path, std::vector<std::string> &dst) { std::vector<DirListNode> content = GetDirListing(path); for(unsigned int i=0; i<content.size(); i++){ const DirListNode &n = content[i]; std::string fullpath = path + DIR_DELIM + n.name; dst.push_back(fullpath); if (n.dir) { GetRecursiveSubPaths(fullpath, dst); } } } bool DeletePaths(const std::vector<std::string> &paths) { bool success = true; // Go backwards to succesfully delete the output of GetRecursiveSubPaths for(int i=paths.size()-1; i>=0; i--){ const std::string &path = paths[i]; bool did = DeleteSingleFileOrEmptyDirectory(path); if(!did){ errorstream<<"Failed to delete "<<path<<std::endl; success = false; } } return success; } bool RecursiveDeleteContent(const std::string &path) { infostream<<"Removing content of \""<<path<<"\""<<std::endl; std::vector<DirListNode> list = GetDirListing(path); for(unsigned int i=0; i<list.size(); i++) { if(trim(list[i].name) == "." || trim(list[i].name) == "..") continue; std::string childpath = path + DIR_DELIM + list[i].name; bool r = RecursiveDelete(childpath); if(r == false) { errorstream<<"Removing \""<<childpath<<"\" failed"<<std::endl; return false; } } return true; } bool CreateAllDirs(const std::string &path) { std::vector<std::string> tocreate; std::string basepath = path; while(!PathExists(basepath)) { tocreate.push_back(basepath); basepath = RemoveLastPathComponent(basepath); if(basepath.empty()) break; } for(int i=tocreate.size()-1;i>=0;i--) if(!CreateDir(tocreate[i])) return false; return true; } bool CopyFileContents(const std::string &source, const std::string &target) { FILE *sourcefile = fopen(source.c_str(), "rb"); if(sourcefile == NULL){ errorstream<<source<<": can't open for reading: " <<strerror(errno)<<std::endl; return false; } FILE *targetfile = fopen(target.c_str(), "wb"); if(targetfile == NULL){ errorstream<<target<<": can't open for writing: " <<strerror(errno)<<std::endl; fclose(sourcefile); return false; } size_t total = 0; bool retval = true; bool done = false; char readbuffer[BUFSIZ]; while(!done){ size_t readbytes = fread(readbuffer, 1, sizeof(readbuffer), sourcefile); total += readbytes; if(ferror(sourcefile)){ errorstream<<source<<": IO error: " <<strerror(errno)<<std::endl; retval = false; done = true; } if(readbytes > 0){ fwrite(readbuffer, 1, readbytes, targetfile); } if(feof(sourcefile) || ferror(sourcefile)){ // flush destination file to catch write errors // (e.g. disk full) fflush(targetfile); done = true; } if(ferror(targetfile)){ errorstream<<target<<": IO error: " <<strerror(errno)<<std::endl; retval = false; done = true; } } infostream<<"copied "<<total<<" bytes from " <<source<<" to "<<target<<std::endl; fclose(sourcefile); fclose(targetfile); return retval; } bool CopyDir(const std::string &source, const std::string &target) { if(PathExists(source)){ if(!PathExists(target)){ fs::CreateAllDirs(target); } bool retval = true; std::vector<DirListNode> content = fs::GetDirListing(source); for(unsigned int i=0; i < content.size(); i++){ std::string sourcechild = source + DIR_DELIM + content[i].name; std::string targetchild = target + DIR_DELIM + content[i].name; if(content[i].dir){ if(!fs::CopyDir(sourcechild, targetchild)){ retval = false; } } else { if(!fs::CopyFileContents(sourcechild, targetchild)){ retval = false; } } } return retval; } else { return false; } } bool PathStartsWith(const std::string &path, const std::string &prefix) { size_t pathsize = path.size(); size_t pathpos = 0; size_t prefixsize = prefix.size(); size_t prefixpos = 0; for(;;){ bool delim1 = pathpos == pathsize || IsDirDelimiter(path[pathpos]); bool delim2 = prefixpos == prefixsize || IsDirDelimiter(prefix[prefixpos]); if(delim1 != delim2) return false; if(delim1){ while(pathpos < pathsize && IsDirDelimiter(path[pathpos])) ++pathpos; while(prefixpos < prefixsize && IsDirDelimiter(prefix[prefixpos])) ++prefixpos; if(prefixpos == prefixsize) return true; if(pathpos == pathsize) return false; } else{ size_t len = 0; do{ char pathchar = path[pathpos+len]; char prefixchar = prefix[prefixpos+len]; if(FILESYS_CASE_INSENSITIVE){ pathchar = tolower(pathchar); prefixchar = tolower(prefixchar); } if(pathchar != prefixchar) return false; ++len; } while(pathpos+len < pathsize && !IsDirDelimiter(path[pathpos+len]) && prefixpos+len < prefixsize && !IsDirDelimiter( prefix[prefixpos+len])); pathpos += len; prefixpos += len; } } } std::string RemoveLastPathComponent(const std::string &path, std::string *removed, int count) { if(removed) *removed = ""; size_t remaining = path.size(); for(int i = 0; i < count; ++i){ // strip a dir delimiter while(remaining != 0 && IsDirDelimiter(path[remaining-1])) remaining--; // strip a path component size_t component_end = remaining; while(remaining != 0 && !IsDirDelimiter(path[remaining-1])) remaining--; size_t component_start = remaining; // strip a dir delimiter while(remaining != 0 && IsDirDelimiter(path[remaining-1])) remaining--; if(removed){ std::string component = path.substr(component_start, component_end - component_start); if(i) *removed = component + DIR_DELIM + *removed; else *removed = component; } } return path.substr(0, remaining); } std::string RemoveRelativePathComponents(std::string path) { size_t pos = path.size(); size_t dotdot_count = 0; while (pos != 0) { size_t component_with_delim_end = pos; // skip a dir delimiter while (pos != 0 && IsDirDelimiter(path[pos-1])) pos--; // strip a path component size_t component_end = pos; while (pos != 0 && !IsDirDelimiter(path[pos-1])) pos--; size_t component_start = pos; std::string component = path.substr(component_start, component_end - component_start); bool remove_this_component = false; if (component == ".") { remove_this_component = true; } else if (component == "..") { remove_this_component = true; dotdot_count += 1; } else if (dotdot_count != 0) { remove_this_component = true; dotdot_count -= 1; } if (remove_this_component) { while (pos != 0 && IsDirDelimiter(path[pos-1])) pos--; if (component_start == 0) { // We need to remove the delemiter too path = path.substr(component_with_delim_end, std::string::npos); } else { path = path.substr(0, pos) + DIR_DELIM + path.substr(component_with_delim_end, std::string::npos); } if (pos > 0) pos++; } } if (dotdot_count > 0) return ""; // remove trailing dir delimiters pos = path.size(); while (pos != 0 && IsDirDelimiter(path[pos-1])) pos--; return path.substr(0, pos); } std::string AbsolutePath(const std::string &path) { #ifdef _WIN32 char *abs_path = _fullpath(NULL, path.c_str(), MAX_PATH); #else char *abs_path = realpath(path.c_str(), NULL); #endif if (!abs_path) return ""; std::string abs_path_str(abs_path); free(abs_path); return abs_path_str; } const char *GetFilenameFromPath(const char *path) { const char *filename = strrchr(path, DIR_DELIM_CHAR); return filename ? filename + 1 : path; } bool safeWriteToFile(const std::string &path, const std::string &content) {