Partially sync engine code

src/base/system.cpp

@@ -9,7 +9,9 @@
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
+#include <iomanip> // std::get_time
 #include <iterator> // std::size
+#include <sstream> // std::istringstream
 #include <string_view>
 
 #include "lock.h"
@@ -3429,6 +3431,22 @@ void str_timestamp(char *buffer, int buffer_size)
 {
 	str_timestamp_format(buffer, buffer_size, FORMAT_NOSPACE);
 }
+
+bool timestamp_from_str(const char *string, const char *format, time_t *timestamp)
+{
+	std::tm tm{};
+	std::istringstream ss(string);
+	ss >> std::get_time(&tm, format);
+	if(ss.fail() || !ss.eof())
+		return false;
+
+	time_t result = mktime(&tm);
+	if(result < 0)
+		return false;
+
+	*timestamp = result;
+	return true;
+}
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif

src/base/system.h

@@ -1779,6 +1779,21 @@ void str_timestamp_format(char *buffer, int buffer_size, const char *format)
 void str_timestamp_ex(time_t time, char *buffer, int buffer_size, const char *format)
 	GNUC_ATTRIBUTE((format(strftime, 4, 0)));
 
+/**
+ * Parses a string into a timestamp following a specified format.
+ *
+ * @ingroup Timestamp
+ *
+ * @param string Pointer to the string to parse
+ * @param format The time format to use (for example FORMAT_NOSPACE below)
+ * @param timestamp Pointer to the timestamp result
+ *
+ * @return true on success, false if the string could not be parsed with the specified format
+ *
+ */
+bool timestamp_from_str(const char *string, const char *format, time_t *timestamp)
+	GNUC_ATTRIBUTE((format(strftime, 2, 0)));
+
 #define FORMAT_TIME "%H:%M:%S"
 #define FORMAT_SPACE "%Y-%m-%d %H:%M:%S"
 #define FORMAT_NOSPACE "%Y-%m-%d_%H-%M-%S"

src/engine/engine.h

@@ -4,40 +4,24 @@
 #define ENGINE_ENGINE_H
 
 #include "kernel.h"
-#include <engine/shared/jobs.h>
+
+#include <memory>
 
 class CFutureLogger;
+class IJob;
 class ILogger;
 
-class CHostLookup : public IJob
-{
-private:
-	void Run() override;
-
-public:
-	CHostLookup();
-	CHostLookup(const char *pHostname, int Nettype);
-
-	int m_Result;
-	char m_aHostname[128];
-	int m_Nettype;
-	NETADDR m_Addr;
-};
-
 class IEngine : public IInterface
 {
 	MACRO_INTERFACE("engine")
 
-protected:
-	class CJobPool m_JobPool;
-
 public:
 	virtual ~IEngine() = default;
 
 	virtual void Init() = 0;
 	virtual void AddJob(std::shared_ptr<IJob> pJob) = 0;
-	virtual void SetAdditionalLogger(std::unique_ptr<ILogger> &&pLogger) = 0;
-	static void RunJobBlocking(IJob *pJob);
+	virtual void ShutdownJobs() = 0;
+	virtual void SetAdditionalLogger(std::shared_ptr<ILogger> &&pLogger) = 0;
 };
 
 extern IEngine *CreateEngine(const char *pAppname, std::shared_ptr<CFutureLogger> pFutureLogger, int Jobs);

src/engine/kernel.h

@@ -3,8 +3,6 @@
 #ifndef ENGINE_KERNEL_H
 #define ENGINE_KERNEL_H
 
-#include <base/system.h>
-
 class IKernel;
 class IInterface;
 
@@ -30,13 +28,13 @@ public: \
 \
 private:
 
