Typosquatting optimization: add caching (#6597)

* Typosquatting optimization: add caching

* update

* Move locker to cache class

* Refactor, Decouple and Update a lot of things

* Update

* Fix unit test

* Update again

* Set default cache expire time as 24 hours

* Some changes

* Use TimeSpan for expire time

* Add some tests for cache

Author: zhhyu

src/NuGetGallery/App_Start/DefaultDependenciesModule.cs

@@ -333,6 +333,11 @@ protected override void Load(ContainerBuilder builder)
                 .As<ITyposquattingService>()
                 .InstancePerLifetimeScope();
 
+            builder.RegisterType<TyposquattingCheckListCacheService>()
+                .AsSelf()
+                .As<ITyposquattingCheckListCacheService>()
+                .SingleInstance();
+
             RegisterMessagingService(builder, configuration);
 
             builder.Register(c => HttpContext.Current.User)

src/NuGetGallery/NuGetGallery.csproj

@@ -423,6 +423,7 @@
     <Compile Include="Infrastructure\Mail\BackgroundMarkdownMessageService.cs" />
     <Compile Include="Services\ISymbolPackageUploadService.cs" />
     <Compile Include="Services\ISymbolPackageFileService.cs" />
+    <Compile Include="Services\ITyposquattingCheckListCacheService.cs" />
     <Compile Include="Services\ITyposquattingConfiguration.cs" />
     <Compile Include="Services\ISymbolsConfiguration.cs" />
     <Compile Include="Services\ITyposquattingService.cs" />
@@ -435,6 +436,7 @@
     <Compile Include="Services\SymbolPackageUploadService.cs" />
     <Compile Include="Services\SymbolPackageFileService.cs" />
     <Compile Include="Services\SymbolPackageService.cs" />
+    <Compile Include="Services\TyposquattingCheckListCacheService.cs" />
     <Compile Include="Services\TyposquattingConfiguration.cs" />
     <Compile Include="Services\SymbolsConfiguration.cs" />
     <Compile Include="Services\CertificatesConfiguration.cs" />

src/NuGetGallery/Services/ITelemetryService.cs

@@ -203,13 +203,15 @@ public interface ITelemetryService
         /// <param name="totalTime">The total time for the typosquatting check logic</param>
         /// <param name="wasUploadBlocked">Whether the uploaded package is blocked because of typosquatting check.</param>
         /// <param name="collisionPackageIds">The list of collision package Ids for this uploaded package.</param>
-        /// <param name="checklistLength">The length of the checklist for typosquatting check</param>
+        /// <param name="checkListLength">The length of the checklist for typosquatting check</param>
+        /// <param name="checkListCacheExpireTime">The expire time for checklist caching</param>
         void TrackMetricForTyposquattingCheckResultAndTotalTime(
             string packageId,
             TimeSpan totalTime,
             bool wasUploadBlocked,
             List<string> collisionPackageIds,
-            int checklistLength);
+            int checkListLength,
+            TimeSpan checkListCacheExpireTime);
 
         /// <summary>
         /// The retrieval time to get the checklist for typosquatting check.

src/NuGetGallery/Services/ITyposquattingCheckListCacheService.cs

@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+
+namespace NuGetGallery
+{
+    /// <summary>
+    /// This interface is used to implement a basic caching for typosquatting checklist.
+    /// /// </summary>
+    public interface ITyposquattingCheckListCacheService
+    {
+        /// <summary>
+        /// The function is used to get the checklist from the cache for typosquatting
+        /// </summary>
+        /// <param name="checkListLength">The length of the checklist for typosquatting</param>
+        /// <param name="checkListExpireTime">The expire time for checklist caching</param>
+        /// <param name="packageService">The package service for checklist retrieval from database</param>
+        IReadOnlyCollection<string> GetTyposquattingCheckList(int checkListLength, TimeSpan checkListExpireTime, IPackageService packageService);
+    }
+}

src/NuGetGallery/Services/ITyposquattingConfiguration.cs

@@ -8,5 +8,6 @@ public interface ITyposquattingConfiguration
         int PackageIdChecklistLength { get; }
         bool IsCheckEnabled { get; }
         bool IsBlockUsersEnabled { get; }
+        double PackageIdChecklistCacheExpireTimeInHours { get; }
     }
 }

src/NuGetGallery/Services/TelemetryService.cs

@@ -150,6 +150,7 @@ internal class Events
         public const string CollisionPackageIdsCount = "CollisionPackageIdsCount";
         public const string CheckListLength = "CheckListLength";
         public const string HasExtraCollisionPackageIds = "HasExtraCollisionPackageIds";
