all hail our enospecv2 overlords

Trolldemorted · Trolldemorted · commit 1e29a7928a32 · 2021-04-22T16:36:40.000+02:00
diff --git a/EnoChecker/Controllers/CheckerController.cs b/EnoChecker/Controllers/CheckerController.cs
@@ -63,27 +63,27 @@ public async Task<IActionResult> Flag([FromBody] CheckerTaskMessage ctm)
                     throw new Exception("invalid method");
                 }
 
-                this.logger.LogInformation($"Task {ctm.RunId} succeeded");
+                this.logger.LogInformation($"Task {ctm.TaskId} succeeded");
                 return this.Json(new CheckerResultMessage(CheckerResult.OK, null));
             }
             catch (OperationCanceledException)
             {
-                this.logger.LogWarning($"Task {ctm.RunId} was cancelled");
+                this.logger.LogWarning($"Task {ctm.TaskId} was cancelled");
                 return this.Json(new CheckerResultMessage(CheckerResult.OFFLINE, null));
             }
             catch (MumbleException e)
             {
-                this.logger.LogWarning($"Task {ctm.RunId} has failed: {e.ToFancyString()}");
+                this.logger.LogWarning($"Task {ctm.TaskId} has failed: {e.ToFancyString()}");
                 return this.Json(new CheckerResultMessage(CheckerResult.MUMBLE, e.Message));
             }
             catch (OfflineException e)
             {
-                this.logger.LogWarning($"Task {ctm.RunId} has failed: {e.ToFancyString()}");
+                this.logger.LogWarning($"Task {ctm.TaskId} has failed: {e.ToFancyString()}");
                 return this.Json(new CheckerResultMessage(CheckerResult.OFFLINE, e.Message));
             }
             catch (Exception e)
             {
-                this.logger.LogError($"Task {ctm.RunId} has failed: {e.ToFancyString()}");
+                this.logger.LogError($"Task {ctm.TaskId} has failed: {e.ToFancyString()}");
                 return this.Json(new CheckerResultMessage(CheckerResult.INTERNAL_ERROR, null));
             }
         }
diff --git a/EnoCore/Configuration/Configuration.cs b/EnoCore/Configuration/Configuration.cs
@@ -37,7 +37,9 @@ public sealed record ConfigurationService(
         int FlagsPerRound,
         int NoisesPerRound,
         int HavocsPerRound,
-        int FlagStores,
+        int FlagVariants,
+        int HavocVariants,
+        int NoiseVariants,
         long WeightFactor,
         bool Active,
         string[] Checkers);
diff --git a/EnoCore/Configuration/JsonConfiguration.cs b/EnoCore/Configuration/JsonConfiguration.cs
@@ -196,10 +196,12 @@ public async Task<ConfigurationService> Validate()
             return new(
                 this.Id,
                 this.Name,
-                this.FlagsPerRoundMultiplier * infoMessage.FlagCount,
-                this.NoisesPerRoundMultiplier * infoMessage.NoiseCount,
-                this.HavocsPerRoundMultiplier * infoMessage.HavocCount,
-                infoMessage.FlagCount,
+                this.FlagsPerRoundMultiplier * infoMessage.FlagVariants,
+                this.NoisesPerRoundMultiplier * infoMessage.NoiseVariants,
+                this.HavocsPerRoundMultiplier * infoMessage.HavocVariants,
+                infoMessage.FlagVariants,
+                infoMessage.NoiseVariants,
+                infoMessage.HavocVariants,
                 this.WeightFactor,
                 this.Active,
                 this.Checkers);
diff --git a/EnoCore/Logging/EnoLogger.cs b/EnoCore/Logging/EnoLogger.cs
@@ -95,7 +95,8 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
                                             module,
                                             null,
                                             task.Payload,
-                                            task.TaskIndex,
+                                            task.UniqueVariantId,
+                                            task.GetTaskChainId(),
                                             task.Id,
                                             task.CurrentRoundId,
                                             task.RelatedRoundId,
@@ -117,14 +118,15 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
                                             module,
                                             null,
                                             taskMessage.Flag,
-                                            taskMessage.FlagIndex,
-                                            taskMessage.RunId,
-                                            taskMessage.RoundId,
+                                            taskMessage.VariantId,
+                                            taskMessage.TaskChainId,
+                                            taskMessage.TaskId,
+                                            taskMessage.CurrentRoundId,
                                             taskMessage.RelatedRoundId,
                                             message,
                                             taskMessage.TeamName,
                                             taskMessage.TeamId,
-                                            taskMessage.ServiceName,
+                                            this.serviceName,
                                             Enum.GetName(typeof(CheckerTaskMethod), taskMessage.Method));
                                         this.provider.Log($"##ENOLOGMESSAGE {JsonSerializer.Serialize(enoLogMessage, EnoCoreUtil.CamelCaseEnumConverterOptions)}\n");
                                         hadScope = true;
