Merge pull request #1 from Tiaansu/fetch-log

Fetch logs, case sensitive support, automatic cleanup of logs result

README.md

@@ -51,3 +51,4 @@ You can check this [repository](https://github.com/Tiaansu/greet-component) for
 ## Thanks to
 - [Amir's omp-node](https://github.com/AmyrAhmady/omp-node) (I copied it's `include` style so other components can use this component)
 - [maddinatOr's samp-log-core](https://github.com/maddinat0r/samp-log-core) (most of the code were from this project)
+- [Toiletduck / Eksqtr](https://github.com/eksqtr) (big thanks to this person. Many ideas were from him)

include/omp-logger.hpp

@@ -35,6 +35,7 @@ namespace OmpLogger
 }
 
 struct IOmpLog;
+struct PaginatedResult;
 
 static const UID OmpLoggerComponent_UID = UID(0xAB3BC9C4E583C8B4);
 class IOmpLoggerComponent : public IComponent
@@ -68,6 +69,8 @@ struct IOmpLog
 
     virtual uint32_t getColor() const = 0;
 
+    virtual PaginatedResult fetchLogs(int linesPerPage, int pageStart, const std::string& searchTerm, bool caseSensitive) const = 0;
+
     virtual bool log(AMX* amx, OmpLogger::ELogLevel level, StringView message) const = 0;
 
     virtual bool log(OmpLogger::ELogLevel level, StringView message) const = 0;
@@ -103,4 +106,11 @@ class OmpLoggerManager
 
 private:
     IOmpLoggerComponent* ompLogger_ = nullptr;
+};
+
+struct PaginatedResult
+{
+    std::vector<std::string> lines;
+    int currentPage;
+    int totalPages;
 };

omp-logger.inc

@@ -31,3 +31,17 @@ native bool:Logger_Info(Logger:id, const format[], OPEN_MP_TAGS:...);
 native bool:Logger_Warning(Logger:id, const format[], OPEN_MP_TAGS:...);
 native bool:Logger_Error(Logger:id, const format[], OPEN_MP_TAGS:...);
 native bool:Logger_Fatal(Logger:id, const format[], OPEN_MP_TAGS:...);
+
+// Logs result
+native Logger_FetchLogs(playerid, Logger:logger, amount, pageStart, const callback[], const search[] = "", bool:caseSensitive = true);
+native Logger_GetResult(LogsResult:result, row, logs[], size = sizeof logs);
+native Logger_FreeResult(LogsResult:result);
+
+// Cleanup results once they go out of scope
+stock operator~(const LogsResult:result[], len)
+{
+    for (new i = 0; i < len; ++ i)
+    {
+        Logger_FreeResult(result[i]);
+    }
+}

src/component.cpp

@@ -3,6 +3,7 @@
 #include <fmt/format.h>
 #include "component.hpp"
 #include "helpers/utils.hpp"
+#include "threaded-queue.hpp"
 
 // API
 IOmpLog* OmpLoggerComponent::createLogger(StringView name, int32_t color, OmpLogger::ELogLevel level, bool isPlugin)
@@ -26,7 +27,7 @@ IOmpLog* OmpLoggerComponent::createLogger(StringView name, int32_t color, OmpLog
         color = 0;
     }
 
-    std::FILE* file = ::fopen(filepath.c_str(), "a");
+    std::FILE* file = ::fopen(filepath.c_str(), "a+");
     if (file == nullptr)
     {
         core_->logLn(LogLevel::Error, "Failed to open log file \"%s\".", filepath.c_str());
@@ -48,6 +49,24 @@ IOmpLog* OmpLoggerComponent::getLogger(int id)
     return pool_.get(id);
 }
 
+// Fetch logs
+ILogsResult* OmpLoggerComponent::initLogsResult(std::vector<std::string> logs)
+{
+    return logsResults_.emplace(logs);
+}
+
+bool OmpLoggerComponent::deleteLogsResult(ILogsResult* result)
+{
+    int id = static_cast<ILogsResult*>(result)->getID();
+    logsResults_.release(id, false);
+    return true;
+}
+
+ILogsResult* OmpLoggerComponent::getLogsResult(int id)
+{
+    return logsResults_.get(id);
+}
+
 // Callbacks
 void OmpLoggerComponent::onLoad(ICore* c)
 {
@@ -68,6 +87,7 @@ void OmpLoggerComponent::onInit(IComponentList* components)
     setAmxFunctions(pawn_->getAmxFunctions());
     setAmxLookups(components);
     pawn_->getEventDispatcher().addEventHandler(this);
+    core_->getEventDispatcher().addEventHandler(this);
 
     IConfig& config = core_->getConfig();
     isLogLevelNameCapitalized_ = (config.getBool("logger.log_level_capitalized")) ? (*config.getBool("logger.log_level_capitalized")) : false;
@@ -193,6 +213,8 @@ void OmpLoggerComponent::free()
         serverLoggerFile_ = nullptr;
     }
 
+    ThreadedQueue::Get()->Destroy();
+
     delete this;
     core_->printLn("[omp-logger] Logger released.");
 }
