log to webui - initial version

src/emsesp.cpp

@@ -40,6 +40,7 @@ WebSettingsService EMSESP::webSettingsService = WebSettingsService(&webServer, &
 WebStatusService  EMSESP::webStatusService  = WebStatusService(&webServer, EMSESP::esp8266React.getSecurityManager());
 WebDevicesService EMSESP::webDevicesService = WebDevicesService(&webServer, EMSESP::esp8266React.getSecurityManager());
 WebAPIService     EMSESP::webAPIService     = WebAPIService(&webServer, EMSESP::esp8266React.getSecurityManager());
+WebLogService     EMSESP::webLogService     = WebLogService(&webServer, EMSESP::esp8266React.getSecurityManager());
 
 using DeviceFlags = EMSdevice;
 using DeviceType  = EMSdevice::DeviceType;
@@ -1209,11 +1210,12 @@ void EMSESP::start() {
 
 // main loop calling all services
 void EMSESP::loop() {
-    esp8266React.loop(); // web
+    esp8266React.loop(); // web services
     system_.loop();      // does LED and checks system health, and syslog service
 
     // if we're doing an OTA upload, skip MQTT and EMS
     if (!system_.upload_status()) {
+        webLogService.loop(); // log in Web UI
         rxservice_.loop();    // process any incoming Rx telegrams
         shower_.loop();       // check for shower on/off
         dallassensor_.loop(); // read dallas sensor temperatures

src/emsesp.h

@@ -35,10 +35,11 @@
 
 #include <ESP8266React.h>
 
-#include "WebStatusService.h"
-#include "WebDevicesService.h"
-#include "WebSettingsService.h"
-#include "WebAPIService.h"
+#include "web/WebStatusService.h"
+#include "web/WebDevicesService.h"
+#include "web/WebSettingsService.h"
+#include "web/WebAPIService.h"
+#include "web/WebLogService.h"
 
 #include "emsdevice.h"
 #include "emsfactory.h"
@@ -205,6 +206,7 @@ class EMSESP {
     static WebStatusService   webStatusService;
     static WebDevicesService  webDevicesService;
     static WebAPIService      webAPIService;
+    static WebLogService      webLogService;
 
     static uuid::log::Logger logger();
 

src/system.cpp

@@ -849,6 +849,7 @@ bool System::command_settings(const char * value, const int8_t id, JsonObject &
     EMSESP::webSettingsService.read([&](WebSettings & settings) {
         node                         = json.createNestedObject("Settings");
         node["tx_mode"]              = settings.tx_mode;
+        node["tx_delay"]             = settings.tx_delay;
         node["ems_bus_id"]           = settings.ems_bus_id;
         node["syslog_enabled"]       = settings.syslog_enabled;
         node["syslog_level"]         = settings.syslog_level;

src/version.h

@@ -1 +1 @@
-#define EMSESP_APP_VERSION "3.1.1b6"
+#define EMSESP_APP_VERSION "3.1.1b7"

src/web/WebDevicesService.h

@@ -29,7 +29,6 @@
 #define DEVICE_DATA_SERVICE_PATH "/rest/deviceData"
 #define WRITE_VALUE_SERVICE_PATH "/rest/writeValue"
 
-
 namespace emsesp {
 
 class WebDevicesService {

src/web/WebLogService.cpp

@@ -0,0 +1,126 @@
+/*
+ * EMS-ESP - https://github.com/emsesp/EMS-ESP
+ * Copyright 2020  Paul Derbyshire
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "emsesp.h"
+
+using namespace std::placeholders;
+
+namespace emsesp {
+
+WebLogService::WebLogService(AsyncWebServer * server, SecurityManager * securityManager)
+    : _events(EVENT_SOURCE_LOG_PATH) {
+    _events.setFilter(securityManager->filterRequest(AuthenticationPredicates::IS_ADMIN));
+    server->addHandler(&_events);
+    server->on(EVENT_SOURCE_LOG_PATH, HTTP_GET, std::bind(&WebLogService::forbidden, this, _1));
+    start();
+}
+
+void WebLogService::forbidden(AsyncWebServerRequest * request) {
+    request->send(403);
+}
+
+void WebLogService::start() {
+    uuid::log::Logger::register_handler(this, uuid::log::Level::INFO); // default is INFO
+}
+
+uuid::log::Level WebLogService::log_level() const {
+    return uuid::log::Logger::get_log_level(this);
+}
+
+void WebLogService::remove_queued_messages(uuid::log::Level level) {
+    unsigned long offset = 0;
+
+    for (auto it = log_messages_.begin(); it != log_messages_.end();) {
+        if (it->content_->level > level) {
+            offset++;
+            it = log_messages_.erase(it);
+        } else {
+            it->id_ -= offset;
+            it++;
+        }
+    }
+
+    log_message_id_ -= offset;
+}
+
+void WebLogService::log_level(uuid::log::Level level) {
+    uuid::log::Logger::register_handler(this, level);
+}
+
+size_t WebLogService::maximum_log_messages() const {
+    return maximum_log_messages_;
+}
+
+void WebLogService::maximum_log_messages(size_t count) {
+    maximum_log_messages_ = std::max((size_t)1, count);
+    while (log_messages_.size() > maximum_log_messages_) {
+        log_messages_.pop_front();
+    }
+}
+
+WebLogService::QueuedLogMessage::QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> && content)
+    : id_(id)
+    , content_(std::move(content)) {
+}
+
+void WebLogService::operator<<(std::shared_ptr<uuid::log::Message> message) {
+    if (log_messages_.size() >= maximum_log_messages_) {
+        log_messages_.pop_front();
+    }
+    log_messages_.emplace_back(log_message_id_++, std::move(message));
+}
+
+void WebLogService::loop() {
+    if (!_events.count()) {
+        return;
+    }
+
+    while (!log_messages_.empty() && can_transmit()) {
+        transmit(log_messages_.front());
+        log_messages_.pop_front();
+    }
+}
+
+bool WebLogService::can_transmit() {
+    const uint64_t now = uuid::get_uptime_ms();
+    if (now < last_transmit_ || now - last_transmit_ < 100) {
+        return false;
+    }
+    return true;
+}
+
+// send to web eventsource
+void WebLogService::transmit(const QueuedLogMessage & message) {
+    DynamicJsonDocument jsonDocument = DynamicJsonDocument(EMSESP_JSON_SIZE_SMALL);
+    JsonObject          logEvent     = jsonDocument.to<JsonObject>();
+    logEvent["time"]                 = uuid::log::format_timestamp_ms(message.content_->uptime_ms, 3);
+    logEvent["level"]                = message.content_->level;
+    logEvent["message"]              = message.content_->text;
+
+    size_t len    = measureJson(jsonDocument);
+    char * buffer = new char[len + 1];
+    if (buffer) {
+        serializeJson(jsonDocument, buffer, len + 1);
+        _events.send(buffer, "message", millis());
+    }
+    delete[] buffer;
+
+    last_transmit_ = uuid::get_uptime_ms();
+}
+
+} // namespace emsesp

src/web/WebLogService.h

@@ -0,0 +1,74 @@
+/*
+ * EMS-ESP - https://github.com/emsesp/EMS-ESP
+ * Copyright 2020  Paul Derbyshire
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef WebLogService_h
+#define WebLogService_h
+
+#include <ArduinoJson.h>
+#include <AsyncJson.h>
+#include <ESPAsyncWebServer.h>
+#include <SecurityManager.h>
+
+#include <uuid/log.h>
+
+#define EVENT_SOURCE_LOG_PATH "/es/log"
+
+namespace emsesp {
+
+class WebLogService : public uuid::log::Handler {
+  public:
+    static constexpr size_t MAX_LOG_MESSAGES = 50;
+
+    WebLogService(AsyncWebServer * server, SecurityManager * securityManager);
+
+    void             start();
+    uuid::log::Level log_level() const;
+    void             log_level(uuid::log::Level level);
+    size_t           maximum_log_messages() const;
+    void             maximum_log_messages(size_t count);
+    void             loop();
+
+    virtual void operator<<(std::shared_ptr<uuid::log::Message> message);
+
+  private:
+    AsyncEventSource _events;
+
+    class QueuedLogMessage {
+      public:
+        QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> && content);
+        ~QueuedLogMessage() = default;
+
+        unsigned long                                   id_;      // Sequential identifier for this log message
+        struct timeval                                  time_;    // Time message was received
+        const std::shared_ptr<const uuid::log::Message> content_; // Log message content
+    };
+
+    void forbidden(AsyncWebServerRequest * request);
+    void remove_queued_messages(uuid::log::Level level);
+    bool can_transmit();
+    void transmit(const QueuedLogMessage & message);
+
+    uint64_t                    last_transmit_        = 0;                // Last transmit time
+    size_t                      maximum_log_messages_ = MAX_LOG_MESSAGES; // Maximum number of log messages to buffer before they are output
+    unsigned long               log_message_id_       = 0;                // The next identifier to use for queued log messages
+    std::list<QueuedLogMessage> log_messages_;                            // Queued log messages, in the order they were received
+};
+
+} // namespace emsesp
+
+#endif

src/web/WebSettingsService.h

@@ -22,7 +22,7 @@
 #include <HttpEndpoint.h>
 #include <FSPersistence.h>
 
-#include "default_settings.h"
+#include "../default_settings.h"
 
 #define EMSESP_SETTINGS_FILE "/config/emsespSettings.json"
 #define EMSESP_SETTINGS_SERVICE_PATH "/rest/emsespSettings"