Server-side performance fixes for Manage Packages page (#6752)

Author: Scott Bommarito

src/NuGetGallery/Services/ActionRequiringEntityPermissions.cs

@@ -55,35 +55,43 @@ public PermissionsCheckResult CheckPermissions(IPrincipal currentPrincipal, User
 
         public PermissionsCheckResult CheckPermissionsOnBehalfOfAnyAccount(User currentUser, TEntity entity)
         {
-            return CheckPermissionsOnBehalfOfAnyAccount(currentUser, entity, out var accountsAllowedOnBehalfOf);
+            return CheckPermissionsOnBehalfOfAnyAccount(currentUser, entity, exitEarly: true, accountsAllowedOnBehalfOf: out var _);
         }
 
         public PermissionsCheckResult CheckPermissionsOnBehalfOfAnyAccount(User currentUser, TEntity entity, out IEnumerable<User> accountsAllowedOnBehalfOf)
+        {
+            return CheckPermissionsOnBehalfOfAnyAccount(currentUser, entity, exitEarly: false, accountsAllowedOnBehalfOf: out accountsAllowedOnBehalfOf);
+        }
+
+        private PermissionsCheckResult CheckPermissionsOnBehalfOfAnyAccount(User currentUser, TEntity entity, bool exitEarly, out IEnumerable<User> accountsAllowedOnBehalfOf)
         {
             accountsAllowedOnBehalfOf = new List<User>();
 
-            var possibleAccountsOnBehalfOf =
-                new[] { currentUser }
-                    .Concat(GetOwners(entity));
+            var possibleAccountsOnBehalfOf = new List<User>
+            {
+                currentUser
+            };
+
+            possibleAccountsOnBehalfOf.AddRange(GetOwners(entity));
 
             if (currentUser != null)
             {
-                possibleAccountsOnBehalfOf =
-                    possibleAccountsOnBehalfOf
-                        .Concat(currentUser.Organizations.Select(o => o.Organization));
+                possibleAccountsOnBehalfOf.AddRange(currentUser.Organizations.Select(o => o.Organization));
             }
 
-            possibleAccountsOnBehalfOf = possibleAccountsOnBehalfOf.Distinct(new UserEqualityComparer());
-
             var aggregateResult = PermissionsCheckResult.Unknown;
 
-            foreach (var accountOnBehalfOf in possibleAccountsOnBehalfOf)
+            foreach (var accountOnBehalfOf in possibleAccountsOnBehalfOf.Distinct(new UserEqualityComparer()))
             {
                 var result = CheckPermissions(currentUser, accountOnBehalfOf, entity);
                 aggregateResult = ChoosePermissionsCheckResult(aggregateResult, result);
                 if (result == PermissionsCheckResult.Allowed)
                 {
                     (accountsAllowedOnBehalfOf as List<User>).Add(accountOnBehalfOf);
+                    if (exitEarly)
+                    {
+                        break;
+                    }
                 }
             }
 
@@ -115,4 +123,4 @@ private PermissionsCheckResult ChoosePermissionsCheckResult(PermissionsCheckResu
             return new[] { current, next }.Max();
         }
     }
-}
+}

src/NuGetGallery/Services/PackageService.cs

@@ -255,30 +255,28 @@ private IEnumerable<Package> GetPackagesForOwners(IEnumerable<int> ownerKeys, bo
                 packages = packages.Where(p => p.Listed);
             }
 
-            if (includeVersions)
-            {
-                return packages
-                .Include(p => p.PackageRegistration)
-                .Include(p => p.PackageRegistration.Owners)
-                .ToList();
-            }
-
-            // Do a best effort of retrieving the latest version. Note that UpdateIsLatest has had concurrency issues
-            // where sometimes packages no rows with IsLatest set. In this case, we'll just select the last inserted
-            // row (descending [Key]) as opposed to reading all rows into memory and sorting on NuGetVersion.
+            if (!includeVersions)
+            {
+                // Do a best effort of retrieving the latest version. Note that UpdateIsLatest has had concurrency issues
+                // where sometimes packages no rows with IsLatest set. In this case, we'll just select the last inserted
+                // row (descending [Key]) as opposed to reading all rows into memory and sorting on NuGetVersion.
+                packages = packages
+                    .GroupBy(p => p.PackageRegistrationKey)
+                    .Select(g => g
+                        // order booleans desc so that true (1) comes first
+                        .OrderByDescending(p => p.IsLatestStableSemVer2)
+                        .ThenByDescending(p => p.IsLatestStable)
+                        .ThenByDescending(p => p.IsLatestSemVer2)
+                        .ThenByDescending(p => p.IsLatest)
+                        .ThenByDescending(p => p.Listed)
+                        .ThenByDescending(p => p.Key)
+                        .FirstOrDefault());
+            }
+            
             return packages
-                .GroupBy(p => p.PackageRegistrationKey)
-                .Select(g => g
-                    // order booleans desc so that true (1) comes first
-                    .OrderByDescending(p => p.IsLatestStableSemVer2)
-                    .ThenByDescending(p => p.IsLatestStable)
-                    .ThenByDescending(p => p.IsLatestSemVer2)
-                    .ThenByDescending(p => p.IsLatest)
-                    .ThenByDescending(p => p.Listed)
-                    .ThenByDescending(p => p.Key)
-                    .FirstOrDefault())
                 .Include(p => p.PackageRegistration)
                 .Include(p => p.PackageRegistration.Owners)
+                .Include(p => p.PackageRegistration.RequiredSigners)
                 .ToList();
         }