endpoints.hpp

Go to the documentation of this file.

// Copyright (C) 2025 Vincent Hamp
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

 
#pragma once
 
#include <esp_http_server.h>
#include <cassert>
#include <concepts>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <ztl/fail.hpp>
#include <ztl/type_traits.hpp>
#include "log.h"
#include "message.hpp"
#include "request.hpp"
#include "response.hpp"
#include "utility.hpp"
 
namespace intf::http {

class Endpoints {
  using key_type = httpd_uri_t;

  using sync_mapped_type = std::vector<std::function<Response(Request const&)>>;

  using async_mapped_type = std::vector<std::function<esp_err_t(Message&)>>;
 
public:
  template<typename T, typename F>
  void subscribe(key_type const& key, std::shared_ptr<T> t, F&& f) {
    assert(key.uri && strlen(key.uri) && key.uri[strlen(key.uri) - 1uz] == '/');
    if constexpr (std::invocable<typename ztl::signature<F>::type,
                                 T*,
                                 Request const&>)
      _sync_map[key].push_back([t, f](auto&&... args) {
        return std::invoke(f, *t, std::forward<decltype(args)>(args)...);
      });
    else if constexpr (std::invocable<typename ztl::signature<F>::type,
                                      T*,
                                      Message&>)
      _async_map[key].push_back([t, f](auto&&... args) {
        return std::invoke(f, *t, std::forward<decltype(args)>(args)...);
      });
    else ztl::fail();
  }
 
protected:
  Response syncResponse(httpd_req_t* req) {
    static constexpr auto chunk_size{16384uz};
 
    auto const key{req2key(req)};
    auto const it{_sync_map.find(key)};
    if (it == cend(_sync_map))
      return std::unexpected<std::string>{"501 Not Implemented"};
 
    // Request body can be red in chunks which avoids triggering the servers
    // receive timeout
    Request r{.uri = std::string(req->uri),
              .body = std::string(req->content_len, '\0')};
    int bytes_red{};
    while (bytes_red < req->content_len) {
      if (auto const tmp{
            httpd_req_recv(req, data(r.body) + bytes_red, chunk_size)};
          tmp > 0)
        bytes_red += tmp;
      else return std::unexpected<std::string>{"500 Internal Server Error"};
    }

    return it->second[0uz](r);
  }

  esp_err_t asyncResponse(httpd_req_t* req) {
    auto const key{req2key(req)};
    auto const it{_async_map.find(key)};
    if (it == cend(_async_map)) return ESP_FAIL;
    httpd_ws_frame_t frame{};
    if (httpd_ws_recv_frame(req, &frame, 0uz)) return ESP_FAIL;
 
    // WebSocket frame must be red in one go
    Message msg{.sock_fd = httpd_req_to_sockfd(req),
                .type = frame.type,
                .payload = std::vector<uint8_t>(frame.len)};
    if (frame.len) {
      frame.payload = data(msg.payload);
      if (httpd_ws_recv_frame(req, &frame, frame.len)) return ESP_FAIL;
    }
 
    return it->second[0uz](msg);
  }
 
private:
  httpd_uri_t req2key(httpd_req_t* req) const {
    return {.uri = req->uri,
            .method = static_cast<httpd_method_t>(req->method)};
  }

  struct key_compare {
    bool operator()(key_type const& lhs, key_type const& rhs) const {
      // Different method
      if (lhs.method != rhs.method) return lhs.method < rhs.method;
      // Compare URI up to prefix length
      else if (auto const lhs_prefix_len{strrchr(lhs.uri, '/') - lhs.uri + 1},
               rhs_prefix_len{strrchr(rhs.uri, '/') - rhs.uri + 1};
               lhs_prefix_len == rhs_prefix_len)
        return strncmp(lhs.uri, rhs.uri, lhs_prefix_len) < 0;
      // Compare URI as is
      else return strcmp(lhs.uri, rhs.uri) < 0;
    }
  };
 
  std::map<key_type, sync_mapped_type, key_compare> _sync_map;
  std::map<key_type, async_mapped_type, key_compare> _async_map;
};
 
} // namespace intf::http