AyonCppApi.h

Go to the documentation of this file.

#ifndef AYONCPPAPI_H
#define AYONCPPAPI_H
 
#include <cstdint>
 
#include <condition_variable>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <sys/types.h>
 
#ifdef __linux__
#include <dlfcn.h>
#endif
 
#include "httplib.h"
#include "nlohmann/json_fwd.hpp"
 
#include "appDataFolder.h"
#include "lib/ynput/lib/logging/AyonLogger.hpp"
 
class AyonApi {
    public:
        AyonApi(const std::optional<std::string> &logFilePos,
                const std::string &authKey,
                const std::string &serverUrl,
                const std::string &ayonProjectName,
                const std::string &siteId,
                std::optional<int> concurrency = std::nullopt);
        ~AyonApi();
 
        std::string getKey();
        std::string getUrl();
 
        nlohmann::json GET(const std::shared_ptr<std::string> endPoint,
                           const std::shared_ptr<httplib::Headers> headers,
                           uint8_t successStatus);
 
        nlohmann::json SPOST(const std::shared_ptr<std::string> endPoint,
                             const std::shared_ptr<httplib::Headers> headers,
                             nlohmann::json jsonPayload,
                             const std::shared_ptr<uint8_t> successStatus);
        nlohmann::json CPOST(const std::shared_ptr<std::string> endPoint,
                             const std::shared_ptr<httplib::Headers> headers,
                             nlohmann::json jsonPayload,
                             const std::shared_ptr<uint8_t> successStatus);
 
        std::pair<std::string, std::string> resolvePath(const std::string &uriPath);
 
        std::unordered_map<std::string, std::string> batchResolvePath(std::vector<std::string> &uriPaths);
 
        std::unordered_map<std::string, std::string> batchResolvePathSerial(const std::vector<std::string> &uriPaths);
 
        std::pair<std::string, std::string> getAssetIdent(const nlohmann::json &uriResolverResponse);
 
        std::shared_ptr<AyonLogger> logPointer();
 
        const std::unordered_map<std::string, std::string>& getSiteRoots();   // TODO think about if this should only support current project or multiple projects
 
        std::string rootReplace(const std::string &rootLessPath);
 
    private:
        std::string serialCorePost(const std::string &endPoint,
                                   httplib::Headers headers,
                                   std::string &payload,
                                   const int &successStatus);
        std::string generativeCorePost(const std::string &endPoint,
                                       httplib::Headers headers,
                                       std::string &payload,
                                       const int &successStatus);
 
        std::string convertUriVecToString(const std::vector<std::string> &uriVec);
 
        bool isSSL() const;
 
        void setSSL();
        
        // Core Dependencies
        std::unique_ptr<httplib::Client> m_ayonServer;
        std::shared_ptr<AyonLogger> m_log;
        
        // Configuration from Constructor
        const std::string m_authKey;
        const std::string m_serverUrl;
        std::string m_ayonProjectName;
        std::string m_siteId;
        const int m_numThreads;
        
        // Runtime State
        std::unordered_map<std::string, std::string> m_siteRoots;
        httplib::Headers m_headers;
        std::string m_userName;
        bool m_serverBusy = false;
        
        // URI Resolution Configuration
        std::string m_uriResolverEndpoint = "/api/resolve";
        std::string m_uriResolverEndpointPathOnlyVar = "?pathOnly=true";
        bool m_pathOnlyResolution = true;
        
        bool m_batchResolveOptimizeVector = true;
        uint8_t m_minGroupSizeForAsyncRequests = 10;
        uint16_t m_regroupSizeForAsyncRequests = 200;
        uint16_t m_maxGroupSizeForAsyncRequests = 300;
        uint16_t m_minVecSizeForGroupSplitAsyncRequests = 50;
        // Max uris per POST in batchResolvePathSerial. The server resolves a batch in one
        // sequential transaction, so an unbounded request holds a DB connection for the whole
        // frontier (risking its connection-pool 503 guard) and grows the body/response without
        // limit. Splitting into capped chunks releases the connection between chunks. Matches
        // m_regroupSizeForAsyncRequests so the serial and async paths cap requests alike.
        uint16_t m_maxSerialBatchSize = 200;
 
        // Retry and Timeout Configuration
        uint8_t m_maxCallRetries = 8;
        uint16_t m_retryWait = 800;
        uint16_t m_serverBusyCode = 503;
        uint16_t m_requestDelayWhenServerBusy = 10000;
        uint16_t m_connectionTimeoutMax = 200;
        uint8_t m_readTimeoutMax = 160;
        uint16_t m_generativeCorePostMaxLoopIterations = 200;
        
        // Thread Synchronization
        std::mutex m_ayonServerMutex;
        std::mutex m_concurrentRequestAfterServerBusyMutex;
        std::condition_variable m_serverBusyCondVar;
        uint8_t m_maxConcurrentRequestsAfterServerBusy = 8;
};
 
#endif   // !AYONCPPAPI_H