mitkDataStorageController.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 mitkDataStorageController_h
#define mitkDataStorageController_h
 
#include <mitkDataStorageBridge.h>
#include <mitkNodeQueryParams.h>
#include <mitkRestServerConfig.h>
#include <httplib.h>
#include <mitkFileSystem.h>
 
#include <MitkRESTAPIExports.h>
 
#include <deque>
#include <mutex>
#include <unordered_map>
 
namespace mitk
{
  class MITKRESTAPI_EXPORT DataStorageController
  {
  public:
    explicit DataStorageController(DataStorageBridge& bridge);
 
    void SetTempDirectory(const std::string& tempDir);
 
    void SetFileAccessConfig(FileAccessMode mode, const std::vector<std::string>& allowedDirs, const std::string& tempDirectory);
 
    void SetMaxActiveTempDirsPerIp(size_t max);
 
    // Node operations
 
    void HandleGET_nodes(const httplib::Request& req, httplib::Response& res);
 
    void HandlePOST_nodes(const httplib::Request& req, httplib::Response& res);
 
    void HandleGET_nodes_uid(const httplib::Request& req, httplib::Response& res);
 
    void HandlePATCH_nodes_uid(const httplib::Request& req, httplib::Response& res);
 
    void HandleDELETE_nodes_uid(const httplib::Request& req, httplib::Response& res);
 
    // Children operations
 
    void HandleGET_nodes_uid_children(const httplib::Request& req, httplib::Response& res);
 
    void HandlePOST_nodes_uid_children(const httplib::Request& req, httplib::Response& res);
 
    // Data operations
 
    void HandleGET_nodes_uid_data(const httplib::Request& req, httplib::Response& res);
 
    void HandlePUT_nodes_uid_data(const httplib::Request& req, httplib::Response& res);
 
    // Property operations
 
    void HandleGET_nodes_uid_properties(const httplib::Request& req, httplib::Response& res);
 
    void HandleGET_nodes_uid_properties_key(const httplib::Request& req, httplib::Response& res);
 
    void HandlePUT_nodes_uid_properties_key(const httplib::Request& req, httplib::Response& res);
 
    void HandleDELETE_nodes_uid_properties_key(const httplib::Request& req, httplib::Response& res);
 
    void HandlePUT_nodes_uid_properties(const httplib::Request& req, httplib::Response& res);
 
    void HandlePATCH_nodes_uid_properties(const httplib::Request& req, httplib::Response& res);
 
  private:
    void SendJsonResponse(httplib::Response& res, int status, const nlohmann::json& body);
    void SendErrorResponse(httplib::Response& res, int status, const nlohmann::json& error);
 
    void SendBinaryResponse(httplib::Response& res, const std::string& data,
                            const std::string& filename);
 
    NodeQueryParams ParseNodeQueryParams(const httplib::Request& req) const;
 
    PropertyQueryParams ParsePropertyQueryParams(const httplib::Request& req, PropertyScope defaultScope = PropertyScope::All) const;
 
    std::string DetermineTransferMode(const httplib::Request& req) const;
 
    std::string ExtractFilenameFromContentDisposition(const httplib::Request& req) const;
 
    nlohmann::json BuildDataMetadata(const mitk::BaseData* data) const;
 
    struct ResolveDataPathResult
    {
      bool success;                    
      std::string filePath;            
      bool isTemporary;                
      int errorStatus;                 
      nlohmann::json errorResponse;    
    };
 
    ResolveDataPathResult ResolveDataPath(const httplib::Request& req, const std::string& contentType);
 
    struct LoadDataResult
    {
      bool success;                              
      std::vector<mitk::BaseData::Pointer> data; 
      int errorStatus;                           
      nlohmann::json errorResponse;              
    };
 
    LoadDataResult LoadDataFromFile(const std::string& filePath, const std::string& requestPath);
 
    void HandlePOST_nodes_uid_generic(const httplib::Request& req, httplib::Response& res, const std::optional<std::string>& parentUID);
 
 
    fs::path AcquireRequestTempDir(const std::string& clientIp);
 
    void ReleaseRequestTempDir(const std::string& clientIp, const fs::path& dir);
 
    DataStorageBridge& m_Bridge;
    std::string m_TempDirectory;
    FileAccessMode m_FileAccessMode = FileAccessMode::Unrestricted;
    std::vector<std::string> m_AllowedFileDirectories;
 
    // Per-IP bounded temp-directory quota.
    // Map key: client IP string.  Value: deque of active dirs ordered by creation time (oldest first).
    // Protected by m_ActiveTempDirsMutex.
    static constexpr size_t DEFAULT_MAX_ACTIVE_TEMP_DIRS_PER_IP = 5;
    size_t m_MaxActiveTempDirsPerIp = DEFAULT_MAX_ACTIVE_TEMP_DIRS_PER_IP;
    mutable std::mutex m_ActiveTempDirsMutex;
    std::unordered_map<std::string, std::deque<fs::path>> m_ActiveTempDirsByIp;
  };
}
 
#endif