mitkRestServer.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkRestServer_h
#define mitkRestServer_h
 
#include <MitkRESTAPIExports.h>
#include <mitkIRestServerService.h>
#include <mitkStorageThreadDispatcherBase.h>
#include <mitkWeakPointer.h>
 
#include <memory>
#include <thread>
#include <atomic>
#include <mutex>
#include <set>
#include <deque>
#include <chrono>
#include <unordered_map>
 
// Forward declaration for httplib
namespace httplib {
  class Server;
  class Request;
  class Response;
}
 
namespace mitk
{
  // Forward declarations
  class DataStorageBridge;
  class HealthController;
  class DataStorageController;
  class SwaggerController;
  class RenderingController;
  class RenderWindowBridge;
 
  class MITKRESTAPI_EXPORT RestServer : public IRestServerService
  {
  public:
    RestServer();
    ~RestServer() override;
 
    // Non-copyable, non-movable (due to thread)
    RestServer(const RestServer&) = delete;
    RestServer& operator=(const RestServer&) = delete;
    RestServer(RestServer&&) = delete;
    RestServer& operator=(RestServer&&) = delete;
 
    bool Start() override;
    void Stop() override;
    bool IsRunning() const override;
 
    void SetConfig(const RestServerConfig& config) override;
    RestServerConfig GetPendingConfig() const override;
    std::optional<RestServerConfig> GetRunningConfig() const override;
 
    void SetDataStorage(DataStorage* dataStorage) override;
    DataStorage::Pointer GetDataStorage() const override;
 
    void SetDispatcher(StorageThreadDispatcherBase* dispatcher);
 
    RenderWindowBridge* GetRenderWindowBridge() override;
 
    std::optional<std::string> GetServerUrl() const override;
    std::optional<std::string> GetLastError() const override;
 
    std::vector<std::string> GetClientIPs() const override;
    std::optional<RequestInfo> GetLastRequestInfo() const override;
 
    void SetLogLimit(std::optional<unsigned int> limit) override;
    std::optional<unsigned int> GetLogLimit() const override;
    std::vector<RequestInfo> GetRequestLog() const override;
    void ClearRequestLog() override;
    uint64_t GetRequestLogVersion() const override;
 
    std::optional<int64_t> GetUptimeSeconds() const override;
 
  private:
    void RecordRequest(const std::string& endpoint, const std::string& method,
                       int responseCode, const std::string& clientIP);
    void RegisterRoutes();
    void ServerThreadFunc();
 
    void SyncDispatcherToController();
 
    bool CheckClientAccess(const httplib::Request& req, httplib::Response& res);
 
    bool CheckRateLimit(const httplib::Request& req, httplib::Response& res);
 
    bool CheckAuthentication(const httplib::Request& req, httplib::Response& res);
 
    // Server components
    std::unique_ptr<httplib::Server> m_Server;
    std::unique_ptr<std::thread> m_ServerThread;
 
    // Business logic
    std::unique_ptr<DataStorageBridge> m_Bridge;
    std::unique_ptr<RenderWindowBridge> m_RenderWindowBridge;
    std::unique_ptr<HealthController> m_HealthController;
    std::unique_ptr<DataStorageController> m_DataStorageController;
    std::unique_ptr<SwaggerController> m_SwaggerController;
    std::unique_ptr<RenderingController> m_RenderingController;
    WeakPointer<StorageThreadDispatcherBase> m_Dispatcher;
 
    // State
    mutable std::mutex m_Mutex;
    RestServerConfig m_PendingConfig;
    std::optional<RestServerConfig> m_RunningConfig;
    std::atomic<bool> m_Running{false};
    std::optional<std::string> m_LastError;
 
    // Request tracking
    std::set<std::string> m_ClientIPs;
 
    // Request logging
    std::deque<RequestInfo> m_RequestLog;
    std::optional<unsigned int> m_LogLimit;
    uint64_t m_RequestLogVersion{0};
 
    // Temporary directory for data serialization
    std::string m_TempDirectory;
 
    // Server start time for uptime tracking
    std::optional<std::chrono::steady_clock::time_point> m_StartTime;
 
    // Rate limiting data (protected by m_Mutex)
    std::unordered_map<std::string, std::deque<std::chrono::steady_clock::time_point>> m_RateLimitMap;
    uint64_t m_RateLimitCheckCount{0};
 
    bool SetupTempDirectory();
 
    static void CleanupTempDirectory(const std::string& tempDir);
  };
}
 
#endif