fix bug in workload history recorder (#42536)

marcpopMSFT · web-flow · commit 83f146d839a5 · 2024-08-13T14:02:59.000-07:00
diff --git a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs
@@ -39,7 +39,7 @@ internal static string GetWorkloadsVersion(WorkloadInfoHelper workloadInfoHelper
         {
             workloadInfoHelper ??= new WorkloadInfoHelper(false);
 
-            return workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
+            return workloadInfoHelper.ManifestProvider.GetWorkloadVersion().Version;
         }
 
         internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadInfoHelper workloadInfoHelper = null, IReporter reporter = null, string dotnetDir = null, bool showVersion = true)
@@ -59,7 +59,7 @@ internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadI
 
             if (showVersion)
             {
-                reporter.WriteLine($" Workload version: {workloadInfoHelper.ManifestProvider.GetWorkloadVersion()}");
+                reporter.WriteLine($" Workload version: {workloadInfoHelper.ManifestProvider.GetWorkloadVersion().Version}");
             }
 
             var useWorkloadSets = InstallStateContents.FromPath(Path.Combine(WorkloadInstallType.GetInstallStateFolder(workloadInfoHelper._currentSdkFeatureBand, workloadInfoHelper.UserLocalPath), "default.json")).UseWorkloadSets;
diff --git a/src/Cli/dotnet/commands/dotnet-workload/WorkloadHistoryRecorder.cs b/src/Cli/dotnet/commands/dotnet-workload/WorkloadHistoryRecorder.cs
@@ -54,15 +54,16 @@ public void Run(Action workloadAction)
         private WorkloadHistoryState GetWorkloadState()
         {
             var resolver = _workloadResolverFunc();
-            var currentWorkloadInfo = resolver.GetWorkloadVersion();
+            var currentWorkloadVersion = resolver.GetWorkloadVersion();
+            var versionString = currentWorkloadVersion.WorkloadInstallType == WorkloadVersion.Type.LooseManifest ? string.Empty : currentWorkloadVersion.Version;
             return new WorkloadHistoryState()
             {
                 ManifestVersions = resolver.GetInstalledManifests().ToDictionary(manifest => manifest.Id.ToString(), manifest => $"{manifest.Version}/{manifest.ManifestFeatureBand}"),
                 InstalledWorkloads = _workloadInstaller.GetWorkloadInstallationRecordRepository()
                                                        .GetInstalledWorkloads(new SdkFeatureBand(_workloadResolver.GetSdkFeatureBand()))
                                                        .Select(id => id.ToString())
                                                        .ToList(),
-                WorkloadSetVersion = resolver.GetWorkloadVersion()
+                WorkloadSetVersion = versionString
             };
 
         }
diff --git a/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommand.cs b/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommand.cs
@@ -93,7 +93,7 @@ public override int Execute()
                     }
                     else
                     {
-                        Reporter.WriteLine(string.Format(LocalizableStrings.WorkloadSetVersion, _workloadListHelper.WorkloadResolver.GetWorkloadVersion() ?? "unknown"));
+                        Reporter.WriteLine(string.Format(LocalizableStrings.WorkloadSetVersion, _workloadListHelper.WorkloadResolver.GetWorkloadVersion().Version ?? "unknown"));
                     }
 
                     Reporter.WriteLine();
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/IWorkloadManifestProvider.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/IWorkloadManifestProvider.cs
@@ -14,8 +14,20 @@ public interface IWorkloadManifestProvider
 
         string GetSdkFeatureBand();
 
-        string? GetWorkloadVersion();
+        WorkloadVersion GetWorkloadVersion();
 
         Dictionary<string, WorkloadSet> GetAvailableWorkloadSets();
     }
+
+    public record WorkloadVersion
+    {
+        public enum Type
+        {
+            WorkloadSet,
+            LooseManifest
+        }
+
+        public string? Version;
+        public Type WorkloadInstallType;
+    }
 }
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/IWorkloadResolver.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/IWorkloadResolver.cs
@@ -20,7 +20,7 @@ public interface IWorkloadResolver
         string GetManifestFeatureBand(string manifestId);
         IEnumerable<WorkloadManifestInfo> GetInstalledManifests();
         string GetSdkFeatureBand();
