ScriptReloadMgr.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 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 General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "ScriptReloadMgr.h"
#include "Errors.h"
 
#ifndef TRINITY_API_USE_DYNAMIC_LINKING
 
// This method should never be called
std::shared_ptr<ModuleReference>
 ScriptReloadMgr::AcquireModuleReferenceOfContext(std::string const& /*context*/)
{
 WPAbort();
}
 
// Returns the empty implemented ScriptReloadMgr
ScriptReloadMgr* ScriptReloadMgr::instance()
{
 static ScriptReloadMgr instance;
 return &instance;
}
 
#else
 
#include "BuiltInConfig.h"
#include "Config.h"
#include "GitRevision.h"
#include "CryptoHash.h"
#include "Duration.h"
#include "Log.h"
#include "MPSCQueue.h"
#include "Optional.h"
#include "Regex.h"
#include "ScriptMgr.h"
#include "StartProcess.h"
#include "Timer.h"
#include "Util.h"
#include "World.h"
#include <boost/algorithm/string/replace.hpp>
#include <boost/dll/runtime_symbol_info.hpp>
#include <boost/filesystem.hpp>
#include <boost/system/system_error.hpp>
#include <efsw/efsw.hpp>
#include <algorithm>
#include <fstream>
#include <future>
#include <memory>
#include <sstream>
#include <thread>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace fs = boost::filesystem;
 
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
 #include <windows.h>
#else // Posix and Apple
 #include <dlfcn.h>
#endif
 
// Promote the sScriptReloadMgr to a HotSwapScriptReloadMgr
// in this compilation unit.
#undef sScriptReloadMgr
#define sScriptReloadMgr static_cast<HotSwapScriptReloadMgr*>(ScriptReloadMgr::instance())
 
// Returns "" on Windows and "lib" on posix.
static char const* GetSharedLibraryPrefix()
{
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
 return "";
#else // Posix
 return "lib";
#endif
}
 
// Returns "dll" on Windows, "dylib" on OS X, and "so" on posix.
static char const* GetSharedLibraryExtension()
{
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
 return "dll";
#elif TRINITY_PLATFORM == TRINITY_PLATFORM_APPLE
 return "dylib";
#else // Posix
 return "so";
#endif
}
 
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
typedef HMODULE HandleType;
#else // Posix
typedef void* HandleType;
#endif
 
static fs::path GetDirectoryOfExecutable()
{
 return boost::dll::program_location().parent_path();
}
 
class SharedLibraryUnloader
{
public:
 explicit SharedLibraryUnloader(fs::path path)
 : path_(std::move(path)) { }
 SharedLibraryUnloader(fs::path path, Optional<fs::path> cache_path)
 : path_(std::move(path)), cache_path_(std::move(cache_path)) { }
 
 void operator() (HandleType handle) const
 {
 // Unload the associated shared library.
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
 bool success = (FreeLibrary(handle) != 0);
#else // Posix
 bool success = (dlclose(handle) == 0);
#endif
 
 if (!success)
 {
 TC_LOG_ERROR("scripts.hotswap", "Failed to unload (syscall) the shared library \"{}\".",
 path_.generic_string());
 
 return;
 }
 
 if (cache_path_)
 {
 boost::system::error_code error;
 if (!fs::remove(*cache_path_, error))
 {
 TC_LOG_ERROR("scripts.hotswap", "Failed to delete the cached shared library \"{}\" ({}).",
 cache_path_->generic_string(), error.message());
 
 return;
 }
 
 TC_LOG_TRACE("scripts.hotswap", "Lazy unloaded the shared library \"{}\" "
 "and deleted it's cached version at \"{}\"",
 path_.generic_string(), cache_path_->generic_string());
 }
 else
 {
 TC_LOG_TRACE("scripts.hotswap", "Lazy unloaded the shared library \"{}\".",
 path_.generic_string());
 }
 }
 
private:
 fs::path const path_;
 Optional<fs::path> const cache_path_;
};
 
typedef std::unique_ptr<typename std::remove_pointer<HandleType>::type, SharedLibraryUnloader> HandleHolder;
 
typedef char const* (*GetScriptModuleRevisionHashType)();
typedef void (*AddScriptsType)();
typedef char const* (*GetScriptModuleType)();
typedef char const* (*GetBuildDirectiveType)();
 
class ScriptModule
 : public ModuleReference
{
public:
 explicit ScriptModule(HandleHolder handle, GetScriptModuleRevisionHashType getScriptModuleRevisionHash,
 AddScriptsType addScripts, GetScriptModuleType getScriptModule,
 GetBuildDirectiveType getBuildDirective, fs::path const& path)
 : _handle(std::forward<HandleHolder>(handle)), _getScriptModuleRevisionHash(getScriptModuleRevisionHash),
 _addScripts(addScripts), _getScriptModule(getScriptModule),
 _getBuildDirective(getBuildDirective), _path(path) { }
 
 ScriptModule(ScriptModule const&) = delete;
 ScriptModule(ScriptModule&& right) = delete;
 
 ScriptModule& operator= (ScriptModule const&) = delete;
 ScriptModule& operator= (ScriptModule&& right) = delete;
 
 static Optional<std::shared_ptr<ScriptModule>>
 CreateFromPath(fs::path const& path, Optional<fs::path> cache_path);
 
 static void ScheduleDelayedDelete(ScriptModule* module);
 
 char const* GetScriptModuleRevisionHash() const override
 {
 return _getScriptModuleRevisionHash();
 }
 
 void AddScripts() const
 {
 return _addScripts();
 }
 
 char const* GetScriptModule() const override
 {
 return _getScriptModule();
 }
 
 char const* GetBuildDirective() const
 {
 return _getBuildDirective();
 }
 
 fs::path const& GetModulePath() const override
 {
 return _path;
 }
 
private:
 HandleHolder _handle;
 
 GetScriptModuleRevisionHashType _getScriptModuleRevisionHash;
 AddScriptsType _addScripts;
 GetScriptModuleType _getScriptModule;
 GetBuildDirectiveType _getBuildDirective;
 
 fs::path _path;
};
 
template<typename Fn>
static bool GetFunctionFromSharedLibrary(HandleType handle, std::string const& name, Fn& fn)
{
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
 fn = reinterpret_cast<Fn>(GetProcAddress(handle, name.c_str()));
#else // Posix
 fn = reinterpret_cast<Fn>(dlsym(handle, name.c_str()));
#endif
 return fn != nullptr;
}
 