@@ -149,6 +151,7 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
                         null,
                         null,
                         null,
+                        null,
                         message,
                         null,
                         null,
diff --git a/EnoCore/Models/CheckerInfoMessage.cs b/EnoCore/Models/CheckerInfoMessage.cs
@@ -4,7 +4,7 @@
 
     public sealed record CheckerInfoMessage(
         string ServiceName,
-        int FlagCount,
-        int NoiseCount,
-        int HavocCount);
+        int FlagVariants,
+        int NoiseVariants,
+        int HavocVariants);
 }
diff --git a/EnoCore/Models/CheckerTask.cs b/EnoCore/Models/CheckerTask.cs
@@ -47,8 +47,23 @@ public sealed record CheckerTask(
         DateTime StartTime,
         int MaxRunningTime,
         long RoundLength,
-        long TaskIndex,
+        long UniqueVariantId,
+        long VariantId,
         CheckerResult CheckerResult,
         string? ErrorMessage,
-        CheckerTaskLaunchStatus CheckerTaskLaunchStatus);
+        CheckerTaskLaunchStatus CheckerTaskLaunchStatus)
+    {
+        public string GetTaskChainId()
+        {
+            return this.Method switch
+            {
+                CheckerTaskMethod.putflag => $"flag_{this.ServiceId}_r{this.RelatedRoundId}_t{this.TeamId}_i{this.UniqueVariantId}",
+                CheckerTaskMethod.getflag => $"flag_{this.ServiceId}_r{this.RelatedRoundId}_t{this.TeamId}_i{this.UniqueVariantId}",
+                CheckerTaskMethod.putnoise => $"noise_{this.ServiceId}_r{this.RelatedRoundId}_t{this.TeamId}_i{this.UniqueVariantId}",
+                CheckerTaskMethod.getnoise => $"noise_{this.ServiceId}_r{this.RelatedRoundId}_t{this.TeamId}_i{this.UniqueVariantId}",
+                CheckerTaskMethod.havoc => $"havoc_{this.ServiceId}_r{this.RelatedRoundId}_t{this.TeamId}_i{this.UniqueVariantId}",
+                _ => throw new NotImplementedException(),
+            };
+        }
+    }
 }
diff --git a/EnoCore/Models/CheckerTaskMessage.cs b/EnoCore/Models/CheckerTaskMessage.cs
@@ -1,17 +1,16 @@
 ﻿namespace EnoCore.Models
 {
     public sealed record CheckerTaskMessage(
-        long RunId,
+        long TaskId,
         CheckerTaskMethod Method,
         string Address,
-        long ServiceId,
-        string ServiceName,
         long TeamId,
         string TeamName,
+        long CurrentRoundId,
         long RelatedRoundId,
-        long RoundId,
         string? Flag,
-        long FlagIndex,
+        long VariantId,
         long Timeout,
-        long RoundLength);
+        long RoundLength,
+        string TaskChainId);
 }
diff --git a/EnoCore/Models/EnoLogMessage.cs b/EnoCore/Models/EnoLogMessage.cs
@@ -15,7 +15,8 @@ public record EnoLogMessage(
         string? Module,
         string? Function,
         string? Flag,
-        long? FlagIndex,
+        long? VariantId,
+        string? TaskChainId,
         long? RunId,
         long? RoundId,
         long? RelatedRoundId,
diff --git a/EnoCore/Models/EnoStatisticsMessage.cs b/EnoCore/Models/EnoStatisticsMessage.cs
@@ -31,7 +31,7 @@ public static CheckerTaskLaunchMessage FromCheckerTask(CheckerTask task)
                 task.CurrentRoundId,
                 task.ServiceName,
                 task.Method.ToString(),
-                task.TaskIndex);
+                task.UniqueVariantId);
         }
     }
 
@@ -50,7 +50,7 @@ public static CheckerTaskFinishedMessage FromCheckerTask(CheckerTask task)
                 task.CurrentRoundId,
                 task.ServiceName,
                 task.Method.ToString(),
-                task.TaskIndex,
+                task.UniqueVariantId,
                 (DateTime.UtcNow - task.StartTime).TotalSeconds,
                 task.CheckerResult.ToString());
         }
diff --git a/EnoCore/Models/Service.cs b/EnoCore/Models/Service.cs
@@ -12,15 +12,19 @@ public Service(
             long flagsPerRound,
             long noisesPerRound,
             long havocsPerRound,
-            long flagStores,
+            long flagVariants,
+            long noiseVariants,
+            long havocVariants,
             bool active)
         {
             this.Id = id;
             this.Name = name;
             this.FlagsPerRound = flagsPerRound;
             this.NoisesPerRound = noisesPerRound;
             this.HavocsPerRound = havocsPerRound;
-            this.FlagStores = flagStores;
+            this.FlagVariants = flagVariants;
+            this.NoiseVariants = noiseVariants;
+            this.HavocVariants = havocVariants;
             this.Active = active;
         }
 
