Implement categorization

CMakeLists.txt

@@ -5,7 +5,8 @@ set(CMAKE_CXX_STANDARD 14)
 add_compile_options("-fno-omit-frame-pointer")
 add_compile_options("-Wall")
 add_compile_options("-fsanitize=address")
-add_compile_options("-O3")
+add_compile_options("-O1")
+add_compile_options("-pthread")
 #No, don't do it, don't do it!
 #add_compile_options("-v")
 
@@ -22,18 +23,11 @@ include_directories(src/util)
 include_directories(src/util/exceptions)
 include_directories(src/util/logger)
 
-
-
 add_executable(log_engine
         src/engine/adapter/Categorization/Categorization.cpp
         src/engine/adapter/Categorization/Categorization.h
         src/engine/adapter/Categorization/Result.h
         src/engine/adapter/Categorization/Rule.h
-        src/engine/adapter/ClientUpTime/ClientUpTime.cpp
-        src/engine/adapter/ClientUpTime/ClientUpTime.h
-        src/engine/adapter/ClientUpTime/Connection.h
-        src/engine/adapter/MultiIPChecker/MultiIPChecker.h
-        src/engine/adapter/OptimizeMe/OptimizeMe.h
         src/engine/adapter/TextSearch/TextSearch.cpp
         src/engine/adapter/TextSearch/TextSearch.h
         src/engine/model/EngineInput.h
@@ -53,8 +47,18 @@ add_executable(log_engine
         src/util/Config.cpp
         src/engine/model/Payload.h
         src/engine/adapter/TextSearch/TextSearchPayload.h
-        src/engine/adapter/PatternAbuser/PatternAbuser.cpp
-        src/engine/adapter/PatternAbuser/PatternAbuser.h src/engine/OutputWrapper.cpp src/engine/OutputWrapper.h src/engine/interface/IJsonSerializable.h)
+        src/engine/OutputWrapper.cpp
+        src/engine/OutputWrapper.h
+        src/engine/interface/IJsonSerializable.h
+        src/engine/task/AsyncExecutionBuffer.cpp
+        src/engine/task/AsyncExecutionBuffer.h
+        src/engine/interface/IEngineOutputElement.h
+        src/engine/adapter/TextSearch/TextSearchBufferElement.h
+        src/engine/adapter/STDOutput.cpp
+        src/engine/adapter/STDOutput.h
+        src/engine/task/TaskScheduler.cpp
+        src/engine/task/TaskScheduler.h
+        src/engine/model/IExecutionTask.h)
 
 target_link_libraries(log_engine
         -fsanitize=address

src/engine/Dispatcher.cpp

@@ -3,92 +3,72 @@
 #include <adapter/TextSearch/TextSearch.h>
 #include <adapter/Categorization/Categorization.h>
 #include "Dispatcher.h"
-
+#include <future>
+#include <adapter/STDOutput.h>
 
 Dispatcher::Dispatcher(const EngineInput &eIN) :
-        engineInput(eIN)
-{
+        engineInput(eIN) {
     logger = new util::Logger("Dispatcher");
     validate(eIN.payload);
     initEngines();
     run();
     terminate();
 }
 
-void Dispatcher::validate(const std::string &payload)
-{
+void Dispatcher::validate(const std::string &payload) {
 
     logger->info("Validating input");
 
-    if (engineInput.serverLogFile.empty())
-    {
+    if (engineInput.serverLogFile.empty()) {
         logger->error("No log file specified");
         throw std::system_error(std::error_code(404, std::system_category()),
                                 "The log file needs to be specified with the -l/-log CLI parameter");
     }
 
-    if (engineInput.function == -1)
-    {
+    if (engineInput.function == -1) {
         logger->error("No function was specified to be executed!");
         throw std::system_error(std::error_code(404, std::system_category()),
                                 "The engine function has to be specified by using the -f/-function CLI parameter");
     }
     engineInput.payload = payload;
 }
 
-void Dispatcher::initEngines()
-{
+void Dispatcher::initEngines() {
     logger->info("Initializing requested Engine Adapter");
     //executionList.push_back(new adapter::OptimizeMe());
     //optimize, do not sync standard input output
     std::ios_base::sync_with_stdio(false);
     //optimize, detach console input
     std::cin.tie(nullptr);
 
-    switch (engineInput.function)
-    {
-        case ENGINE_FUNCTION::SEARCH:
-        {
+    switch (engineInput.function) {
+        case ENGINE_FUNCTION::SEARCH: {
             nlohmann::json jsonPayload = nlohmann::json::parse(engineInput.payload);
             TextSearchPayload stackAllocation;
             stackAllocation.fromJson(jsonPayload);
-            executionList.push_back(new adapter::TextSearch(engineInput.serverLogFile, stackAllocation));
+            taskScheduler.registerTask(new adapter::TextSearch(engineInput.serverLogFile, stackAllocation));
             break;
         }
-        case ENGINE_FUNCTION::SEARCH_AND_CATEGORIZE:
-        {
-            executionList.push_back(new adapter::Categorization());
+        case ENGINE_FUNCTION::SEARCH_AND_CATEGORIZE: {
+            taskScheduler.registerTask(new adapter::Categorization());
             break;
         }
-        case ENGINE_FUNCTION::CLIENT_UPTIME:
-        {
+        case ENGINE_FUNCTION::CLIENT_UPTIME: {
             //executionList.push_back(new adapter::ClientUpTime(engineInput.serverLogFile, engineInput.searchStrings));
             break;
         }
-        default:
-        {
+        default: {
             logger->warn("Engine function " + std::to_string(engineInput.function) + " is not implemented");
             break;
         }
     }
-
-    for (IEngineAdapter *engine : executionList)
-    {
-        logger->info("Loaded " + engine->getName() + " into executionList");
-    }
 }
 
-void Dispatcher::run()
-{
-    for (IEngineAdapter *engine : executionList)
-    {
-        logger->info("Running " + engine->getName() + " Engine  Adapter");
-        engine->run();
-    }
+void Dispatcher::run() {
+    taskScheduler.start();
 }
 
-void Dispatcher::terminate()
-{
+void Dispatcher::terminate() {
     logger->info("Terminating Engine Routine");
     logger->info("Engine stopped");
 }

src/engine/Dispatcher.h

@@ -14,6 +14,7 @@
 #include <model/EngineInput.h>
 #include <logger/Logger.h>
 #include <json.hpp>
+#include <task/TaskScheduler.h>
 #include "interface/IEngineAdapter.h"
 
 class Dispatcher
@@ -22,8 +23,7 @@ class Dispatcher
     EngineInput engineInput;
     util::Logger *logger;
     nlohmann::json configuration;
-
-    std::list<IEngineAdapter *> executionList;
+    TaskScheduler taskScheduler;
 
     void validate(const std::string &payload);
 

src/engine/adapter/Categorization/Categorization.cpp

@@ -16,6 +16,10 @@
 
 using namespace adapter;
 
+void Categorization::terminate() {
+
+}
+
 Categorization::Categorization()
 {
     //load rules from fileStream into JSON object
@@ -40,7 +44,7 @@ Categorization::Categorization()
 Categorization::~Categorization()
 = default;
 
-void Categorization::run()
+void Categorization::run(AsyncExecutionBuffer &asyncExecutionBuffer)
 {
 }
 

src/engine/adapter/Categorization/Categorization.h

@@ -25,7 +25,7 @@ namespace adapter
 
         ~Categorization() override;
 
-        void run() override;
+        void run(AsyncExecutionBuffer &asyncExecutionBuffer) override;
 
         int getEngineFunction() const override;
 
@@ -36,6 +36,8 @@ namespace adapter
             return (rules);
         }
 
+        void terminate() override;
+
     private:
         std::map<std::string, Rule> rules;