@@ -210,7 +232,13 @@ void OmpLoggerComponent::onAmxLoad(IPawnScript& script)
 
 void OmpLoggerComponent::onAmxUnload(IPawnScript& script)
 {
-    debugEraseAMX(script.GetAMX());
+    AMX* amx = script.GetAMX();
+    debugEraseAMX(amx);
+}
+
+void OmpLoggerComponent::onTick(Microseconds elapsed, TimePoint now)
+{
+    ThreadedQueue::Get()->Process();
 }
 
 OmpLoggerComponent::~OmpLoggerComponent()
@@ -219,6 +247,10 @@ OmpLoggerComponent::~OmpLoggerComponent()
     {
         pawn_->getEventDispatcher().removeEventHandler(this);
     }
+    if (core_)
+    {
+        core_->getEventDispatcher().removeEventHandler(this);
+    }
 }
 
 // API - Config

src/component.hpp

@@ -11,10 +11,12 @@
 #include "omp-logger.hpp"
 #include "omp-log.hpp"
 #include "debug-manager.hpp"
+#include "logs-result.hpp"
 
 class OmpLoggerComponent final
     : public IOmpLoggerComponent
     , public PawnEventHandler
+    , public CoreEventHandler
 {
 private:
     ICore* core_ = nullptr;
@@ -23,6 +25,8 @@ class OmpLoggerComponent final
 
     MarkedPoolStorage<OmpLog, IOmpLog, 1, 1000> pool_;
 
+    MarkedPoolStorage<LogsResult, ILogsResult, 1, 5000> logsResults_;
+
     inline static OmpLoggerComponent* instance_ = nullptr;
 
     // configs
@@ -44,6 +48,13 @@ class OmpLoggerComponent final
 
     IOmpLog* getLogger(int id) override;
 
+    // Fetch logs
+    ILogsResult* initLogsResult(std::vector<std::string> logs);
+
+    bool deleteLogsResult(ILogsResult* result);
+
+    ILogsResult* getLogsResult(int id);
+
     // Component
     StringView componentName() const override
     {
@@ -54,6 +65,8 @@ class OmpLoggerComponent final
     {
         return SemanticVersion(0, 0, 1, 0);
     }
+
+    void onTick(Microseconds elapsed, TimePoint now) override;
 
     void onLoad(ICore* c) override;
 

src/logs-result.cpp

@@ -0,0 +1,19 @@
+#include "logs-result.hpp"
+#include "component.hpp"
+
+using namespace Impl;
+
+int LogsResult::getID() const
+{
+    return poolID;
+}
+
+std::string LogsResult::getLog(int row) const
+{
+    return logs_.at(row);
+}
+
+LogsResult::LogsResult(std::vector<std::string> logs)
+    : logs_(std::move(logs))
+{
+}

src/logs-result.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <sdk.hpp>
+#include <Impl/pool_impl.hpp>
+
+using namespace Impl;
+
+struct ILogsResult
+{
+    virtual int getID() const = 0;
+
+    virtual std::string getLog(int row) const = 0;
+};
+
+class LogsResult final
+    : public ILogsResult
+    , public PoolIDProvider
+    , public NoCopy
+{
+private:
+    std::vector<std::string> logs_;
+
+public:
+    int getID() const override;
+
+    std::string getLog(int row) const override;
+
+    LogsResult(std::vector<std::string> logs);
+};

src/natives.cpp

@@ -1,12 +1,15 @@
 #include <algorithm>
 #include <string>
+#include <vector>
+#include <thread>
 
 #include <sdk.hpp>
 #include <Server/Components/Pawn/Impl/pawn_natives.hpp>
 
 #include "component.hpp"
 #include "natives.hpp"
 #include "omp-logger.hpp"
+#include "threaded-queue.hpp"
 #include "helpers/format.hpp"
 
 SCRIPT_API(Logger_Create, int(std::string const& name, int32_t color, OmpLogger::ELogLevel level))
@@ -56,4 +59,39 @@ SCRIPT_API(Logger_Fatal, bool(IOmpLog& logger, cell const* format))
 {
     AMX* amx = GetAMX();
     return logger.log(amx, OmpLogger::ELogLevel::Fatal, AmxStringFormatter(format, amx, GetParams(), 2));
+}
+
+SCRIPT_API(Logger_FetchLogs, bool(IPlayer& player, IOmpLog& logger, int linesPerPage, int pageStart, std::string const& callback, std::string const& searchTerm, bool caseSensitive))
+{
+    AMX* amx = GetAMX();
+
+    auto func = [&player, &logger, amx, callback, searchTerm, linesPerPage, pageStart, caseSensitive]() {
+
+        int funcIDX = 0;
+        if (!amx_FindPublic(amx, callback.c_str(), &funcIDX))
+        {
+            PaginatedResult result = logger.fetchLogs(linesPerPage, pageStart, searchTerm, caseSensitive);
+            ILogsResult* logsResult = OmpLoggerComponent::Get()->initLogsResult(result.lines);
+            amx_Push(amx, result.totalPages);
+            amx_Push(amx, result.currentPage);
+            amx_Push(amx, (int)result.lines.size());
+            amx_Push(amx, logsResult->getID());
+            amx_Push(amx, logger.getID());
+            amx_Push(amx, player.getID());
+            amx_Exec(amx, NULL, funcIDX);
+        }
+    };
+    ThreadedQueue::Get()->Dispatch(func);
+    return 1;
+}
+
+SCRIPT_API(Logger_GetResult, int(ILogsResult& result, int row, OutputOnlyString& logs))
+{
+    logs = result.getLog(row);
+    return std::get<StringView>(logs).length();
+}
+
+SCRIPT_API(Logger_FreeResult, bool(ILogsResult& result))
+{
+    return OmpLoggerComponent::Get()->deleteLogsResult(&result);
 }

src/natives.hpp

@@ -104,4 +104,104 @@ namespace pawn_natives
         ParamCast(AMX*, cell*, int) = delete;
         ParamCast() = delete;
     };
+
+    // Logs result
+    template <>
+    struct ParamLookup<ILogsResult>
+    {
+        static ILogsResult* Val(cell ref) noexcept
+        {
+            if (auto pool = OmpLoggerComponent::Get())
+            {
+                return pool->getLogsResult(ref);
+            }
+            return nullptr;
+        }
+    };
+
+    template <>
+    class ParamCast<ILogsResult*>
+    {
+    public:
+        ParamCast(AMX* amx, cell* params, int idx) noexcept
+        {
+            value_ = ParamLookup<ILogsResult>::Val(params[idx]);
+        }
+
+        ~ParamCast()
+        {
+        }
+
+        ParamCast(ParamCast<ILogsResult*> const&) = delete;
+        ParamCast(ParamCast<ILogsResult*>&&) = delete;
+
+        operator ILogsResult*()
+        {
+            return value_;
+        }
+
+        bool Error() const
+        {
+            return false;
+        }
+
+        static constexpr int Size = 1;
+
+    private:
+        ILogsResult* value_;
+    };
+
+    template <>
+    class ParamCast<ILogsResult&>
+    {
+    public:
+        ParamCast(AMX* amx, cell* params, int idx)
+        {
+            value_ = ParamLookup<ILogsResult>::Val(params[idx]);
+            if (value_ == nullptr)
+            {
+                AmxFuncCallInfo dest;
+                if (!DebugManager::Get()->GetFunctionCall(amx, amx->cip, dest))
+                {
+                    OmpLoggerComponent::Get()->getCore()->logLn(LogLevel::Warning, "Invalid logs result id %i", static_cast<int>(params[idx]));
+                }
+                else
+                {
+                    OmpLoggerComponent::Get()->getCore()->logLn(LogLevel::Warning, "Invalid logs result id %i (%s:%i)",  static_cast<int>(params[idx]), dest.file, static_cast<int>(dest.line));
+                }
+                error_ = true;
+            }
+        }
+
+        ~ParamCast()
+        {
+        }
+
+        ParamCast(ParamCast<ILogsResult&> const&) = delete;
+        ParamCast(ParamCast<ILogsResult&>&&) = delete;
+
+        operator ILogsResult&()
+        {
+            return *value_;
+        }
+
+        bool Error() const
+        {
+            return error_;
+        }
+
+        static constexpr int Size = 1;
+
+    private:
+        ILogsResult* value_;
+        bool error_ = false;
+    };
+
+    template <>
+    class ParamCast<const ILogsResult&>
+    {
+    public:
+        ParamCast(AMX*, cell*, int) = delete;
+        ParamCast() = delete;
+    };
 }