// Load a shared library from the given path.
Optional<std::shared_ptr<ScriptModule>>
 ScriptModule::CreateFromPath(fs::path const& path, Optional<fs::path> cache_path)
{
 auto const load_path = [&] () -> fs::path {
 if (cache_path)
 return *cache_path;
 else
 return path;
 }();
 
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
 HandleType handle = LoadLibrary(load_path.generic_string().c_str());
#else // Posix
 HandleType handle = dlopen(load_path.generic_string().c_str(), RTLD_LAZY);
#endif
 
 if (!handle)
 {
 if (cache_path)
 {
 TC_LOG_ERROR("scripts.hotswap", "Could not dynamic load the shared library \"{}\" "
 "(the library is cached at {})",
 path.generic_string(), cache_path->generic_string());
 }
 else
 {
 TC_LOG_ERROR("scripts.hotswap", "Could not dynamic load the shared library \"{}\".",
 path.generic_string());
 }
 
 return {};
 }
 
 // Use RAII to release the library on failure.
 HandleHolder holder(handle, SharedLibraryUnloader(path, std::move(cache_path)));
 
 GetScriptModuleRevisionHashType getScriptModuleRevisionHash;
 AddScriptsType addScripts;
 GetScriptModuleType getScriptModule;
 GetBuildDirectiveType getBuildDirective;
 
 if (GetFunctionFromSharedLibrary(handle, "GetScriptModuleRevisionHash", getScriptModuleRevisionHash) &&
 GetFunctionFromSharedLibrary(handle, "AddScripts", addScripts) &&
 GetFunctionFromSharedLibrary(handle, "GetScriptModule", getScriptModule) &&
 GetFunctionFromSharedLibrary(handle, "GetBuildDirective", getBuildDirective))
 {
 auto module = new ScriptModule(std::move(holder), getScriptModuleRevisionHash,
 addScripts, getScriptModule, getBuildDirective, path);
 
 // Unload the module at the next update tick as soon as all references are removed
 return std::shared_ptr<ScriptModule>(module, ScheduleDelayedDelete);
 }
 else
 {
 TC_LOG_ERROR("scripts.hotswap", "Could not extract all required functions from the shared library \"{}\"!",
 path.generic_string());
 
 return {};
 }
}
 
static bool HasValidScriptModuleName(std::string const& name)
{
 // Detects scripts_NAME.dll's / .so's
 static Trinity::regex const regex(
 Trinity::StringFormat("^{}[sS]cripts_[a-zA-Z0-9_]+\\.{}$",
 GetSharedLibraryPrefix(),
 GetSharedLibraryExtension()));
 
 return Trinity::regex_match(name, regex);
}
 
class LibraryUpdateListener : public efsw::FileWatchListener
{
public:
 LibraryUpdateListener() { }
 virtual ~LibraryUpdateListener() { }
 
 void handleFileAction(efsw::WatchID /*watchid*/, std::string const& dir,
 std::string const& filename, efsw::Action action, std::string oldFilename = "") final override;
};
 
static LibraryUpdateListener libraryUpdateListener;
 
class SourceUpdateListener : public efsw::FileWatchListener
{
 fs::path const path_;
 
 std::string const script_module_name_;
 
 efsw::WatchID const watcher_id_;
 
public:
 explicit SourceUpdateListener(fs::path path, std::string script_module_name);
 
 virtual ~SourceUpdateListener();
 
 void handleFileAction(efsw::WatchID /*watchid*/, std::string const& dir,
 std::string const& filename, efsw::Action action, std::string oldFilename = "") final override;
};
 
namespace std
{
 template <>
 struct hash<fs::path>
 {
 hash<string> hasher;
 
 std::size_t operator()(fs::path const& key) const noexcept
 {
 return hasher(key.generic_string());
 }
 };
}
 
template<typename... T>
static int InvokeCMakeCommand(T&&... args)
{
 auto const executable = BuiltInConfig::GetCMakeCommand();
 return Trinity::StartProcess(executable, {
 std::forward<T>(args)...
 }, "scripts.hotswap");
}
 
template<typename... T>
static std::shared_ptr<Trinity::AsyncProcessResult> InvokeAsyncCMakeCommand(T&&... args)
{
 auto const executable = BuiltInConfig::GetCMakeCommand();
 return Trinity::StartAsyncProcess(executable, {
 std::forward<T>(args)...
 }, "scripts.hotswap");
}
 
static std::string CalculateScriptModuleProjectName(std::string const& module)
{
 std::string module_project = "scripts_" + module;
 strToLower(module_project);
 
 return module_project;
}
 
static bool IsDebuggerBlockingRebuild()
{
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
 if (IsDebuggerPresent())
 return true;
#endif
 return false;
}
 
