Add OTA support to ESP-IDF webserver (#9264)

esphome/components/web_server_base/web_server_base.cpp

@@ -14,11 +14,114 @@
 #endif
 #endif
 
+#if defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
+#include <esp_ota_ops.h>
+#include <esp_task_wdt.h>
+#endif
+
 namespace esphome {
 namespace web_server_base {
 
 static const char *const TAG = "web_server_base";
 
+#if defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
+// Minimal OTA backend implementation for web server
+// This allows OTA updates via web server without requiring the OTA component
+// TODO: In the future, this should be refactored into a common ota_base component
+// that both web_server and ota components can depend on, avoiding code duplication
+// while keeping the components independent. This would allow both ESP-IDF and Arduino
+// implementations to share the base OTA functionality without requiring the full OTA component.
+// The IDFWebServerOTABackend class is intentionally designed with the same interface
+// as OTABackend to make it easy to swap to using OTABackend when the ota component
+// is split into ota and ota_base in the future.
+class IDFWebServerOTABackend {
+ public:
+  bool begin() {
+    this->partition_ = esp_ota_get_next_update_partition(nullptr);
+    if (this->partition_ == nullptr) {
+      ESP_LOGE(TAG, "No OTA partition available");
+      return false;
+    }
+
+#if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
+    // The following function takes longer than the default timeout of WDT due to flash erase
+#if ESP_IDF_VERSION_MAJOR >= 5
+    esp_task_wdt_config_t wdtc;
+    wdtc.idle_core_mask = 0;
+#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
+    wdtc.idle_core_mask |= (1 << 0);
+#endif
+#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1
+    wdtc.idle_core_mask |= (1 << 1);
+#endif
+    wdtc.timeout_ms = 15000;
+    wdtc.trigger_panic = false;
+    esp_task_wdt_reconfigure(&wdtc);
+#else
+    esp_task_wdt_init(15, false);
+#endif
+#endif
+
+    esp_err_t err = esp_ota_begin(this->partition_, 0, &this->update_handle_);
+
+#if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
+    // Set the WDT back to the configured timeout
+#if ESP_IDF_VERSION_MAJOR >= 5
+    wdtc.timeout_ms = CONFIG_ESP_TASK_WDT_TIMEOUT_S * 1000;
+    esp_task_wdt_reconfigure(&wdtc);
+#else
+    esp_task_wdt_init(CONFIG_ESP_TASK_WDT_TIMEOUT_S, false);
+#endif
+#endif
+
+    if (err != ESP_OK) {
+      esp_ota_abort(this->update_handle_);
+      this->update_handle_ = 0;
+      ESP_LOGE(TAG, "esp_ota_begin failed: %s", esp_err_to_name(err));
+      return false;
+    }
+    return true;
+  }
+
+  bool write(uint8_t *data, size_t len) {
+    esp_err_t err = esp_ota_write(this->update_handle_, data, len);
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "esp_ota_write failed: %s", esp_err_to_name(err));
+      return false;
+    }
+    return true;
+  }
+
+  bool end() {
+    esp_err_t err = esp_ota_end(this->update_handle_);
+    this->update_handle_ = 0;
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "esp_ota_end failed: %s", esp_err_to_name(err));
+      return false;
+    }
+
+    err = esp_ota_set_boot_partition(this->partition_);
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "esp_ota_set_boot_partition failed: %s", esp_err_to_name(err));
+      return false;
+    }
+
+    return true;
+  }
+
+  void abort() {
+    if (this->update_handle_ != 0) {
+      esp_ota_abort(this->update_handle_);
+      this->update_handle_ = 0;
+    }
+  }
+
+ private:
+  esp_ota_handle_t update_handle_{0};
+  const esp_partition_t *partition_{nullptr};
+};
+#endif
+
 void WebServerBase::add_handler(AsyncWebHandler *handler) {
   // remove all handlers
 
@@ -31,6 +134,33 @@ void WebServerBase::add_handler(AsyncWebHandler *handler) {
   }
 }
 
