server: fix listing resource limits

Fixes #12179

Recently behaviour for updating resource limits for account/domain has
changed with adding entries only for those types which don't have a
default value. This results in listResourceLimits API returning only a
single entry for a resource type. This PR fixes the behaviour.

Signed-off-by: Abhishek Kumar <abhishek.mrt22@gmail.com>

Author: shwstppr

server/src/main/java/com/cloud/resourcelimit/ResourceLimitManagerImpl.java

@@ -21,6 +21,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
+import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -36,9 +37,6 @@
 import javax.inject.Inject;
 import javax.naming.ConfigurationException;
 
-import com.cloud.event.ActionEventUtils;
-import com.cloud.event.EventTypes;
-import com.cloud.utils.Ternary;
 import org.apache.cloudstack.acl.SecurityChecker.AccessType;
 import org.apache.cloudstack.api.ApiCommandResourceType;
 import org.apache.cloudstack.api.response.AccountResponse;
@@ -86,6 +84,8 @@
 import com.cloud.domain.Domain;
 import com.cloud.domain.DomainVO;
 import com.cloud.domain.dao.DomainDao;
+import com.cloud.event.ActionEventUtils;
+import com.cloud.event.EventTypes;
 import com.cloud.exception.InvalidParameterValueException;
 import com.cloud.exception.PermissionDeniedException;
 import com.cloud.exception.ResourceAllocationException;
@@ -118,6 +118,7 @@
 import com.cloud.user.ResourceLimitService;
 import com.cloud.user.dao.AccountDao;
 import com.cloud.utils.Pair;
+import com.cloud.utils.Ternary;
 import com.cloud.utils.component.ManagerBase;
 import com.cloud.utils.concurrency.NamedThreadFactory;
 import com.cloud.utils.db.DB;
@@ -804,42 +805,43 @@ public List<ResourceLimitVO> searchForLimits(Long id, Long accountId, Long domai
                 limits.addAll(foundLimits);
             }
         } else {
-            limits.addAll(foundLimits);
-
-            // see if any limits are missing from the table, and if yes - get it from the config table and add
-            ResourceType[] resourceTypes = ResourceCount.ResourceType.values();
-            if (foundLimits.size() != resourceTypes.length) {
-                List<String> accountLimitStr = new ArrayList<>();
-                List<String> domainLimitStr = new ArrayList<>();
-                for (ResourceLimitVO foundLimit : foundLimits) {
-                    if (foundLimit.getAccountId() != null) {
-                        accountLimitStr.add(foundLimit.getType().toString());
-                    } else {
-                        domainLimitStr.add(foundLimit.getType().toString());
-                    }
-                }
+            limits = getConsolidatedResourceLimitsForAllResourceTypes(accountId, domainId, foundLimits, isAccount);
+        }
+        addTaggedResourceLimits(limits, resourceType, isAccount ? ResourceOwnerType.Account : ResourceOwnerType.Domain, isAccount ? accountId : domainId, hostTags, storageTags);
+        return limits;
+    }
 
-                // get default from config values
-                if (isAccount) {
-                    if (accountLimitStr.size() < resourceTypes.length) {
-                        for (ResourceType rt : resourceTypes) {
-                            if (!accountLimitStr.contains(rt.toString())) {
-                                limits.add(new ResourceLimitVO(rt, findCorrectResourceLimitForAccount(_accountMgr.getAccount(accountId), rt, null), accountId, ResourceOwnerType.Account));
-                            }
-                        }
-                    }
-                } else {
-                    if (domainLimitStr.size() < resourceTypes.length) {
-                        for (ResourceType rt : resourceTypes) {
-                            if (!domainLimitStr.contains(rt.toString())) {
-                                limits.add(new ResourceLimitVO(rt, findCorrectResourceLimitForDomain(_domainDao.findById(domainId), rt, null), domainId, ResourceOwnerType.Domain));
-                            }
-                        }
-                    }
-                }
+    private List<ResourceLimitVO> getConsolidatedResourceLimitsForAllResourceTypes(Long accountId, Long domainId,
+                      List<ResourceLimitVO> foundLimits, boolean isAccount) {
+        List<ResourceLimitVO> limits = new ArrayList<>(foundLimits);
+
+        Set<ResourceType> allResourceTypes = EnumSet.allOf(ResourceType.class);
+        Set<ResourceType> foundUntaggedTypes = foundLimits.stream()
+                .filter(l -> StringUtils.isEmpty(l.getTag()))
+                .map(ResourceLimitVO::getType)
+                .collect(Collectors.toSet());
+
+        if (foundUntaggedTypes.containsAll(allResourceTypes)) {
+            return limits;
+        }
+
+        ResourceOwnerType ownerType = isAccount ? ResourceOwnerType.Account : ResourceOwnerType.Domain;
+        long ownerId = isAccount ? accountId : domainId;
+
+        for (ResourceType rt : allResourceTypes) {
+            if (foundUntaggedTypes.contains(rt)) {
+                continue;
             }
+            long max;
+            if (isAccount) {
+                Account acct = _accountMgr.getAccount(accountId);
+                max = findCorrectResourceLimitForAccount(acct, rt, null);
+            } else {
+                DomainVO dom = _domainDao.findById(domainId);
+                max = findCorrectResourceLimitForDomain(dom, rt, null);
+            }
+            limits.add(new ResourceLimitVO(rt, max, ownerId, ownerType));
         }
-        addTaggedResourceLimits(limits, resourceType, isAccount ? ResourceOwnerType.Account : ResourceOwnerType.Domain, isAccount ? accountId : domainId, hostTags, storageTags);
         return limits;
     }