web_server: ensure fair network sharing + prevent lost state changes via deferred publish at high event load (#7538)

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com> Co-authored-by: Keith Burzinski <kbx81x@gmail.com>
2025-09-08 06:12:20 +01:00 · 2025-02-24 18:19:31 -08:00
parent c424fea524
commit 5e44a035a3
9 changed files with 832 additions and 200 deletions
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -72,8 +72,146 @@ UrlMatch match_url(const std::string &url, bool only_domain = false) {
  return match;
 }

-WebServer::WebServer(web_server_base::WebServerBase *base)
-    : base_(base), entities_iterator_(ListEntitiesIterator(this)) {
+#ifdef USE_ARDUINO
+// helper for allowing only unique entries in the queue
+void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_generator_t *message_generator) {
+  DeferredEvent item(source, message_generator);
+
+  auto iter = std::find_if(this->deferred_queue_.begin(), this->deferred_queue_.end(),
+                           [&item](const DeferredEvent &test) -> bool { return test == item; });
+
+  if (iter != this->deferred_queue_.end()) {
+    (*iter) = item;
+  } else {
+    this->deferred_queue_.push_back(item);
+  }
+}
+
+void DeferredUpdateEventSource::process_deferred_queue_() {
+  while (!deferred_queue_.empty()) {
+    DeferredEvent &de = deferred_queue_.front();
+    std::string message = de.message_generator_(web_server_, de.source_);
+    if (this->try_send(message.c_str(), "state")) {
+      // O(n) but memory efficiency is more important than speed here which is why std::vector was chosen
+      deferred_queue_.erase(deferred_queue_.begin());
+    } else {
+      break;
+    }
+  }
+}
+
+void DeferredUpdateEventSource::loop() {
+  process_deferred_queue_();
+  if (!this->entities_iterator_.completed())
+    this->entities_iterator_.advance();
+}
+
+void DeferredUpdateEventSource::deferrable_send_state(void *source, const char *event_type,
+                                                      message_generator_t *message_generator) {
+  // allow all json "details_all" to go through before publishing bare state events, this avoids unnamed entries showing
+  // up in the web GUI and reduces event load during initial connect
+  if (!entities_iterator_.completed() && 0 != strcmp(event_type, "state_detail_all"))
+    return;
+
+  if (source == nullptr)
+    return;
+  if (event_type == nullptr)
+    return;
+  if (message_generator == nullptr)
+    return;
+
+  if (0 != strcmp(event_type, "state_detail_all") && 0 != strcmp(event_type, "state")) {
+    ESP_LOGE(TAG, "Can't defer non-state event");
+  }
+
+  if (!deferred_queue_.empty())
+    process_deferred_queue_();
+  if (!deferred_queue_.empty()) {
+    // deferred queue still not empty which means downstream event queue full, no point trying to send first
+    deq_push_back_with_dedup_(source, message_generator);
+  } else {
+    std::string message = message_generator(web_server_, source);
+    if (!this->try_send(message.c_str(), "state")) {
+      deq_push_back_with_dedup_(source, message_generator);
+    }
+  }
+}
+
+// used for logs plus the initial ping/config
+void DeferredUpdateEventSource::try_send_nodefer(const char *message, const char *event, uint32_t id,
+                                                 uint32_t reconnect) {
+  this->send(message, event, id, reconnect);
+}
+
+void DeferredUpdateEventSourceList::loop() {
+  for (DeferredUpdateEventSource *dues : *this) {
+    dues->loop();
+  }
+}
+
+void DeferredUpdateEventSourceList::deferrable_send_state(void *source, const char *event_type,
+                                                          message_generator_t *message_generator) {
+  for (DeferredUpdateEventSource *dues : *this) {
+    dues->deferrable_send_state(source, event_type, message_generator);
+  }
+}
+
+void DeferredUpdateEventSourceList::try_send_nodefer(const char *message, const char *event, uint32_t id,
+                                                     uint32_t reconnect) {
+  for (DeferredUpdateEventSource *dues : *this) {
+    dues->try_send_nodefer(message, event, id, reconnect);
+  }
+}
+
+void DeferredUpdateEventSourceList::add_new_client(WebServer *ws, AsyncWebServerRequest *request) {
+  DeferredUpdateEventSource *es = new DeferredUpdateEventSource(ws, "/events");
+  this->push_back(es);
+
+  es->onConnect([this, ws, es](AsyncEventSourceClient *client) {
+    ws->defer([this, ws, es]() { this->on_client_connect_(ws, es); });
+  });
+
+  es->onDisconnect([this, ws](AsyncEventSource *source, AsyncEventSourceClient *client) {
+    ws->defer([this, source]() { this->on_client_disconnect_((DeferredUpdateEventSource *) source); });
+  });
+
+  es->handleRequest(request);
+}
+
+void DeferredUpdateEventSourceList::on_client_connect_(WebServer *ws, DeferredUpdateEventSource *source) {
+  // Configure reconnect timeout and send config
+  // this should always go through since the AsyncEventSourceClient event queue is empty on connect
+  std::string message = ws->get_config_json();
+  source->try_send_nodefer(message.c_str(), "ping", millis(), 30000);
+
+  for (auto &group : ws->sorting_groups_) {
+    message = json::build_json([group](JsonObject root) {
+      root["name"] = group.second.name;
+      root["sorting_weight"] = group.second.weight;
+    });
+
+    // up to 31 groups should be able to be queued initially without defer
+    source->try_send_nodefer(message.c_str(), "sorting_group");
+  }
+
+  source->entities_iterator_.begin(ws->include_internal_);
+
+  // just dump them all up-front and take advantage of the deferred queue
+  //     on second thought that takes too long, but leaving the commented code here for debug purposes
+  // while(!source->entities_iterator_.completed()) {
+  //  source->entities_iterator_.advance();
+  //}
+}
+
+void DeferredUpdateEventSourceList::on_client_disconnect_(DeferredUpdateEventSource *source) {
+  // This method was called via WebServer->defer() and is no longer executing in the
+  // context of the network callback. The object is now dead and can be safely deleted.
+  this->remove(source);
+  delete source;  // NOLINT
+}
+#endif
+
+WebServer::WebServer(web_server_base::WebServerBase *base) : base_(base) {
 #ifdef USE_ESP32
  to_schedule_lock_ = xSemaphoreCreateMutex();
 #endif
@@ -101,34 +239,27 @@ void WebServer::setup() {
  this->setup_controller(this->include_internal_);
  this->base_->init();

-  this->events_.onConnect([this](AsyncEventSourceClient *client) {
-    // Configure reconnect timeout and send config
-    client->send(this->get_config_json().c_str(), "ping", millis(), 30000);
-
-    for (auto &group : this->sorting_groups_) {
-      client->send(json::build_json([group](JsonObject root) {
-                     root["name"] = group.second.name;
-                     root["sorting_weight"] = group.second.weight;
-                   }).c_str(),
-                   "sorting_group");
-    }
-
-    this->entities_iterator_.begin(this->include_internal_);
-  });
-
 #ifdef USE_LOGGER
  if (logger::global_logger != nullptr && this->expose_log_) {
    logger::global_logger->add_on_log_callback(
-        [this](int level, const char *tag, const char *message) { this->events_.send(message, "log", millis()); });
+        // logs are not deferred, the memory overhead would be too large
+        [this](int level, const char *tag, const char *message) {
+          this->events_.try_send_nodefer(message, "log", millis());
+        });
  }
 #endif
+
+#ifdef USE_ESP_IDF
  this->base_->add_handler(&this->events_);
+#endif
  this->base_->add_handler(this);

  if (this->allow_ota_)
    this->base_->add_ota_handler();

-  this->set_interval(10000, [this]() { this->events_.send("", "ping", millis(), 30000); });
+  // doesn't need defer functionality - if the queue is full, the client JS knows it's alive because it's clearly
+  // getting a lot of events
+  this->set_interval(10000, [this]() { this->events_.try_send_nodefer("", "ping", millis(), 30000); });
 }
 void WebServer::loop() {
 #ifdef USE_ESP32
@@ -147,7 +278,8 @@ void WebServer::loop() {
    }
  }
 #endif
-  this->entities_iterator_.advance();
+
+  this->events_.loop();
 }
 void WebServer::dump_config() {
  ESP_LOGCONFIG(TAG, "Web Server:");
@@ -219,9 +351,9 @@ void WebServer::handle_js_request(AsyncWebServerRequest *request) {

 #ifdef USE_SENSOR
 void WebServer::on_sensor_update(sensor::Sensor *obj, float state) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->sensor_json(obj, state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", sensor_state_json_generator);
 }
 void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (sensor::Sensor *obj : App.get_sensors()) {
@@ -240,6 +372,12 @@ void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlM
  }
  request->send(404);
 }
+std::string WebServer::sensor_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->sensor_json((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::sensor_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->sensor_json((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::sensor_json(sensor::Sensor *obj, float value, JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    std::string state;
@@ -267,9 +405,9 @@ std::string WebServer::sensor_json(sensor::Sensor *obj, float value, JsonDetail

 #ifdef USE_TEXT_SENSOR
 void WebServer::on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->text_sensor_json(obj, state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", text_sensor_state_json_generator);
 }
 void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (text_sensor::TextSensor *obj : App.get_text_sensors()) {
@@ -288,6 +426,14 @@ void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const
  }
  request->send(404);
 }
+std::string WebServer::text_sensor_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->text_sensor_json((text_sensor::TextSensor *) (source),
+                                      ((text_sensor::TextSensor *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::text_sensor_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->text_sensor_json((text_sensor::TextSensor *) (source),
+                                      ((text_sensor::TextSensor *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::text_sensor_json(text_sensor::TextSensor *obj, const std::string &value,
                                        JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
@@ -306,9 +452,9 @@ std::string WebServer::text_sensor_json(text_sensor::TextSensor *obj, const std:

 #ifdef USE_SWITCH
 void WebServer::on_switch_update(switch_::Switch *obj, bool state) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->switch_json(obj, state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", switch_state_json_generator);
 }
 void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (switch_::Switch *obj : App.get_switches()) {
@@ -339,6 +485,12 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
  }
  request->send(404);
 }
+std::string WebServer::switch_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->switch_json((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::switch_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->switch_json((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::switch_json(switch_::Switch *obj, bool value, JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "switch-" + obj->get_object_id(), value ? "ON" : "OFF", value, start_config);
@@ -379,6 +531,12 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
  }
  request->send(404);
 }
+std::string WebServer::button_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->button_json((button::Button *) (source), DETAIL_STATE);
+}
+std::string WebServer::button_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->button_json((button::Button *) (source), DETAIL_ALL);
+}
 std::string WebServer::button_json(button::Button *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "button-" + obj->get_object_id(), start_config);
@@ -396,9 +554,9 @@ std::string WebServer::button_json(button::Button *obj, JsonDetail start_config)

 #ifdef USE_BINARY_SENSOR
 void WebServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->binary_sensor_json(obj, state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", binary_sensor_state_json_generator);
 }
 void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (binary_sensor::BinarySensor *obj : App.get_binary_sensors()) {
@@ -417,6 +575,14 @@ void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, con
  }
  request->send(404);
 }
+std::string WebServer::binary_sensor_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->binary_sensor_json((binary_sensor::BinarySensor *) (source),
+                                        ((binary_sensor::BinarySensor *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::binary_sensor_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->binary_sensor_json((binary_sensor::BinarySensor *) (source),
+                                        ((binary_sensor::BinarySensor *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::binary_sensor_json(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "binary_sensor-" + obj->get_object_id(), value ? "ON" : "OFF", value,
@@ -435,9 +601,9 @@ std::string WebServer::binary_sensor_json(binary_sensor::BinarySensor *obj, bool

 #ifdef USE_FAN
 void WebServer::on_fan_update(fan::Fan *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->fan_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", fan_state_json_generator);
 }
 void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (fan::Fan *obj : App.get_fans()) {
@@ -494,6 +660,12 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
  }
  request->send(404);
 }
+std::string WebServer::fan_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->fan_json((fan::Fan *) (source), DETAIL_STATE);
+}
+std::string WebServer::fan_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->fan_json((fan::Fan *) (source), DETAIL_ALL);
+}
 std::string WebServer::fan_json(fan::Fan *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "fan-" + obj->get_object_id(), obj->state ? "ON" : "OFF", obj->state,
@@ -519,9 +691,9 @@ std::string WebServer::fan_json(fan::Fan *obj, JsonDetail start_config) {

 #ifdef USE_LIGHT
 void WebServer::on_light_update(light::LightState *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->light_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", light_state_json_generator);
 }
 void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (light::LightState *obj : App.get_lights()) {
@@ -613,6 +785,12 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
  }
  request->send(404);
 }
+std::string WebServer::light_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->light_json((light::LightState *) (source), DETAIL_STATE);
+}
+std::string WebServer::light_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->light_json((light::LightState *) (source), DETAIL_ALL);
+}
 std::string WebServer::light_json(light::LightState *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "light-" + obj->get_object_id(), start_config);
@@ -638,9 +816,9 @@ std::string WebServer::light_json(light::LightState *obj, JsonDetail start_confi

 #ifdef USE_COVER
 void WebServer::on_cover_update(cover::Cover *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->cover_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", cover_state_json_generator);
 }
 void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (cover::Cover *obj : App.get_covers()) {
@@ -698,6 +876,12 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
  }
  request->send(404);
 }
+std::string WebServer::cover_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->cover_json((cover::Cover *) (source), DETAIL_STATE);
+}
+std::string WebServer::cover_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->cover_json((cover::Cover *) (source), DETAIL_STATE);
+}
 std::string WebServer::cover_json(cover::Cover *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "cover-" + obj->get_object_id(), obj->is_fully_closed() ? "CLOSED" : "OPEN",
@@ -722,9 +906,9 @@ std::string WebServer::cover_json(cover::Cover *obj, JsonDetail start_config) {

 #ifdef USE_NUMBER
 void WebServer::on_number_update(number::Number *obj, float state) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->number_json(obj, state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", number_state_json_generator);
 }
 void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (auto *obj : App.get_numbers()) {
@@ -760,6 +944,12 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
  request->send(404);
 }

+std::string WebServer::number_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->number_json((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::number_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->number_json((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::number_json(number::Number *obj, float value, JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    set_json_id(root, obj, "number-" + obj->get_object_id(), start_config);
@@ -796,9 +986,9 @@ std::string WebServer::number_json(number::Number *obj, float value, JsonDetail

 #ifdef USE_DATETIME_DATE
 void WebServer::on_date_update(datetime::DateEntity *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->date_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", date_state_json_generator);
 }
 void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (auto *obj : App.get_dates()) {
@@ -827,7 +1017,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
    }

    if (request->hasParam("value")) {
-      std::string value = request->getParam("value")->value().c_str();
+      std::string value = request->getParam("value")->value().c_str();  // NOLINT
      call.set_date(value);
    }

@@ -838,6 +1028,12 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
  request->send(404);
 }

+std::string WebServer::date_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->date_json((datetime::DateEntity *) (source), DETAIL_STATE);
+}
+std::string WebServer::date_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->date_json((datetime::DateEntity *) (source), DETAIL_ALL);
+}
 std::string WebServer::date_json(datetime::DateEntity *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "date-" + obj->get_object_id(), start_config);
@@ -858,9 +1054,9 @@ std::string WebServer::date_json(datetime::DateEntity *obj, JsonDetail start_con

 #ifdef USE_DATETIME_TIME
 void WebServer::on_time_update(datetime::TimeEntity *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->time_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", time_state_json_generator);
 }
 void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (auto *obj : App.get_times()) {
@@ -889,7 +1085,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
    }

    if (request->hasParam("value")) {
-      std::string value = request->getParam("value")->value().c_str();
+      std::string value = request->getParam("value")->value().c_str();  // NOLINT
      call.set_time(value);
    }

@@ -899,6 +1095,12 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
  }
  request->send(404);
 }
+std::string WebServer::time_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->time_json((datetime::TimeEntity *) (source), DETAIL_STATE);
+}
+std::string WebServer::time_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->time_json((datetime::TimeEntity *) (source), DETAIL_ALL);
+}
 std::string WebServer::time_json(datetime::TimeEntity *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "time-" + obj->get_object_id(), start_config);
@@ -919,9 +1121,9 @@ std::string WebServer::time_json(datetime::TimeEntity *obj, JsonDetail start_con

 #ifdef USE_DATETIME_DATETIME
 void WebServer::on_datetime_update(datetime::DateTimeEntity *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->datetime_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", datetime_state_json_generator);
 }
 void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (auto *obj : App.get_datetimes()) {
@@ -950,7 +1152,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
    }

    if (request->hasParam("value")) {
-      std::string value = request->getParam("value")->value().c_str();
+      std::string value = request->getParam("value")->value().c_str();  // NOLINT
      call.set_datetime(value);
    }

@@ -960,6 +1162,12 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
  }
  request->send(404);
 }
+std::string WebServer::datetime_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->datetime_json((datetime::DateTimeEntity *) (source), DETAIL_STATE);
+}
+std::string WebServer::datetime_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->datetime_json((datetime::DateTimeEntity *) (source), DETAIL_ALL);
+}
 std::string WebServer::datetime_json(datetime::DateTimeEntity *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "datetime-" + obj->get_object_id(), start_config);
@@ -981,9 +1189,9 @@ std::string WebServer::datetime_json(datetime::DateTimeEntity *obj, JsonDetail s

 #ifdef USE_TEXT
 void WebServer::on_text_update(text::Text *obj, const std::string &state) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->text_json(obj, state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", text_state_json_generator);
 }
 void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (auto *obj : App.get_texts()) {
@@ -1008,7 +1216,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
    auto call = obj->make_call();
    if (request->hasParam("value")) {
      String value = request->getParam("value")->value();
-      call.set_value(value.c_str());
+      call.set_value(value.c_str());  // NOLINT
    }

    this->defer([call]() mutable { call.perform(); });
@@ -1018,6 +1226,12 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
  request->send(404);
 }

+std::string WebServer::text_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->text_json((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::text_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->text_json((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::text_json(text::Text *obj, const std::string &value, JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    set_json_id(root, obj, "text-" + obj->get_object_id(), start_config);
@@ -1045,9 +1259,9 @@ std::string WebServer::text_json(text::Text *obj, const std::string &value, Json

 #ifdef USE_SELECT
 void WebServer::on_select_update(select::Select *obj, const std::string &state, size_t index) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->select_json(obj, state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", select_state_json_generator);
 }
 void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (auto *obj : App.get_selects()) {
@@ -1074,7 +1288,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM

    if (request->hasParam("option")) {
      auto option = request->getParam("option")->value();
-      call.set_option(option.c_str());  // NOLINT(clang-diagnostic-deprecated-declarations)
+      call.set_option(option.c_str());  // NOLINT
    }

    this->schedule_([call]() mutable { call.perform(); });
@@ -1083,6 +1297,12 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
  }
  request->send(404);
 }
+std::string WebServer::select_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->select_json((select::Select *) (source), ((select::Select *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::select_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->select_json((select::Select *) (source), ((select::Select *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::select_json(select::Select *obj, const std::string &value, JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "select-" + obj->get_object_id(), value, value, start_config);
@@ -1107,9 +1327,9 @@ std::string WebServer::select_json(select::Select *obj, const std::string &value

 #ifdef USE_CLIMATE
 void WebServer::on_climate_update(climate::Climate *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->climate_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", climate_state_json_generator);
 }
 void WebServer::handle_climate_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (auto *obj : App.get_climates()) {
@@ -1126,6 +1346,7 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
      request->send(200, "application/json", data.c_str());
      return;
    }
+
    if (match.method != "set") {
      request->send(404);
      return;
@@ -1135,17 +1356,17 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url

    if (request->hasParam("mode")) {
      auto mode = request->getParam("mode")->value();
-      call.set_mode(mode.c_str());
+      call.set_mode(mode.c_str());  // NOLINT
    }

    if (request->hasParam("fan_mode")) {
      auto mode = request->getParam("fan_mode")->value();
-      call.set_fan_mode(mode.c_str());
+      call.set_fan_mode(mode.c_str());  // NOLINT
    }

    if (request->hasParam("swing_mode")) {
      auto mode = request->getParam("swing_mode")->value();
-      call.set_swing_mode(mode.c_str());
+      call.set_swing_mode(mode.c_str());  // NOLINT
    }

    if (request->hasParam("target_temperature_high")) {
@@ -1172,6 +1393,12 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
  }
  request->send(404);
 }
+std::string WebServer::climate_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->climate_json((climate::Climate *) (source), DETAIL_STATE);
+}
+std::string WebServer::climate_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->climate_json((climate::Climate *) (source), DETAIL_ALL);
+}
 std::string WebServer::climate_json(climate::Climate *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "climate-" + obj->get_object_id(), start_config);
@@ -1268,9 +1495,9 @@ std::string WebServer::climate_json(climate::Climate *obj, JsonDetail start_conf

 #ifdef USE_LOCK
 void WebServer::on_lock_update(lock::Lock *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->lock_json(obj, obj->state, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", lock_state_json_generator);
 }
 void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (lock::Lock *obj : App.get_locks()) {
@@ -1301,6 +1528,12 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
  }
  request->send(404);
 }
+std::string WebServer::lock_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->lock_json((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_STATE);
+}
+std::string WebServer::lock_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->lock_json((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_ALL);
+}
 std::string WebServer::lock_json(lock::Lock *obj, lock::LockState value, JsonDetail start_config) {
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "lock-" + obj->get_object_id(), lock::lock_state_to_string(value), value,
@@ -1319,9 +1552,9 @@ std::string WebServer::lock_json(lock::Lock *obj, lock::LockState value, JsonDet

 #ifdef USE_VALVE
 void WebServer::on_valve_update(valve::Valve *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->valve_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", valve_state_json_generator);
 }
 void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (valve::Valve *obj : App.get_valves()) {
@@ -1372,6 +1605,12 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
  }
  request->send(404);
 }
+std::string WebServer::valve_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->valve_json((valve::Valve *) (source), DETAIL_STATE);
+}
+std::string WebServer::valve_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->valve_json((valve::Valve *) (source), DETAIL_ALL);
+}
 std::string WebServer::valve_json(valve::Valve *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "valve-" + obj->get_object_id(), obj->is_fully_closed() ? "CLOSED" : "OPEN",
@@ -1394,9 +1633,9 @@ std::string WebServer::valve_json(valve::Valve *obj, JsonDetail start_config) {

 #ifdef USE_ALARM_CONTROL_PANEL
 void WebServer::on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->alarm_control_panel_json(obj, obj->get_state(), DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", alarm_control_panel_state_json_generator);
 }
 void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (alarm_control_panel::AlarmControlPanel *obj : App.get_alarm_control_panels()) {
@@ -1416,7 +1655,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques

    auto call = obj->make_call();
    if (request->hasParam("code")) {
-      call.set_code(request->getParam("code")->value().c_str());
+      call.set_code(request->getParam("code")->value().c_str());  // NOLINT
    }

    if (match.method == "disarm") {
@@ -1440,6 +1679,16 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
  }
  request->send(404);
 }
+std::string WebServer::alarm_control_panel_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->alarm_control_panel_json((alarm_control_panel::AlarmControlPanel *) (source),
+                                              ((alarm_control_panel::AlarmControlPanel *) (source))->get_state(),
+                                              DETAIL_STATE);
+}
+std::string WebServer::alarm_control_panel_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->alarm_control_panel_json((alarm_control_panel::AlarmControlPanel *) (source),
+                                              ((alarm_control_panel::AlarmControlPanel *) (source))->get_state(),
+                                              DETAIL_ALL);
+}
 std::string WebServer::alarm_control_panel_json(alarm_control_panel::AlarmControlPanel *obj,
                                                alarm_control_panel::AlarmControlPanelState value,
                                                JsonDetail start_config) {
@@ -1461,8 +1710,9 @@ std::string WebServer::alarm_control_panel_json(alarm_control_panel::AlarmContro

 #ifdef USE_EVENT
 void WebServer::on_event(event::Event *obj, const std::string &event_type) {
-  this->events_.send(this->event_json(obj, event_type, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", event_state_json_generator);
 }
+
 void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (event::Event *obj : App.get_events()) {
    if (obj->get_object_id() != match.id)
@@ -1481,6 +1731,14 @@ void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMa
  }
  request->send(404);
 }
+
+std::string WebServer::event_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->event_json((event::Event *) (source), *(((event::Event *) (source))->last_event_type),
+                                DETAIL_STATE);
+}
+std::string WebServer::event_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->event_json((event::Event *) (source), *(((event::Event *) (source))->last_event_type), DETAIL_ALL);
+}
 std::string WebServer::event_json(event::Event *obj, const std::string &event_type, JsonDetail start_config) {
  return json::build_json([this, obj, event_type, start_config](JsonObject root) {
    set_json_id(root, obj, "event-" + obj->get_object_id(), start_config);
@@ -1506,9 +1764,9 @@ std::string WebServer::event_json(event::Event *obj, const std::string &event_ty

 #ifdef USE_UPDATE
 void WebServer::on_update(update::UpdateEntity *obj) {
-  if (this->events_.count() == 0)
+  if (this->events_.empty())
    return;
-  this->events_.send(this->update_json(obj, DETAIL_STATE).c_str(), "state");
+  this->events_.deferrable_send_state(obj, "state", update_state_json_generator);
 }
 void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlMatch &match) {
  for (update::UpdateEntity *obj : App.get_updates()) {
@@ -1537,6 +1795,12 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
  }
  request->send(404);
 }
+std::string WebServer::update_state_json_generator(WebServer *web_server, void *source) {
+  return web_server->update_json((update::UpdateEntity *) (source), DETAIL_STATE);
+}
+std::string WebServer::update_all_json_generator(WebServer *web_server, void *source) {
+  return web_server->update_json((update::UpdateEntity *) (source), DETAIL_STATE);
+}
 std::string WebServer::update_json(update::UpdateEntity *obj, JsonDetail start_config) {
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "update-" + obj->get_object_id(), start_config);
@@ -1575,6 +1839,12 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) {
  if (request->url() == "/")
    return true;

+#ifdef USE_ARDUINO
+  if (request->url() == "/events") {
+    return true;
+  }
+#endif
+
 #ifdef USE_WEBSERVER_CSS_INCLUDE
  if (request->url() == "/0.css")
    return true;
@@ -1597,7 +1867,7 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) {
  }
 #endif

-  UrlMatch match = match_url(request->url().c_str(), true);
+  UrlMatch match = match_url(request->url().c_str(), true);  // NOLINT
  if (!match.valid)
    return false;
 #ifdef USE_SENSOR
@@ -1708,6 +1978,13 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
    return;
  }

+#ifdef USE_ARDUINO
+  if (request->url() == "/events") {
+    this->events_.add_new_client(this, request);
+    return;
+  }
+#endif
+
 #ifdef USE_WEBSERVER_CSS_INCLUDE
  if (request->url() == "/0.css") {
    this->handle_css_request(request);
@@ -1729,7 +2006,7 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
  }
 #endif

-  UrlMatch match = match_url(request->url().c_str());
+  UrlMatch match = match_url(request->url().c_str());  // NOLINT
 #ifdef USE_SENSOR
  if (match.domain == "sensor") {
    this->handle_sensor_request(request, match);