Merge remote-tracking branch 'origin/dev' into nrf52_core

esphome/components/http_request/__init__.py

@@ -1,17 +1,17 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
 from esphome import automation
+import esphome.codegen as cg
+from esphome.components import esp32
+import esphome.config_validation as cv
 from esphome.const import (
-    __version__,
+    CONF_ESP8266_DISABLE_SSL_SUPPORT,
     CONF_ID,
-    CONF_TIMEOUT,
     CONF_METHOD,
+    CONF_TIMEOUT,
     CONF_TRIGGER_ID,
     CONF_URL,
-    CONF_ESP8266_DISABLE_SSL_SUPPORT,
+    __version__,
 )
-from esphome.core import Lambda, CORE
-from esphome.components import esp32
+from esphome.core import CORE, Lambda
 
 DEPENDENCIES = ["network"]
 AUTO_LOAD = ["json"]
@@ -40,6 +40,8 @@ CONF_VERIFY_SSL = "verify_ssl"
 CONF_FOLLOW_REDIRECTS = "follow_redirects"
 CONF_REDIRECT_LIMIT = "redirect_limit"
 CONF_WATCHDOG_TIMEOUT = "watchdog_timeout"
+CONF_BUFFER_SIZE_RX = "buffer_size_rx"
+CONF_BUFFER_SIZE_TX = "buffer_size_tx"
 
 CONF_MAX_RESPONSE_BUFFER_SIZE = "max_response_buffer_size"
 CONF_ON_RESPONSE = "on_response"
@@ -110,6 +112,12 @@ CONFIG_SCHEMA = cv.All(
                 cv.positive_not_null_time_period,
                 cv.positive_time_period_milliseconds,
             ),
