Refactor message logging.

Author: Mysticial

SerialPrograms/Source/Controllers/SerialPABotBase/Connection/BotBaseMessage.h

@@ -10,8 +10,11 @@
 #include <stdint.h>
 #include <cstring>
 #include <string>
+#include "Common/Cpp/PrettyPrint.h"
 #include "Common/Cpp/Exceptions.h"
 #include "Common/Cpp/LifetimeSanitizer.h"
+#include "Common/SerialPABotBase/SerialPABotBase_Protocol.h"
+#include "CommonFramework/GlobalSettingsPanel.h"
 
 namespace PokemonAutomation{
 
@@ -73,6 +76,65 @@ class BotBaseRequest{
 
 
 
+class BotBaseMessageType{
+public:
+    template <typename ChildType>
+    static const BotBaseMessageType& instance(){
+        static const ChildType type;
+        return type;
+    }
+
+    BotBaseMessageType(const char* name, uint8_t type, uint8_t body_size)
+        : m_name(name)
+        , m_type(type)
+        , m_size(body_size)
+    {}
+
+    uint8_t type() const{
+        return m_type;
+    }
+
+    friend bool operator<(const BotBaseMessageType& x, const BotBaseMessageType& y){
+        return x.m_type < y.m_type;
+    }
+
+
+public:
+    virtual bool should_print(const std::string& body) const{
+        if (GlobalSettings::instance().LOG_EVERYTHING){
+            return true;
+        }
+        if (PABB_MSG_IS_ACK(m_type)){
+            return false;
+        }
+        return true;
+    }
+    virtual bool is_valid(const std::string& body) const{
+        return body.size() == m_size;
+    }
+    virtual std::string tostr(const std::string& body) const{
+        std::string ret;
+        ret += "(0x" + tostr_hex(m_type) + ") ";
+        ret += m_name;
+        if (!is_valid(body)){
+            ret += ": (Invalid: Size = " + std::to_string(body.size()) + ")";
+        }
+        return ret;
+    }
+
+
+private:
+    const char* m_name;
+    const uint8_t m_type;
+    const uint8_t m_size;   //  Excluding header and CRC.
+};
+
+
+
+
+
+
+
 
 }
 #endif

SerialPrograms/Source/Controllers/SerialPABotBase/Connection/MessageLogger.cpp

@@ -5,88 +5,14 @@
  */
 
 #include "Common/Cpp/PrettyPrint.h"
-#include "Common/SerialPABotBase/SerialPABotBase_Protocol.h"
-#include "Controllers/SerialPABotBase/Connection/MessageConverter.h"
-#include "BotBaseMessage.h"
 #include "MessageLogger.h"
 
 namespace PokemonAutomation{
 
 
-//void MessageLogger::log(std::string msg){
-//    log(msg);
-//}
-void MessageLogger::on_send(const BotBaseMessage& message, bool is_retransmit){
-    bool print = false;
-    do{
-        if (is_retransmit){
-            print = true;
-        }
-        if (PABB_MSG_IS_REQUEST(message.type)){
-            print = true;
-        }
-        if (PABB_MSG_IS_COMMAND(message.type)){
-            print = true;
-        }
-        if (message.type == PABB_MSG_REQUEST_CLOCK){
-            print = false;
-        }
-#if 0
-        if (message.type == PABB_MSG_CONTROLLER_STATE){
-//            pabb_controller_state body;
-//            memcpy(&body, message.body.c_str(), sizeof(pabb_controller_state));
-//            print = body.ticks >= 5;
-            print = false;
-        }
-#endif
-
-        if (m_log_everything.load(std::memory_order_relaxed)){
-            print = true;
-        }
-
-    }while (false);
-    if (!print){
-        return;
-    }
-    std::string str = message_to_string(message);
-    if (str.empty()){
-        return;
-    }
-    if (is_retransmit){
-        log("Re-Send: " + str, COLOR_DARKGREEN);
-    }else{
-        log("Sending: " + str, COLOR_DARKGREEN);
-    }
-}
-void MessageLogger::on_recv(const BotBaseMessage& message){
-    bool print = false;
-    do{
-        if (PABB_MSG_IS_ERROR(message.type)){
-            print = true;
-        }
-        if (PABB_MSG_IS_INFO(message.type)){
-            print = true;
-        }
-
-        if (m_log_everything.load(std::memory_order_relaxed)){
-            print = true;
-        }
-
-    }while (false);
-    if (!print){
-        return;
-    }
-    std::string str = message_to_string(message);
-    if (!str.empty()){
-        log("Receive: " + str, COLOR_DARKGREEN);
-    }
-}
-
-
 
 SerialLogger::SerialLogger(Logger& logger, bool log_everything)
-    : MessageLogger(log_everything)
-    , m_logger(logger)
+    : m_logger(logger)
     , m_history(200)
 {}
 void SerialLogger::log(const char* msg, Color color){

SerialPrograms/Source/Controllers/SerialPABotBase/Connection/MessageLogger.h

@@ -7,39 +7,16 @@
 #ifndef PokemonAutomation_MessageLogger_H
 #define PokemonAutomation_MessageLogger_H
 
-#include <atomic>
 #include "Common/Cpp/AbstractLogger.h"
 #include "Common/Cpp/Time.h"
 #include "Common/Cpp/Containers/CircularBuffer.h"
 #include "Common/Cpp/Concurrency/SpinLock.h"
-#include "MessageSniffer.h"
 
 namespace PokemonAutomation{
 
 
-class MessageLogger : public Logger, public MessageSniffer{
-public:
-    MessageLogger(bool log_everything = false)
-        : m_log_everything_owner(log_everything)
-        , m_log_everything(m_log_everything_owner)
-    {}
-    MessageLogger(std::atomic<bool>& log_everything)
-        : m_log_everything_owner(false)
-        , m_log_everything(log_everything)
-    {}
-
-
-    virtual void on_send(const BotBaseMessage& message, bool is_retransmit) override;
-    virtual void on_recv(const BotBaseMessage& message) override;
-
-private:
-    std::atomic<bool> m_log_everything_owner;
-    std::atomic<bool>& m_log_everything;
-};
-
-
 
-class SerialLogger : public MessageLogger{
+class SerialLogger : public Logger{
 public:
     SerialLogger(Logger& logger, bool log_everything);
 

SerialPrograms/Source/Controllers/SerialPABotBase/Connection/PABotBase.cpp

@@ -9,7 +9,8 @@
 #include "Common/Cpp/PanicDump.h"
 #include "Common/Cpp/Concurrency/SpinPause.h"
 #include "Common/SerialPABotBase/SerialPABotBase_Protocol.h"
-#include "Controllers/SerialPABotBase/SerialPABotBase_Routines_Protocol.h"
+#include "Controllers/SerialPABotBase/Messages/SerialPABotBase_MessageWrappers_BaseProtocol_StaticRequests.h"
+#include "Controllers/SerialPABotBase/Messages/SerialPABotBase_MessageWrappers_BaseProtocol_CommandQueue.h"
 #include "PABotBase.h"
 
 //#include <iostream>
@@ -40,7 +41,6 @@ namespace PokemonAutomation{
 PABotBase::PABotBase(
     Logger& logger,
     std::unique_ptr<StreamConnection> connection,
-    MessageLogger* message_logger,
     std::chrono::milliseconds retransmit_delay
 )
     : PABotBaseConnection(logger, std::move(connection))
@@ -52,8 +52,6 @@ PABotBase::PABotBase(
     , m_state(State::RUNNING)
     , m_error(false)
 {
-    set_sniffer(message_logger);
-
     //  We must initialize this last because it will trigger the lifetime
     //  sanitizer if it beats it to construction.
     m_retransmit_thread = Thread([this]{

SerialPrograms/Source/Controllers/SerialPABotBase/Connection/PABotBase.h

@@ -41,20 +41,17 @@
 namespace PokemonAutomation{
 
 
-class PABotBase : public BotBaseController, private PABotBaseConnection{
+class PABotBase : public BotBaseController, public PABotBaseConnection{
     static const seqnum_t MAX_SEQNUM_GAP = (seqnum_t)-1 >> 2;
 
 public:
     PABotBase(
         Logger& logger,
         std::unique_ptr<StreamConnection> connection,
-        MessageLogger* message_logger = nullptr,
         std::chrono::milliseconds retransmit_delay = std::chrono::milliseconds(100)
     );
     virtual ~PABotBase();
 
-    using PABotBaseConnection::set_sniffer;
-
     void connect();
     virtual void stop(std::string error_message = "") override;
 

SerialPrograms/Source/Controllers/SerialPABotBase/Connection/PABotBaseConnection.cpp

@@ -4,6 +4,7 @@
  * 
  */
 
+#include "Common/Cpp/Exceptions.h"
 #include "Common/CRC32.h"
 #include "Common/SerialPABotBase/SerialPABotBase_Protocol.h"
 //#include "Controllers/SerialPABotBase/Connection/MessageConverter.h"
@@ -16,12 +17,11 @@
 
 namespace PokemonAutomation{
 
-MessageSniffer null_sniffer;
+
 
 PABotBaseConnection::PABotBaseConnection(Logger& logger, std::unique_ptr<StreamConnection> connection)
     : m_connection(std::move(connection))
     , m_logger(logger)
-    , m_sniffer(&null_sniffer)
 {
     m_connection->add_listener(*this);
 }
@@ -38,11 +38,16 @@ void PABotBaseConnection::safely_stop(){
 }
 
 
-void PABotBaseConnection::set_sniffer(MessageSniffer* sniffer){
-    if (sniffer == nullptr){
-        sniffer = &null_sniffer;
+void PABotBaseConnection::add_message_printer(const BotBaseMessageType& type){
+    auto ret = m_printers.emplace(type.type(), &type);
+    if (ret.second){
+        return;
     }
-    m_sniffer = sniffer;
+    throw InternalProgramError(
+        nullptr,
+        PA_CURRENT_FUNCTION,
+        "Duplicate Message Type: 0x" + tostr_hex(type.type())
+    );
 }
 
 
@@ -63,7 +68,18 @@ void PABotBaseConnection::send_message(const BotBaseMessage& message, bool is_re
     }
 
 //    log("Sending: " + message_to_string(type, msg));
-    m_sniffer->on_send(message, is_retransmit);
+    {
+        std::string str = is_retransmit ? "Re-send" : "Sending";
+        auto iter = m_printers.find(message.type);
+        if (iter == m_printers.end()){
+            m_logger.log(str + ": Unknown Message Type (0x" + tostr_hex(message.type) + ")", COLOR_RED);
+        }else if (is_retransmit || iter->second->should_print(message.body)){
+            m_logger.log(
+                str + ": " + iter->second->tostr(message.body),
+                is_retransmit ? COLOR_ORANGE : COLOR_DARKGREEN
+            );
+        }
+    }
 
     size_t total_bytes = PABB_PROTOCOL_OVERHEAD + message.body.size();
     if (total_bytes > PABB_PROTOCOL_MAX_PACKET_SIZE){
@@ -91,16 +107,16 @@ void PABotBaseConnection::push_error_byte(ErrorBatchType type, char byte){
     case ErrorBatchType::NO_ERROR_:
         break;
     case ErrorBatchType::ZERO_BYTES:
-        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " zero byte(s).");
+        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " zero byte(s).", COLOR_RED);
         break;
     case ErrorBatchType::FF_BYTES:
-        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " 0xff byte(s).");
+        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " 0xff byte(s).", COLOR_RED);
         break;
     case ErrorBatchType::ASCII_BYTES:
-        m_logger.log("Received possible ASCII: " + m_current_error_batch);
+        m_logger.log("Received possible ASCII: " + m_current_error_batch, COLOR_RED);
         break;
     case ErrorBatchType::OTHER:
-//        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " invalid length byte(s).");
+//        m_logger.log("Skipped " + std::to_string(m_current_error_batch.size()) + " invalid length byte(s).", COLOR_RED);
         break;
     }
 
@@ -118,7 +134,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
         uint8_t length = ~m_recv_buffer[0];
 
         if (m_recv_buffer[0] == 0){
-//            m_logger.log("Skipping zero byte.");
+//            m_logger.log("Skipping zero byte.", COLOR_RED);
             push_error_byte(ErrorBatchType::ZERO_BYTES, 0);
             m_recv_buffer.pop_front();
             continue;
@@ -129,7 +145,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
             if (length == 0){
                 push_error_byte(ErrorBatchType::FF_BYTES, ~length);
             }else{
-                m_logger.log("Message is too short: bytes = " + std::to_string(length));
+                m_logger.log("Message is too short: bytes = " + std::to_string(length), COLOR_RED);
                 push_error_byte(ErrorBatchType::OTHER, ~length);
             }
             m_recv_buffer.pop_front();
@@ -142,7 +158,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
 //            std::string text = ascii < 32
 //                ? ", ascii = " + std::to_string(ascii)
 //                : std::string(", char = ") + ascii;
-//            m_logger.log("Message is too long: bytes = " + std::to_string(length) + text);
+//            m_logger.log("Message is too long: bytes = " + std::to_string(length) + text, COLOR_RED);
             push_error_byte(ErrorBatchType::ASCII_BYTES, ~length);
             m_recv_buffer.pop_front();
             continue;
@@ -169,7 +185,7 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
             //  Compare
 //            std::cout << checksumA << " / " << checksumE << std::endl;
             if (checksumA != checksumE){
-                m_logger.log("Invalid Checksum: bytes = " + std::to_string(length));
+                m_logger.log("Invalid Checksum: bytes = " + std::to_string(length), COLOR_RED);
 //                std::cout << checksumA << " / " << checksumE << std::endl;
 //                log(message_to_string(message[1], &message[2], length - PABB_PROTOCOL_OVERHEAD));
                 m_recv_buffer.pop_front();
@@ -179,7 +195,14 @@ void PABotBaseConnection::on_recv(const void* data, size_t bytes){
         m_recv_buffer.erase(m_recv_buffer.begin(), m_recv_buffer.begin() + length);
 
         BotBaseMessage msg(message[1], std::string(&message[2], length - PABB_PROTOCOL_OVERHEAD));
-        m_sniffer->on_recv(msg);
+        {
+            auto iter = m_printers.find(msg.type);
+            if (iter == m_printers.end()){
+                m_logger.log("Receive: Unknown Message Type (0x" + tostr_hex(msg.type) + ")", COLOR_RED);
+            }else if (iter->second->should_print(msg.body)){
+                m_logger.log("Receive: " + iter->second->tostr(msg.body), COLOR_DARKGREEN);
+            }
+        }
         on_recv_message(std::move(msg));
     }
 }