-// This kernel thingie makes the structure very flat and basiclly singletons.
+// This kernel thingie makes the structure very flat and basically singletons.
 // I'm not sure if this is a good idea but it works for now.
 class IKernel
 {
 	// hide the implementation
-	virtual bool RegisterInterfaceImpl(const char *pInterfaceName, IInterface *pInterface, bool Destroy) = 0;
-	virtual bool ReregisterInterfaceImpl(const char *pInterfaceName, IInterface *pInterface) = 0;
+	virtual void RegisterInterfaceImpl(const char *pInterfaceName, IInterface *pInterface, bool Destroy) = 0;
+	virtual void ReregisterInterfaceImpl(const char *pInterfaceName, IInterface *pInterface) = 0;
 	virtual IInterface *RequestInterfaceImpl(const char *pInterfaceName) = 0;
 
 public:
@@ -46,14 +44,14 @@ class IKernel
 
 	// templated access to handle pointer conversions and interface names
 	template<class TINTERFACE>
-	bool RegisterInterface(TINTERFACE *pInterface, bool Destroy = true)
+	void RegisterInterface(TINTERFACE *pInterface, bool Destroy = true)
 	{
-		return RegisterInterfaceImpl(TINTERFACE::InterfaceName(), pInterface, Destroy);
+		RegisterInterfaceImpl(TINTERFACE::InterfaceName(), pInterface, Destroy);
 	}
 	template<class TINTERFACE>
-	bool ReregisterInterface(TINTERFACE *pInterface)
+	void ReregisterInterface(TINTERFACE *pInterface)
 	{
-		return ReregisterInterfaceImpl(TINTERFACE::InterfaceName(), pInterface);
+		ReregisterInterfaceImpl(TINTERFACE::InterfaceName(), pInterface);
 	}
 
 	// Usage example:

src/engine/server/roundstatistics.cpp

@@ -1,5 +1,7 @@
 #include "roundstatistics.h"
 
+#include <base/system.h>
+
 #include <game/infclass/classes.h>
 
 int CRoundStatistics::CPlayerStats::OnScoreEvent(int EventType, EPlayerClass Class)

src/engine/server/server.cpp

@@ -4068,18 +4068,18 @@ const char *CServer::GetAnnouncementLine(char const *pFileName)
 		str_copy(m_aAnnouncementFile, pFileName);
 		m_vAnnouncements.clear();
 
-		IOHANDLE File = m_pStorage->OpenFile(pFileName, IOFLAG_READ | IOFLAG_SKIP_BOM, IStorage::TYPE_ALL);
-		if(!File)
+		CLineReader LineReader;
+		if(!LineReader.OpenFile(m_pStorage->OpenFile(pFileName, IOFLAG_READ, IStorage::TYPE_ALL)))
+		{
 			return 0;
-
-		char *pLine;
-		CLineReader Reader;
-		Reader.Init(File);
-		while((pLine = Reader.Get()))
+		}
+		while(const char *pLine = LineReader.Get())
+		{
 			if(str_length(pLine) && pLine[0] != '#')
+			{
 				m_vAnnouncements.emplace_back(pLine);
-
-		io_close(File);
+			}
+		}
 	}
 
 	if(m_vAnnouncements.empty())

src/engine/shared/config.cpp

@@ -1,10 +1,13 @@
 /* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
 /* If you are missing that file, acquire a complete release at teeworlds.com.                */
-#include <engine/config.h>
-#include <engine/shared/config.h>
+
+#include <base/system.h>
+
 #include <engine/shared/protocol.h>
 #include <engine/storage.h>
 
+#include "config.h"
+
 CConfig g_Config;
 
 void EscapeParam(char *pDst, const char *pSrc, int Size)

src/engine/shared/config.h

@@ -4,7 +4,9 @@
 #define ENGINE_SHARED_CONFIG_H
 
 #include <base/detect.h>
+
 #include <engine/config.h>
+#include <engine/storage.h>
 
 #define CONFIG_FILE "settings_ddnet.cfg"
 #define AUTOEXEC_FILE "autoexec.cfg"

src/engine/shared/console.cpp

