Add ModMetadata API (#5131)

* mod can create a ModMetadata object where store its values and retrieve it.
* Modmetadata object can only be fetched at mod loading
* Save when modified using same time as map interval or at server stop
* add helper function to get mod storage path
* ModMetadata has exactly same calls than all every other Metadata

doc/lua_api.txt

@@ -2629,6 +2629,11 @@ These functions return the leftover itemstack.
 * `HTTPApiTable.fetch_async_get(handle)`: returns HTTPRequestResult
     * Return response data for given asynchronous HTTP request
 
+### Storage API:
+* `minetest.get_mod_storage()`:
+    * returns reference to mod private `StorageRef`
+    * must be called during mod load time
+
 ### Misc.
 * `minetest.get_connected_players()`: returns list of `ObjectRefs`
 * `minetest.player_exists(name)`: boolean, whether player exists (regardless of online status)
@@ -2791,7 +2796,7 @@ Class reference
 ---------------
 
 ### `MetaDataRef`
-See `NodeMetaRef` and `ItemStackMetaRef`.
+See `StorageRef`, `NodeMetaRef` and `ItemStackMetaRef`.
 
 #### Methods
 * `set_string(name, value)`
@@ -2845,6 +2850,9 @@ Can be gotten via `minetest.get_node_timer(pos)`.
 * `is_started()`: returns boolean state of timer
     * returns `true` if timer is started, otherwise `false`
 
+### `StorageRef`
+This is basically a reference to a C++ `ModMetadata`
+
 ### `ObjectRef`
 Moving things in the game are generally these.
 

src/metadata.cpp

@@ -76,13 +76,27 @@ const std::string &Metadata::getString(const std::string &name,
 	return resolveString(it->second, recursion);
 }
 
-void Metadata::setString(const std::string &name, const std::string &var)
+/**
+ * Sets var to name key in the metadata storage
+ *
+ * @param name
+ * @param var
+ * @return true if key-value pair is created or changed
+ */
+bool Metadata::setString(const std::string &name, const std::string &var)
 {
 	if (var.empty()) {
 		m_stringvars.erase(name);
-	} else {
+		return true;
-		m_stringvars[name] = var;
 	}
+
+	StringMap::iterator it = m_stringvars.find(name);
+	if (it != m_stringvars.end() && it->second == var) {
+		return false;
+	}
+
+	m_stringvars[name] = var;
+	return true;
 }
 
 const std::string &Metadata::resolveString(const std::string &str,

src/metadata.h

@@ -46,7 +46,7 @@ public:
 	size_t size() const;
 	bool contains(const std::string &name) const;
 	const std::string &getString(const std::string &name, u16 recursion = 0) const;
-	void setString(const std::string &name, const std::string &var);
+	virtual bool setString(const std::string &name, const std::string &var);
 	const StringMap &getStrings() const
 	{
 		return m_stringvars;

src/mods.cpp

@@ -21,13 +21,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <fstream>
 #include "mods.h"
 #include "filesys.h"
-#include "util/strfnd.h"
 #include "log.h"
 #include "subgame.h"
 #include "settings.h"
-#include "util/strfnd.h"
 #include "convert_json.h"
-#include "exceptions.h"
 
 static bool parseDependsLine(std::istream &is,
 		std::string &dep, std::set<char> &symbols)
@@ -356,3 +353,80 @@ Json::Value getModstoreUrl(std::string url)
 }
 
 #endif
+
+ModMetadata::ModMetadata(const std::string &mod_name):
+	m_mod_name(mod_name),
+	m_modified(false)
+{
+	m_stringvars.clear();
+}
+
+void ModMetadata::clear()
+{
+	Metadata::clear();
+	m_modified = true;
+}
+
+bool ModMetadata::save(const std::string &root_path)
+{
+	Json::Value json;
+	for (StringMap::const_iterator it = m_stringvars.begin();
+			it != m_stringvars.end(); ++it) {
+		json[it->first] = it->second;
+	}
+
+	if (!fs::PathExists(root_path)) {
+		if (!fs::CreateAllDirs(root_path)) {
+			errorstream << "ModMetadata[" << m_mod_name << "]: Unable to save. '"
+				<< root_path << "' tree cannot be created." << std::endl;
+			return false;
+		}
+	} else if (!fs::IsDir(root_path)) {
+		errorstream << "ModMetadata[" << m_mod_name << "]: Unable to save. '"
+			<< root_path << "' is not a directory." << std::endl;
+		return false;
+	}
+
+	bool w_ok = fs::safeWriteToFile(root_path + DIR_DELIM + m_mod_name,
+		Json::FastWriter().write(json));
+
+	if (w_ok) {
+		m_modified = false;
+	} else {
+		errorstream << "ModMetadata[" << m_mod_name << "]: failed write file." << std::endl;
+	}
+	return w_ok;
+}
+
+bool ModMetadata::load(const std::string &root_path)
+{
+	m_stringvars.clear();
+
+	std::ifstream is((root_path + DIR_DELIM + m_mod_name).c_str(), std::ios_base::binary);
+	if (!is.good()) {
+		return false;
+	}
+
+	Json::Reader reader;
+	Json::Value root;
+	if (!reader.parse(is, root)) {
+		errorstream << "ModMetadata[" << m_mod_name << "]: failed read data "
+			"(Json decoding failure)." << std::endl;
+		return false;
+	}
+
+	const Json::Value::Members attr_list = root.getMemberNames();
+	for (Json::Value::Members::const_iterator it = attr_list.begin();
+			it != attr_list.end(); ++it) {
+		Json::Value attr_value = root[*it];
+		m_stringvars[*it] = attr_value.asString();
+	}
+
+	return true;
+}
+
+bool ModMetadata::setString(const std::string &name, const std::string &var)
+{
+	m_modified = Metadata::setString(name, var);
+	return m_modified;
+}

src/mods.h

@@ -28,6 +28,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <map>
 #include <json/json.h>
 #include "config.h"
+#include "metadata.h"
 
 #define MODNAME_ALLOWED_CHARS "abcdefghijklmnopqrstuvwxyz0123456789_"
 
@@ -205,4 +206,24 @@ struct ModStoreModDetails {
 	bool valid;
 };
 
+class ModMetadata: public Metadata
+{
+public:
+	ModMetadata(const std::string &mod_name);
+	~ModMetadata() {}
+
+	virtual void clear();
+
+	bool save(const std::string &root_path);
+	bool load(const std::string &root_path);
+
+	bool isModified() const { return m_modified; }
+	const std::string &getModName() const { return m_mod_name; }
+
+	virtual bool setString(const std::string &name, const std::string &var);
+private:
+	std::string m_mod_name;
+	bool m_modified;
+};
+
 #endif

src/script/lua_api/CMakeLists.txt

@@ -15,6 +15,7 @@ set(common_SCRIPT_LUA_API_SRCS
 	${CMAKE_CURRENT_SOURCE_DIR}/l_particles.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_rollback.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_server.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/l_storage.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_util.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_vmanip.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_settings.cpp

src/script/lua_api/l_storage.cpp

@@ -0,0 +1,143 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2017 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
+
+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 "lua_api/l_storage.h"
+#include "l_internal.h"
+#include "mods.h"
+#include "server.h"
+
+int ModApiStorage::l_get_mod_storage(lua_State *L)
+{
+	lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_CURRENT_MOD_NAME);
+	if (!lua_isstring(L, -1)) {
+		return 0;
+	}
+
+	std::string mod_name = lua_tostring(L, -1);
+
+	ModMetadata *store = new ModMetadata(mod_name);
+	// For server side
+	if (Server *server = getServer(L)) {
+		store->load(server->getModStoragePath());
+		server->registerModStorage(store);
+	} else {
+		assert(false); // this should not happen
+	}
+
+	StorageRef::create(L, store);
+	int object = lua_gettop(L);
+
+	lua_pushvalue(L, object);
+	return 1;
+}
+
+void ModApiStorage::Initialize(lua_State *L, int top)
+{
+	API_FCT(get_mod_storage);
+}
+
+StorageRef::StorageRef(ModMetadata *object):
+	m_object(object)
+{
+}
+
+void StorageRef::create(lua_State *L, ModMetadata *object)
+{
+	StorageRef *o = new StorageRef(object);
+	*(void **)(lua_newuserdata(L, sizeof(void *))) = o;
+	luaL_getmetatable(L, className);
+	lua_setmetatable(L, -2);
+}
+
+int StorageRef::gc_object(lua_State *L)
+{
+	StorageRef *o = *(StorageRef **)(lua_touserdata(L, 1));
+	// Server side
+	if (Server *server = getServer(L))
+		server->unregisterModStorage(getobject(o)->getModName());
+	delete o;
+	return 0;
+}
+
+void StorageRef::Register(lua_State *L)
+{
+	lua_newtable(L);
+	int methodtable = lua_gettop(L);
+	luaL_newmetatable(L, className);
+	int metatable = lua_gettop(L);
+
+	lua_pushliteral(L, "__metatable");
+	lua_pushvalue(L, methodtable);
+	lua_settable(L, metatable);  // hide metatable from Lua getmetatable()
+
+	lua_pushliteral(L, "metadata_class");
+	lua_pushlstring(L, className, strlen(className));
+	lua_settable(L, metatable);
+
+	lua_pushliteral(L, "__index");
+	lua_pushvalue(L, methodtable);
+	lua_settable(L, metatable);
+
+	lua_pushliteral(L, "__gc");
+	lua_pushcfunction(L, gc_object);
+	lua_settable(L, metatable);
+
+	lua_pop(L, 1);  // drop metatable
+
+	luaL_openlib(L, 0, methods, 0);  // fill methodtable
+	lua_pop(L, 1);  // drop methodtable
+}
+
+StorageRef* StorageRef::checkobject(lua_State *L, int narg)
+{
+	luaL_checktype(L, narg, LUA_TUSERDATA);
+	void *ud = luaL_checkudata(L, narg, className);
+	if (!ud) luaL_typerror(L, narg, className);
+	return *(StorageRef**)ud;  // unbox pointer
+}
+
+ModMetadata* StorageRef::getobject(StorageRef *ref)
+{
+	ModMetadata *co = ref->m_object;
+	return co;
+}
+
+Metadata* StorageRef::getmeta(bool auto_create)
+{
+	return m_object;
+}
+
+void StorageRef::clearMeta()
+{
+	m_object->clear();
+}
+
+const char StorageRef::className[] = "StorageRef";
+const luaL_reg StorageRef::methods[] = {
+	luamethod(MetaDataRef, get_string),
+	luamethod(MetaDataRef, set_string),
+	luamethod(MetaDataRef, get_int),
+	luamethod(MetaDataRef, set_int),
+	luamethod(MetaDataRef, get_float),
+	luamethod(MetaDataRef, set_float),
+	luamethod(MetaDataRef, to_table),
+	luamethod(MetaDataRef, from_table),
+	{0,0}
+};

src/script/lua_api/l_storage.h

@@ -0,0 +1,62 @@
+/*
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2017 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
+
+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.
+*/
+
+#ifndef __L_STORAGE_H__
+#define __L_STORAGE_H__
+
+#include "lua_api/l_base.h"
+#include "l_metadata.h"
+
+class ModMetadata;
+
+class ModApiStorage: public ModApiBase
+{
+protected:
+	static int l_get_mod_storage(lua_State *L);
+public:
+	static void Initialize(lua_State *L, int top);
+
+};
+
+class StorageRef: public MetaDataRef
+{
+private:
+	ModMetadata *m_object;
+
+	static const char className[];
+	static const luaL_reg methods[];
+
+	virtual Metadata* getmeta(bool auto_create);
+	virtual void clearMeta();
+
+	// garbage collector
+	static int gc_object(lua_State *L);
+public:
+	StorageRef(ModMetadata *object);
+	~StorageRef() {}
+
+	static void Register(lua_State *L);
+	static void create(lua_State *L, ModMetadata *object);
+
+	static StorageRef *checkobject(lua_State *L, int narg);
+	static ModMetadata* getobject(StorageRef *ref);
+};
+
+#endif /* __L_STORAGE_H__ */

src/script/scripting_game.cpp

@@ -41,6 +41,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "lua_api/l_vmanip.h"
 #include "lua_api/l_settings.h"
 #include "lua_api/l_http.h"
+#include "lua_api/l_storage.h"
 
 extern "C" {
 #include "lualib.h"
@@ -92,6 +93,7 @@ void GameScripting::InitializeModApi(lua_State *L, int top)
 	ModApiServer::Initialize(L, top);
 	ModApiUtil::Initialize(L, top);
 	ModApiHttp::Initialize(L, top);
+	ModApiStorage::Initialize(L, top);
 
 	// Register reference classes (userdata)
 	InvRef::Register(L);
@@ -108,6 +110,7 @@ void GameScripting::InitializeModApi(lua_State *L, int top)
 	NodeTimerRef::Register(L);
 	ObjectRef::Register(L);
 	LuaSettings::Register(L);
+	StorageRef::Register(L);
 }
 
 void log_deprecated(const std::string &message)

src/server.cpp

@@ -178,8 +178,8 @@ Server::Server(
 	m_admin_chat(iface),
 	m_ignore_map_edit_events(false),
 	m_ignore_map_edit_events_peer_id(0),
-	m_next_sound_id(0)
+	m_next_sound_id(0),
-
+	m_mod_storage_save_timer(10.0f)
 {
 	m_liquid_transform_timer = 0.0;
 	m_liquid_transform_every = 1.0;
@@ -788,6 +788,18 @@ void Server::AsyncRunStep(bool initial_step)
 					<< "packet size is " << pktSize << std::endl;
 		}
 		m_clients.unlock();
+
+		m_mod_storage_save_timer -= dtime;
+		if (m_mod_storage_save_timer <= 0.0f) {
+			infostream << "Saving registered mod storages." << std::endl;
+			m_mod_storage_save_timer = g_settings->getFloat("server_map_save_interval");
+			for (UNORDERED_MAP<std::string, ModMetadata *>::const_iterator
+				it = m_mod_storages.begin(); it != m_mod_storages.end(); ++it) {
+				if (it->second->isModified()) {
+					it->second->save(getModStoragePath());
+				}
+			}
+		}
 	}
 
 	/*
@@ -3404,6 +3416,11 @@ std::string Server::getBuiltinLuaPath()
 	return porting::path_share + DIR_DELIM + "builtin";
 }
 
+std::string Server::getModStoragePath() const
+{
+	return m_path_world + DIR_DELIM + "mod_storage";
+}
+
 v3f Server::findSpawnPos()
 {
 	ServerMap &map = m_env->getServerMap();
@@ -3525,6 +3542,28 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version
 	return playersao;
 }
 
+bool Server::registerModStorage(ModMetadata *storage)
+{
+	if (m_mod_storages.find(storage->getModName()) != m_mod_storages.end()) {
+		errorstream << "Unable to register same mod storage twice. Storage name: "
+				<< storage->getModName() << std::endl;
+		return false;
+	}
+
+	m_mod_storages[storage->getModName()] = storage;
+	return true;
+}
+
+void Server::unregisterModStorage(const std::string &name)
+{
+	UNORDERED_MAP<std::string, ModMetadata *>::const_iterator it = m_mod_storages.find(name);
+	if (it != m_mod_storages.end()) {
+		// Save unconditionaly on unregistration
+		it->second->save(getModStoragePath());
+		m_mod_storages.erase(name);
+	}
+}
+
 void dedicated_server_loop(Server &server, bool &kill)
 {
 	DSTACK(FUNCTION_NAME);

src/server.h

@@ -299,7 +299,8 @@ public:
 	const ModSpec* getModSpec(const std::string &modname) const;
 	void getModNames(std::vector<std::string> &modlist);
 	std::string getBuiltinLuaPath();
-	inline std::string getWorldPath() const { return m_path_world; }
+	inline const std::string &getWorldPath() const { return m_path_world; }
+	std::string getModStoragePath() const;
 
 	inline bool isSingleplayer()
 			{ return m_simple_singleplayer_mode; }
@@ -360,6 +361,9 @@ public:
 	void SendInventory(PlayerSAO* playerSAO);
 	void SendMovePlayer(u16 peer_id);
 
+	bool registerModStorage(ModMetadata *storage);
+	void unregisterModStorage(const std::string &name);
+
 	// Bind address
 	Address m_bind_addr;
 
@@ -650,6 +654,9 @@ private:
 	// value = "" (visible to all players) or player name
 	std::map<std::string, std::string> m_detached_inventories_player;
 
+	UNORDERED_MAP<std::string, ModMetadata *> m_mod_storages;
+	float m_mod_storage_save_timer;
+
 	DISABLE_CLASS_COPY(Server);
 };