+        public const string CheckListCacheExpireTimeInHours = "CheckListCacheExpireTimeInHours";
 
         public TelemetryService(IDiagnosticsService diagnosticsService, ITelemetryClient telemetryClient = null)
         {
@@ -722,15 +723,17 @@ public void TrackMetricForTyposquattingCheckResultAndTotalTime(
             TimeSpan totalTime,
             bool wasUploadBlocked,
             List<string> collisionPackageIds,
-            int checklistLength)
+            int checkListLength,
+            TimeSpan checkListCacheExpireTime)
         {
             TrackMetric(Events.TyposquattingCheckResultAndTotalTimeInMs, totalTime.TotalMilliseconds, properties => {
                 properties.Add(PackageId, packageId);
                 properties.Add(WasUploadBlocked, wasUploadBlocked.ToString());
                 properties.Add(CollisionPackageIds, string.Join(",", collisionPackageIds.Take(TyposquattingCollisionIdsMaxPropertyValue)));
                 properties.Add(CollisionPackageIdsCount, collisionPackageIds.Count.ToString());
-                properties.Add(CheckListLength, checklistLength.ToString());
+                properties.Add(CheckListLength, checkListLength.ToString());
                 properties.Add(HasExtraCollisionPackageIds, (collisionPackageIds.Count > TyposquattingCollisionIdsMaxPropertyValue).ToString());
+                properties.Add(CheckListCacheExpireTimeInHours, checkListCacheExpireTime.ToString());
             });
         }
 

src/NuGetGallery/Services/TyposquattingCheckListCacheService.cs

@@ -0,0 +1,73 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NuGetGallery
+{
+    public class TyposquattingCheckListCacheService : ITyposquattingCheckListCacheService
+    {
+        private readonly object Locker = new object();
+
+        private List<string> Cache;
+        private DateTime LastRefreshTime;
+
+        private int TyposquattingCheckListConfiguredLength;
+
+        public TyposquattingCheckListCacheService()
+        {
+            TyposquattingCheckListConfiguredLength = -1;
+            LastRefreshTime = DateTime.MinValue;
+        }
+
+        public IReadOnlyCollection<string> GetTyposquattingCheckList(int checkListConfiguredLength, TimeSpan checkListExpireTime, IPackageService packageService)
+        {
+            if (packageService == null)
+            {
+                throw new ArgumentNullException(nameof(packageService));
+            }
+            if (checkListConfiguredLength < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(checkListConfiguredLength), "Negative values are not supported.");
+            }
+            if (checkListExpireTime.CompareTo(TimeSpan.Zero) < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(checkListExpireTime), "Negative values are not supported.");
+            }
+
+            if (ShouldCacheBeUpdated(checkListConfiguredLength, checkListExpireTime))
+            {
+                lock (Locker)
+                {
+                    if (ShouldCacheBeUpdated(checkListConfiguredLength, checkListExpireTime))
+                    {
+                        TyposquattingCheckListConfiguredLength = checkListConfiguredLength;
+
+                        Cache = packageService.GetAllPackageRegistrations()
+                            .OrderByDescending(pr => pr.IsVerified)
+                            .ThenByDescending(pr => pr.DownloadCount)
+                            .Select(pr => pr.Id)
+                            .Take(TyposquattingCheckListConfiguredLength)
+                            .ToList();
+
+                        LastRefreshTime = DateTime.UtcNow;
+                    }
+                }
+            }
+
+            return Cache;
+        }
+
+        private bool ShouldCacheBeUpdated(int checkListConfiguredLength, TimeSpan checkListExpireTime)
+        {
+            return Cache == null || checkListConfiguredLength != TyposquattingCheckListConfiguredLength || IsCheckListCacheExpired(checkListExpireTime);
+        }
+
+        private bool IsCheckListCacheExpired(TimeSpan checkListExpireTime)
+        {
+            return DateTime.UtcNow >= LastRefreshTime.Add(checkListExpireTime);
+        }
+    }
+}

src/NuGetGallery/Services/TyposquattingConfiguration.cs

