* 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
* `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)
---------------
### `MetaDataRef`
-See `NodeMetaRef` and `ItemStackMetaRef`.
+See `StorageRef`, `NodeMetaRef` and `ItemStackMetaRef`.
#### Methods
* `set_string(name, value)`
* `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.
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 {
- m_stringvars[name] = var;
+ return true;
+ }
+
+ 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,
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;
#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)
}
#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;
+}
#include <map>
#include <json/json.h>
#include "config.h"
+#include "metadata.h"
#define MODNAME_ALLOWED_CHARS "abcdefghijklmnopqrstuvwxyz0123456789_"
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
const Json::Value::Members attr_list = attr_root.getMemberNames();
for (Json::Value::Members::const_iterator it = attr_list.begin();
- it != attr_list.end(); ++it) {
+ it != attr_list.end(); ++it) {
Json::Value attr_value = attr_root[*it];
sao->setExtendedAttribute(*it, attr_value.asString());
}
${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
--- /dev/null
+/*
+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}
+};
--- /dev/null
+/*
+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__ */
#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"
ModApiServer::Initialize(L, top);
ModApiUtil::Initialize(L, top);
ModApiHttp::Initialize(L, top);
+ ModApiStorage::Initialize(L, top);
// Register reference classes (userdata)
InvRef::Register(L);
NodeTimerRef::Register(L);
ObjectRef::Register(L);
LuaSettings::Register(L);
+ StorageRef::Register(L);
}
void log_deprecated(const std::string &message)
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;
<< "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());
+ }
+ }
+ }
}
/*
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();
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);
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; }
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;
// 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);
};
projects / oweals / minetest.git / commitdiff