[NuGet Symbol Server] Add symbols delete support to gallery (#6513)

Author: shishirx34

…llery.Core/Auditing/PackageCreatedVia.cs …ery.Core/Auditing/PackageAuditReasons.cssrc/NuGetGallery.Core/Auditing/PackageCreatedVia.cs renamed to src/NuGetGallery.Core/Auditing/PackageAuditReasons.cs src/NuGetGallery.Core/Auditing/PackageCreatedVia.cs renamed to src/NuGetGallery.Core/Auditing/PackageAuditReasons.cs

@@ -15,4 +15,17 @@ public static class PackageCreatedVia
         /// </summary>
         public const string Web = "Created via web.";
     }
+
+    public static class PackageDeletedVia
+    {
+        /// <summary>
+        /// Package has been deleted via NuGet API (nuget.exe delete)
+        /// </summary>
+        public const string Api = "Deleted via API.";
+
+        /// <summary>
+        /// Package has been deleted via NuGet web interface (browser)
+        /// </summary>
+        public const string Web = "Deleted via web.";
+    }
 }

src/NuGetGallery.Core/NuGetGallery.Core.csproj

@@ -91,7 +91,7 @@
     <Compile Include="Auditing\CredentialAuditRecord.cs" />
     <Compile Include="Auditing\AuditedPackageAction.cs" />
     <Compile Include="Auditing\IAuditingService.cs" />
-    <Compile Include="Auditing\PackageCreatedVia.cs" />
+    <Compile Include="Auditing\PackageAuditReasons.cs" />
     <Compile Include="Auditing\AuditedPackageRegistrationAction.cs" />
     <Compile Include="Auditing\AuditedEntities\AuditedPackageRegistration.cs" />
     <Compile Include="Auditing\PackageRegistrationAuditRecord.cs" />

src/NuGetGallery/Controllers/PackagesController.cs

@@ -21,6 +21,7 @@
 using NuGetGallery.AsyncFileUpload;
 using NuGetGallery.Auditing;
 using NuGetGallery.Configuration;
+using NuGetGallery.Diagnostics;
 using NuGetGallery.Filters;
 using NuGetGallery.Helpers;
 using NuGetGallery.Infrastructure.Lucene;
@@ -88,6 +89,7 @@ public partial class PackagesController
         private readonly IPackageOwnershipManagementService _packageOwnershipManagementService;
         private readonly IContentObjectService _contentObjectService;
         private readonly ISymbolPackageUploadService _symbolPackageUploadService;
