wip

CMakeLists.txt

@@ -2,12 +2,12 @@ cmake_minimum_required(VERSION 3.16)
 
 project(distrins)
 
-add_library(asio INTERFACE)
+add_library(Asio INTERFACE IMPORTED GLOBAL)
-target_compile_options(asio INTERFACE -D ASIO_STANDALONE)
+target_compile_options(Asio INTERFACE -D ASIO_STANDALONE)
-target_include_directories(asio INTERFACE lib/asio/include)
+target_include_directories(Asio INTERFACE lib/asio/include)
 
 find_package (Threads REQUIRED)
-target_link_libraries(asio INTERFACE Threads::Threads)
+target_link_libraries(Asio INTERFACE Threads::Threads)
 
 add_subdirectory(src)
 

src/core/EventBus.cpp

@@ -1,18 +1,14 @@
 #include "EventBus.hpp"
 #include <string>
-#include <iostream>
 
 namespace Plains {
 namespace Core {
 
-EventBus::EventBus() {};
+EventBus::EventBus(Logger& logger) : logger(logger) {};
 
 void EventBus::test() {
-    std::cout << "Testing from within EventBus!" << std::endl;
+    logger.debug << "Testing from within EventBus!" << Logger::commit;
 }
 
-void EventBus::run() {
-    std::cout << "Run event queue.... oops done! Exiting..." << std::endl;
-}
 
 }}

src/core/Logger.cpp

@@ -9,32 +9,41 @@ using std::cout;
 using std::cerr;
 using std::endl;
 
-//static string getTimeStamp() { return ctime ( time ( 0 ) ); }
+Logger::Logger(enum Level logLevel) :
-
-Logger::Logger(enum Level logLevel, EventBus& eventBus) :
     logLevel(logLevel),
-    eventBus(eventBus),
     debug(DEBUG, *this),
     info(INFO, *this),
     warn(WARN, *this),
     fatal(FATAL, *this)
 {
-    //info(this);
+    output = new ofstream("plains.log");
-    logFile = ofstream("plains.log");
 
-    if (!logFile) {
+    if (!output) {
-        cerr << "Unable to open Logfile" << endl;
+        cerr << "Unable to open Logfile!" << endl;
-        //logFile = cout.fstream;
+        //std::ostream osteam();
+        //aoutput = cout;
+        //output->rdbuf(cout.rdbuf());
+        //output.rdbuf(NULL);
     }
     else {
-        cout << "Log file opened" << endl;
+        debug << "Logfile successfully opened!" << commit;
-        //oldStdOut = cout.rdbuf();
-        //cout.rdbuf(logFile.rdbuf());
     }
 }
 
 Logger::~Logger() {
-    logFile.close();
+    output->close();
+    delete output;
+}
+
+string Logger::genTimeStamp() {
+    time_t rawtime;
+    struct tm * timeinfo;
+    char buffer[80];
+    time (&rawtime);
+    timeinfo = localtime(&rawtime);
+    strftime(buffer,sizeof(buffer),"%d-%m-%Y %H:%M:%S",timeinfo);
+
+    return string(buffer);
 }
 
 void Logger::setLogLevel(Level level) {
@@ -51,26 +60,69 @@ void Logger::log(Level lvl, const char* msg) {
     }
 }
 
-Logger::Sink::Sink (const Level level, Logger& parent) : level(level), parent(parent) {}
+Logger::Sink::Sink (const Level level, Logger& parent) :
+    level(level),
+    parent(parent),
+    lineIsPrefixed(false) {}
 
 void Logger::Sink::ln  ( const string& msg ) {
-    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg << endl;
+    ln(msg.c_str());
 }
 
 void Logger::Sink::ln  ( const char* msg ) {
-    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg << endl;
+    if ( level >= parent.logLevel ) {
+        // If line has already been started, abort it and start new one:
+        if(lineIsPrefixed) *parent.output << endl;
+        prefixLine(true);
+        *parent.output <<  msg << endl;
+    }
+}
+
+void Logger::Sink::prefixLine(bool resetToFalse) {
+    if (!lineIsPrefixed) {
+        *parent.output << Logger::genTimeStamp() << " ";
+        lineIsPrefixed = resetToFalse ? false : true;
+    }
 }
 
 Logger::Sink& Logger::Sink::operator<<(const string& msg) {
-    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg;
+    if ( level >= parent.logLevel ) {
+        prefixLine();
+        *parent.output << msg;
+    }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const char* msg) {
-    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg;
+    if ( level >= parent.logLevel ) {
+        prefixLine();
+        *parent.output << msg;
+    }
+    return *this;
+}
+
+Logger::Sink& Logger::Sink::operator<<(const unsigned long msg) {
+    if ( level >= parent.logLevel ) {
+        prefixLine();
+        *parent.output << msg;
+    }
+    return *this;
+}
+
+Logger::Sink& Logger::Sink::operator<<(const char character) {
+    if ( level >= parent.logLevel ) {
+        switch(character) {
+            // COMMIT - End message line
+            case 0:
+              *parent.output << endl;
+              lineIsPrefixed = false;
+            break;
+        }
+    }
     return *this;
 }
 
 
 
+
 }}