+#ifdef USE_WEBSERVER_OTA
+void OTARequestHandler::report_ota_progress_(AsyncWebServerRequest *request) {
+  const uint32_t now = millis();
+  if (now - this->last_ota_progress_ > 1000) {
+    if (request->contentLength() != 0) {
+      float percentage = (this->ota_read_length_ * 100.0f) / request->contentLength();
+      ESP_LOGD(TAG, "OTA in progress: %0.1f%%", percentage);
+    } else {
+      ESP_LOGD(TAG, "OTA in progress: %u bytes read", this->ota_read_length_);
+    }
+    this->last_ota_progress_ = now;
+  }
+}
+
+void OTARequestHandler::schedule_ota_reboot_() {
+  ESP_LOGI(TAG, "OTA update successful!");
+  this->parent_->set_timeout(100, []() {
+    ESP_LOGI(TAG, "Performing OTA reboot now");
+    App.safe_reboot();
+  });
+}
+
+void OTARequestHandler::ota_init_(const char *filename) {
+  ESP_LOGI(TAG, "OTA Update Start: %s", filename);
+  this->ota_read_length_ = 0;
+}
+
 void report_ota_error() {
 #ifdef USE_ARDUINO
   StreamString ss;
@@ -44,8 +174,7 @@ void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const Strin
 #ifdef USE_ARDUINO
   bool success;
   if (index == 0) {
-    ESP_LOGI(TAG, "OTA Update Start: %s", filename.c_str());
-    this->ota_read_length_ = 0;
+    this->ota_init_(filename.c_str());
 #ifdef USE_ESP8266
     Update.runAsync(true);
     // NOLINTNEXTLINE(readability-static-accessed-through-instance)
@@ -72,31 +201,68 @@ void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const Strin
     return;
   }
   this->ota_read_length_ += len;
-
-  const uint32_t now = millis();
-  if (now - this->last_ota_progress_ > 1000) {
-    if (request->contentLength() != 0) {
-      float percentage = (this->ota_read_length_ * 100.0f) / request->contentLength();
-      ESP_LOGD(TAG, "OTA in progress: %0.1f%%", percentage);
-    } else {
-      ESP_LOGD(TAG, "OTA in progress: %u bytes read", this->ota_read_length_);
-    }
-    this->last_ota_progress_ = now;
-  }
+  this->report_ota_progress_(request);
 
   if (final) {
     if (Update.end(true)) {
-      ESP_LOGI(TAG, "OTA update successful!");
-      this->parent_->set_timeout(100, []() { App.safe_reboot(); });
+      this->schedule_ota_reboot_();
     } else {
       report_ota_error();
     }
   }
-#endif
+#endif  // USE_ARDUINO
+
+#ifdef USE_ESP_IDF
+  // ESP-IDF implementation
+  if (index == 0 && !this->ota_backend_) {
+    // Initialize OTA on first call
+    this->ota_init_(filename.c_str());
+    this->ota_success_ = false;
+
+    auto *backend = new IDFWebServerOTABackend();
+    if (!backend->begin()) {
+      ESP_LOGE(TAG, "OTA begin failed");
+      delete backend;
+      return;
+    }
+    this->ota_backend_ = backend;
+  }
+
+  auto *backend = static_cast<IDFWebServerOTABackend *>(this->ota_backend_);
+  if (!backend) {
+    return;
+  }
+
+  // Process data
+  if (len > 0) {
+    if (!backend->write(data, len)) {
+      ESP_LOGE(TAG, "OTA write failed");
+      backend->abort();
+      delete backend;
+      this->ota_backend_ = nullptr;
+      return;
+    }
+    this->ota_read_length_ += len;
+    this->report_ota_progress_(request);
+  }
+
+  // Finalize
+  if (final) {
+    this->ota_success_ = backend->end();
+    if (this->ota_success_) {
+      this->schedule_ota_reboot_();
+    } else {
+      ESP_LOGE(TAG, "OTA end failed");
+    }
+    delete backend;
+    this->ota_backend_ = nullptr;
+  }
+#endif  // USE_ESP_IDF
 }
+
 void OTARequestHandler::handleRequest(AsyncWebServerRequest *request) {
-#ifdef USE_ARDUINO
   AsyncWebServerResponse *response;
+#ifdef USE_ARDUINO
   if (!Update.hasError()) {
     response = request->beginResponse(200, "text/plain", "Update Successful!");
   } else {
@@ -105,16 +271,20 @@ void OTARequestHandler::handleRequest(AsyncWebServerRequest *request) {
     Update.printError(ss);
     response = request->beginResponse(200, "text/plain", ss);
   }
+#endif  // USE_ARDUINO
+#ifdef USE_ESP_IDF
+  // Send response based on the OTA result
+  response = request->beginResponse(200, "text/plain", this->ota_success_ ? "Update Successful!" : "Update Failed!");
+#endif  // USE_ESP_IDF
   response->addHeader("Connection", "close");
   request->send(response);
-#endif
 }
 
 void WebServerBase::add_ota_handler() {
-#ifdef USE_ARDUINO
   this->add_handler(new OTARequestHandler(this));  // NOLINT
-#endif
 }
+#endif
+
 float WebServerBase::get_setup_priority() const {
   // Before WiFi (captive portal)
   return setup_priority::WIFI + 2.0f;