Modify Request Manager Duplication Checks

modula/Common/Include/Request.h

@@ -23,7 +23,8 @@
 class Request : public Message {
 private:
     Timer* mTimer; //!< Timer associated with the request.
-    DLManager* mResourceList;
+    DLManager* mResourceList; //!< DLL to store the Resources to be configured.
+    uint64_t mSource;
 
 public:
     Request();
@@ -32,10 +33,12 @@ class Request : public Message {
     int32_t getResourcesCount();
     Timer* getTimer();
     DLManager* getResDlMgr();
+    uint64_t getSource();
 
     void addResource(ResIterable* resIterable);
     void setTimer(Timer* timer);
     void unsetTimer();
+    void setSource(uint64_t source);
     void clearResources();
 
     ErrCode deserialize(char* buf);

modula/Common/Request.cpp

@@ -6,6 +6,7 @@
 Request::Request() {
     this->mTimer = nullptr;
     this->mResourceList = nullptr;
+    this->mSource = 0;
 }
 
 int32_t Request::getResourcesCount() {
@@ -24,6 +25,10 @@ DLManager* Request::getResDlMgr() {
     return this->mResourceList;
 }
 
+uint64_t Request::getSource() {
+    return this->mSource;
+}
+
 void Request::addResource(ResIterable* resIterable) {
     if(this->mResourceList == nullptr) {
         try {
@@ -47,6 +52,10 @@ void Request::unsetTimer() {
     this->mTimer = nullptr;
 }
 
+void Request::setSource(uint64_t source) {
+    this->mSource = source;
+}
+
 void Request::clearResources() {
     if(this->mResourceList != nullptr) {
         DL_ITERATE(this->mResourceList) {

resource-tuner/core/RequestManager.cpp

@@ -84,8 +84,11 @@ int8_t RequestManager::requestMatch(Request* request) {
     int32_t clientTID = request->getClientTID();
 
     // Get the list of Requests for this client
+    std::shared_ptr<ClientDataManager> clientDataManager =
+            ClientDataManager::getInstance();
+
     std::unordered_set<int64_t>* clientHandles =
-        ClientDataManager::getInstance()->getRequestsByClientID(clientTID);
+        clientDataManager->getRequestsByClientID(clientTID);
 
     if(clientHandles == nullptr || clientHandles->size() == 0) {
         return false;
@@ -94,22 +97,47 @@ int8_t RequestManager::requestMatch(Request* request) {
     // If it is, we can use multiple threads from the pool for faster checking
 
     for(int64_t handle: *clientHandles) {
-        Request* targetRequest = this->mActiveRequests[handle].first;
+        int8_t requestProcessingStatus = this->getRequestProcessingStatus(handle);
+        if(requestProcessingStatus == REQ_NOT_FOUND) {
+            continue;
+        }
+
+        int8_t clientPermission =
+            clientDataManager->getClientLevelByID(request->getClientPID());
+
+        if(clientPermission == PERMISSION_SYSTEM) {
+            // For system processes, only check for requests
+            // which haven't been completed or cancelled
+            if((requestProcessingStatus & REQ_CANCELLED) ||
+               (requestProcessingStatus & REQ_COMPLETED)) {
+                continue;
+            }
+        }
+
+        auto it = this->mActiveRequests.find(handle);
+        if(it == this->mActiveRequests.end()) continue;
+        Request* targetRequest = it->second.first;
         if(targetRequest == nullptr) {
             continue;
         }
 
+        if(request->getSource() != targetRequest->getSource()) {
+            continue;
+        }
+
         // Check that the Number of Resources in the requests are the same
         if(request->getResourcesCount() != targetRequest->getResourcesCount()) {
-            return false;
+            continue;
         }
 
-        if(!request->getResDlMgr()->matchAgainst(targetRequest->getResDlMgr(), resourceCmpPolicy)) {
-            return false;
+        if(!request->getResDlMgr()->matchAgainst(
+            targetRequest->getResDlMgr(), resourceCmpPolicy)) {
+            continue;
         }
+        return true;
     }
 
-    return true;
+    return false;
 }
 
 int8_t RequestManager::verifyHandle(int64_t handle) {

resource-tuner/signals/SignalHandler.cpp

@@ -125,6 +125,11 @@ static Request* createResourceTuningRequest(Signal* signal) {
         request->setProperties(signal->getProperties());
         request->setClientPID(signal->getClientPID());
         request->setClientTID(signal->getClientTID());
+        request->setSource(
+            CONSTRUCT_SIG_CODE(
+                signal->getSignalCode(),
+                signal->getSignalType())
+            );
 
         std::vector<Resource*>* signalLocks = signalInfo->mSignalResources;