-        string? GetWorkloadVersion();
+        WorkloadVersion GetWorkloadVersion();
         IEnumerable<WorkloadId> GetUpdatedWorkloads(WorkloadResolver advertisingManifestResolver, IEnumerable<WorkloadId> installedWorkloads);
         WorkloadManifest GetManifestFromWorkload(WorkloadId workloadId);
 
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/SdkDirectoryWorkloadManifestProvider.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/SdkDirectoryWorkloadManifestProvider.cs
@@ -243,18 +243,26 @@ void ThrowExceptionIfManifestsNotAvailable()
             }
         }
 
-        public string? GetWorkloadVersion()
+        public WorkloadVersion GetWorkloadVersion()
         {
             if (_globalJsonWorkloadSetVersion != null)
             {
-                return _globalJsonWorkloadSetVersion;
+                return new WorkloadVersion()
+                {
+                    Version = _globalJsonWorkloadSetVersion,
+                    WorkloadInstallType = WorkloadVersion.Type.WorkloadSet
+                };
             }
 
             ThrowExceptionIfManifestsNotAvailable();
 
             if (_workloadSet?.Version is not null)
             {
-                return _workloadSet?.Version!;
+                return new WorkloadVersion()
+                {
+                    Version = _workloadSet.Version,
+                    WorkloadInstallType = WorkloadVersion.Type.WorkloadSet
+                };
             }
 
             using (SHA256 sha256Hash = SHA256.Create())
@@ -271,7 +279,11 @@ void ThrowExceptionIfManifestsNotAvailable()
                     sb.Append(bytes[b].ToString("x2"));
                 }
 
-                return $"{_sdkVersionBand.ToStringWithoutPrerelease()}-manifests.{sb}";
+                return new WorkloadVersion()
+                {
+                    Version = $"{_sdkVersionBand.ToStringWithoutPrerelease()}-manifests.{sb}",
+                    WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+                };
             }
         }
 
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/TempDirectoryWorkloadManifestProvider.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/TempDirectoryWorkloadManifestProvider.cs
@@ -53,7 +53,11 @@ public IEnumerable<string> GetManifestDirectories()
         }
 
         public string GetSdkFeatureBand() => _sdkVersionBand;
-        public string? GetWorkloadVersion() => _sdkVersionBand.ToString() + ".2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+        {
+            Version = _sdkVersionBand + ".2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
         public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => new();
     }
 }
diff --git a/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/WorkloadResolver.cs b/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/WorkloadResolver.cs
@@ -115,7 +115,7 @@ public void RefreshWorkloadManifests()
             InitializeManifests();
         }
 
-        public string? GetWorkloadVersion() => _manifestProvider.GetWorkloadVersion();
+        public WorkloadVersion GetWorkloadVersion() => _manifestProvider.GetWorkloadVersion();
 
         private void LoadManifestsFromProvider(IWorkloadManifestProvider manifestProvider)
         {
@@ -778,7 +778,11 @@ public void RefreshWorkloadManifests() { }
             public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => new();
             public IEnumerable<ReadableWorkloadManifest> GetManifests() => Enumerable.Empty<ReadableWorkloadManifest>();
             public string GetSdkFeatureBand() => _sdkFeatureBand;
-            public string? GetWorkloadVersion() => _sdkFeatureBand.ToString() + ".2";
+            public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+            {
+                Version = _sdkFeatureBand + ".2",
+                WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+            };
         }
     }
 
diff --git a/test/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/FakeManifestProvider.cs b/test/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/FakeManifestProvider.cs
@@ -40,7 +40,11 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()
 
         public string GetSdkFeatureBand() => "8.0.100";
         public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => throw new NotImplementedException();
-        public string? GetWorkloadVersion() => "8.0.100.2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+                                                           {
+                                                               Version = "8.0.100.2",
+                                                               WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+                                                           };
     }
 
     internal class InMemoryFakeManifestProvider : IWorkloadManifestProvider, IEnumerable<(string id, string content)>
@@ -67,6 +71,10 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()
         IEnumerator IEnumerable.GetEnumerator() => throw new NotImplementedException();
         public string GetSdkFeatureBand() => "8.0.100";
         public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => throw new NotImplementedException();
