ClientDataManager.h

// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// SPDX-License-Identifier: BSD-3-Clause-Clear
 
#ifndef CLIENT_DATA_MANAGER_H
#define CLIENT_DATA_MANAGER_H
 
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <shared_mutex>
#include <memory>
#include <mutex>
#include "string.h"
#include "unistd.h"
#include "fstream"
#include "sstream"
 
#include "ErrCodes.h"
#include "DLManager.h"
#include "UrmSettings.h"
#include "MemoryPool.h"
#include "Logger.h"
#include "Utils.h"
 
#define PER_CLIENT_TID_CAP 32
 
typedef struct _client_info {
    uint8_t mClientType;
    int32_t mCurClientThreads;
    int32_t mClientTIDs[PER_CLIENT_TID_CAP];
 
    _client_info(): mCurClientThreads(0) {}
} ClientInfo;
 
typedef struct {
    std::unordered_set<int64_t>* mClientHandles;
    int64_t mLastRequestTimestamp;
    double mHealth;
} ClientTidData;
 
class ClientDataManager {
private:
    static std::shared_ptr<ClientDataManager> mClientDataManagerInstance;
    static std::mutex instanceProtectionLock;
    std::unordered_map<int32_t, ClientInfo*> mClientRepo; 
    std::unordered_map<int32_t, ClientTidData*> mClientTidRepo; 
    std::shared_timed_mutex mGlobalTableMutex;
 
    ClientDataManager();
 
public:
    int8_t clientExists(int32_t clientPID, int32_t clientTID);
 
    int8_t createNewClient(int32_t clientPID, int32_t clientTID);
 
    std::unordered_set<int64_t>* getRequestsByClientID(int32_t clientTID);
 
    void insertRequestByClientId(int32_t clientTID, int64_t requestHandle);
 
    void deleteRequestByClientId(int32_t clientTID, int64_t requestHandle);
 
    double getHealthByClientID(int32_t clientTID);
 
    int64_t getLastRequestTimestampByClientID(int32_t clientTID);
 
    void updateHealthByClientID(int32_t clientTID, double health);
 
    void updateLastRequestTimestampByClientID(int32_t clientTID, int64_t currentMillis);
 
    int8_t getClientLevelByClientID(int32_t clientPID);
 
    void getThreadsByClientId(int32_t clientPID, std::vector<int32_t>& threadIDs);
 
    void getActiveClientList(std::vector<int32_t>& clientList);
 
    void deleteClientPID(int32_t clientPID);
 
    void deleteClientTID(int32_t clientTID);
 
    static std::shared_ptr<ClientDataManager> getInstance() {
        if(mClientDataManagerInstance == nullptr) {
            instanceProtectionLock.lock();
            if(mClientDataManagerInstance == nullptr) {
                try {
                    mClientDataManagerInstance = std::shared_ptr<ClientDataManager> (new ClientDataManager());
                } catch(const std::bad_alloc& e) {
                    instanceProtectionLock.unlock();
                    return nullptr;
                }
            }
            instanceProtectionLock.unlock();
        }
        return mClientDataManagerInstance;
    }
};
 
#endif