Add generic IPC mechanism between Lua envs

src/script/cpp_api/s_async.cpp

@@ -50,11 +50,12 @@ AsyncEngine::~AsyncEngine()
 	}
 
 	// Wait for threads to finish
+	infostream << "AsyncEngine: Waiting for " << workerThreads.size()
+		<< " threads" << std::endl;
 	for (AsyncWorkerThread *workerThread : workerThreads) {
 		workerThread->wait();
 	}
 
-	// Force kill all threads
 	for (AsyncWorkerThread *workerThread : workerThreads) {
 		delete workerThread;
 	}

src/script/lua_api/CMakeLists.txt

@@ -6,6 +6,7 @@ set(common_SCRIPT_LUA_API_SRCS
 	${CMAKE_CURRENT_SOURCE_DIR}/l_env.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_http.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_inventory.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/l_ipc.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_item.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_itemstackmeta.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/l_mapgen.cpp

src/script/lua_api/l_ipc.cpp

@@ -0,0 +1,68 @@
+// Minetest
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#include "lua_api/l_ipc.h"
+#include "lua_api/l_internal.h"
+#include "common/c_packer.h"
+#include "server.h"
+#include "debug.h"
+
+typedef std::shared_lock<std::shared_mutex> SharedReadLock;
+typedef std::unique_lock<std::shared_mutex> SharedWriteLock;
+
+int ModApiIPC::l_ipc_get(lua_State *L)
+{
+	auto *store = getGameDef(L)->getModIPCStore();
+
+	auto key = readParam<std::string>(L, 1);
+
+	{
+		SharedReadLock autolock(store->mutex);
+		auto it = store->map.find(key);
+		if (it == store->map.end())
+			lua_pushnil(L);
+		else
+			script_unpack(L, it->second.get());
+	}
+	return 1;
+}
+
+int ModApiIPC::l_ipc_set(lua_State *L)
+{
+	auto *store = getGameDef(L)->getModIPCStore();
+
+	auto key = readParam<std::string>(L, 1);
+
+	luaL_checkany(L, 2);
+	std::unique_ptr<PackedValue> pv;
+	if (!lua_isnil(L, 2)) {
+		pv.reset(script_pack(L, 2));
+		if (pv->contains_userdata)
+			throw LuaError("Userdata not allowed");
+	}
+
+	{
+		SharedWriteLock autolock(store->mutex);
+		if (pv)
+			store->map[key] = std::move(pv);
+		else
+			store->map.erase(key); // delete the map value for nil
+	}
+	return 0;
+}
+
+/*
+ * Implementation note:
+ * Iterating over the IPC table is intentionally not supported.
+ * Mods should know what they have set.
+ * This has the nice side effect that mods are able to use a randomly generated key
+ * if they really *really* want to avoid other code touching their data.
+ */
+
+void ModApiIPC::Initialize(lua_State *L, int top)
+{
+	FATAL_ERROR_IF(!getGameDef(L)->getModIPCStore(), "ModIPCStore missing from gamedef");
+
+	API_FCT(ipc_get);
+	API_FCT(ipc_set);
+}

src/script/lua_api/l_ipc.h

@@ -0,0 +1,15 @@
+// Minetest
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#pragma once
+
+#include "lua_api/l_base.h"
+
+class ModApiIPC : public ModApiBase {
+private:
+	static int l_ipc_get(lua_State *L);
+	static int l_ipc_set(lua_State *L);
+
+public:
+	static void Initialize(lua_State *L, int top);
+};

src/script/scripting_emerge.cpp

@@ -35,6 +35,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "lua_api/l_util.h"
 #include "lua_api/l_vmanip.h"
 #include "lua_api/l_settings.h"
+#include "lua_api/l_ipc.h"
 
 extern "C" {
 #include <lualib.h>
@@ -89,5 +90,6 @@ void EmergeScripting::InitializeModApi(lua_State *L, int top)
 	ModApiMapgen::InitializeEmerge(L, top);
 	ModApiServer::InitializeAsync(L, top);
 	ModApiUtil::InitializeAsync(L, top);
+	ModApiIPC::Initialize(L, top);
 	// TODO ^ these should also be renamed to InitializeRO or such
 }

src/script/scripting_server.cpp

@@ -46,6 +46,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "lua_api/l_settings.h"
 #include "lua_api/l_http.h"
 #include "lua_api/l_storage.h"
+#include "lua_api/l_ipc.h"
 
 extern "C" {
 #include <lualib.h>
@@ -121,6 +122,7 @@ void ServerScripting::initAsync()
 	asyncEngine.registerStateInitializer(ModApiCraft::InitializeAsync);
 	asyncEngine.registerStateInitializer(ModApiItem::InitializeAsync);
 	asyncEngine.registerStateInitializer(ModApiServer::InitializeAsync);
+	asyncEngine.registerStateInitializer(ModApiIPC::Initialize);
 	// not added: ModApiMapgen is a minefield for thread safety
 	// not added: ModApiHttp async api can't really work together with our jobs
 	// not added: ModApiStorage is probably not thread safe(?)
@@ -176,6 +178,7 @@ void ServerScripting::InitializeModApi(lua_State *L, int top)
 	ModApiHttp::Initialize(L, top);
 	ModApiStorage::Initialize(L, top);
 	ModApiChannels::Initialize(L, top);
+	ModApiIPC::Initialize(L, top);
 }
 
 void ServerScripting::InitializeAsync(lua_State *L, int top)