class HotSwapScriptReloadMgr final
 : public ScriptReloadMgr
{
 friend class ScriptReloadMgr;
 friend class SourceUpdateListener;
 
 enum class ChangeStateRequest : uint8
 {
 CHANGE_REQUEST_ADDED,
 CHANGE_REQUEST_MODIFIED,
 CHANGE_REQUEST_REMOVED
 };
 
 enum class BuildJobType : uint8
 {
 BUILD_JOB_NONE,
 BUILD_JOB_RERUN_CMAKE,
 BUILD_JOB_COMPILE,
 BUILD_JOB_INSTALL,
 };
 
 // Represents a job which was invoked through a source or shared library change
 class BuildJob
 {
 // Script module which is processed in the current running job
 std::string script_module_name_;
 // The C++ project name of the module which is processed
 std::string script_module_project_name_;
 // The build directive of the current module which is processed
 // like "Release" or "Debug". The build directive from the
 // previous same module is used if there was any.
 std::string script_module_build_directive_;
 // The time where the build job started
 uint32 start_time_;
 
 // Type of the current running job
 BuildJobType type_;
 // The async process result of the current job
 std::shared_ptr<Trinity::AsyncProcessResult> async_result_;
 
 public:
 explicit BuildJob(std::string script_module_name, std::string script_module_project_name,
 std::string script_module_build_directive)
 : script_module_name_(std::move(script_module_name)),
 script_module_project_name_(std::move(script_module_project_name)),
 script_module_build_directive_(std::move(script_module_build_directive)),
 start_time_(getMSTime()), type_(BuildJobType::BUILD_JOB_NONE) { }
 
 bool IsValid() const
 {
 return type_ != BuildJobType::BUILD_JOB_NONE;
 }
 
 std::string const& GetModuleName() const { return script_module_name_; }
 
 std::string const& GetProjectName() const { return script_module_project_name_; }
 
 std::string const& GetBuildDirective() const { return script_module_build_directive_; }
 
 uint32 GetTimeFromStart() const { return GetMSTimeDiffToNow(start_time_); }
 
 BuildJobType GetType() const { return type_; }
 
 std::shared_ptr<Trinity::AsyncProcessResult> const& GetProcess() const
 {
 ASSERT(async_result_, "Tried to access an empty process handle!");
 return async_result_;
 }
 
 void UpdateCurrentJob(BuildJobType type,
 std::shared_ptr<Trinity::AsyncProcessResult> async_result)
 {
 ASSERT(type != BuildJobType::BUILD_JOB_NONE, "None isn't allowed here!");
 ASSERT(async_result, "The async result must not be empty!");
 
 type_ = type;
 async_result_ = std::move(async_result);
 }
 };
 
 class ScriptReloaderMessage
 {
 public:
 virtual ~ScriptReloaderMessage() { }
 
 virtual void operator() (HotSwapScriptReloadMgr* reloader) = 0;
 };
 
 template<typename T>
 class ScriptReloaderMessageImplementation
 : public ScriptReloaderMessage
 {
 T dispatcher_;
 
 public:
 explicit ScriptReloaderMessageImplementation(T dispatcher)
 : dispatcher_(std::move(dispatcher)) { }
 
 void operator() (HotSwapScriptReloadMgr* reloader) final override
 {
 dispatcher_(reloader);
 }
 };
 
 template<typename T>
 auto MakeMessage(T&& dispatcher)
 -> ScriptReloaderMessageImplementation<typename std::decay<T>::type>*
 {
 return new ScriptReloaderMessageImplementation<typename std::decay<T>::type>
 (std::forward<T>(dispatcher));
 }
 
public:
 HotSwapScriptReloadMgr()
 : _libraryWatcher(-1), _unique_library_name_counter(0),
 _last_time_library_changed(0), _last_time_sources_changed(0),
 _last_time_user_informed(0), terminate_early(false) { }
 
 virtual ~HotSwapScriptReloadMgr()
 {
 // Delete all messages
 ScriptReloaderMessage* message;
 while (_messages.Dequeue(message))
 delete message;
 }
 
 static fs::path GetLibraryDirectory()
 {
 // When an absolute path is given in the config use it,
 // otherwise interpret paths relative to the executable.
 fs::path path(sConfigMgr->GetStringDefault("HotSwap.ScriptDir", "scripts"));
 if (path.is_absolute())
 return path;
 else
 return fs::absolute(path, GetDirectoryOfExecutable());
 }
 
 static fs::path GetSourceDirectory()
 {
 fs::path dir = BuiltInConfig::GetSourceDirectory();
 dir /= "src";
 dir /= "server";
 dir /= "scripts";
 return dir;
 }
 
 void Initialize() final override
 {
 if (!sWorld->getBoolConfig(CONFIG_HOTSWAP_ENABLED))
 return;
 
 if (BuiltInConfig::GetBuildDirectory().find(" ") != std::string::npos)
 {
 TC_LOG_ERROR("scripts.hotswap", "Your build directory path \"{}\" "
 "contains spaces, which isn't allowed for compatibility reasons! "
 "You need to create a build directory which doesn't contain any space character "
 "in it's path!",
 BuiltInConfig::GetBuildDirectory());
 
 return;
 }
 
 {
 auto const library_directory = GetLibraryDirectory();
 if (!fs::exists(library_directory) || !fs::is_directory(library_directory))
 {
 TC_LOG_ERROR("scripts.hotswap", "Library directory \"{}\" doesn't exist!.",
 library_directory.generic_string());
 return;
 }
 }
 
 temporary_cache_path_ = CalculateTemporaryCachePath();
 
 // We use the boost filesystem function versions which accept
 // an error code to prevent it from throwing exceptions.
 boost::system::error_code code;
 if ((!fs::exists(temporary_cache_path_, code)
 || (fs::remove_all(temporary_cache_path_, code) > 0)) &&
 !fs::create_directories(temporary_cache_path_, code))
 {
 TC_LOG_ERROR("scripts.hotswap", "Couldn't create the cache directory at \"{}\".",
 temporary_cache_path_.generic_string());
 
 return;
 }
 
 // Used to silent compiler warnings
 (void)code;
 
 // Correct the CMake prefix when needed
 if (sWorld->getBoolConfig(CONFIG_HOTSWAP_PREFIX_CORRECTION_ENABLED))
 DoCMakePrefixCorrectionIfNeeded();
 
 InitializeDefaultLibraries();
 InitializeFileWatchers();
 }
 
 void Update() final override
 {
 // Consume all messages
 ScriptReloaderMessage* message;
 while (_messages.Dequeue(message))
 {
 (*message)(this);
 delete message;
 }
 
 DispatchRunningBuildJobs();
 DispatchModuleChanges();
 }
 
 void Unload() final override
 {
 if (_libraryWatcher >= 0)
 {
 _fileWatcher.removeWatch(_libraryWatcher);
 _libraryWatcher = -1;
 }
 
 // If a build is in progress cancel it
 if (_build_job)
 {
 _build_job->GetProcess()->Terminate();
 _build_job.reset();
 }
 
 // Release all strong references to script modules
 // to trigger unload actions as early as possible,
 // otherwise the worldserver will crash on exit.
 _running_script_modules.clear();
 }
 
 template<typename T>
 void QueueMessage(T&& message)
 {
 _messages.Enqueue(MakeMessage(std::forward<T>(message)));
 }
 
 void QueueSharedLibraryChanged(fs::path const& path)
 {
 _last_time_library_changed = getMSTime();
 _libraries_changed.insert(path);
 }
 
 void QueueAddSourceFile(std::string const& module_name, fs::path const& path)
 {
 UpdateSourceChangeRequest(module_name, path, ChangeStateRequest::CHANGE_REQUEST_ADDED);
 }
 
 void QueueModifySourceFile(std::string const& module_name, fs::path const& path)
 {
 UpdateSourceChangeRequest(module_name, path, ChangeStateRequest::CHANGE_REQUEST_MODIFIED);
 }
 
 void QueueRemoveSourceFile(std::string const& module_name, fs::path const& path)
 {
 UpdateSourceChangeRequest(module_name, path, ChangeStateRequest::CHANGE_REQUEST_REMOVED);
 }
 
private:
 // Loads all shared libraries which are contained in the
 // scripts directory on startup.
 void InitializeDefaultLibraries()
 {
 fs::path const libraryDirectory(GetLibraryDirectory());
 fs::directory_iterator const dir_end;
 
 uint32 count = 0;
 
 // Iterate through all shared libraries in the script directory and load it
 for (fs::directory_iterator dir_itr(libraryDirectory); dir_itr != dir_end ; ++dir_itr)
 if (fs::is_regular_file(dir_itr->path()) && HasValidScriptModuleName(dir_itr->path().filename().generic_string()))
 {
 TC_LOG_INFO("scripts.hotswap", "Loading script module \"{}\"...",
 dir_itr->path().filename().generic_string());
 
 // Don't swap the script context to do bulk loading
 ProcessLoadScriptModule(dir_itr->path(), false);
 ++count;
 }
 
 TC_LOG_INFO("scripts.hotswap", ">> Loaded {} script modules.", count);
 }
 
 // Initialize all enabled file watchers.
 // Needs to be called after InitializeDefaultLibraries()!
 void InitializeFileWatchers()
 {
 _libraryWatcher = _fileWatcher.addWatch(GetLibraryDirectory().generic_string(), &libraryUpdateListener, false);
 if (_libraryWatcher >= 0)
 {
 TC_LOG_INFO("scripts.hotswap", ">> Library reloader is listening on \"{}\".",
 GetLibraryDirectory().generic_string());
 }
 else
 {
 TC_LOG_ERROR("scripts.hotswap", "Failed to initialize the library reloader on \"{}\".",
 GetLibraryDirectory().generic_string());
 }
 
 _fileWatcher.watch();
 }
 
 static fs::path CalculateTemporaryCachePath()
 {
 auto path = fs::temp_directory_path();
 path /= Trinity::StringFormat("tc_script_cache_{}_{}",
 GitRevision::GetBranch(),
 ByteArrayToHexStr(Trinity::Crypto::SHA1::GetDigestOf(sConfigMgr->GetFilename())));
 
 return path;
 }
 
 fs::path GenerateUniquePathForLibraryInCache(fs::path path)
 {
 ASSERT(!temporary_cache_path_.empty(),
 "The temporary cache path wasn't set!");
 
 // Create the cache path and increment the library counter to use an unique name for each library
 auto cache_path = temporary_cache_path_;
 cache_path /= Trinity::StringFormat("{}.{}{}",
 path.stem().generic_string(),
 _unique_library_name_counter++,
 path.extension().generic_string());
 
 return cache_path;
 }
 
 void UpdateSourceChangeRequest(std::string const& module_name,
 fs::path const& path,
 ChangeStateRequest state)
 {
 _last_time_sources_changed = getMSTime();
 
 // Write when there is no module with the given name known
 auto module_itr = _sources_changed.find(module_name);
 
 // When the file was modified it's enough to mark the module as
 // dirty by initializing the associated map.
 if (module_itr == _sources_changed.end())
 module_itr = _sources_changed.insert(std::make_pair(
 module_name, decltype(_sources_changed)::mapped_type{})).first;
 
 // Leave when the file was just modified as explained above
 if (state == ChangeStateRequest::CHANGE_REQUEST_MODIFIED)
 return;
 
 // Insert when the given path isn't existent
 auto const itr = module_itr->second.find(path);
 if (itr == module_itr->second.end())
 {
 module_itr->second.insert(std::make_pair(path, state));
 return;
 }
 
 ASSERT((itr->second == ChangeStateRequest::CHANGE_REQUEST_ADDED)
 || (itr->second == ChangeStateRequest::CHANGE_REQUEST_REMOVED),
 "Stored value is invalid!");
 
 ASSERT((state == ChangeStateRequest::CHANGE_REQUEST_ADDED)
 || (state == ChangeStateRequest::CHANGE_REQUEST_REMOVED),
 "The given state is invalid!");
 
 ASSERT(state != itr->second,
 "Tried to apply a state which is stored already!");
 
 module_itr->second.erase(itr);
 }
 
 void DispatchModuleChanges()
 {
 // When there are no libraries to change return
 if (_libraries_changed.empty())
 return;
 
 // Wait some time after changes to catch bulk changes
 if (GetMSTimeDiffToNow(_last_time_library_changed) < 500)
 return;
 
 for (auto const& path : _libraries_changed)
 {
 bool const is_running =
 _running_script_module_names.find(path) != _running_script_module_names.end();
 
 bool const exists = fs::exists(path);
 
 if (is_running)
 {
 if (exists)
 ProcessReloadScriptModule(path);
 else
 ProcessUnloadScriptModule(path);
 }
 else if (exists)
 ProcessLoadScriptModule(path);
 }
 
 _libraries_changed.clear();
 }
 
 void ProcessLoadScriptModule(fs::path const& path, bool swap_context = true)
 {
 ASSERT(_running_script_module_names.find(path) == _running_script_module_names.end(),
 "Can't load a module which is running already!");
 
 // Copy the shared library into a cache
 auto cache_path = GenerateUniquePathForLibraryInCache(path);
 
 {
 boost::system::error_code code;
 fs::copy_file(path, cache_path, fs::copy_option::fail_if_exists, code);
 if (code)
 {
 TC_LOG_FATAL("scripts.hotswap", ">> Failed to create cache entry for module "
 "\"{}\" at \"{}\" with reason (\"{}\")!",
 path.filename().generic_string(), cache_path.generic_string(),
 code.message());
 
 // Find a better solution for this but it's much better
 // to start the core without scripts
 std::this_thread::sleep_for(std::chrono::seconds(5));
 ABORT();
 return;
 }
 
 TC_LOG_TRACE("scripts.hotswap", ">> Copied the shared library \"{}\" to \"{}\" for caching.",
 path.filename().generic_string(), cache_path.generic_string());
 }
 
 auto module = ScriptModule::CreateFromPath(path, cache_path);
 if (!module)
 {
 TC_LOG_FATAL("scripts.hotswap", ">> Failed to load script module \"{}\"!",
 path.filename().generic_string());
 
 // Find a better solution for this but it's much better
 // to start the core without scripts
 std::this_thread::sleep_for(std::chrono::seconds(5));
 ABORT();
 return;
 }
 
 // Limit the git revision hash to 7 characters.
 std::string module_revision((*module)->GetScriptModuleRevisionHash());
 if (module_revision.size() >= 7)
 module_revision = module_revision.substr(0, 7);
 
 std::string const module_name = (*module)->GetScriptModule();
 TC_LOG_INFO("scripts.hotswap", ">> Loaded script module \"{}\" (\"{}\" - {}).",
 path.filename().generic_string(), module_name, module_revision);
 
 if (module_revision.empty())
 {
 TC_LOG_WARN("scripts.hotswap", ">> Script module \"{}\" has an empty revision hash!",
 path.filename().generic_string());
 }
 else
 {
 // Trim the revision hash
 std::string my_revision_hash = GitRevision::GetHash();
 std::size_t const trim = std::min(module_revision.size(), my_revision_hash.size());
 my_revision_hash = my_revision_hash.substr(0, trim);
 module_revision = module_revision.substr(0, trim);
 
 if (my_revision_hash != module_revision)
 {
 TC_LOG_WARN("scripts.hotswap", ">> Script module \"{}\" has a different revision hash! "
 "Binary incompatibility could lead to unknown behaviour!", path.filename().generic_string());
 }
 }
 
 {
 auto const itr = _running_script_modules.find(module_name);
 if (itr != _running_script_modules.end())
 {
 TC_LOG_ERROR("scripts.hotswap", ">> Attempt to load a module twice \"{}\" (loaded module is at {})!",
 path.generic_string(), itr->second.first->GetModulePath().generic_string());
 
 return;
 }
 }
 
 // Create the source listener
 auto listener = std::make_unique<SourceUpdateListener>(
 sScriptReloadMgr->GetSourceDirectory() / module_name,
 module_name);
 
 // Store the module
 _known_modules_build_directives.insert(std::make_pair(module_name, (*module)->GetBuildDirective()));
 _running_script_modules.insert(std::make_pair(module_name,
 std::make_pair(*module, std::move(listener))));
 _running_script_module_names.insert(std::make_pair(path, module_name));
 
 // Process the script loading after the module was registered correctly (#17557).
 sScriptMgr->SetScriptContext(module_name);
 (*module)->AddScripts();
 TC_LOG_TRACE("scripts.hotswap", ">> Registered all scripts of module {}.", module_name);
 
 if (swap_context)
 sScriptMgr->SwapScriptContext();
 }
 
 void ProcessReloadScriptModule(fs::path const& path)
 {
 ProcessUnloadScriptModule(path, false);
 ProcessLoadScriptModule(path);
 }
 
 void ProcessUnloadScriptModule(fs::path const& path, bool finish = true)
 {
 auto const itr = _running_script_module_names.find(path);
 
 ASSERT(itr != _running_script_module_names.end(),
 "Can't unload a module which isn't running!");
 
 // Unload the script context
 sScriptMgr->ReleaseScriptContext(itr->second);
 
 if (finish)
 sScriptMgr->SwapScriptContext();
 
 TC_LOG_INFO("scripts.hotswap", "Released script module \"{}\" (\"{}\")...",
 path.filename().generic_string(), itr->second);
 
 // Unload the script module
 auto ref = _running_script_modules.find(itr->second);
 ASSERT(ref != _running_script_modules.end() &&
 "Expected the script reference to be present!");
 
 // Yield a message when there are other owning references to
 // the module which prevents it from unloading.
 // The module will be unloaded once all scripts provided from the module
 // are destroyed.
 if (ref->second.first.use_count() != 1)
 {
 TC_LOG_INFO("scripts.hotswap",
 "Script module {} is still used by {} spell, aura or instance scripts. "
 "Will lazy unload the module once all scripts stopped using it, "
 "to use the latest version of an edited script unbind yourself from "
 "the instance or re-cast the spell.",
 ref->second.first->GetScriptModule(), ref->second.first.use_count() - 1);
 }
 
 // Remove the owning reference from the reloader
 _running_script_modules.erase(ref);
 _running_script_module_names.erase(itr);
 }
 
 void DispatchRunningBuildJobs()
 {
 if (_build_job)
 {
 // Terminate the current build job when an associated source was changed
 // while compiling and the terminate early option is enabled.
 if (sWorld->getBoolConfig(CONFIG_HOTSWAP_EARLY_TERMINATION_ENABLED))
 {
 if (!terminate_early && _sources_changed.find(_build_job->GetModuleName()) != _sources_changed.end())
 {
 /*
 FIXME: Currently crashes the server
 TC_LOG_INFO("scripts.hotswap", "Terminating the running build of module \"{}\"...",
 _build_job->GetModuleName());
 
 _build_job->GetProcess()->Terminate();
 _build_job.reset();
 
 // Continue with the default execution path
 DispatchRunningBuildJobs();
 return;
 */
 
 terminate_early = true;
 return;
 }
 }
 
 // Wait for the current build job to finish, if the job finishes in time
 // evaluate it and continue with the next one.
 if (_build_job->GetProcess()->GetFutureResult().
 wait_for(0s) == std::future_status::ready)
 ProcessReadyBuildJob();
 else
 return; // Return when the job didn't finish in time
 
 // Skip this cycle when the previous job scheduled a new one
 if (_build_job)
 return;
 }
 
 // Avoid burst updates through waiting for a short time after changes
 if ((_last_time_sources_changed != 0) &&
 (GetMSTimeDiffToNow(_last_time_sources_changed) < 500))
 return;
 
 // If the changed sources are empty do nothing
 if (_sources_changed.empty())
 return;
 
 // Wait until are attached debugger were detached.
 if (IsDebuggerBlockingRebuild())
 {
 if ((_last_time_user_informed == 0) ||
 (GetMSTimeDiffToNow(_last_time_user_informed) > 7500))
 {
 _last_time_user_informed = getMSTime();
 
 // Informs the user that the attached debugger is blocking the automatic script rebuild.
 TC_LOG_INFO("scripts.hotswap", "Your attached debugger is blocking the TrinityCore "
 "automatic script rebuild, please detach it!");
 }
 
 return;
 }
 
 // Find all source files of a changed script module and removes
 // it from the changed source list, invoke the build afterwards.
 bool rebuild_buildfiles;
 auto module_name = [&]
 {
 auto itr = _sources_changed.begin();
 auto name = itr->first;
 rebuild_buildfiles = !itr->second.empty();
 
 if (sLog->ShouldLog("scripts.hotswap", LogLevel::LOG_LEVEL_TRACE))
 for (auto const& entry : itr->second)
 {
 TC_LOG_TRACE("scripts.hotswap", "Source file {} was {}.",
 entry.first.generic_string(),
 ((entry.second == ChangeStateRequest::CHANGE_REQUEST_ADDED) ?
 "added" : "removed"));
 }
 
 _sources_changed.erase(itr);
 return name;
 }();
 
 // Erase the added delete history all modules when we
 // invoke a cmake rebuild since we add all
 // added files of other modules to the build as well
 if (rebuild_buildfiles)
 {
 for (auto& entry : _sources_changed)
 entry.second.clear();
 }
 
 ASSERT(!module_name.empty(),
 "The current module name is invalid!");
 
 TC_LOG_INFO("scripts.hotswap", "Recompiling Module \"{}\"...",
 module_name);
 
 // Calculate the project name of the script module
 auto project_name = CalculateScriptModuleProjectName(module_name);
 
 // Find the best build directive for the module
 auto build_directive = [&] () -> std::string
 {
 auto directive = sConfigMgr->GetStringDefault("HotSwap.ReCompilerBuildType", "");
 if (!directive.empty())
 return directive;
 
 auto const itr = _known_modules_build_directives.find(module_name);
 if (itr != _known_modules_build_directives.end())
 return itr->second;
 else // If no build directive of the module was found use the one from the game library
 return _BUILD_DIRECTIVE;
 }();
 
 // Initiate the new build job
 _build_job = BuildJob(std::move(module_name),
 std::move(project_name), std::move(build_directive));
 
 // Rerun CMake when we need to recreate the build files
 if (rebuild_buildfiles
 && sWorld->getBoolConfig(CONFIG_HOTSWAP_BUILD_FILE_RECREATION_ENABLED))
 DoRerunCMake();
 else
 DoCompileCurrentProcessedModule();
 }
 
 void ProcessReadyBuildJob()
 {
 ASSERT(_build_job->IsValid(), "Invalid build job!");
 
 // Retrieve the result
 auto const error = _build_job->GetProcess()->GetFutureResult().get();
 
 if (terminate_early)
 {
 _build_job.reset();
 terminate_early = false;
 return;
 }
 
 switch (_build_job->GetType())
 {
 case BuildJobType::BUILD_JOB_RERUN_CMAKE:
 {
 if (!error)
 {
 TC_LOG_INFO("scripts.hotswap", ">> Successfully updated the build files!");
 }
 else
 {
 TC_LOG_INFO("scripts.hotswap", ">> Failed to update the build files at \"{}\", "
 "it's possible that recently added sources are not included "
 "in your next builds, rerun CMake manually.",
 BuiltInConfig::GetBuildDirectory());
 }
 // Continue with building the changes sources
 DoCompileCurrentProcessedModule();
 return;
 }
 case BuildJobType::BUILD_JOB_COMPILE:
 {
 if (!error) // Build was successful
 {
 if (sWorld->getBoolConfig(CONFIG_HOTSWAP_INSTALL_ENABLED))
 {
 // Continue with the installation when it's enabled
 TC_LOG_INFO("scripts.hotswap",
 ">> Successfully build module {}, continue with installing...",
 _build_job->GetModuleName());
 
 DoInstallCurrentProcessedModule();
 return;
 }
 
 // Skip the installation because it's disabled in config
 TC_LOG_INFO("scripts.hotswap",
 ">> Successfully build module {}, skipped the installation.",
 _build_job->GetModuleName());
 }
 else // Build wasn't successful
 {
 TC_LOG_ERROR("scripts.hotswap",
 ">> The build of module {} failed! See the log for details.",
 _build_job->GetModuleName());
 }
 break;
 }
 case BuildJobType::BUILD_JOB_INSTALL:
 {
 if (!error)
 {
 // Installation was successful
 TC_LOG_INFO("scripts.hotswap", ">> Successfully installed module {} in {}s",
 _build_job->GetModuleName(),
 _build_job->GetTimeFromStart() / IN_MILLISECONDS);
 }
 else
 {
 // Installation wasn't successful
 TC_LOG_INFO("scripts.hotswap",
 ">> The installation of module {} failed! See the log for details.",
 _build_job->GetModuleName());
 }
 break;
 }
 default:
 break;
 }
 
 // Clear the current job
 _build_job.reset();
 }
 
 void DoRerunCMake()
 {
 ASSERT(_build_job, "There isn't any active build job!");
 
 TC_LOG_INFO("scripts.hotswap", "Rerunning CMake because there were sources added or removed...");
 
 _build_job->UpdateCurrentJob(BuildJobType::BUILD_JOB_RERUN_CMAKE,
 InvokeAsyncCMakeCommand(BuiltInConfig::GetBuildDirectory()));
 }
 
 void DoCompileCurrentProcessedModule()
 {
 ASSERT(_build_job, "There isn't any active build job!");
 
 TC_LOG_INFO("scripts.hotswap", "Starting asynchronous build job for module {}...",
 _build_job->GetModuleName());
 
 _build_job->UpdateCurrentJob(BuildJobType::BUILD_JOB_COMPILE,
 InvokeAsyncCMakeCommand(
 "--build", BuiltInConfig::GetBuildDirectory(),
 "--target", _build_job->GetProjectName(),
 "--config", _build_job->GetBuildDirective()));
 }
 
 void DoInstallCurrentProcessedModule()
 {
 ASSERT(_build_job, "There isn't any active build job!");
 
 TC_LOG_INFO("scripts.hotswap", "Starting asynchronous install job for module {}...",
 _build_job->GetModuleName());
 
 _build_job->UpdateCurrentJob(BuildJobType::BUILD_JOB_INSTALL,
 InvokeAsyncCMakeCommand(
 "-DCOMPONENT=" + _build_job->GetProjectName(),
 "-DBUILD_TYPE=" + _build_job->GetBuildDirective(),
 "-P", fs::absolute("cmake_install.cmake",
 BuiltInConfig::GetBuildDirectory()).generic_string()));
 }
 
 void DoCMakePrefixCorrectionIfNeeded()
 {
 TC_LOG_INFO("scripts.hotswap", "Correcting your CMAKE_INSTALL_PREFIX in \"{}\"...",
 BuiltInConfig::GetBuildDirectory());
 
 auto const cmake_cache_path = fs::absolute("CMakeCache.txt",
 BuiltInConfig::GetBuildDirectory());
 
 // Stop when the CMakeCache wasn't found
 if (![&]
 {
 boost::system::error_code error;
 if (!fs::exists(cmake_cache_path, error))
 {
 TC_LOG_ERROR("scripts.hotswap", ">> CMake cache \"{}\" doesn't exist, "
 "set the \"BuildDirectory\" option in your worldserver.conf to point"
 "to your build directory!",
 cmake_cache_path.generic_string());
 
 return false;
 }
 else
 return true;
 }())
 return;
 
 TC_LOG_TRACE("scripts.hotswap", "Checking CMake cache (\"{}\") "
 "for the correct CMAKE_INSTALL_PREFIX location...",
 cmake_cache_path.generic_string());
 
 std::string cmake_cache_content;
 {
 std::ifstream in(cmake_cache_path.generic_string());
 if (!in.is_open())
 {
 TC_LOG_ERROR("scripts.hotswap", ">> Failed to read the CMake cache at \"{}\"!",
 cmake_cache_path.generic_string());
 
 return;
 }
 
 std::ostringstream ss;
 ss << in.rdbuf();
 cmake_cache_content = ss.str();
 
 in.close();
 }
 
 static std::string const prefix_key = "CMAKE_INSTALL_PREFIX:PATH=";
 
 // Extract the value of CMAKE_INSTALL_PREFIX
 auto begin = cmake_cache_content.find(prefix_key);
 if (begin != std::string::npos)
 {
 begin += prefix_key.length();
 auto const end = cmake_cache_content.find("\n", begin);
 if (end != std::string::npos)
 {
 fs::path value = cmake_cache_content.substr(begin, end - begin);
 
 auto current_path = fs::current_path();
 
 #if TRINITY_PLATFORM != TRINITY_PLATFORM_WINDOWS
 // The worldserver location is ${CMAKE_INSTALL_PREFIX}/bin
 // on all other platforms then windows
 current_path = current_path.parent_path();
 #endif
 
 if (value != current_path)
 {
 // Prevent correction of the install prefix
 // when we are starting the core from inside the build tree
 bool const is_in_path = [&]
 {
 fs::path base = BuiltInConfig::GetBuildDirectory();
 fs::path branch = value;
 while (!branch.empty())
 {
 if (base == branch)
 return true;
 
 branch = branch.parent_path();
 }
 
 return false;
 }();
 
 if (is_in_path)
 return;
 
 TC_LOG_INFO("scripts.hotswap", ">> Found outdated CMAKE_INSTALL_PREFIX (\"{}\"), "
 "worldserver is currently installed at {}",
 value.generic_string(), current_path.generic_string());
 }
 else
 {
 TC_LOG_INFO("scripts.hotswap", ">> CMAKE_INSTALL_PREFIX is equal to the current path of execution.");
 return;
 }
 }
 }
 
 TC_LOG_INFO("scripts.hotswap", "Invoking CMake cache correction...");
 
 auto const error = InvokeCMakeCommand(
 "-DCMAKE_INSTALL_PREFIX:PATH=" + fs::current_path().generic_string(),
 BuiltInConfig::GetBuildDirectory());
 
 if (error)
 {
 TC_LOG_ERROR("scripts.hotswap", ">> Failed to update the CMAKE_INSTALL_PREFIX! "
 "This could lead to unexpected behaviour!");
 }
 else
 {
 TC_LOG_ERROR("scripts.hotswap", ">> Successfully corrected your CMAKE_INSTALL_PREFIX variable"
 "to point at your current path of execution.");
 }
 }
 
 // File watcher instance and watcher ID's
 efsw::FileWatcher _fileWatcher;
 efsw::WatchID _libraryWatcher;
 
 // Unique library name counter which is used to
 // generate unique names for every shared library version.
 uint32 _unique_library_name_counter;
 
 // Queue which is used for thread safe message processing
 MPSCQueue<ScriptReloaderMessage> _messages;
 
 // Change requests to load or unload shared libraries
 std::unordered_set<fs::path /*path*/> _libraries_changed;
 // The timestamp which indicates the last time a library was changed
 uint32 _last_time_library_changed;
 
 // Contains all running script modules
 // The associated shared libraries are unloaded immediately
 // on loosing ownership through RAII.
 std::unordered_map<std::string /*module name*/,
 std::pair<std::shared_ptr<ScriptModule>, std::unique_ptr<SourceUpdateListener>>
 > _running_script_modules;
 // Container which maps the path of a shared library to it's module name
 std::unordered_map<fs::path, std::string /*module name*/> _running_script_module_names;
 // Container which maps the module name to it's last known build directive
 std::unordered_map<std::string /*module name*/, std::string /*build directive*/> _known_modules_build_directives;
 
 // Modules which were changed and are queued for recompilation
 std::unordered_map<std::string /*module*/,
 std::unordered_map<fs::path /*path*/, ChangeStateRequest /*state*/>> _sources_changed;
 // Tracks the time since the last module has changed to avoid burst updates
 uint32 _last_time_sources_changed;
 
 // Tracks the last timestamp the user was informed about a certain repeating event.
 uint32 _last_time_user_informed;
 
 // Represents the current build job which is in progress
 Optional<BuildJob> _build_job;
 
 // Is true when the build job dispatcher should stop after
 // the current job has finished
 bool terminate_early;
 
 // The path to the tc_scripts temporary cache
 fs::path temporary_cache_path_;
};
 