@@ -8,25 +8,31 @@ namespace NuGetGallery.Services
     public sealed class TyposquattingConfiguration : ITyposquattingConfiguration
     {
         private const int DefaultPackageIdCheckListLength = 20000;
+        private const double DefaultPackageIdChecklistCacheExpireTimeInHours = 24;
         public int PackageIdChecklistLength { get; }
         public bool IsCheckEnabled { get; }
         public bool IsBlockUsersEnabled { get; }
+        public double PackageIdChecklistCacheExpireTimeInHours { get; }
+
         public TyposquattingConfiguration()
             : this(packageIdChecklistLength: DefaultPackageIdCheckListLength,
                   isCheckEnabled: false,
-                  isBlockUsersEnabled: false)
+                  isBlockUsersEnabled: false,
+                  packageIdChecklistCacheExpireTimeInHours: DefaultPackageIdChecklistCacheExpireTimeInHours)
         {
         }
 
         [JsonConstructor]
         public TyposquattingConfiguration(
             int packageIdChecklistLength,
             bool isCheckEnabled,
-            bool isBlockUsersEnabled)
+            bool isBlockUsersEnabled,
+            double packageIdChecklistCacheExpireTimeInHours)
         {
             PackageIdChecklistLength = packageIdChecklistLength;
             IsCheckEnabled = isCheckEnabled;
             IsBlockUsersEnabled = isBlockUsersEnabled;
+            PackageIdChecklistCacheExpireTimeInHours = packageIdChecklistCacheExpireTimeInHours;
         }
     }
 }

src/NuGetGallery/Services/TyposquattingService.cs

@@ -20,86 +20,84 @@ public class TyposquattingService : ITyposquattingService
             new ThresholdInfo (lowerBound: 50, upperBound: 129, threshold: 2)
         };
 
-        private static int TyposquattingCheckListLength;
-
         private readonly IContentObjectService _contentObjectService;
         private readonly IPackageService _packageService;
         private readonly IReservedNamespaceService _reservedNamespaceService;
         private readonly ITelemetryService _telemetryService;
+        private readonly ITyposquattingCheckListCacheService _typosquattingCheckListCacheService;
 