@@ -30,7 +34,9 @@ public Service(
         public long FlagsPerRound { get; set; }
         public long NoisesPerRound { get; set; }
         public long HavocsPerRound { get; set; }
-        public long FlagStores { get; set; }
+        public long FlagVariants { get; set; }
+        public long NoiseVariants { get; set; }
+        public long HavocVariants { get; set; }
         public bool Active { get; set; }
 #pragma warning restore SA1516 // Elements should be separated by blank line
     }
diff --git a/EnoCore/Scoreboard/Scoreboard.cs b/EnoCore/Scoreboard/Scoreboard.cs
@@ -7,45 +7,54 @@
     using System.Text.Json;
     using EnoCore.Models;
 
+    public record ScoreboardInfo(
+        string? DnsSuffix,
+        ScoreboardService[] Services,
+        ScoreboardInfoTeam[] Teams);
+
+    public record ScoreboardInfoTeam(
+        long TeamId,
+        string TeamName,
+        string? LogoUrl,
+        string? CountryCode);
+
     public record Scoreboard(
         long CurrentRound,
         string? StartTimestamp,
-        double? StartTimeEpoch,
         string? EndTimestamp,
-        double? EndTimeEpoch,
+        string? DnsSuffix,
         ScoreboardService[] Services,
         ScoreboardTeam[] Teams);
 
+    public record ScoreboardTeam(
+        string TeamName,
+        long TeamId,
+        string? LogoUrl,
+        string? CountryCode,
+        double TotalScore,
+        double AttackScore,
+        double DefenseScore,
+        double ServiceLevelAgreementScore,
+        ScoreboardTeamServiceDetails[] ServiceDetails);
+
+    public record ScoreboardTeamServiceDetails(
+        long ServiceId,
+        double AttackScore,
+        double DefenseScore,
+        double ServiceLevelAgreementScore,
+        ServiceStatus ServiceStatus,
+        string? Message);
+
     public record ScoreboardService(
         long ServiceId,
         string ServiceName,
-        long MaxStores,
+        long FlagVariants,
         ScoreboardFirstBlood[] FirstBloods);
 
     public record ScoreboardFirstBlood(
         long TeamId,
+        string TeamName,
         string Timestamp,
-        double TimeEpoch,
         long RoundId,
-        string? StoreDescription,
-        long StoreIndex);
-
-    public record ScoreboardTeam(
-        string Name,
-        long TeamId,
-        string? LogoUrl,
-        string? CountryCode,
-        double TotalPoints,
-        double AttackPoints,
-        double LostDefensePoints,
-        double ServiceLevelAgreementPoints,
-        ScoreboardTeamDetails[] ServiceDetails);
-
-    public record ScoreboardTeamDetails(
-        long ServiceId,
-        double AttackPoints,
-        double LostDefensePoints,
-        double ServiceLevelAgreementPoints,
-        ServiceStatus ServiceStatus,
-        string? Message);
+        long FlagVariantId);
 }
diff --git a/EnoCore/Scoreboard/ScoreboardInfo.cs b/EnoCore/Scoreboard/ScoreboardInfo.cs
diff --git a/EnoDatabase/EnoDatabase.Scoring.cs b/EnoDatabase/EnoDatabase.Scoring.cs
@@ -213,10 +213,10 @@ public async Task<Scoreboard> GetCurrentScoreboard(long roundId)
 
             foreach (var service in services)
             {
-                var firstBloods = new SubmittedFlag[service.FlagStores];
+                var firstBloods = new SubmittedFlag[service.FlagVariants];
                 for (int i = 0; i < service.FlagsPerRound; i++)
                 {
-                    var storeId = i % service.FlagStores;
+                    var storeId = i % service.FlagVariants;
                     var fb = await this.context.SubmittedFlags
                         .Where(sf => sf.FlagServiceId == service.Id)
                         .Where(sf => sf.FlagRoundOffset == i)
@@ -242,11 +242,10 @@ public async Task<Scoreboard> GetCurrentScoreboard(long roundId)
                         .Where(sf => sf != null)
                         .Select(sf => new ScoreboardFirstBlood(
                             sf.AttackerTeamId,
+                            string.Empty, // TODO
                             sf.Timestamp.ToString(EnoCoreUtil.DateTimeFormat),
-                            EnoCoreUtil.SecondsSinceEpoch(sf.Timestamp),
                             sf.RoundId,
-                            null,
-                            sf.FlagRoundOffset % service.FlagStores))
+                            sf.FlagRoundOffset % service.FlagVariants))
                         .ToArray()));
             }
 