-        public string? GetWorkloadVersion() => "8.0.100.2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+        {
+            Version = "8.0.100.2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
     }
 }
diff --git a/test/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/SdkDirectoryWorkloadManifestProviderTests.cs b/test/Microsoft.NET.Sdk.WorkloadManifestReader.Tests/SdkDirectoryWorkloadManifestProviderTests.cs
@@ -93,14 +93,14 @@ var sdkDirectoryWorkloadManifestProvider
 
             if (useWorkloadSet)
             {
-                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Should().Be("8.0.200");
+                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Version.Should().Be("8.0.200");
             }
             else
             {
                 string[] manifests = sdkDirectoryWorkloadManifestProvider.GetManifests().OrderBy(m => m.ManifestId).Select(m => $"{m.ManifestId}.{m.ManifestFeatureBand}.{m.ManifestVersion}").ToArray();
                 manifests.Length.Should().Be(1);
                 manifests.Should().Contain("android.8.0.200.33.0.2-rc.1");
-                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Should().Be("8.0.200-manifests.4ba11739");
+                sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Version.Should().Be("8.0.200-manifests.4ba11739");
             }
 
             Directory.Delete(Path.Combine(_manifestRoot, "8.0.100"), recursive: true);
diff --git a/test/dotnet-workload-install.Tests/MockManifestProvider.cs b/test/dotnet-workload-install.Tests/MockManifestProvider.cs
@@ -48,6 +48,10 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()
         }
 
         public string GetSdkFeatureBand() => SdkFeatureBand.ToString();
-        public string GetWorkloadVersion() => SdkFeatureBand.ToString() + ".2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion
+        {
+            Version = GetSdkFeatureBand() + ".2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
     }
 }
diff --git a/test/dotnet-workload-search.Tests/MockWorkloadResolver.cs b/test/dotnet-workload-search.Tests/MockWorkloadResolver.cs
@@ -39,7 +39,11 @@ public void RefreshWorkloadManifests() { /* noop */ }
         public IEnumerable<WorkloadManifestInfo> GetInstalledManifests() => _installedManifests ?? throw new NotImplementedException();
         public IWorkloadResolver CreateOverlayResolver(IWorkloadManifestProvider overlayManifestProvider) => throw new NotImplementedException();
         public string GetSdkFeatureBand() => "12.0.400";
