Add support for "check validator" message in orchestrator (#303)

Progress on NuGet/NuGetGallery#7354

Author: joelverhagen

src/NuGet.Services.ServiceBus/BrokeredMessageSerializer.cs

@@ -14,9 +14,6 @@ namespace NuGet.Services.ServiceBus
     /// <typeparam name="TMessage">A type decorated with a <see cref="SchemaAttribute"/>.</typeparam>
     public class BrokeredMessageSerializer<TMessage> : IBrokeredMessageSerializer<TMessage>
     {
-        private const string SchemaNameKey = "SchemaName";
-        private const string SchemaVersionKey = "SchemaVersion";
-
         private static readonly string SchemaName;
         private static readonly int SchemaVersion;
 
@@ -40,43 +37,49 @@ public IBrokeredMessage Serialize(TMessage message)
             var json = JsonConvert.SerializeObject(message);
             var brokeredMessage = new BrokeredMessageWrapper(json);
 
-            brokeredMessage.Properties[SchemaNameKey] = SchemaName;
-            brokeredMessage.Properties[SchemaVersionKey] = SchemaVersion;
+            brokeredMessage.Properties[BrokeredMessageSerializer.SchemaNameKey] = SchemaName;
+            brokeredMessage.Properties[BrokeredMessageSerializer.SchemaVersionKey] = SchemaVersion;
 
             return brokeredMessage;
         }
 
         public TMessage Deserialize(IBrokeredMessage message)
         {
-            AssertTypeAndSchemaVersion(message, SchemaName, SchemaVersion);
+            message.AssertTypeAndSchemaVersion(SchemaName, SchemaVersion);
 
             return JsonConvert.DeserializeObject<TMessage>(message.GetBody());
         }
+    }
+
+    public static class BrokeredMessageSerializer
+    {
+        public const string SchemaNameKey = "SchemaName";
+        public const string SchemaVersionKey = "SchemaVersion";
 
-        private static void AssertTypeAndSchemaVersion(IBrokeredMessage message, string type, int schemaVersion)
+        public static void AssertTypeAndSchemaVersion(this IBrokeredMessage message, string type, int schemaVersion)
         {
-            if (GetType(message) != type)
+            if (message.GetSchemaName() != type)
             {
                 throw new FormatException($"The provided message should have {SchemaNameKey} property '{type}'.");
             }
 
-            if (GetSchemaVersion(message) != schemaVersion)
+            if (message.GetSchemaVersion() != schemaVersion)
             {
                 throw new FormatException($"The provided message should have {SchemaVersionKey} property '{schemaVersion}'.");
             }
         }
 
-        private static int GetSchemaVersion(IBrokeredMessage message)
+        public static int GetSchemaVersion(this IBrokeredMessage message)
         {
             return GetProperty<int>(message, SchemaVersionKey, "an integer");
         }
 
-        private static string GetType(IBrokeredMessage message)
+        public static string GetSchemaName(this IBrokeredMessage message)
         {
             return GetProperty<string>(message, SchemaNameKey, "a string");
         }
 
-        private static T GetProperty<T>(IBrokeredMessage message, string key, string typeLabel)
+        private static T GetProperty<T>(this IBrokeredMessage message, string key, string typeLabel)
         {
             object value;
             if (!message.Properties.TryGetValue(key, out value))

src/NuGet.Services.Validation/CheckValidatorData.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;
+
+namespace NuGet.Services.Validation
+{
+    public class CheckValidatorData
+    {
+        public CheckValidatorData(Guid validationId)
+        {
+            if (validationId == Guid.Empty)
+            {
+                throw new ArgumentOutOfRangeException(nameof(validationId));
+            }
+
+            ValidationId = validationId;
+        }
+
+        public Guid ValidationId { get; }
+    }
+}

src/NuGet.Services.Validation/NuGet.Services.Validation.csproj

@@ -48,6 +48,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CheckValidatorData.cs" />
     <Compile Include="Entities\BaseValidationIssue.cs" />
     <Compile Include="Entities\CertificateChainLink.cs" />
     <Compile Include="Entities\EndCertificate.cs" />
@@ -167,6 +168,8 @@
     <Compile Include="Migrations\ValidationMigrationsConfiguration.cs" />
     <Compile Include="PackageValidationEnqueuer.cs" />
     <Compile Include="PackageValidationMessageData.cs" />
+    <Compile Include="PackageValidationMessageType.cs" />
+    <Compile Include="ProcessValidationSetData.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\AssemblyInfo.*.cs" />
     <Compile Include="ServiceBusMessageSerializer.cs" />

src/NuGet.Services.Validation/PackageValidationMessageData.cs

@@ -2,58 +2,80 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using NuGet.Versioning;
 
 namespace NuGet.Services.Validation
 {
     public class PackageValidationMessageData
     {
-        public PackageValidationMessageData(
-           string packageId,
-           string packageVersion,
-           Guid validationTrackingId)
-         : this(packageId, packageVersion, validationTrackingId, validatingType: ValidatingType.Package, deliveryCount: 0, entityKey: null)
-        {
-        }
-
-        public PackageValidationMessageData(
+        public static PackageValidationMessageData NewProcessValidationSet(
             string packageId,
             string packageVersion,
             Guid validationTrackingId,
             ValidatingType validatingType,
-            int? entityKey = null)
-          : this(packageId, packageVersion, validationTrackingId, validatingType, deliveryCount: 0, entityKey: entityKey)
+            int? entityKey)
         {
+            return new PackageValidationMessageData(
+                PackageValidationMessageType.ProcessValidationSet,
+                processValidationSet: new ProcessValidationSetData(
+                    packageId,
+                    packageVersion,
+                    validationTrackingId,
+                    validatingType,
+                    entityKey),
+                checkValidator: null,
+                deliveryCount: 0);
+        }
+
+        public static PackageValidationMessageData NewCheckValidator(Guid validationId)
+        {
+            return new PackageValidationMessageData(
+                PackageValidationMessageType.CheckValidator,
+                processValidationSet: null,
+                checkValidator: new CheckValidatorData(validationId),
+                deliveryCount: 0);
         }
 
         internal PackageValidationMessageData(
-            string packageId,
-            string packageVersion,
-            Guid validationTrackingId,
-            ValidatingType validatingType,
-            int deliveryCount,
-            int? entityKey = null)
+            PackageValidationMessageType type,
+            ProcessValidationSetData processValidationSet,
+            CheckValidatorData checkValidator,
+            int deliveryCount)
         {
-            if (validationTrackingId == Guid.Empty)
+            switch (type)
+            {
+                case PackageValidationMessageType.ProcessValidationSet:
+                    if (processValidationSet == null)
+                    {
+                        throw new ArgumentNullException(nameof(processValidationSet));
+                    }
+                    break;
+                case PackageValidationMessageType.CheckValidator:
+                    if (checkValidator == null)
+                    {
+                        throw new ArgumentNullException(nameof(checkValidator));
+                    }
+                    break;
+                default:
+                    throw new NotSupportedException($"The package validation message type '{type}' is not supported.");
+            }
+
+            var notNullCount = 0;
+            notNullCount += processValidationSet != null ? 1 : 0;
+            notNullCount += checkValidator != null ? 1 : 0;
+            if (notNullCount > 1)
             {
-                throw new ArgumentOutOfRangeException(nameof(validationTrackingId));
+                throw new ArgumentException("There should be exactly one non-null data instance provided.");
             }
 
-            PackageId = packageId ?? throw new ArgumentNullException(nameof(packageId));
-            PackageVersion = packageVersion ?? throw new ArgumentNullException(nameof(packageVersion));
-            PackageNormalizedVersion = NuGetVersion.Parse(packageVersion).ToNormalizedString();
-            ValidationTrackingId = validationTrackingId;
+            Type = type;
+            ProcessValidationSet = processValidationSet;
+            CheckValidator = checkValidator;
             DeliveryCount = deliveryCount;
-            ValidatingType = validatingType;
-            EntityKey = entityKey;
         }
 
-        public string PackageId { get; }
-        public string PackageVersion { get; }
-        public string PackageNormalizedVersion { get; }
-        public Guid ValidationTrackingId { get; }
+        public PackageValidationMessageType Type { get; }
+        public ProcessValidationSetData ProcessValidationSet { get; }
+        public CheckValidatorData CheckValidator { get; }
         public int DeliveryCount { get; }
-        public ValidatingType ValidatingType { get; }
-        public int? EntityKey { get; }
     }
 }

src/NuGet.Services.Validation/PackageValidationMessageType.cs

@@ -0,0 +1,11 @@
+// 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.
+
+namespace NuGet.Services.Validation
+{
+    public enum PackageValidationMessageType
+    {
+        ProcessValidationSet,
+        CheckValidator,
+    }
+}

src/NuGet.Services.Validation/ProcessValidationSetData.cs

@@ -0,0 +1,38 @@
+// 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 NuGet.Versioning;
+
+namespace NuGet.Services.Validation
+{
+    public class ProcessValidationSetData
+    {
+        public ProcessValidationSetData(
+            string packageId,
+            string packageVersion,
+            Guid validationTrackingId,
+            ValidatingType validatingType,
+            int? entityKey)
+        {
+            if (validationTrackingId == Guid.Empty)
+            {
+                throw new ArgumentOutOfRangeException(nameof(validationTrackingId));
+            }
+
+            PackageId = packageId;
+            PackageVersion = packageVersion;
+            PackageNormalizedVersion = NuGetVersion.Parse(packageVersion).ToNormalizedString();
+            ValidationTrackingId = validationTrackingId;
+            ValidatingType = validatingType;
+            EntityKey = entityKey;
+        }
+
+        public string PackageId { get; }
+        public string PackageVersion { get; }
+        public string PackageNormalizedVersion { get; }
+        public Guid ValidationTrackingId { get; }
+        public ValidatingType ValidatingType { get; }
+        public int? EntityKey { get; }
+    }
+}

src/NuGet.Services.Validation/ServiceBusMessageSerializer.cs

@@ -8,38 +8,67 @@ namespace NuGet.Services.Validation
 {
     public class ServiceBusMessageSerializer : IServiceBusMessageSerializer
     {
-        private const string PackageValidationSchemaName = "PackageValidationMessageData";
+        private const string ProcessValidationSetSchemaName = "PackageValidationMessageData";
+        private const string CheckValidatorSchemaName = "PackageValidationCheckValidatorMessageData";
 
-        private static readonly BrokeredMessageSerializer<PackageValidationMessageData1> _serializer = new BrokeredMessageSerializer<PackageValidationMessageData1>();
+        private static readonly BrokeredMessageSerializer<ProcessValidationSetData1> _processValidationSetSerializer = new BrokeredMessageSerializer<ProcessValidationSetData1>();
+        private static readonly BrokeredMessageSerializer<CheckValidatorData1> _checkValidatorSerializer = new BrokeredMessageSerializer<CheckValidatorData1>();
 
         public IBrokeredMessage SerializePackageValidationMessageData(PackageValidationMessageData message)
         {
-            return _serializer.Serialize(new PackageValidationMessageData1
+            switch (message.Type)
             {
-                PackageId = message.PackageId,
-                PackageVersion = message.PackageVersion,
-                PackageNormalizedVersion = message.PackageNormalizedVersion,
-                ValidationTrackingId = message.ValidationTrackingId,
-                ValidatingType = message.ValidatingType,
-                EntityKey = message.EntityKey
-            });
+                case PackageValidationMessageType.ProcessValidationSet:
+                    return _processValidationSetSerializer.Serialize(new ProcessValidationSetData1
+                    {
+                        PackageId = message.ProcessValidationSet.PackageId,
+                        PackageVersion = message.ProcessValidationSet.PackageVersion,
+                        PackageNormalizedVersion = message.ProcessValidationSet.PackageNormalizedVersion,
+                        ValidationTrackingId = message.ProcessValidationSet.ValidationTrackingId,
+                        ValidatingType = message.ProcessValidationSet.ValidatingType,
+                        EntityKey = message.ProcessValidationSet.EntityKey,
+                    });
+                case PackageValidationMessageType.CheckValidator:
+                    return _checkValidatorSerializer.Serialize(new CheckValidatorData1
+                    {
+                        ValidationId = message.CheckValidator.ValidationId,
+                    });
+                default:
+                    throw new NotSupportedException($"The package validation message type '{message.Type}' is not supported.");
+            }
         }
 
         public PackageValidationMessageData DeserializePackageValidationMessageData(IBrokeredMessage message)
         {
-            var data = _serializer.Deserialize(message);
-
-            return new PackageValidationMessageData(
-                data.PackageId,
-                data.PackageVersion,
-                data.ValidationTrackingId,
-                data.ValidatingType,
-                message.DeliveryCount,
-                data.EntityKey);
+            var schemaName = message.GetSchemaName();
+            switch (schemaName)
+            {
+                case ProcessValidationSetSchemaName:
+                    var processValidationSet = _processValidationSetSerializer.Deserialize(message);
+                    return new PackageValidationMessageData(
+                        PackageValidationMessageType.ProcessValidationSet,
+                        processValidationSet: new ProcessValidationSetData(
+                            processValidationSet.PackageId,
+                            processValidationSet.PackageVersion,
+                            processValidationSet.ValidationTrackingId,
+                            processValidationSet.ValidatingType,
+                            processValidationSet.EntityKey),
+                        checkValidator: null,
+                        deliveryCount: message.DeliveryCount);
+                case CheckValidatorSchemaName:
+                    var checkValidator = _checkValidatorSerializer.Deserialize(message);
+                    return new PackageValidationMessageData(
+                        PackageValidationMessageType.CheckValidator,
+                        processValidationSet: null,
+                        checkValidator: new CheckValidatorData(checkValidator.ValidationId),
+                        deliveryCount: message.DeliveryCount);
+                default:
+                    throw new FormatException($"The provided schema name '{schemaName}' is not supported.");
+            }
         }
 
-        [Schema(Name = PackageValidationSchemaName, Version = 1)]
-        private class PackageValidationMessageData1
+        [Schema(Name = ProcessValidationSetSchemaName, Version = 1)]
+        private class ProcessValidationSetData1
         {
             public string PackageId { get; set; }
             public string PackageVersion { get; set; }
@@ -48,5 +77,11 @@ private class PackageValidationMessageData1
             public ValidatingType ValidatingType { get; set; }
             public int? EntityKey { get; set; }
         }
+
+        [Schema(Name = CheckValidatorSchemaName, Version = 1)]
+        private class CheckValidatorData1
+        {
+            public Guid ValidationId { get; set; }
+        }
     }
 }