@@ -264,7 +263,7 @@ public async Task<Scoreboard> GetCurrentScoreboard(long roundId)
                     team.DefensePoints,
                     team.ServiceLevelAgreementPoints,
                     team.TeamServicePoints.Select(
-                        tsp => new ScoreboardTeamDetails(
+                        tsp => new ScoreboardTeamServiceDetails(
                             tsp.ServiceId,
                             tsp.AttackPoints,
                             tsp.DefensePoints,
@@ -279,9 +278,8 @@ public async Task<Scoreboard> GetCurrentScoreboard(long roundId)
             var scoreboard = new Scoreboard(
                 roundId,
                 round?.Begin.ToString(EnoCoreUtil.DateTimeFormat),
-                round?.Begin.Subtract(DateTime.UnixEpoch).TotalSeconds,
                 round?.End.ToString(EnoCoreUtil.DateTimeFormat),
-                round?.End.Subtract(DateTime.UnixEpoch).TotalSeconds,
+                string.Empty, // TODO
                 scoreboardServices.ToArray(),
                 scoreboardTeams.ToArray());
             this.logger.LogInformation($"{nameof(this.GetCurrentScoreboard)} Finished after: {sw.ElapsedMilliseconds}ms");
diff --git a/EnoDatabase/EnoDatabase.cs b/EnoDatabase/EnoDatabase.cs
diff --git a/EnoEngine/Program.cs b/EnoEngine/Program.cs
diff --git a/EnoLauncher/Program.cs b/EnoLauncher/Program.cs
diff --git a/FlagShooter/Program.cs b/FlagShooter/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -63,27 +63,27 @@ public async Task<IActionResult> Flag([FromBody] CheckerTaskMessage ctm)`
`63`	`63`	`throw new Exception("invalid method");`
`64`	`64`	`}`
`65`	`65`
`66`		`- this.logger.LogInformation($"Task {ctm.RunId} succeeded");`
	`66`	`+ this.logger.LogInformation($"Task {ctm.TaskId} succeeded");`
`67`	`67`	`return this.Json(new CheckerResultMessage(CheckerResult.OK, null));`
`68`	`68`	`}`
`69`	`69`	`catch (OperationCanceledException)`
`70`	`70`	`{`
`71`		`- this.logger.LogWarning($"Task {ctm.RunId} was cancelled");`
	`71`	`+ this.logger.LogWarning($"Task {ctm.TaskId} was cancelled");`
`72`	`72`	`return this.Json(new CheckerResultMessage(CheckerResult.OFFLINE, null));`
`73`	`73`	`}`
`74`	`74`	`catch (MumbleException e)`
`75`	`75`	`{`
`76`		`- this.logger.LogWarning($"Task {ctm.RunId} has failed: {e.ToFancyString()}");`
	`76`	`+ this.logger.LogWarning($"Task {ctm.TaskId} has failed: {e.ToFancyString()}");`
`77`	`77`	`return this.Json(new CheckerResultMessage(CheckerResult.MUMBLE, e.Message));`
`78`	`78`	`}`
`79`	`79`	`catch (OfflineException e)`
`80`	`80`	`{`
`81`		`- this.logger.LogWarning($"Task {ctm.RunId} has failed: {e.ToFancyString()}");`
	`81`	`+ this.logger.LogWarning($"Task {ctm.TaskId} has failed: {e.ToFancyString()}");`
`82`	`82`	`return this.Json(new CheckerResultMessage(CheckerResult.OFFLINE, e.Message));`
`83`	`83`	`}`
`84`	`84`	`catch (Exception e)`
`85`	`85`	`{`
`86`		`- this.logger.LogError($"Task {ctm.RunId} has failed: {e.ToFancyString()}");`
	`86`	`+ this.logger.LogError($"Task {ctm.TaskId} has failed: {e.ToFancyString()}");`
`87`	`87`	`return this.Json(new CheckerResultMessage(CheckerResult.INTERNAL_ERROR, null));`
`88`	`88`	`}`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public static CheckerTaskLaunchMessage FromCheckerTask(CheckerTask task)`
`31`	`31`	`task.CurrentRoundId,`
`32`	`32`	`task.ServiceName,`
`33`	`33`	`task.Method.ToString(),`
`34`		`- task.TaskIndex);`
	`34`	`+ task.UniqueVariantId);`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`@@ -50,7 +50,7 @@ public static CheckerTaskFinishedMessage FromCheckerTask(CheckerTask task)`
`50`	`50`	`task.CurrentRoundId,`
`51`	`51`	`task.ServiceName,`
`52`	`52`	`task.Method.ToString(),`
`53`		`- task.TaskIndex,`
	`53`	`+ task.UniqueVariantId,`
`54`	`54`	`(DateTime.UtcNow - task.StartTime).TotalSeconds,`
`55`	`55`	`task.CheckerResult.ToString());`
`56`	`56`	`}`