refactor: initial async web server

lib/WebServerHandlers/UpgradeHandler.h

@@ -1,6 +1,6 @@
 #include <Arduino.h>
 
-class UpgradeHandler : public RequestHandler {
+class UpgradeHandler : public AsyncWebHandler {
 public:
   enum class UpgradeType {
     FIRMWARE = 0,
@@ -12,7 +12,7 @@ public:
     NO_FILE,
     SUCCESS,
     PROHIBITED,
-    ABORTED,
+    SIZE_MISMATCH,
     ERROR_ON_START,
     ERROR_ON_WRITE,
     ERROR_ON_FINISH
@@ -22,27 +22,20 @@ public:
     UpgradeType type;
     UpgradeStatus status;
     String error;
+    unsigned int written = 0;
   } UpgradeResult;
 
-  typedef std::function<bool(HTTPMethod, const String&)> CanHandleCallback;
+  typedef std::function<bool(AsyncWebServerRequest *request, UpgradeType)> BeforeUpgradeCallback;
-  typedef std::function<bool(const String&)> CanUploadCallback;
+  typedef std::function<void(AsyncWebServerRequest *request, const UpgradeResult&, const UpgradeResult&)> AfterUpgradeCallback;
-  typedef std::function<bool(UpgradeType)> BeforeUpgradeCallback;
-  typedef std::function<void(const UpgradeResult&, const UpgradeResult&)> AfterUpgradeCallback;
   
-  UpgradeHandler(const char* uri) {
+  UpgradeHandler(AsyncURIMatcher uri) : uri(uri) {}
-    this->uri = uri;
-  }
 
-  UpgradeHandler* setCanHandleCallback(CanHandleCallback callback = nullptr) {
+  bool canHandle(AsyncWebServerRequest *request) const override final {
-    this->canHandleCallback = callback;
+    if (!request->isHTTP()) {
-
+      return false;
-    return this;
+    }
-  }
+    
-
+    return this->uri.matches(request);
-  UpgradeHandler* setCanUploadCallback(CanUploadCallback callback = nullptr) {
-    this->canUploadCallback = callback;
-
-    return this;
   }
 
   UpgradeHandler* setBeforeUpgradeCallback(BeforeUpgradeCallback callback = nullptr) {
@@ -57,67 +50,55 @@ public:
     return this;
   }
 
-  #if defined(ARDUINO_ARCH_ESP32)
+  void handleRequest(AsyncWebServerRequest *request) override final {
-  bool canHandle(WebServer &server, HTTPMethod method, const String &uri) override {
-    return this->canHandle(method, uri);
-  }
-  #endif
-
-  bool canHandle(HTTPMethod method, const String& uri) override {
-    return method == HTTP_POST && uri.equals(this->uri) && (!this->canHandleCallback || this->canHandleCallback(method, uri));
-  }
-
-  #if defined(ARDUINO_ARCH_ESP32)
-  bool canUpload(WebServer &server, const String &uri) override {
-    return this->canUpload(uri);
-  }
-  #endif
-
-  bool canUpload(const String& uri) override {
-    return uri.equals(this->uri) && (!this->canUploadCallback || this->canUploadCallback(uri));
-  }
-
-  bool handle(WebServer& server, HTTPMethod method, const String& uri) override {
     if (this->afterUpgradeCallback) {
-      this->afterUpgradeCallback(this->firmwareResult, this->filesystemResult);
+      this->afterUpgradeCallback(request, this->firmwareResult, this->filesystemResult);
     }
 
     this->firmwareResult.status = UpgradeStatus::NONE;
     this->firmwareResult.error.clear();
+    this->firmwareResult.written = 0;
 
     this->filesystemResult.status = UpgradeStatus::NONE;
     this->filesystemResult.error.clear();
-
+    this->filesystemResult.written = 0;
-    return true;
   }
 
-  void upload(WebServer& server, const String& uri, HTTPUpload& upload) override {
+  void handleUpload(AsyncWebServerRequest *request, const String &fileName, size_t index, uint8_t *data, size_t dataLength, bool isFinal) override final {
-    UpgradeResult* result;
+    UpgradeResult* result = nullptr;
-    if (upload.name.equals(F("firmware"))) {
+    unsigned int fileSize = 0;
+
+    const auto& fwName = request->hasParam("fw[name]", true) ? request->getParam("fw[name]", true)->value() : String();
+    const auto& fsName = request->hasParam("fs[name]", true) ? request->getParam("fs[name]", true)->value() : String();
+
+    if (fileName.equals(fwName)) {
       result = &this->firmwareResult;
+      if (request->hasParam("fw[size]", true)) {
+        fileSize = request->getParam("fw[size]", true)->value().toInt();
+      }
 
-    } else if (upload.name.equals(F("filesystem"))) {
+    } else if (fileName.equals(fsName)) {
       result = &this->filesystemResult;
-      
+      if (request->hasParam("fs[size]", true)) {
-    } else {
+        fileSize = request->getParam("fs[size]", true)->value().toInt();
+      } 
+    }
+
+    if (result == nullptr || result->status != UpgradeStatus::NONE) {
       return;
     }
 
-    if (result->status != UpgradeStatus::NONE) {
+    if (this->beforeUpgradeCallback && !this->beforeUpgradeCallback(request, result->type)) {
-      return;
-    }
-
-    if (this->beforeUpgradeCallback && !this->beforeUpgradeCallback(result->type)) {
       result->status = UpgradeStatus::PROHIBITED;
       return;
     }
 
-    if (!upload.filename.length()) {
+    if (!fileName.length() || !fileSize) {
       result->status = UpgradeStatus::NO_FILE;
       return;
     }
 
-    if (upload.status == UPLOAD_FILE_START) {
+    if (index == 0) {
       // reset
       if (Update.isRunning()) {
         Update.end(false);
@@ -125,91 +106,89 @@ public:
       }
 
       bool begin = false;
-      #ifdef ARDUINO_ARCH_ESP8266
-      Update.runAsync(true);
-      
-      if (result->type == UpgradeType::FIRMWARE) {
-        begin = Update.begin((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000, U_FLASH);
-        
-      } else if (result->type == UpgradeType::FILESYSTEM) {
-        close_all_fs();
-        begin = Update.begin((size_t)FS_end - (size_t)FS_start, U_FS);
-      }
-      #elif defined(ARDUINO_ARCH_ESP32)
       if (result->type == UpgradeType::FIRMWARE) {
         begin = Update.begin(UPDATE_SIZE_UNKNOWN, U_FLASH);
         
       } else if (result->type == UpgradeType::FILESYSTEM) {
         begin = Update.begin(UPDATE_SIZE_UNKNOWN, U_SPIFFS);
       }
-      #endif
 
       if (!begin || Update.hasError()) {
         result->status = UpgradeStatus::ERROR_ON_START;
-        #ifdef ARDUINO_ARCH_ESP8266
-        result->error = Update.getErrorString();
-        #else
         result->error = Update.errorString();
-        #endif
 
-        Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s', on start: %s"), upload.filename.c_str(), result->error.c_str());
+        Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s', on start: %s"), fileName.c_str(), result->error.c_str());
         return;
       }
       
-      Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s', started"), upload.filename.c_str());
+      Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s', started"), fileName.c_str());
+    }
+    
+    if (dataLength) {
+      result->written += dataLength;
 
-    } else if (upload.status == UPLOAD_FILE_WRITE) {
+      if (Update.write(data, dataLength) != dataLength) {
-      if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
         Update.end(false);
-
         result->status = UpgradeStatus::ERROR_ON_WRITE;
-        #ifdef ARDUINO_ARCH_ESP8266
-        result->error = Update.getErrorString();
-        #else
         result->error = Update.errorString();
-        #endif
 
         Log.serrorln(
           FPSTR(L_PORTAL_OTA),
-          F("File '%s', on writing %d bytes: %s"),
+          F("File '%s', on write %d bytes, %d of %d bytes"),
-          upload.filename.c_str(), upload.totalSize, result->error.c_str()
+          fileName.c_str(),
+          dataLength,
+          result->written,
+          fileSize
         );
-
+        return;
-      } else {
-        Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s', writed %d bytes"), upload.filename.c_str(), upload.totalSize);
       }
 
-    } else if (upload.status == UPLOAD_FILE_END) {
+      Log.sinfoln(
-      if (Update.end(true)) {
+        FPSTR(L_PORTAL_OTA),
-        result->status = UpgradeStatus::SUCCESS;
+        F("File '%s', write %d bytes, %d of %d bytes"),
+        fileName.c_str(),
+        dataLength,
+        result->written,
+        fileSize
+      );
+    }
 
-        Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s': finish"), upload.filename.c_str());
+    if (result->written > fileSize || (isFinal && result->written < fileSize)) {
-
-      } else {
-        result->status = UpgradeStatus::ERROR_ON_FINISH;
-        #ifdef ARDUINO_ARCH_ESP8266
-        result->error = Update.getErrorString();
-        #else
-        result->error = Update.errorString();
-        #endif
-
-        Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s', on finish: %s"), upload.filename.c_str(), result->error);
-      }
-
-    } else if (upload.status == UPLOAD_FILE_ABORTED) {
       Update.end(false);
-      result->status = UpgradeStatus::ABORTED;
+      result->status = UpgradeStatus::SIZE_MISMATCH;
 
-      Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s': aborted"), upload.filename.c_str());
+      Log.serrorln(
+        FPSTR(L_PORTAL_OTA),
+        F("File '%s', size mismatch: %d of %d bytes"),
+        fileName.c_str(),
+        result->written,
+        fileSize
+      );
+      return;
+    }
+    
+    if (isFinal) {
+      if (!Update.end(true)) {
+        result->status = UpgradeStatus::ERROR_ON_FINISH;
+        result->error = Update.errorString();
+
+        Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s', on finish: %s"), fileName.c_str(), result->error);
+        return;
+      }
+
+      result->status = UpgradeStatus::SUCCESS;
+      Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s': finish"), fileName.c_str());
     }
   }
 
+  bool isRequestHandlerTrivial() const override final {
+    return false;
+  }
+
 protected:
-  CanHandleCallback canHandleCallback;
-  CanUploadCallback canUploadCallback;
   BeforeUpgradeCallback beforeUpgradeCallback;
   AfterUpgradeCallback afterUpgradeCallback;
-  const char* uri = nullptr;
+  AsyncURIMatcher uri;
 
   UpgradeResult firmwareResult{UpgradeType::FIRMWARE, UpgradeStatus::NONE};
   UpgradeResult filesystemResult{UpgradeType::FILESYSTEM, UpgradeStatus::NONE};

platformio.ini

@@ -17,6 +17,9 @@ core_dir = .pio
 version = 1.5.6
 framework = arduino
 lib_deps = 
+  ESP32Async/AsyncTCP
+  ;ESP32Async/ESPAsyncWebServer
+  https://github.com/ESP32Async/ESPAsyncWebServer#main
 	bblanchon/ArduinoJson@^7.4.2
 	;ihormelnyk/OpenTherm Library@^1.1.5
 	https://github.com/Laxilef/opentherm_library#esp32_timer
@@ -34,6 +37,9 @@ build_flags =
 	;-D DEBUG_ESP_CORE -D DEBUG_ESP_WIFI -D DEBUG_ESP_HTTP_SERVER -D DEBUG_ESP_PORT=Serial
 	-D BUILD_VERSION='"${this.version}"'
 	-D BUILD_ENV='"$PIOENV"'
+  -D CONFIG_ASYNC_TCP_STACK_SIZE=4096
+	-D ARDUINOJSON_USE_DOUBLE=0
+	-D ARDUINOJSON_USE_LONG_LONG=0
 	-D DEFAULT_SERIAL_ENABLED=${secrets.serial_enabled}
 	-D DEFAULT_SERIAL_BAUD=${secrets.serial_baud}
 	-D DEFAULT_TELNET_ENABLED=${secrets.telnet_enabled}
@@ -98,7 +104,7 @@ board_build.partitions = esp32_partitions.csv
 lib_deps =
 	${env.lib_deps}
 	laxilef/ESP32Scheduler@^1.0.1
-nimble_lib = h2zero/NimBLE-Arduino@2.3.3
+nimble_lib = https://github.com/h2zero/NimBLE-Arduino
 lib_ignore = 
 extra_scripts = 
 	post:tools/esp32.py
@@ -234,7 +240,7 @@ build_flags =
 	${esp32_defaults.build_flags}
 	-D ARDUINO_USB_MODE=0
 	-D ARDUINO_USB_CDC_ON_BOOT=1
-	-D CONFIG_BT_NIMBLE_EXT_ADV=1
+	;-D CONFIG_BT_NIMBLE_EXT_ADV=1
 	-D USE_BLE=1
 	-D DEFAULT_OT_IN_GPIO=35
 	-D DEFAULT_OT_OUT_GPIO=36

src/main.cpp

@@ -1,6 +1,3 @@
-#define ARDUINOJSON_USE_DOUBLE 0
-#define ARDUINOJSON_USE_LONG_LONG 0
-
 #include <Arduino.h>
 #include <ArduinoJson.h>
 #include <FileData.h>
@@ -216,7 +213,7 @@ void setup() {
   tRegulator = new RegulatorTask(true, 10000);
   Scheduler.start(tRegulator);
 
-  tPortal = new PortalTask(true, 0);
+  tPortal = new PortalTask(true, 10);
   Scheduler.start(tPortal);
 
   tMain = new MainTask(true, 100);

src/strings.h

@@ -164,6 +164,7 @@ const char S_POWER[]                                PROGMEM = "power";
 const char S_PREFIX[]                               PROGMEM = "prefix";
 const char S_PROTOCOL_VERSION[]                     PROGMEM = "protocolVersion";
 const char S_PURPOSE[]                              PROGMEM = "purpose";
+const char S_PSRAM[]                                PROGMEM = "psram";
 const char S_P_FACTOR[]                             PROGMEM = "p_factor";
 const char S_P_MULTIPLIER[]                         PROGMEM = "p_multiplier";
 const char S_REAL_SIZE[]                            PROGMEM = "realSize";

src_data/pages/upgrade.html

@@ -62,19 +62,19 @@
 
           <form action="/api/upgrade" id="upgrade">
             <fieldset class="primary">
-              <label for="firmware-file">
+              <label>
                 <span data-i18n>upgrade.fw</span>:
                 <div class="grid">
-                  <input type="file" name="firmware" id="firmware-file" accept=".bin">
+                  <input type="file" name="fw[file]" accept=".bin">
-                  <button type="button" class="upgrade-firmware-result hidden" disabled></button>
+                  <button type="button" class="fwResult hidden" disabled></button>
                 </div>
               </label>
 
-              <label for="filesystem-file">
+              <label>
                 <span data-i18n>upgrade.fs</span>:
                 <div class="grid">
-                  <input type="file" name="filesystem" id="filesystem-file" accept=".bin">
+                  <input type="file" name="fs[file]" accept=".bin">
-                  <button type="button" class="upgrade-filesystem-result hidden" disabled></button>
+                  <button type="button" class="fsResult hidden" disabled></button>
                 </div>
               </label>
             </fieldset>
@@ -108,7 +108,125 @@
         lang.build();
 
         setupRestoreBackupForm('#restore');
-        setupUpgradeForm('#upgrade');
+
+        const upgradeForm = document.querySelector('#upgrade');
+        if (upgradeForm) {
+          upgradeForm.reset();
+          const statusToText = (status) => {
+            switch (status) {
+              case 0:
+                return "None";
+              case 1:
+                return "No file";
+              case 2:
+                return "Success";
+              case 3:
+                return "Prohibited";
+              case 4:
+                return "Size mismatch";
+              case 5:
+                return "Error on start";
+              case 6:
+                return "Error on write";
+              case 7:
+                return "Error on finish";
+              default:
+                return "Unknown";
+            }
+          };
+
+          upgradeForm.addEventListener('submit', async (event) => {
+            event.preventDefault();
+
+            hide('.fwResult');
+            hide('.fsResult');
+
+            let button = upgradeForm.querySelector('button[type="submit"]');
+            button.textContent = i18n('button.uploading');
+            button.setAttribute('disabled', true);
+            button.setAttribute('aria-busy', true);
+
+            try {
+              let fd = new FormData();
+
+              const fw = upgradeForm.querySelector("[name='fw[file]']").files;
+              if (fw.length > 0) {
+                fd.append("fw[name]", fw[0].name);
+                fd.append("fw[size]", fw[0].size);
+                fd.append("fw[file]", fw[0]);
+              }
+
+              const fs = upgradeForm.querySelector("[name='fs[file]']").files;
+              if (fs.length > 0) {
+                fd.append("fs[name]", fs[0].name);
+                fd.append("fs[size]", fs[0].size);
+                fd.append("fs[file]", fs[0]);
+              }
+
+              let response = await fetch(upgradeForm.action, {
+                method: "POST",
+                cache: "no-cache",
+                credentials: "include",
+                body: fd
+              });
+              
+              if (response.status != 202 && response.status != 406) {
+                throw new Error('Response not valid');
+              }
+
+              const result = await response.json();
+              let resItem = upgradeForm.querySelector('.fwResult');
+              if (resItem && result.firmware.status > 1) {
+                resItem.textContent = statusToText(result.firmware.status);
+                resItem.classList.remove('hidden');
+
+                if (result.firmware.status == 2) {
+                  resItem.classList.remove('failed');
+                  resItem.classList.add('success');
+                } else {
+                  resItem.classList.remove('success');
+                  resItem.classList.add('failed');
+
+                  if (result.firmware.error != "") {
+                    resItem.textContent += `: ${result.firmware.error}`;
+                  }
+                }
+              }
+
+              resItem = upgradeForm.querySelector('.fsResult');
+              if (resItem && result.filesystem.status > 1) {
+                resItem.textContent = statusToText(result.filesystem.status);
+                resItem.classList.remove('hidden');
+
+                if (result.filesystem.status == 2) {
+                  resItem.classList.remove('failed');
+                  resItem.classList.add('success');
+                } else {
+                  resItem.classList.remove('success');
+                  resItem.classList.add('failed');
+
+                  if (result.filesystem.error != "") {
+                    resItem.textContent += `: ${result.filesystem.error}`;
+                  }
+                }
+              }
+
+            } catch (err) {
+              console.log(err);
+              button.textContent = i18n('button.error');
+              button.classList.add('failed');
+
+            } finally {
+              setTimeout(() => {
+                button.removeAttribute('aria-busy');
+                button.removeAttribute('disabled');
+                button.classList.remove('success', 'failed');
+                button.textContent = i18n(button.dataset.i18n);
+                upgradeForm.reset();
+              }, 10000);
+            }
+          });
+        }
       });
     </script>
   </body>