-        public TyposquattingService(IContentObjectService contentObjectService, IPackageService packageService, IReservedNamespaceService reservedNamespaceService, ITelemetryService telemetryService)
+        public TyposquattingService(IContentObjectService contentObjectService,
+                                    IPackageService packageService,
+                                    IReservedNamespaceService reservedNamespaceService,
+                                    ITelemetryService telemetryService,
+                                    ITyposquattingCheckListCacheService typosquattingCheckListCacheService)
         {
             _contentObjectService = contentObjectService ?? throw new ArgumentNullException(nameof(contentObjectService));
             _packageService = packageService ?? throw new ArgumentNullException(nameof(packageService));
             _reservedNamespaceService = reservedNamespaceService ?? throw new ArgumentNullException(nameof(reservedNamespaceService));
             _telemetryService = telemetryService ?? throw new ArgumentNullException(nameof(telemetryService));
-
-            TyposquattingCheckListLength = _contentObjectService.TyposquattingConfiguration.PackageIdChecklistLength;
+            _typosquattingCheckListCacheService = typosquattingCheckListCacheService ?? throw new ArgumentNullException(nameof(typosquattingCheckListCacheService));
         }
 
         public bool IsUploadedPackageIdTyposquatting(string uploadedPackageId, User uploadedPackageOwner, out List<string> typosquattingCheckCollisionIds)
         {
+            var checkListConfiguredLength = _contentObjectService.TyposquattingConfiguration.PackageIdChecklistLength;
+            var checkListExpireTimeInHours = TimeSpan.FromHours(_contentObjectService.TyposquattingConfiguration.PackageIdChecklistCacheExpireTimeInHours);
             typosquattingCheckCollisionIds = new List<string>();
             var wasUploadBlocked = false;
+
             if (!_contentObjectService.TyposquattingConfiguration.IsCheckEnabled || _reservedNamespaceService.GetReservedNamespacesForId(uploadedPackageId).Any())
             {
                 return wasUploadBlocked;
             }
-
             if (uploadedPackageId == null)
             {
                 throw new ArgumentNullException(nameof(uploadedPackageId));
             }
-
             if (uploadedPackageOwner == null)
             {
                 throw new ArgumentNullException(nameof(uploadedPackageOwner));
             }
 
+            var totalTimeStopwatch = Stopwatch.StartNew();
             var checklistRetrievalStopwatch = Stopwatch.StartNew();
-            var packageRegistrations = _packageService.GetAllPackageRegistrations();
-            var packagesCheckList = packageRegistrations
-                .OrderByDescending(pr => pr.IsVerified)
-                .ThenByDescending(pr => pr.DownloadCount)
-                .Select(pr => pr.Id)
-                .Take(TyposquattingCheckListLength)
-                .ToList();
+            var packageIdsCheckList = _typosquattingCheckListCacheService.GetTyposquattingCheckList(checkListConfiguredLength, checkListExpireTimeInHours, _packageService);
             checklistRetrievalStopwatch.Stop();
 
+            _telemetryService.TrackMetricForTyposquattingChecklistRetrievalTime(uploadedPackageId, checklistRetrievalStopwatch.Elapsed);
+
             var algorithmProcessingStopwatch = Stopwatch.StartNew();
             var threshold = GetThreshold(uploadedPackageId);
             var normalizedUploadedPackageId = TyposquattingStringNormalization.NormalizeString(uploadedPackageId);
-
             var collisionIds = new ConcurrentBag<string>();
-            Parallel.ForEach(packagesCheckList, (packageId, loopState) =>
+            Parallel.ForEach(packageIdsCheckList, (packageId, loopState) =>
             {
                 string normalizedPackageId = TyposquattingStringNormalization.NormalizeString(packageId);
                 if (TyposquattingDistanceCalculation.IsDistanceLessThanThreshold(normalizedUploadedPackageId, normalizedPackageId, threshold))
                 {
                     collisionIds.Add(packageId);
                 }
             });
-
             algorithmProcessingStopwatch.Stop();
 
-            var totalTime = checklistRetrievalStopwatch.Elapsed.Add(algorithmProcessingStopwatch.Elapsed);
-            _telemetryService.TrackMetricForTyposquattingChecklistRetrievalTime(uploadedPackageId, checklistRetrievalStopwatch.Elapsed);
             _telemetryService.TrackMetricForTyposquattingAlgorithmProcessingTime(uploadedPackageId, algorithmProcessingStopwatch.Elapsed);
 
             if (collisionIds.Count == 0)
             {
+                totalTimeStopwatch.Stop();
                 _telemetryService.TrackMetricForTyposquattingCheckResultAndTotalTime(
                     uploadedPackageId,
-                    totalTime,
+                    totalTimeStopwatch.Elapsed,
                     wasUploadBlocked,
                     typosquattingCheckCollisionIds,
-                    TyposquattingCheckListLength);
+                    packageIdsCheckList.Count,
+                    checkListExpireTimeInHours);
 
                 return false;
             }
 
             var ownersCheckStopwatch = Stopwatch.StartNew();
-            var collisionPackagesIdAndOwners = packageRegistrations
+            var collisionPackagesIdAndOwners = _packageService.GetAllPackageRegistrations()
                 .Where(pr => collisionIds.Contains(pr.Id))
                 .Select(pr => new { Id = pr.Id, Owners = pr.Owners.Select(x => x.Key).ToList() })
                 .ToList();
@@ -122,21 +120,21 @@ public bool IsUploadedPackageIdTyposquatting(string uploadedPackageId, User uplo
                 .Any(pio => pio.Owners.Any(k => k == uploadedPackageOwner.Key));
 
             wasUploadBlocked = _contentObjectService.TyposquattingConfiguration.IsBlockUsersEnabled && !isUserAllowedTyposquatting;
-
             ownersCheckStopwatch.Stop();
 
-            totalTime = totalTime.Add(ownersCheckStopwatch.Elapsed);
             _telemetryService.TrackMetricForTyposquattingOwnersCheckTime(uploadedPackageId, ownersCheckStopwatch.Elapsed);
+
+            totalTimeStopwatch.Stop();
             _telemetryService.TrackMetricForTyposquattingCheckResultAndTotalTime(
                     uploadedPackageId,
-                    totalTime,
+                    totalTimeStopwatch.Elapsed,
                     wasUploadBlocked,
                     typosquattingCheckCollisionIds,
-                    TyposquattingCheckListLength);
+                    packageIdsCheckList.Count,
+                    checkListExpireTimeInHours);
 
             return wasUploadBlocked;
         }
-
         private static int GetThreshold(string packageId)
         {
             foreach (var thresholdInfo in ThresholdsList)
@@ -150,7 +148,6 @@ private static int GetThreshold(string packageId)
             throw new ArgumentException(String.Format("There is no predefined typo-squatting threshold for this package Id: {0}", packageId));
         }
     }
-
     public class ThresholdInfo
     {
         public int LowerBound { get; }

tests/NuGetGallery.Facts/NuGetGallery.Facts.csproj

@@ -157,6 +157,7 @@
     <Compile Include="Services\ActionRequiringEntityPermissionsFacts.cs" />
     <Compile Include="Services\CertificatesConfigurationFacts.cs" />
     <Compile Include="Services\CuratedFeedServiceFacts.cs" />
+    <Compile Include="Services\TyposquattingCheckListCacheServiceFacts.cs" />
     <Compile Include="Services\TyposquattingServiceFacts.cs" />
     <Compile Include="Services\CloudDownloadCountServiceFacts.cs" />
     <Compile Include="Services\CertificateServiceFacts.cs" />