-        public string GetWorkloadVersion() => "12.0.400.2";
+        public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion()
+        {
+            Version = "12.0.400.2",
+            WorkloadInstallType = WorkloadVersion.Type.LooseManifest
+        };
         public IEnumerable<WorkloadId> GetUpdatedWorkloads(WorkloadResolver advertisingManifestResolver, IEnumerable<WorkloadId> installedWorkloads) => throw new NotImplementedException();
         WorkloadResolver IWorkloadResolver.CreateOverlayResolver(IWorkloadManifestProvider overlayManifestProvider) => throw new NotImplementedException();
         WorkloadManifest IWorkloadResolver.GetManifestFromWorkload(WorkloadId workloadId) => throw new NotImplementedException();

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ internal static string GetWorkloadsVersion(WorkloadInfoHelper workloadInfoHelper`
`39`	`39`	`{`
`40`	`40`	`workloadInfoHelper ??= new WorkloadInfoHelper(false);`
`41`	`41`
`42`		`- return workloadInfoHelper.ManifestProvider.GetWorkloadVersion();`
	`42`	`+ return workloadInfoHelper.ManifestProvider.GetWorkloadVersion().Version;`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadInfoHelper workloadInfoHelper = null, IReporter reporter = null, string dotnetDir = null, bool showVersion = true)`
`@@ -59,7 +59,7 @@ internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadI`
`59`	`59`
`60`	`60`	`if (showVersion)`
`61`	`61`	`{`
`62`		`- reporter.WriteLine($" Workload version: {workloadInfoHelper.ManifestProvider.GetWorkloadVersion()}");`
	`62`	`+ reporter.WriteLine($" Workload version: {workloadInfoHelper.ManifestProvider.GetWorkloadVersion().Version}");`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`var useWorkloadSets = InstallStateContents.FromPath(Path.Combine(WorkloadInstallType.GetInstallStateFolder(workloadInfoHelper._currentSdkFeatureBand, workloadInfoHelper.UserLocalPath), "default.json")).UseWorkloadSets;`
Original file line number	Diff line number	Diff line change
`@@ -54,15 +54,16 @@ public void Run(Action workloadAction)`
`54`	`54`	`private WorkloadHistoryState GetWorkloadState()`
`55`	`55`	`{`
`56`	`56`	`var resolver = _workloadResolverFunc();`
`57`		`- var currentWorkloadInfo = resolver.GetWorkloadVersion();`
	`57`	`+ var currentWorkloadVersion = resolver.GetWorkloadVersion();`
	`58`	`+ var versionString = currentWorkloadVersion.WorkloadInstallType == WorkloadVersion.Type.LooseManifest ? string.Empty : currentWorkloadVersion.Version;`
`58`	`59`	`return new WorkloadHistoryState()`
`59`	`60`	`{`
`60`	`61`	`ManifestVersions = resolver.GetInstalledManifests().ToDictionary(manifest => manifest.Id.ToString(), manifest => $"{manifest.Version}/{manifest.ManifestFeatureBand}"),`
`61`	`62`	`InstalledWorkloads = _workloadInstaller.GetWorkloadInstallationRecordRepository()`
`62`	`63`	`.GetInstalledWorkloads(new SdkFeatureBand(_workloadResolver.GetSdkFeatureBand()))`
`63`	`64`	`.Select(id => id.ToString())`
`64`	`65`	`.ToList(),`
`65`		`- WorkloadSetVersion = resolver.GetWorkloadVersion()`
	`66`	`+ WorkloadSetVersion = versionString`
`66`	`67`	`};`
`67`	`68`
`68`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ public override int Execute()`
`93`	`93`	`}`
`94`	`94`	`else`
`95`	`95`	`{`
`96`		`- Reporter.WriteLine(string.Format(LocalizableStrings.WorkloadSetVersion, _workloadListHelper.WorkloadResolver.GetWorkloadVersion() ?? "unknown"));`
	`96`	`+ Reporter.WriteLine(string.Format(LocalizableStrings.WorkloadSetVersion, _workloadListHelper.WorkloadResolver.GetWorkloadVersion().Version ?? "unknown"));`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`Reporter.WriteLine();`
Original file line number	Diff line number	Diff line change
`@@ -243,18 +243,26 @@ void ThrowExceptionIfManifestsNotAvailable()`
`243`	`243`	`}`
`244`	`244`	`}`
`245`	`245`
`246`		`- public string? GetWorkloadVersion()`
	`246`	`+ public WorkloadVersion GetWorkloadVersion()`
`247`	`247`	`{`
`248`	`248`	`if (_globalJsonWorkloadSetVersion != null)`
`249`	`249`	`{`
`250`		`- return _globalJsonWorkloadSetVersion;`
	`250`	`+ return new WorkloadVersion()`
	`251`	`+ {`
	`252`	`+ Version = _globalJsonWorkloadSetVersion,`
	`253`	`+ WorkloadInstallType = WorkloadVersion.Type.WorkloadSet`
	`254`	`+ };`
`251`	`255`	`}`
`252`	`256`
`253`	`257`	`ThrowExceptionIfManifestsNotAvailable();`
`254`	`258`
`255`	`259`	`if (_workloadSet?.Version is not null)`
`256`	`260`	`{`
`257`		`- return _workloadSet?.Version!;`
	`261`	`+ return new WorkloadVersion()`
	`262`	`+ {`
	`263`	`+ Version = _workloadSet.Version,`
	`264`	`+ WorkloadInstallType = WorkloadVersion.Type.WorkloadSet`
	`265`	`+ };`
`258`	`266`	`}`
`259`	`267`
`260`	`268`	`using (SHA256 sha256Hash = SHA256.Create())`
`@@ -271,7 +279,11 @@ void ThrowExceptionIfManifestsNotAvailable()`
`271`	`279`	`sb.Append(bytes[b].ToString("x2"));`
`272`	`280`	`}`
`273`	`281`
`274`		`- return $"{_sdkVersionBand.ToStringWithoutPrerelease()}-manifests.{sb}";`
	`282`	`+ return new WorkloadVersion()`
	`283`	`+ {`
	`284`	`+ Version = $"{_sdkVersionBand.ToStringWithoutPrerelease()}-manifests.{sb}",`
	`285`	`+ WorkloadInstallType = WorkloadVersion.Type.LooseManifest`
	`286`	`+ };`
`275`	`287`	`}`
`276`	`288`	`}`
`277`	`289`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,11 @@ public IEnumerable<string> GetManifestDirectories()`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`public string GetSdkFeatureBand() => _sdkVersionBand;`
`56`		`- public string? GetWorkloadVersion() => _sdkVersionBand.ToString() + ".2";`
	`56`	`+ public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion`
	`57`	`+ {`
	`58`	`+ Version = _sdkVersionBand + ".2",`
	`59`	`+ WorkloadInstallType = WorkloadVersion.Type.LooseManifest`
	`60`	`+ };`