+        private readonly IDiagnosticsSource _trace;
 
         public PackagesController(
             IPackageService packageService,
@@ -111,7 +113,8 @@ public PackagesController(
             IValidationService validationService,
             IPackageOwnershipManagementService packageOwnershipManagementService,
             IContentObjectService contentObjectService,
-            ISymbolPackageUploadService symbolPackageUploadService)
+            ISymbolPackageUploadService symbolPackageUploadService,
+            IDiagnosticsService diagnosticsService)
         {
             _packageService = packageService;
             _uploadFileService = uploadFileService;
@@ -135,6 +138,7 @@ public PackagesController(
             _packageOwnershipManagementService = packageOwnershipManagementService;
             _contentObjectService = contentObjectService;
             _symbolPackageUploadService = symbolPackageUploadService;
+            _trace = diagnosticsService?.SafeGetSource(nameof(PackagesController)) ?? throw new ArgumentNullException(nameof(diagnosticsService));
         }
 
         [HttpGet]
@@ -220,7 +224,7 @@ private async Task<ActionResult> UploadSymbolsPackageInternal(SubmitPackageReque
             var existingPackageRegistration = packageForUploadingSymbols.PackageRegistration;
 
             IEnumerable<User> accountsAllowedOnBehalfOf = Enumerable.Empty<User>();
-            bool isAllowed = ActionsRequiringPermissions.UploadNewPackageVersion.CheckPermissionsOnBehalfOfAnyAccount(currentUser, existingPackageRegistration, out accountsAllowedOnBehalfOf) == PermissionsCheckResult.Allowed;
+            bool isAllowed = ActionsRequiringPermissions.UploadSymbolPackage.CheckPermissionsOnBehalfOfAnyAccount(currentUser, existingPackageRegistration, out accountsAllowedOnBehalfOf) == PermissionsCheckResult.Allowed;
             if (!isAllowed)
             {
                 accountsAllowedOnBehalfOf = new[] { currentUser };
@@ -363,7 +367,7 @@ private async Task<JsonResult> UploadSymbolsPackageInternal(PackageArchiveReader
 
             // Evaluate the permissions for user on behalf of any account possible, since the user 
             // could change the ownership before submitting the package.
-            if (ActionsRequiringPermissions.UploadNewPackageVersion.CheckPermissionsOnBehalfOfAnyAccount(
+            if (ActionsRequiringPermissions.UploadSymbolPackage.CheckPermissionsOnBehalfOfAnyAccount(
                 currentUser, existingPackageRegistration, out accountsAllowedOnBehalfOf) != PermissionsCheckResult.Allowed)
             {
                 return Json(HttpStatusCode.Conflict, new[] { string.Format(CultureInfo.CurrentCulture, Strings.PackageIdNotAvailable, existingPackageRegistration.Id) });
@@ -1161,6 +1165,40 @@ public virtual ActionResult Delete(string id, string version)
             return View(model);
         }
 
+        [HttpGet]
+        [UIAuthorize]
+        [RequiresAccountConfirmation("delete a symbols package")]
+        public virtual ActionResult DeleteSymbols(string id, string version)
+        {
+            var package = _packageService.FindPackageByIdAndVersion(id, version);
+            if (package == null)
+            {
+                return HttpNotFound();
+            }
+
+            var currentUser = GetCurrentUser();
+            if (ActionsRequiringPermissions.DeleteSymbolPackage.CheckPermissionsOnBehalfOfAnyAccount(currentUser, package) != PermissionsCheckResult.Allowed)
+            {
+                return HttpForbidden();
+            }
+
+            var model = new DeletePackageViewModel(package, currentUser, DeleteReasons);
+
+            model.VersionSelectList = new SelectList(
+                model
+                .PackageVersions
+                .Where(p => !p.Deleted 
+                    && p.LatestSymbolsPackage != null
+                    && p.LatestSymbolsPackage.StatusKey == PackageStatus.Available)
+                .Select(p => new
+                {
+                    text = p.NuGetVersion.ToFullString() + (p.LatestVersionSemVer2 ? " (Latest)" : string.Empty),
+                    url = Url.DeleteSymbolsPackage(p)
+                }), "url", "text", Url.DeleteSymbolsPackage(model));
+
+            return View(model);
+        }
+
         [UIAuthorize(Roles = "Admins")]
         [RequiresAccountConfirmation("reflow a package")]
         public virtual async Task<ActionResult> Reflow(string id, string version)
@@ -1278,6 +1316,67 @@ await _packageDeleteService.HardDeletePackagesAsync(
             return Delete(firstPackage.PackageRegistration.Id, firstPackage.Version);
         }
 
+        [UIAuthorize]
+        [HttpPost]
+        [RequiresAccountConfirmation("delete a symbols package")]
+        [ValidateAntiForgeryToken]
+        public virtual async Task<ActionResult> DeleteSymbolsPackage(string id, string version)
+        {
+            var package = _packageService.FindPackageByIdAndVersionStrict(id, version);
+            if (package == null)
+            {
+                return new HttpStatusCodeResult(HttpStatusCode.NotFound,
+                    string.Format(Strings.PackageWithIdAndVersionNotFound, id, version));
+            }
+
+            if (ActionsRequiringPermissions.DeleteSymbolPackage.CheckPermissionsOnBehalfOfAnyAccount(GetCurrentUser(), package)
+                != PermissionsCheckResult.Allowed)
+            {
+                return new HttpStatusCodeResult(HttpStatusCode.Forbidden, Strings.SymbolsPackage_UploadNotAllowed);
+            }
+
+            if (package.PackageRegistration.IsLocked)
+            {
+                return new HttpStatusCodeResult(HttpStatusCode.Forbidden,
+                    string.Format(CultureInfo.CurrentCulture, Strings.PackageIsLocked, package.PackageRegistration.Id));
+            }
+
+            // Get all available symbol packages for a given package, ideally this should
+            // always return one symbol package. For thoroughness we can cleanup the data
+            // for any inconsistencies.
+            var availableSymbolPackages = package
+                .SymbolPackages
+                .Where(sp => sp.StatusKey == PackageStatus.Available);
+
+            if (availableSymbolPackages.Count() > 1)
+            {
+                _trace.Warning($"Multiple({availableSymbolPackages.Count()}) available symbol packages found for {package.Id}, {package.Version}");
+            }
+
+            if (availableSymbolPackages.Any())
+            {
+                foreach (var symbolPackage in availableSymbolPackages)
+                {
+                    await _symbolPackageUploadService.DeleteSymbolsPackageAsync(symbolPackage);
+                }
+
+                TempData["Message"] = Strings.SymbolsPackage_Deleted;
+
+                await _auditingService.SaveAuditRecordAsync(
+                    new PackageAuditRecord(package, AuditedPackageAction.SymbolsDelete, PackageDeletedVia.Web));
+
+                _telemetryService.TrackSymbolPackageDeleteEvent(package.Id, package.Version);
+
+                // Redirect to the package details page
+                return Redirect(Url.Package(package, relativeUrl: true));
+            }
+            else
+            {
+                return new HttpStatusCodeResult(HttpStatusCode.BadRequest,
+                    string.Format(Strings.SymbolsPackage_PackageNotAvailable, id, version));
+            }
+        }
+
         [UIAuthorize]
         [HttpPost]
         [RequiresAccountConfirmation("unlist a package")]
@@ -1697,7 +1796,7 @@ public virtual async Task<JsonResult> VerifySymbolsPackageInternal(
 
                 // Evaluate the permissions for the owner, the permissions for uploading a symbols should be same as that of
                 // uploading a new version of a given package.
-                var checkPermissionsOfUploadNewVersion = ActionsRequiringPermissions.UploadNewPackageVersion.CheckPermissions(currentUser, owner, existingPackageRegistration);
+                var checkPermissionsOfUploadNewVersion = ActionsRequiringPermissions.UploadSymbolPackage.CheckPermissions(currentUser, owner, existingPackageRegistration);
                 if (checkPermissionsOfUploadNewVersion != PermissionsCheckResult.Allowed)
                 {
                     if (checkPermissionsOfUploadNewVersion == PermissionsCheckResult.AccountFailure)

src/NuGetGallery/NuGetGallery.csproj

@@ -1778,6 +1778,7 @@
     <Content Include="Views\Shared\ConfirmationRequired.cshtml" />
     <Content Include="Views\Pages\Contact.cshtml" />
     <Content Include="Views\Shared\_DeletePackage.cshtml" />
+    <Content Include="Views\Packages\DeleteSymbols.cshtml" />
   </ItemGroup>
   <ItemGroup>
     <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />

src/NuGetGallery/Scripts/gallery/page-delete-package.js

@@ -14,4 +14,10 @@
             e.preventDefault();
         }
     });
+
+    $('#delete-symbols-form').submit(function (e) {
+        if (!confirm('Deleting this symbols package will make it unavailable for download and remove all corresponding symbols from the symbol server. Are you sure you want to continue with the delete?')) {
+            e.preventDefault();
+        }
+    });
 });

src/NuGetGallery/Services/ActionsRequiringPermissions.cs

@@ -45,13 +45,21 @@ public static class ActionsRequiringPermissions
                 packageRegistrationPermissionsRequirement: PermissionsRequirement.Owner);
 
         /// <summary>
-        /// The action of uploading a symbol package for an existing package.
+        /// The action of uploading a symbols package for an existing package.
         /// </summary>
         public static ActionRequiringPackagePermissions UploadSymbolPackage =
             new ActionRequiringPackagePermissions(
                 accountOnBehalfOfPermissionsRequirement: RequireOwnerOrOrganizationMember,
                 packageRegistrationPermissionsRequirement: PermissionsRequirement.Owner);
 
+        /// <summary>
+        /// The action of deleting a symbols package for an existing package.
+        /// </summary>
+        public static ActionRequiringPackagePermissions DeleteSymbolPackage =
+            new ActionRequiringPackagePermissions(
+                accountOnBehalfOfPermissionsRequirement: RequireOwnerOrOrganizationMember,
+                packageRegistrationPermissionsRequirement: RequireOwnerOrSiteAdmin);
+
         /// <summary>
         /// The action of verify a package verification key.
         /// </summary>

src/NuGetGallery/Services/ISymbolPackageUploadService.cs

@@ -34,5 +34,11 @@ public interface ISymbolPackageUploadService
         /// <param name="currentUser">The user performing the uploads.</param>
         /// <returns>Awaitable task with <see cref="SymbolPackageValidationResult"/></returns>
         Task<SymbolPackageValidationResult> ValidateUploadedSymbolsPackage(Stream uploadStream, User currentUser);
+
+        /// <summary>
+        /// Mark the specifed symbol package for deletion and delete the corressponding snupkg as well.
+        /// </summary>
+        /// <param name="symbolPackage">The <see cref="SymbolPackage"/> entity to be marked for deletion</param>
+        Task DeleteSymbolsPackageAsync(SymbolPackage symbolPackage);
     }
 }

