kbf/src/web_service.cpp

#include "kbf/web_service.h"

#include <kbf/macros.h>

#include <utility>

using namespace kbf;
using http::Request;
using http::Response;

WebService::WebService() : server() {
    ESP_LOGI(TAG, "%s()", __func__);
}

WebService::~WebService() {
    ESP_LOGI(TAG, "%s()", __func__);
    if (running) {
        stop();
    }
}

void WebService::start(int port) {
    ESP_LOGI(TAG, "%s(%d)", __func__, port);

    if (running) {
        ABORT("WebService already running");
    }

    running = true;
    server.start(port);
}

void WebService::startSSL(const unsigned char *const cert_start, const unsigned char *const cert_end,
                          const unsigned char *const key_start, const unsigned char *const key_end,
                          int port) {

    ESP_LOGI(TAG, "%s(%d)", __func__, port);

    if (running) {
        ABORT("WebService already running");
    }

    running = true;
    server.startSSL(cert_start, cert_end, key_start, key_end, port);
}

void WebService::stop() {
    ESP_LOGI(TAG, "%s()", __func__);

    if (!running) {
        ESP_LOGW(TAG, "stop(): not running");
        return;
    }

    server.stop();
    running = false;
}

Response WebService::startPipeline(const Request &request, HandlerArg *arg) {
    ESP_LOGD(TAG, "%s()", __func__);

    currentController = &arg->controller;
    middlewareIt      = std::nullopt;

    ESP_LOGI(TAG, "%s %s",
             request.method == http::GET ? "GET" : request.method == http::POST ? "POST" : "UNKNOWN",
             request.uri.c_str());

    return next(request);
}

Response WebService::handleGet(const Request &request, void *data) {
    ESP_LOGD(TAG, "%s()", __func__);

    auto arg = static_cast<HandlerArg *>(data);
    arg->webService.currentMethod = &Controller::get;

    return arg->webService.startPipeline(request, arg);
}

Response WebService::handlePost(const Request &request, void *data) {
    ESP_LOGD(TAG, "%s()", __func__);

    auto arg = static_cast<HandlerArg *>(data);
    arg->webService.currentMethod = &Controller::post;

    return arg->webService.startPipeline(request, arg);
}

WebService::Controller::Controller(std::string path) : path(std::move(path)) {}

void WebService::Controller::responseSentHandler(const Response &response, void *data) {
    ESP_LOGD(TAG, "%s()", __func__);

    auto arg = static_cast<HandlerArg *>(data);
    arg->controller.onResponseSent(response);
}

Response WebService::next(const Request &request) { // noqa
    ESP_LOGD(TAG, "%s()", __func__);

    if (middlewareIt == std::nullopt) {
        middlewareIt = middlewares.begin();
    } else {
        (*middlewareIt)++;
    }

    if (*middlewareIt == middlewares.end()) {
        ESP_LOGD(TAG, "  running controller");
        auto result = (currentController->*currentMethod)(request);
        currentMethod     = nullptr;
        currentController = nullptr;
        return result;
    }

    ESP_LOGD(TAG, "  running middleware %d", *middlewareIt - middlewares.begin());
    return (**middlewareIt)->run(request, *this);
}