http_server.h

Go to the documentation of this file.

#pragma once
 
#include <uwebsockets/App.h>
 
#include <BS_thread_pool.hpp>
#include <atomic>
#include <chrono>
#include <expected>
#include <filesystem>
#include <functional>
#include <future>
#include <memory>
#include <string>
#include <string_view>
#include <thread>
#include <utility>
#include <vector>
 
#include "api/router.h"
#include "api/web_api.h"
#include "auto_tuning/status.h"  // Status (returned by the GET /api/auto-tuning callback)
#include "config.h"              // FieldbusConfig (the body of POST /api/init)
#include "game_loop.h"           // GameLoopHealth (returned by the GET /api/game-loop callback)
#include "net/http_client.h"     // net::Response (an auto-tuning reply, passed through verbatim)
#include "node/eni_collector.h"  // EniCollectorOptions (returned by the GET /api/eni callback)
 
namespace mm::core {
class UserCache;
}  // namespace mm::core
 
namespace mm::node {
class DeviceManager;
class MonitoringManager;
class ProcedureRegistry;
}  // namespace mm::node
 
class HttpServer {
 public:
  using InitDeviceManagerFn =
      std::function<std::expected<void, std::string>(const FieldbusConfig& fieldbus)>;
 
  using GetLogFn = std::function<std::vector<std::string>()>;
 
  using RefreshCertFn = std::function<std::expected<void, std::string>()>;
 
  using GetGameLoopHealthFn = std::function<GameLoopHealth()>;
 
  using SetGameLoopPeriodFn = std::function<std::expected<void, std::string>(uint32_t periodUs)>;
 
  using AutoTuningRunFn =
      std::function<std::expected<mm::net::Response, std::string>(const std::string& body)>;
 
  using AutoTuningStatusFn = std::function<mm::auto_tuning::Status()>;
 
  using AutoTuningSpecFn = std::function<std::expected<mm::net::Response, std::string>()>;
 
  using EniOptionsFn = std::function<mm::node::EniCollectorOptions()>;
 
  using RunCaptureFn = std::function<std::expected<std::filesystem::path, std::string>(
      const std::string& adapter, int seconds)>;
 
  struct Config {
    std::string bindAddress{"127.0.0.1"};
    uint16_t port = 61447;  
    std::string certFile;   
    std::string keyFile;    
    std::string version;    
    std::string
        startedConfig;  
    InitDeviceManagerFn
        initDeviceManager;      
    GetLogFn getLog;            
    RefreshCertFn refreshCert;  
    GetGameLoopHealthFn
        getGameLoopHealth;  
    SetGameLoopPeriodFn
        setGameLoopPeriod;          
    AutoTuningRunFn runAutoTuning;  
    AutoTuningStatusFn
        autoTuningStatus;             
    AutoTuningSpecFn autoTuningSpec;  
    EniOptionsFn eniOptions;  
    RunCaptureFn runCapture;  
    std::string corsOrigin{"https://motion-master.synapticon.com"};
  };
 
  HttpServer(Config config, mm::node::DeviceManager& deviceManager,
             mm::node::MonitoringManager& monitoringManager,
             mm::node::ProcedureRegistry& procedureRegistry, mm::core::UserCache& userCache);
 
  ~HttpServer();
 
  bool start();
 
  void stop();
 
  void addRoutes(mm::api::RegisterRoutesFn module);
 
 private:
  void run();
 
  Config config_;
  mm::node::DeviceManager& deviceManager_;
  mm::node::MonitoringManager& monitoringManager_;
  mm::node::ProcedureRegistry& procedureRegistry_;
  mm::core::UserCache& userCache_;
  std::vector<mm::api::RegisterRoutesFn> routeModules_;
  std::atomic<bool> running_{false};
  std::thread thread_;
  std::atomic<uWS::Loop*> loop_{nullptr};
  std::atomic<uWS::SSLApp*> app_{nullptr};
  std::promise<bool> listenResult_;
  std::atomic<bool> stopping_{false};
  std::atomic<bool> captureRunning_{false};
  BS::light_thread_pool pool_{32};
};