`57`	`61`	`public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => new();`
`58`	`62`	`}`
`59`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ public void RefreshWorkloadManifests()`
`115`	`115`	`InitializeManifests();`
`116`	`116`	`}`
`117`	`117`
`118`		`- public string? GetWorkloadVersion() => _manifestProvider.GetWorkloadVersion();`
	`118`	`+ public WorkloadVersion GetWorkloadVersion() => _manifestProvider.GetWorkloadVersion();`
`119`	`119`
`120`	`120`	`private void LoadManifestsFromProvider(IWorkloadManifestProvider manifestProvider)`
`121`	`121`	`{`
`@@ -778,7 +778,11 @@ public void RefreshWorkloadManifests() { }`
`778`	`778`	`public Dictionary<string, WorkloadSet> GetAvailableWorkloadSets() => new();`
`779`	`779`	`public IEnumerable<ReadableWorkloadManifest> GetManifests() => Enumerable.Empty<ReadableWorkloadManifest>();`
`780`	`780`	`public string GetSdkFeatureBand() => _sdkFeatureBand;`
`781`		`- public string? GetWorkloadVersion() => _sdkFeatureBand.ToString() + ".2";`
	`781`	`+ public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion`
	`782`	`+ {`
	`783`	`+ Version = _sdkFeatureBand + ".2",`
	`784`	`+ WorkloadInstallType = WorkloadVersion.Type.LooseManifest`
	`785`	`+ };`
`782`	`786`	`}`
`783`	`787`	`}`
`784`	`788`
Original file line number	Diff line number	Diff line change
`@@ -93,14 +93,14 @@ var sdkDirectoryWorkloadManifestProvider`
`93`	`93`
`94`	`94`	`if (useWorkloadSet)`
`95`	`95`	`{`
`96`		`- sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Should().Be("8.0.200");`
	`96`	`+ sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Version.Should().Be("8.0.200");`
`97`	`97`	`}`
`98`	`98`	`else`
`99`	`99`	`{`
`100`	`100`	`string[] manifests = sdkDirectoryWorkloadManifestProvider.GetManifests().OrderBy(m => m.ManifestId).Select(m => $"{m.ManifestId}.{m.ManifestFeatureBand}.{m.ManifestVersion}").ToArray();`
`101`	`101`	`manifests.Length.Should().Be(1);`
`102`	`102`	`manifests.Should().Contain("android.8.0.200.33.0.2-rc.1");`
`103`		`- sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Should().Be("8.0.200-manifests.4ba11739");`
	`103`	`+ sdkDirectoryWorkloadManifestProvider.GetWorkloadVersion().Version.Should().Be("8.0.200-manifests.4ba11739");`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`Directory.Delete(Path.Combine(_manifestRoot, "8.0.100"), recursive: true);`
Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,10 @@ public IEnumerable<ReadableWorkloadManifest> GetManifests()`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`public string GetSdkFeatureBand() => SdkFeatureBand.ToString();`
`51`		`- public string GetWorkloadVersion() => SdkFeatureBand.ToString() + ".2";`
	`51`	`+ public WorkloadVersion GetWorkloadVersion() => new WorkloadVersion`
	`52`	`+ {`
	`53`	`+ Version = GetSdkFeatureBand() + ".2",`
	`54`	`+ WorkloadInstallType = WorkloadVersion.Type.LooseManifest`
	`55`	`+ };`
`52`	`56`	`}`
`53`	`57`	`}`