@@ -627,22 +627,20 @@ void CConsole::ExecuteFile(const char *pFilename, int ClientID, bool LogFailure,
 	m_pFirstExec = &ThisFile;
 
 	// exec the file
-	IOHANDLE File = m_pStorage->OpenFile(pFilename, IOFLAG_READ | IOFLAG_SKIP_BOM, StorageType);
-
-	char aBuf[128];
-	if(File)
+	CLineReader LineReader;
+	bool Success = false;
+	char aBuf[32 + IO_MAX_PATH_LENGTH];
+	if(LineReader.OpenFile(m_pStorage->OpenFile(pFilename, IOFLAG_READ, StorageType)))
 	{
-		char *pLine;
-		CLineReader Reader;
-
 		str_format(aBuf, sizeof(aBuf), "executing '%s'", pFilename);
 		Print(IConsole::OUTPUT_LEVEL_STANDARD, "console", aBuf);
-		Reader.Init(File);
 
-		while((pLine = Reader.Get()))
+		while(const char *pLine = LineReader.Get())
+		{
 			ExecuteLine(pLine, ClientID);
+		}
 
-		io_close(File);
+		Success = true;
 	}
 	else if(LogFailure)
 	{

src/engine/shared/engine.cpp

@@ -7,33 +7,22 @@
 #include <engine/console.h>
 #include <engine/engine.h>
 #include <engine/shared/config.h>
+#include <engine/shared/jobs.h>
 #include <engine/shared/network.h>
 #include <engine/storage.h>
 
-CHostLookup::CHostLookup() = default;
-
-CHostLookup::CHostLookup(const char *pHostname, int Nettype)
-{
-	str_copy(m_aHostname, pHostname);
-	m_Nettype = Nettype;
-}
-
-void CHostLookup::Run()
-{
-	m_Result = net_host_lookup(m_aHostname, &m_Addr, m_Nettype);
-}
-
 class CEngine : public IEngine
 {
-public:
 	IConsole *m_pConsole;
 	IStorage *m_pStorage;
-	bool m_Logging;
 
+	bool m_Logging;
 	std::shared_ptr<CFutureLogger> m_pFutureLogger;
 
 	char m_aAppName[256];
 
+	CJobPool m_JobPool;
+
 	static void Con_DbgLognetwork(IConsole::IResult *pResult, void *pUserData)
 	{
 		CEngine *pEngine = static_cast<CEngine *>(pUserData);
@@ -56,13 +45,13 @@ class CEngine : public IEngine
 		}
 	}
 
+public:
 	CEngine(bool Test, const char *pAppname, std::shared_ptr<CFutureLogger> pFutureLogger, int Jobs) :
 		m_pFutureLogger(std::move(pFutureLogger))
 	{
 		str_copy(m_aAppName, pAppname);
 		if(!Test)
 		{
-			//
 			dbg_msg("engine", "running on %s-%s-%s", CONF_FAMILY_STRING, CONF_PLATFORM_STRING, CONF_ARCH_STRING);
 #ifdef CONF_ARCH_ENDIAN_LITTLE
 			dbg_msg("engine", "arch is little endian");
@@ -73,9 +62,9 @@ class CEngine : public IEngine
 #endif
 
 			char aVersionStr[128];
-			if(!os_version_str(aVersionStr, sizeof(aVersionStr)))
+			if(os_version_str(aVersionStr, sizeof(aVersionStr)))
 			{
-				dbg_msg("engine", "operation system version: %s", aVersionStr);
+				dbg_msg("engine", "operating system version: %s", aVersionStr);
 			}
 
 			// init the network
@@ -90,7 +79,7 @@ class CEngine : public IEngine
 
 	~CEngine() override
 	{
-		m_JobPool.Destroy();
+		CNetBase::CloseLog();
 	}
 
 	void Init() override
@@ -101,8 +90,6 @@ class CEngine : public IEngine
 		if(!m_pConsole || !m_pStorage)
 			return;
 
-		char aFullPath[IO_MAX_PATH_LENGTH];
-		m_pStorage->GetCompletePath(IStorage::TYPE_SAVE, "dumps/", aFullPath, sizeof(aFullPath));
 		m_pConsole->Register("dbg_lognetwork", "", CFGFLAG_SERVER | CFGFLAG_CLIENT, Con_DbgLognetwork, this, "Log the network");
 	}
 
@@ -113,16 +100,16 @@ class CEngine : public IEngine
 		m_JobPool.Add(std::move(pJob));
 	}
 
-	void SetAdditionalLogger(std::unique_ptr<ILogger> &&pLogger) override
+	void ShutdownJobs() override
 	{
-		m_pFutureLogger->Set(std::move(pLogger));
+		m_JobPool.Shutdown();
 	}
-};
 
-void IEngine::RunJobBlocking(IJob *pJob)
-{
-	CJobPool::RunBlocking(pJob);
-}
+	void SetAdditionalLogger(std::shared_ptr<ILogger> &&pLogger) override
+	{
+		m_pFutureLogger->Set(pLogger);
+	}
+};
 
 IEngine *CreateEngine(const char *pAppname, std::shared_ptr<CFutureLogger> pFutureLogger, int Jobs) { return new CEngine(false, pAppname, std::move(pFutureLogger), Jobs); }
 IEngine *CreateTestEngine(const char *pAppname, int Jobs) { return new CEngine(true, pAppname, nullptr, Jobs); }