wip

src/core/Logger.cpp

@@ -10,26 +10,27 @@ using std::cerr;
 using std::endl;
 
 Logger::Logger(enum Level logLevel) :
-    logLevel(logLevel),
+    _logLevel(logLevel),
     debug(DEBUG, *this),
     info(INFO, *this),
     warn(WARN, *this),
     fatal(FATAL, *this)
 {
-    output = new ofstream("plains.log", std::ios_base::app);
+    _output = new ofstream("plains.log", std::ios_base::app);
 
-    if (!(*output)) {
+    if (!(*_output)) {
         cout << "Unable to open Logfile! writing to /tmp/plains.log" << endl;
-        output = new ofstream("/tmp/plains.log");
+        _output = new ofstream("/tmp/plains.log");
     }
     else {
+        debug << "============================" << commit;
         debug << "Logfile successfully opened!" << commit;
     }
 }
 
 Logger::~Logger() {
-    output->close();
-    delete output;
+    _output->close();
+    delete _output;
 }
 
 string Logger::genTimeStamp() {
@@ -43,8 +44,7 @@ string Logger::genTimeStamp() {
     return string(buffer);
 }
 
-void Logger::setLogLevel(Level level) {
-}
+void Logger::setLogLevel(Level level) { _logLevel = level; }
 
 void Logger::log(Level lvl, const string& msg) { log ( lvl, msg.c_str() ); }
 
@@ -67,11 +67,11 @@ void Logger::Sink::ln  ( const string& msg ) {
 }
 
 void Logger::Sink::ln  ( const char* msg ) {
-    if ( _level>= _parent.logLevel ) {
+    if ( _level >= _parent._logLevel ) {
         // If line has already been started, abort it and start new one:
-        if(_lineIsPrefixed) *_parent.output << endl;
+        if(_lineIsPrefixed) *_parent._output << endl;
         prefixLine(true);
-        *_parent.output <<  msg << endl;
+        *_parent._output <<  msg << endl;
     }
 }
 
@@ -85,58 +85,58 @@ void Logger::Sink::prefixLine(bool resetToFalse) {
             case WARN:  lvlString = "WARN";  break;
             case FATAL: lvlString = "FATAL"; break;
         }
-        *_parent.output << Logger::genTimeStamp() << " [" << lvlString << "] ";
+        *_parent._output << Logger::genTimeStamp() << " [" << lvlString << "] ";
         _lineIsPrefixed = resetToFalse ? false : true;
     }
 }
 
 Logger::Sink& Logger::Sink::operator<<(const string& msg) {
-    if ( _level>= _parent.logLevel ) {
+    if ( _level >= _parent._logLevel ) {
         prefixLine();
-        *_parent.output << msg;
+        *_parent._output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const char* msg) {
-    if ( _level>= _parent.logLevel ) {
+    if ( _level >= _parent._logLevel ) {
         prefixLine();
-        *_parent.output << msg;
+        *_parent._output << msg;
     }
     return *this;
 }
 
 
 Logger::Sink& Logger::Sink::operator<<(const int msg) {
-    if ( _level>= _parent.logLevel ) {
+    if ( _level >= _parent._logLevel ) {
         prefixLine();
-        *_parent.output << msg;
+        *_parent._output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const long msg) {
-    if ( _level>= _parent.logLevel ) {
+    if ( _level >= _parent._logLevel ) {
         prefixLine();
-        *_parent.output << msg;
+        *_parent._output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const unsigned long msg) {
-    if ( _level>= _parent.logLevel ) {
+    if ( _level >= _parent._logLevel ) {
         prefixLine();
-        *_parent.output << msg;
+        *_parent._output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const char character) {
-    if ( _level>= _parent.logLevel ) {
+    if ( _level >= _parent._logLevel ) {
         switch(character) {
             // COMMIT - End message line
             case 0:
-              *_parent.output << endl;
+              *_parent._output << endl;
               _lineIsPrefixed = false;
             break;
         }

src/core/include/Logger.hpp

@@ -45,8 +45,8 @@ class Logger {
     Sink fatal;
 
     private:
-    enum Level logLevel;
-    ofstream* output;
+    enum Level _logLevel;
+    ofstream* _output;
     static string genTimeStamp();
 };
 

src/core/main.cpp

@@ -14,24 +14,28 @@ int main(int args, char **argv) {
     Logger logger(Logger::DEBUG);
     logger.info.ln ("Starting PlaiNS...");
 
-    try{
+    try
+    {
         vector<string> arguments;
         for ( unsigned index = 0; index < args; ++index ) {
             arguments.push_back (argv[index]);
         }
 
+        logger.debug.ln ("Loading Configuration...");
         ConfigManager cfg(logger, arguments);
+
+        logger.debug.ln ("Start Event Bus...");
         EventBus      eventBus(logger);
+
+        logger.debug.ln ("Start DNS resolver...");
         Resolver::Server resolver(logger, eventBus);
 
         //Record testrec = ARecord();
-        logger.debug.ln ("Running DNS resolver...");
-        resolver.run();
+        //logger.debug.ln ("Running DNS resolver...");
+        //resolver.run();
         logger.info.ln ("PlaiNS successfully started.");
         // Run something on main thread...
-        logger.info.ln ("Done - shutting down. Bye!");
-
-        
+        logger.info.ln ("Shutting down PlaiNS. Good Bye!");        
     }
     catch (std::exception& e)
     {

src/resolver/Server.cpp

@@ -30,21 +30,21 @@ static char* intToHex(unsigned byteCount, int c) {
     static char* out = new char[32];
     const char* byte = (char*)&c;
 
-    printf("%x\n", c);
-    printf("%x\n", byte[0] & 0xFF);
-    printf("%x\n", byte[1] & 0xFF);
+    //printf("%x\n", c);
+    //printf("%x\n", byte[0] & 0xFF);
+    //printf("%x\n", byte[1] & 0xFF);
     
 
     out[byteCount*3] = 0x0; //Terminate string
     //out[4] = 0xE; //Terminate string
     for (unsigned i = 0; i < byteCount; i++) {
-        std::cout << "i(" << i << ") ";
+        //std::cout << "i(" << i << ") ";
         //char byte = (c >> (i*8)) & 0xFF;
         const char* nibble = byteToHex(byte[i]);
         out[i*3]     = nibble[0];
         out[i*3+1]   = nibble[1];
         out[i*3+2]   = ' ';
-        std::cout <<  "Char1(" << out[0] << ") Char2(" << out[1] << ") Char3(" << out[2] << ")" << std::endl;
+        //std::cout <<  "Char1(" << out[0] << ") Char2(" << out[1] << ") Char3(" << out[2] << ")" << std::endl;
     }
     return out;
 }
@@ -53,6 +53,7 @@ Server::Server(Logger& logger, EventBus& eventBus)
   : _logger(logger),
     _eventBus(eventBus)
 {
+/*
     _logger.debug << "Testing some stuff..." << Logger::commit;
     _logger.debug << "Message header overall size: " << sizeof(Message::Header) << Logger::commit;
 //    _logger.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
@@ -86,44 +87,43 @@ Server::Server(Logger& logger, EventBus& eventBus)
     "Additional Record Count: " << intToHex(2, header->arCount) << Logger::commit;
     myfile.close();
     //Testing over
-
-    _socket = new udp::socket(_io_context, udp::endpoint(udp::v4(), 8853));
+    _logger.debug << "Done testing" << Logger::commit;
+*/
+    _udpSocket = new udp::socket(_ioContext, udp::endpoint(udp::v4(), 8853));
+    _ioContext.run();
+    doReceive();
 }
 
-Server::~Server() {
-    
-}
+Server::~Server() {}
 
-void Server::run() {
-    _io_context.run();
-    do_receive();
-}
+//void Server::run() {
+//    _ioContext.run();
+//    doReceive();
+//}
 
-void Server::do_receive()
+void Server::doReceive()
 {
-  _socket->async_receive_from(
-      asio::buffer(_data, 1024), _sender_endpoint,
-      [this](std::error_code ec, std::size_t bytes_recvd)
-      {
-        if (!ec && bytes_recvd > 0)
-        {
-          do_send(bytes_recvd);
+    _udpSocket->async_receive_from(
+        asio::buffer(_data, 1024), _sender_endpoint,
+        [this](std::error_code ec, std::size_t bytes_recvd)
+    {
+        if (!ec && bytes_recvd > 0) {
+            doSend(bytes_recvd);
         }
-        else
-        {
-          do_receive();
+        else {
+            doReceive();
         }
-      });
+    });
 }
 
-void Server::do_send(std::size_t length)
+void Server::doSend(std::size_t length)
 {
-  _socket->async_send_to (
-      asio::buffer(_data, length), _sender_endpoint,
-      [this](std::error_code /*ec*/, std::size_t /*_bytessent*/)
-      {
-        do_receive();
-      });
+    _udpSocket->async_send_to (
+        asio::buffer(_data, length), _sender_endpoint,
+        [this](std::error_code /*ec*/, std::size_t /*_bytessent*/)
+    {
+        doReceive();
+    });
 }
 
 

src/resolver/include/Server.hpp

@@ -17,18 +17,18 @@ class Server
     private:
     EventBus& _eventBus;
     Logger& _logger;
-    asio::io_context _io_context;
-    asio::ip::udp::socket* _socket;
+    asio::io_context _ioContext;
+    asio::ip::udp::socket* _udpSocket;
     asio::ip::udp::endpoint _sender_endpoint;
     char _data[1024];
 
-    void do_receive();
-    void do_send(std::size_t length);
+    void doReceive();
+    void doSend(std::size_t length);
 
     public:
     Server(Logger& logger, EventBus& eventBus);
     ~Server();
-    void run();
+    //void run();
 };