class ScriptModuleDeleteMessage
{
public:
 explicit ScriptModuleDeleteMessage(ScriptModule* module)
 : module_(module) { }
 
 void operator() (HotSwapScriptReloadMgr*)
 {
 module_.reset();
 }
 
private:
 std::unique_ptr<ScriptModule> module_;
};
 
void ScriptModule::ScheduleDelayedDelete(ScriptModule* module)
{
 sScriptReloadMgr->QueueMessage(ScriptModuleDeleteMessage(module));
}
 
static char const* ActionToString(efsw::Action action)
{
 switch (action)
 {
 case efsw::Action::Add:
 return "added";
 case efsw::Action::Delete:
 return "deleted";
 case efsw::Action::Moved:
 return "moved";
 default:
 return "modified";
 }
}
 
void LibraryUpdateListener::handleFileAction(efsw::WatchID watchid, std::string const& dir,
 std::string const& filename, efsw::Action action, std::string oldFilename)
{
 // TC_LOG_TRACE("scripts.hotswap", "Library listener detected change on possible module \"{}\ ({})".", filename, ActionToString(action));
 
 // Split moved actions into a delete and an add action
 if (action == efsw::Action::Moved)
 {
 ASSERT(!oldFilename.empty(), "Old filename doesn't exist!");
 handleFileAction(watchid, dir, oldFilename, efsw::Action::Delete);
 handleFileAction(watchid, dir, filename, efsw::Action::Add);
 return;
 }
 
 sScriptReloadMgr->QueueMessage([=](HotSwapScriptReloadMgr* reloader) mutable
 {
 auto const path = fs::absolute(
 filename,
 sScriptReloadMgr->GetLibraryDirectory());
 
 if (!HasValidScriptModuleName(filename))
 return;
 
 switch (action)
 {
 case efsw::Actions::Add:
 TC_LOG_TRACE("scripts.hotswap", ">> Loading \"{}\" ({})...",
 path.generic_string(), ActionToString(action));
 reloader->QueueSharedLibraryChanged(path);
 break;
 case efsw::Actions::Delete:
 TC_LOG_TRACE("scripts.hotswap", ">> Unloading \"{}\" ({})...",
 path.generic_string(), ActionToString(action));
 reloader->QueueSharedLibraryChanged(path);
 break;
 case efsw::Actions::Modified:
 TC_LOG_TRACE("scripts.hotswap", ">> Reloading \"{}\" ({})...",
 path.generic_string(), ActionToString(action));
 reloader->QueueSharedLibraryChanged(path);
 break;
 default:
 ABORT();
 break;
 }
 });
}
 