+            cv.SplitDefault(CONF_BUFFER_SIZE_RX, esp32_idf=512): cv.All(
+                cv.uint16_t, cv.only_with_esp_idf
+            ),
+            cv.SplitDefault(CONF_BUFFER_SIZE_TX, esp32_idf=512): cv.All(
+                cv.uint16_t, cv.only_with_esp_idf
+            ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.require_framework_version(
@@ -137,6 +145,9 @@ async def to_code(config):
 
     if CORE.is_esp32:
         if CORE.using_esp_idf:
+            cg.add(var.set_buffer_size_rx(config[CONF_BUFFER_SIZE_RX]))
+            cg.add(var.set_buffer_size_tx(config[CONF_BUFFER_SIZE_TX]))
+
             esp32.add_idf_sdkconfig_option(
                 "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE",
                 config.get(CONF_VERIFY_SSL),

esphome/components/http_request/http_request_idf.cpp

@@ -18,6 +18,12 @@ namespace http_request {
 
 static const char *const TAG = "http_request.idf";
 
+void HttpRequestIDF::dump_config() {
+  HttpRequestComponent::dump_config();
+  ESP_LOGCONFIG(TAG, "  Buffer Size RX: %u", this->buffer_size_rx_);
+  ESP_LOGCONFIG(TAG, "  Buffer Size TX: %u", this->buffer_size_tx_);
+}
+
 std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::string method, std::string body,
                                                      std::list<Header> headers) {
   if (!network::is_connected()) {
@@ -63,6 +69,9 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::strin
     config.user_agent = this->useragent_;
   }
 
+  config.buffer_size = this->buffer_size_rx_;
+  config.buffer_size_tx = this->buffer_size_tx_;
+
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->get_watchdog_timeout());
 
@@ -77,7 +86,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::strin
     esp_http_client_set_header(client, header.name, header.value);
   }
 
-  int body_len = body.length();
+  const int body_len = body.length();
 
   esp_err_t err = esp_http_client_open(client, body_len);
   if (err != ESP_OK) {
@@ -109,18 +118,62 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::strin
     return nullptr;
   }
 
-  container->content_length = esp_http_client_fetch_headers(client);
-  const auto status_code = esp_http_client_get_status_code(client);
-  container->status_code = status_code;
+  auto is_ok = [](int code) { return code >= HttpStatus_Ok && code < HttpStatus_MultipleChoices; };
 
-  if (status_code < 200 || status_code >= 300) {
-    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), status_code);
+  container->content_length = esp_http_client_fetch_headers(client);
+  container->status_code = esp_http_client_get_status_code(client);
+  if (is_ok(container->status_code)) {
+    container->duration_ms = millis() - start;
+    return container;
+  }
+
+  if (this->follow_redirects_) {
+    auto is_redirect = [](int code) {
+      return code == HttpStatus_MovedPermanently || code == HttpStatus_Found || code == HttpStatus_SeeOther ||
+             code == HttpStatus_TemporaryRedirect || code == HttpStatus_PermanentRedirect;
+    };
+    auto num_redirects = this->redirect_limit_;
+    while (is_redirect(container->status_code) && num_redirects > 0) {
+      err = esp_http_client_set_redirection(client);
+      if (err != ESP_OK) {
+        ESP_LOGE(TAG, "esp_http_client_set_redirection failed: %s", esp_err_to_name(err));
         this->status_momentary_error("failed", 1000);
         esp_http_client_cleanup(client);
         return nullptr;
       }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+      char url[256]{};
+      if (esp_http_client_get_url(client, url, sizeof(url) - 1) == ESP_OK) {
+        ESP_LOGV(TAG, "redirecting to url: %s", url);
+      }
+#endif
+      err = esp_http_client_open(client, 0);
+      if (err != ESP_OK) {
+        ESP_LOGE(TAG, "esp_http_client_open failed: %s", esp_err_to_name(err));
+        this->status_momentary_error("failed", 1000);
+        esp_http_client_cleanup(client);
+        return nullptr;
+      }
+
+      container->content_length = esp_http_client_fetch_headers(client);
+      container->status_code = esp_http_client_get_status_code(client);
+      if (is_ok(container->status_code)) {
         container->duration_ms = millis() - start;
         return container;
+      }
+
+      num_redirects--;
+    }
+
+    if (num_redirects == 0) {
+      ESP_LOGW(TAG, "Reach redirect limit count=%d", this->redirect_limit_);
+    }
+  }
+
+  ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
+  this->status_momentary_error("failed", 1000);
+  esp_http_client_cleanup(client);
+  return nullptr;
 }
 
 int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {

esphome/components/http_request/http_request_idf.h

@@ -24,8 +24,18 @@ class HttpContainerIDF : public HttpContainer {
 
 class HttpRequestIDF : public HttpRequestComponent {
  public:
+  void dump_config() override;
+
   std::shared_ptr<HttpContainer> start(std::string url, std::string method, std::string body,
                                        std::list<Header> headers) override;
+
+  void set_buffer_size_rx(uint16_t buffer_size_rx) { this->buffer_size_rx_ = buffer_size_rx; }
+  void set_buffer_size_tx(uint16_t buffer_size_tx) { this->buffer_size_tx_ = buffer_size_tx; }
+
+ protected:
+  // if zero ESP-IDF will use DEFAULT_HTTP_BUF_SIZE
+  uint16_t buffer_size_rx_{};
+  uint16_t buffer_size_tx_{};
 };
 
 }  // namespace http_request

esphome/loader.py

@@ -1,17 +1,17 @@
-import logging
-from typing import Callable, Optional, Any, ContextManager
-from types import ModuleType
-import importlib
-import importlib.util
-import importlib.resources
-import importlib.abc
-import sys
-from pathlib import Path
 from dataclasses import dataclass
+import importlib
+import importlib.abc
+import importlib.resources
+import importlib.util
+import logging
+from pathlib import Path
+import sys
+from types import ModuleType
+from typing import Any, Callable, ContextManager, Optional
 
 from esphome.const import SOURCE_FILE_EXTENSIONS
-import esphome.core.config
 from esphome.core import CORE
+import esphome.core.config
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -175,7 +175,11 @@ def _lookup_module(domain):
     try:
         module = importlib.import_module(f"esphome.components.{domain}")
     except ImportError as e:
-        if "No module named" not in str(e):
+        if "No module named" in str(e):
+            _LOGGER.error(
+                "Unable to import component %s: %s", domain, str(e), exc_info=False
+            )
+        else:
             _LOGGER.error("Unable to import component %s:", domain, exc_info=True)
         return None
     except Exception:  # pylint: disable=broad-except