src/NuGetGallery/Services/ITelemetryService.cs

@@ -165,6 +165,13 @@ public interface ITelemetryService
         /// <param name="packageVersion">The version of the package that has the symbols uploaded.</param>
         void TrackSymbolPackagePushEvent(string packageId, string packageVersion);
 
+        /// <summary>
+        /// A telemetry event emitted when a symbol package is deleted.
+        /// </summary>
+        /// <param name="packageId">The id of the package for which symbols are deleted.</param>
+        /// <param name="packageVersion">The version of the package for which the symbols are delted.</param>
+        void TrackSymbolPackageDeleteEvent(string packageId, string packageVersion);
+
         /// <summary>
         /// A telemetry event emitted when a symbol package fails to be pushed.
         /// </summary>

src/NuGetGallery/Services/SymbolPackageUploadService.cs

@@ -230,5 +230,20 @@ await _symbolPackageFileService.DeletePackageFileAsync(
 
             return PackageCommitResult.Success;
         }
+
+        public async Task DeleteSymbolsPackageAsync(SymbolPackage symbolPackage)
+        {
+            if (symbolPackage == null)
+            {
+                throw new ArgumentNullException(nameof(symbolPackage));
+            }
+
+            if (await _symbolPackageFileService.DoesPackageFileExistAsync(symbolPackage.Package))
+            {
+                await _symbolPackageFileService.DeletePackageFileAsync(symbolPackage.Id, symbolPackage.Version);
+            }
+
+            await _symbolPackageService.UpdateStatusAsync(symbolPackage, PackageStatus.Deleted, commitChanges: true);
+        }
     }
 }

src/NuGetGallery/Services/TelemetryService.cs

@@ -50,6 +50,7 @@ internal class Events
             public const string AccountDeleteCompleted = "AccountDeleteCompleted";
             public const string AccountDeleteRequested = "AccountDeleteRequested";
             public const string SymbolPackagePush = "SymbolPackagePush";
+            public const string SymbolPackageDelete = "SymbolPackageDelete";
             public const string SymbolPackagePushFailure = "SymbolPackagePushFailure";
             public const string SymbolPackageGalleryValidation = "SymbolPackageGalleryValidation";
             public const string PackageMetadataComplianceError = "PackageMetadataComplianceError";
@@ -409,6 +410,10 @@ public void TrackSymbolPackagePushEvent(string packageId, string packageVersion)
         {
             TrackMetricForSymbolPackage(Events.SymbolPackagePush, packageId, packageVersion);
         }
+        public void TrackSymbolPackageDeleteEvent(string packageId, string packageVersion)
+        {
+            TrackMetricForSymbolPackage(Events.SymbolPackageDelete, packageId, packageVersion);
+        }
 
         public void TrackSymbolPackagePushFailureEvent(string packageId, string packageVersion)
         {