static bool HasCXXSourceFileExtension(fs::path const& path)
{
 static Trinity::regex const regex("^\\.(h|hpp|c|cc|cpp)$");
 return Trinity::regex_match(path.extension().generic_string(), regex);
}
 
SourceUpdateListener::SourceUpdateListener(fs::path path, std::string script_module_name)
 : path_(std::move(path)), script_module_name_(std::move(script_module_name)),
 watcher_id_(sScriptReloadMgr->_fileWatcher.addWatch(path_.generic_string(), this, true))
{
 if (watcher_id_ >= 0)
 {
 TC_LOG_TRACE("scripts.hotswap", ">> Attached the source recompiler to \"{}\".",
 path_.generic_string());
 }
 else
 {
 TC_LOG_ERROR("scripts.hotswap", "Failed to initialize thesource recompiler on \"{}\".",
 path_.generic_string());
 }
}
 
SourceUpdateListener::~SourceUpdateListener()
{
 if (watcher_id_ >= 0)
 {
 sScriptReloadMgr->_fileWatcher.removeWatch(watcher_id_);
 
 TC_LOG_TRACE("scripts.hotswap", ">> Detached the source recompiler from \"{}\".",
 path_.generic_string());
 }
}
 
void SourceUpdateListener::handleFileAction(efsw::WatchID watchid, std::string const& dir,
 std::string const& filename, efsw::Action action, std::string oldFilename)
{
 // TC_LOG_TRACE("scripts.hotswap", "Source listener detected change on possible file \"{}/{}\" ({}).", dir, filename, ActionToString(action));
 
 // Skip the file change notification if the recompiler is disabled
 if (!sWorld->getBoolConfig(CONFIG_HOTSWAP_RECOMPILER_ENABLED))
 return;
 
 // Split moved actions into a delete and an add action
 if (action == efsw::Action::Moved)
 {
 ASSERT(!oldFilename.empty(), "Old filename doesn't exist!");
 handleFileAction(watchid, dir, oldFilename, efsw::Action::Delete);
 handleFileAction(watchid, dir, filename, efsw::Action::Add);
 return;
 }
 
 fs::path path = fs::absolute(
 filename,
 dir);
 
 // Check if the file is a C/C++ source file.
 if (!path.has_extension() || !HasCXXSourceFileExtension(path))
 return;
 
 sScriptReloadMgr->QueueMessage([=, this, path = std::move(path)](HotSwapScriptReloadMgr* reloader)
 {
 TC_LOG_TRACE("scripts.hotswap", "Detected source change on module \"{}\", "
 "queued for recompilation...", script_module_name_);
 
 switch (action)
 {
 case efsw::Actions::Add:
 TC_LOG_TRACE("scripts.hotswap", "Source file {} of module {} was added.",
 path.generic_string(), script_module_name_);
 reloader->QueueAddSourceFile(script_module_name_, path);
 break;
 case efsw::Actions::Delete:
 TC_LOG_TRACE("scripts.hotswap", "Source file {} of module {} was deleted.",
 path.generic_string(), script_module_name_);
 reloader->QueueRemoveSourceFile(script_module_name_, path);
 break;
 case efsw::Actions::Modified:
 TC_LOG_TRACE("scripts.hotswap", "Source file {} of module {} was modified.",
 path.generic_string(), script_module_name_);
 reloader->QueueModifySourceFile(script_module_name_, path);
 break;
 default:
 ABORT();
 break;
 }
 });
}
 
// Returns the module reference of the given context
std::shared_ptr<ModuleReference>
 ScriptReloadMgr::AcquireModuleReferenceOfContext(std::string const& context)
{
 // Return empty references for the static context exported by the worldserver
 if (context == ScriptMgr::GetNameOfStaticContext())
 return { };
 
 auto const itr = sScriptReloadMgr->_running_script_modules.find(context);
 ASSERT(itr != sScriptReloadMgr->_running_script_modules.end()
 && "Requested a reference to a non existent script context!");
 
 return itr->second.first;
}
 
// Returns the full hot swap implemented ScriptReloadMgr
ScriptReloadMgr* ScriptReloadMgr::instance()
{
 static HotSwapScriptReloadMgr instance;
 return &instance;
}
 
#endif // #ifndef TRINITY_API_USE_DYNAMIC_LINKING