src/core/include/EventBus.hpp

@@ -1,14 +1,18 @@
 #ifndef EVENT_BUS_HPP
 #define EVENT_BUS_HPP
+#include "Logger.hpp"
+
 
 namespace Plains {
 namespace Core {
 
 class EventBus {
+    private:
+    Logger& logger;
+
     public:
-    EventBus();
+    EventBus(Logger& logger);
     void test();
-    void run(); // Run the event queue worker
 };
 
 }}

src/core/include/Logger.hpp

@@ -3,35 +3,39 @@
 #include <string>
 #include <fstream>
 #include <ostream>
-#include "EventBus.hpp"
 
 namespace Plains {
 namespace Core {
 
 using std::string;
 using std::ofstream;
-using std::ostream;
+//using std::ostream;
-using std::streambuf;
+//using std::streambuf;
 
 class Logger {
     public:
     enum Level { DEBUG, INFO, WARN, FATAL };
-    Logger(Level logLevel, EventBus& eventBus);
+    Logger(Level logLevel);
     ~Logger();
     void setLogLevel(Level level);
     void log(Level lvl, const char* msg);
     void log(Level lvl, const string& msg);
+    static const char commit = 0;
 
     class Sink {
         private:
+        bool lineIsPrefixed;
         Logger& parent;
         const Logger::Level level;
+        void prefixLine(bool resetToFalse = false);
         public:
         Sink(const Level level, Logger& parent);
         void ln (const string& msg);
         void ln (const char* msg);
+        Sink& operator<<(const char character);
         Sink& operator<<(const string& msg);
         Sink& operator<<(const char* msg);
+        Sink& operator<<(const unsigned long msg);
     };
 
     Sink debug;
@@ -40,10 +44,9 @@ class Logger {
     Sink fatal;
 
     private:
-    EventBus& eventBus;
     enum Level logLevel;
-    ofstream logFile;
+    ofstream* output;
-    streambuf* oldStdOut;
+    static string genTimeStamp();
 };
 
 

src/core/main.cpp

@@ -16,18 +16,16 @@ int main(int args, char **argv) {
         arguments.push_back (argv[index]);
     }
 
-    EventBus      eventBus;
+    Logger        logger(Logger::DEBUG);
-    Logger        logger(Logger::DEBUG, eventBus);
+    EventBus      eventBus(logger);
     ConfigManager cfg(logger, arguments);
     Resolver::Server resolver(logger, eventBus);
 
     //Record testrec = ARecord();
 
-    logger.info << "Testing overloading!" << " with chaining!\n";
+    logger.info << "Testing overloading!" << " with chaining!" << Logger::commit;
-    logger.debug.ln ("Booting complete.");
+    logger.debug.ln ("PlaiNS successfully started.");
 
-    //Run eventBus on main thread.
-    eventBus.run();
     return 0;
 }
 

src/resolver/CMakeLists.txt

@@ -3,4 +3,4 @@ add_library(Resolver OBJECT Server.cpp)
 
 target_include_directories(Resolver PUBLIC include)
 
-target_link_libraries(Resolver PRIVATE asio Core)
+target_link_libraries(Resolver PRIVATE Core PUBLIC Asio)

src/resolver/Server.cpp

@@ -1,7 +1,4 @@
 #include "Server.hpp"
-#include <asio.hpp>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
 
 //Testing:
 #include "Message.hpp"
@@ -10,8 +7,8 @@ namespace Plains {
 namespace Resolver {
 
 Server::Server(Logger& logger, EventBus& eventBus) : logger(logger), eventBus(eventBus) {
-//    logger.debug << "Testing some stuff..." << endl;
+    logger.debug << "Testing some stuff..." << Logger::commit;
-//    logger.debug << "Message class overall size:" << sizeof(Message) << endl;
+    logger.debug << "Message class overall size:" << sizeof(Message) << Logger::commit;
 //    logger.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
 //    logger.debug << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;
 

src/resolver/include/Server.hpp

@@ -1,23 +1,38 @@
 #ifndef SERVER_HPP
 #define SERVER_HPP
+#include "asio.hpp"
 #include "Core.hpp"
+#include <cstdlib>
+
 
 namespace Plains {
 namespace Resolver {
 
 using Core::EventBus;
 using Core::Logger;
+using asio::ip::udp;
+
 
 class Server
 {
-    const EventBus& eventBus;
+    private:
-    const Logger& logger;
+    EventBus& eventBus;
+    Logger& logger;
+    asio::io_context io_context;
 
     public:
     Server(Logger& logger, EventBus& eventBus);
     ~Server();
 };
 
+
+
+
+
+
+
+
+
 }}
 
 #endif