Async-related script cleanups

src/script/cpp_api/s_async.cpp

@@ -32,20 +32,19 @@ extern "C" {
 #include "filesys.h"
 #include "porting.h"
 #include "common/c_internal.h"
+#include "lua_api/l_base.h"
 
 /******************************************************************************/
 AsyncEngine::~AsyncEngine()
 {
-
 	// Request all threads to stop
 	for (AsyncWorkerThread *workerThread : workerThreads) {
 		workerThread->stop();
 	}
 
-
 	// Wake up all threads
-	for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
-			it != workerThreads.end(); ++it) {
+	for (auto it : workerThreads) {
+		(void)it;
 		jobQueueCounter.post();
 	}
 
@@ -68,6 +67,7 @@ AsyncEngine::~AsyncEngine()
 /******************************************************************************/
 void AsyncEngine::registerStateInitializer(StateInitializer func)
 {
+	FATAL_ERROR_IF(initDone, "Initializer may not be registered after init");
 	stateInitializers.push_back(func);
 }
 
@@ -85,36 +85,36 @@ void AsyncEngine::initialize(unsigned int numEngines)
 }
 
 /******************************************************************************/
-unsigned int AsyncEngine::queueAsyncJob(const std::string &func,
-		const std::string &params)
+u32 AsyncEngine::queueAsyncJob(std::string &&func, std::string &&params,
+		const std::string &mod_origin)
 {
 	jobQueueMutex.lock();
-	LuaJobInfo toAdd;
-	toAdd.id = jobIdCounter++;
-	toAdd.serializedFunction = func;
-	toAdd.serializedParams = params;
+	u32 jobId = jobIdCounter++;
 
-	jobQueue.push_back(toAdd);
+	jobQueue.emplace_back();
+	auto &to_add = jobQueue.back();
+	to_add.id = jobId;
+	to_add.function = std::move(func);
+	to_add.params = std::move(params);
+	to_add.mod_origin = mod_origin;
 
 	jobQueueCounter.post();
-
 	jobQueueMutex.unlock();
-
-	return toAdd.id;
+	return jobId;
 }
 
 /******************************************************************************/
-LuaJobInfo AsyncEngine::getJob()
+bool AsyncEngine::getJob(LuaJobInfo *job)
 {
 	jobQueueCounter.wait();
 	jobQueueMutex.lock();
 
-	LuaJobInfo retval;
+	bool retval = false;
 
 	if (!jobQueue.empty()) {
-		retval = jobQueue.front();
+		*job = std::move(jobQueue.front());
 		jobQueue.pop_front();
-		retval.valid = true;
+		retval = true;
 	}
 	jobQueueMutex.unlock();
 
@@ -122,10 +122,10 @@ LuaJobInfo AsyncEngine::getJob()
 }
 
 /******************************************************************************/
-void AsyncEngine::putJobResult(const LuaJobInfo &result)
+void AsyncEngine::putJobResult(LuaJobInfo &&result)
 {
 	resultQueueMutex.lock();
-	resultQueue.push_back(result);
+	resultQueue.emplace_back(std::move(result));
 	resultQueueMutex.unlock();
 }
 
@@ -134,26 +134,30 @@ void AsyncEngine::step(lua_State *L)
 {
 	int error_handler = PUSH_ERROR_HANDLER(L);
 	lua_getglobal(L, "core");
-	resultQueueMutex.lock();
+
+	ScriptApiBase *script = ModApiBase::getScriptApiBase(L);
+
+	MutexAutoLock autolock(resultQueueMutex);
 	while (!resultQueue.empty()) {
-		LuaJobInfo jobDone = resultQueue.front();
+		LuaJobInfo j = std::move(resultQueue.front());
 		resultQueue.pop_front();
 
 		lua_getfield(L, -1, "async_event_handler");
-
-		if (lua_isnil(L, -1)) {
+		if (lua_isnil(L, -1))
 			FATAL_ERROR("Async event handler does not exist!");
-		}
-
 		luaL_checktype(L, -1, LUA_TFUNCTION);
 
-		lua_pushinteger(L, jobDone.id);
-		lua_pushlstring(L, jobDone.serializedResult.data(),
-				jobDone.serializedResult.size());
+		lua_pushinteger(L, j.id);
+		lua_pushlstring(L, j.result.data(), j.result.size());
 
-		PCALL_RESL(L, lua_pcall(L, 2, 0, error_handler));
+		// Call handler
+		const char *origin = j.mod_origin.empty() ? nullptr : j.mod_origin.c_str();
+		script->setOriginDirect(origin);
+		int result = lua_pcall(L, 2, 0, error_handler);
+		if (result)
+			script_error(L, result, origin, "<async>");
 	}
-	resultQueueMutex.unlock();
+
 	lua_pop(L, 2); // Pop core and error handler
 }
 
@@ -168,8 +172,8 @@ void AsyncEngine::prepareEnvironment(lua_State* L, int top)
 /******************************************************************************/
 AsyncWorkerThread::AsyncWorkerThread(AsyncEngine* jobDispatcher,
 		const std::string &name) :
-	Thread(name),
 	ScriptApiBase(ScriptingType::Async),
+	Thread(name),
 	jobDispatcher(jobDispatcher)
 {
 	lua_State *L = getStack();
@@ -196,9 +200,9 @@ void* AsyncWorkerThread::run()
 {
 	lua_State *L = getStack();
 
-	std::string script = getServer()->getBuiltinLuaPath() + DIR_DELIM + "init.lua";
 	try {
-		loadScript(script);
+		loadMod(getServer()->getBuiltinLuaPath() + DIR_DELIM + "init.lua",
+			BUILTIN_MOD_NAME);
 	} catch (const ModError &e) {
 		errorstream << "Execution of async base environment failed: "
 			<< e.what() << std::endl;
@@ -213,44 +217,44 @@ void* AsyncWorkerThread::run()
 	}
 
 	// Main loop
+	LuaJobInfo j;
 	while (!stopRequested()) {
 		// Wait for job
-		LuaJobInfo toProcess = jobDispatcher->getJob();
-
-		if (!toProcess.valid || stopRequested()) {
+		if (!jobDispatcher->getJob(&j) || stopRequested())
 			continue;
-		}
 
 		lua_getfield(L, -1, "job_processor");
-		if (lua_isnil(L, -1)) {
+		if (lua_isnil(L, -1))
 			FATAL_ERROR("Unable to get async job processor!");
-		}
-
 		luaL_checktype(L, -1, LUA_TFUNCTION);
 
-		// Call it
-		lua_pushlstring(L,
-				toProcess.serializedFunction.data(),
-				toProcess.serializedFunction.size());
-		lua_pushlstring(L,
-				toProcess.serializedParams.data(),
-				toProcess.serializedParams.size());
+		if (luaL_loadbuffer(L, j.function.data(), j.function.size(), "=(async)")) {
+			errorstream << "ASYNC WORKER: Unable to deserialize function" << std::endl;
+			lua_pushnil(L);
+		}
+		lua_pushlstring(L, j.params.data(), j.params.size());
 
+		// Call it
+		setOriginDirect(j.mod_origin.empty() ? nullptr : j.mod_origin.c_str());
 		int result = lua_pcall(L, 2, 1, error_handler);
 		if (result) {
-			PCALL_RES(result);
-			toProcess.serializedResult = "";
+			try {
+				scriptError(result, "<async>");
+			} catch (const ModError &e) {
+				errorstream << e.what() << std::endl;
+			}
 		} else {
 			// Fetch result
 			size_t length;
 			const char *retval = lua_tolstring(L, -1, &length);
-			toProcess.serializedResult = std::string(retval, length);
+			j.result.assign(retval, length);
 		}
 
 		lua_pop(L, 1);  // Pop retval
 
 		// Put job result
-		jobDispatcher->putJobResult(toProcess);
+		if (!j.result.empty())
+			jobDispatcher->putJobResult(std::move(j));
 	}
 
 	lua_pop(L, 2);  // Pop core and error handler