kbf/src/http/client.cpp

#include "kbf/http/client.h"

#include <freertos/task.h>
#include <esp_log.h>

#include "kbf/macros.h"

using namespace kbf;
using std::make_shared;

http::Client::Client(bool async) : buffer(), async(async) {
    ESP_LOGD(TAG, "Client()");
    init();
}

void http::Client::init() {
    ESP_LOGD(TAG, "init()");
    esp_http_client_config_t config{};
    config.event_handler         = handleHttpEvent;
    config.user_data             = this;
    config.host                  = "localhost";
    config.path                  = "/";
    config.disable_auto_redirect = false; // do not set to true, IDF bug :(
    config.max_redirection_count = 0;
    config.is_async              = async;
    handle = esp_http_client_init(&config);
}


http::Client::~Client() {
    ESP_LOGD(TAG, "~Client()");
    CHECK(esp_http_client_cleanup(handle));
}

shared_ptr<http::Response> http::Client::get(const string &url) {
    ESP_LOGD(TAG, "get(%s)", url.c_str());

    if (running) {
        ESP_LOGE(TAG, "request already in progress");
        return nullptr;
    }
    running = true;

    response = shared_ptr<Response>(new Response()); // TODO why doesn't make_shared work here? :/
    buffer.clear();

    esp_http_client_set_method(handle, HTTP_METHOD_GET);
    esp_http_client_set_url(handle, url.c_str());
    auto err = esp_http_client_perform(handle);

    if (err == ESP_ERR_HTTP_MAX_REDIRECT) {
        // TODO this seems get triggered on HTTP 4XX
        ESP_LOGW(TAG, "reached redirect limit");
        updateResponse(*this);
        err = ESP_OK;
    }

    if (err == ESP_ERR_HTTP_EAGAIN) {
        ESP_LOGD(TAG, "async request in progress, returning nullptr");
        return nullptr;
    } else if (err == ESP_OK) {
        ESP_LOGD(TAG, "success");
        return response;
    } else if (err == ESP_ERR_HTTP_FETCH_HEADER && !retry) {
        ESP_LOGD(TAG, "fetching headers failed, maybe the connection was dropped? retrying...");
        retry = true;
        esp_http_client_cleanup(handle);
        init();
        return get(url);
    } else {
        ESP_LOGE(TAG, "HTTP GET failed: %s", esp_err_to_name(err));
        ABORT("debug me");
    }
}

esp_err_t http::Client::handleHttpEvent(esp_http_client_event_t *event) {
    auto client = (Client *) event->user_data;

    switch (event->event_id) {
        case HTTP_EVENT_ERROR:
            ESP_LOGW(TAG, "fixme: unhandled error event: HTTP_EVENT_ERROR");
            if (client->onError) client->onError(*client);
            client->running = false;
            client->retry   = false;
            break;
        case HTTP_EVENT_ON_CONNECTED:
            ESP_LOGD(TAG, "connected");
            break;
        case HTTP_EVENT_HEADERS_SENT:
            ESP_LOGD(TAG, "request sent");
            break;
        case HTTP_EVENT_ON_HEADER:
            ESP_LOGD(TAG, "header received: %s: %s", event->header_key, event->header_value);
            client->response->headers[event->header_key] = event->header_value;
            break;
        case HTTP_EVENT_ON_DATA:
            ESP_LOGD(TAG, "data received");
            if (esp_http_client_is_chunked_response(client->handle)) {
                ESP_LOGE(TAG, "received chunked data");
                ABORT("not implemented");
            }
            client->buffer.append((char *) event->data, event->data_len);
            break;
        case HTTP_EVENT_ON_FINISH:
            ESP_LOGD(TAG, "finished");
            updateResponse(*client);
            break;
        case HTTP_EVENT_DISCONNECTED:
            ESP_LOGW(TAG, "disconnected");
            client->running = false;
            client->retry   = false;
            break;
    }

    return ESP_OK;
}

void http::Client::updateResponse(http::Client &client) {
    client.response->status = esp_http_client_get_status_code(client.handle);
    client.response->body   = client.buffer;

    ESP_LOGD(TAG, "HTTP status: %d, Content-Length: %s", client.response->status,
             client.response->headers["Content-Length"].c_str());
    ESP_LOG_BUFFER_HEXDUMP(TAG, client.response->body.data(), client.response->body.length(),
                           ESP_LOG_VERBOSE);

    if (client.onSuccess) { client.onSuccess(client, *client.response); }
    client.running = false;
    client.retry   = false;
}