Support modern Octopus features added since repo last regularly maintained

.gitignore

@@ -8,4 +8,6 @@ make/psmake.*
 *.nupkg
 reports/
 wiki/
-Manual.md
+Manual.md
+.idea/
+launchSettings.json

Jenkinsfile

@@ -0,0 +1,28 @@
+pipeline {
+ agent any
+ environment {
+  dotnet = '"C:\\Program Files\\dotnet\\dotnet.exe"'
+ }
+ stages {
+  stage('Restore Packages') {
+   steps {
+    bat "$dotnet restore --configfile NuGet.Config"
+   }
+  }
+  stage('Clean') {
+   steps {
+    bat "$dotnet clean"
+   }
+  }
+  stage('Build') {
+   steps {
+    bat "$dotnet build --configuration Release"
+   }
+  }
+  stage('Publish') {
+   steps {
+    bat "$dotnet publish --configuration Release --runtime win-x64 --output \"E:/OctopusProjectBuilder/$env.BRANCH_NAME\""
+   }
+  }
+ }
+}

OctopusProjectBuilder.Console/OctopusProjectBuilder.Console.csproj

@@ -22,7 +22,7 @@
     <PackageReference Include="Common.Logging" Version="3.4.1" />
     <PackageReference Include="FluentCommandLineParser" Version="1.4.3" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.0.2" />
-    <PackageReference Include="Octopus.Client" Version="4.39.4" />
+    <PackageReference Include="Octopus.Client" Version="11.2.3274" />
   </ItemGroup>
 
   <ItemGroup>

OctopusProjectBuilder.Console/Options.cs

@@ -2,10 +2,12 @@
 {
     internal class Options
     {
-        public enum Verb { Upload, Download, CleanupConfig }
+        public enum Verb { Upload, Download, CleanupConfig, Validate }
         public string OctopusUrl { get; set; }
         public string OctopusApiKey { get; set; }
+        public string ProjectName { get; set; }
         public string DefinitionsDir { get; set; }
+        public bool Normalize { get; set; }
         public Verb Action { get; set; }
     }
 }

OctopusProjectBuilder.Console/Program.cs

@@ -1,12 +1,16 @@
 using System;
+using System.IO;
 using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
 using Fclp;
 using Microsoft.Extensions.Logging;
 using Octopus.Client;
+using Octopus.Client.Model;
+using OctopusProjectBuilder.Model;
 using OctopusProjectBuilder.Uploader;
 using OctopusProjectBuilder.YamlReader;
+using OctopusProjectBuilder.YamlReader.Model;
 
 namespace OctopusProjectBuilder.Console
 {
@@ -33,6 +37,8 @@ static int Main(string[] args)
                     DownloadDefinitions(options).GetAwaiter().GetResult();
                 else if (options.Action == Options.Verb.CleanupConfig)
                     CleanupConfig(options);
+                else if (options.Action == Options.Verb.Validate)
+                    ValidateConfig(options);
             }
             catch (Exception e)
             {
@@ -42,6 +48,11 @@ static int Main(string[] args)
             return 0;
         }
 
+        private static SystemModel ValidateConfig(Options options)
+        {
+            return new YamlSystemModelRepository(_loggerFactory).Load(options.DefinitionsDir);
+        }
+
         private static void CleanupConfig(Options options)
         {
             new YamlSystemModelRepository(_loggerFactory).CleanupConfig(options.DefinitionsDir);
@@ -55,10 +66,167 @@ private static async Task UploadDefinitions(Options options)
 
         private static async Task DownloadDefinitions(Options options)
         {
-            var model = await new ModelDownloader(await BuildRepository(options), _loggerFactory).DownloadModel();
-            new YamlSystemModelRepository(_loggerFactory).Save(model, options.DefinitionsDir);
+            var repository = await BuildRepository(options);
+            var model = await new ModelDownloader(repository, _loggerFactory)
+                .DownloadModel(options.ProjectName);
+
+            await new YamlSystemModelRepository(_loggerFactory).Save(model, options.DefinitionsDir, async yaml =>
+            {
+                if (options.Normalize && yaml.LibraryVariableSets != null)
+                {
+                    foreach (var libraryVariableSet in yaml.LibraryVariableSets
+                        .Where(x => model.Projects
+                            .Any(p => p.IncludedLibraryVariableSetRefs.Any(r => r.Name == x.Name))))
+                    {
+                        if (libraryVariableSet.ContentType != LibraryVariableSet.VariableSetContentType.ScriptModule)
+                        {
+                            continue;
+                        }
+
+                        YamlVariable contentType = libraryVariableSet.Variables
+                            .Where(v => v.Name == "Octopus.Script.Module.Language[" + libraryVariableSet.Name + "]")
+                            .FirstOrDefault();
+                        string extension;
+                        if (contentType == null)
+                        {
+                            extension = "script";
+                        }
+                        else
+                        {
+                            switch (contentType.Value)
+                            {
+                                case "PowerShell":
+                                    extension = "ps1";
+                                    break;
+                                default:
+                                    extension = "script";
+                                    break;
+                            }
+                        }
+
+                        YamlVariable content = libraryVariableSet.Variables
+                            .Where(v => v.Name == "Octopus.Script.Module[" + libraryVariableSet.Name + "]")
+                            .FirstOrDefault();
+                        if (contentType == null)
+                        {
+                            continue;
+                        }
+
+                        string path = Path.Combine(options.DefinitionsDir,
+                            "LibraryVariableSet_" + libraryVariableSet.Name + "." + extension);
+                        File.WriteAllText(path, content.Value);
+                        content.Value = null;
+                        content.File = path;
+                    }
+                }
+
+                // Massage model: reduce identification
+                if (options.Normalize && yaml.Projects != null)
+                {
+                    foreach (var project in yaml.Projects)
+                    {
+                        // Normalize IDs on project variable templates
+                        foreach (var variable in project.Templates)
+                        {
+                            variable.Id = null;
+                        }
+
+                        // Normalize deployment step templates
+                        foreach (var step in project.DeploymentProcess.Steps)
+                        {
+                            foreach (var action in step.Actions.Where(action =>
+                                action.Properties.Any(x => x.Key == "Octopus.Action.Template.Id")))
+                            {
+                                var actionTemplateId = action.Properties
+                                    .FirstOrDefault(property => property.Key == "Octopus.Action.Template.Id");
+                                var template =
+                                    await repository.ActionTemplates.Get(actionTemplateId.Value);
+                                var actionTemplateVersion = action.Properties
+                                    .FirstOrDefault(property => property.Key == "Octopus.Action.Template.Version");
+
+                                if (actionTemplateVersion != null)
+                                {
+                                    var templateVersion =
+                                        int.Parse(actionTemplateVersion.Value);
+                                    var versionedTemplate =
+                                        await repository.ActionTemplates.GetVersion(template, templateVersion);
+
+                                    action.Properties = action.Properties.Where(property =>
+                                            versionedTemplate.Properties.All(property2 =>
+                                                property2.Key != property.Key) &&
+                                            property.Key != "Octopus.Action.Template.Version")
+                                        .ToArray();
+                                }
+
+                                actionTemplateId.ValueType = "StepTemplateNameToId";
+                                actionTemplateId.Value = template.Name;
+                            }
+
+                            foreach (var action in step.Actions)
+                            {
+                                HandleSplitActionToFile(project.Name, action, options.DefinitionsDir);
+                            }
+                        }
+                    }
+                }
+            });
         }
 
+        private static void HandleSplitActionToFile(string projectName, YamlDeploymentAction action, string directory)
+        {
+            if (action.ActionType == "Octopus.Script")
+            {
+                var scriptSource = action.Properties
+                    .FirstOrDefault(property => property.Key == "Octopus.Action.Script.ScriptSource");
+                if (scriptSource == null)
+                {
+                    return;
+                }
+
+                var syntax = action.Properties
+                    .FirstOrDefault(property => property.Key == "Octopus.Action.Script.Syntax");
+                if (syntax == null)
+                {
+                    return;
+                }
+
+                string extension;
+                switch (syntax.Value)
+                {
+                    case "PowerShell":
+                        extension = "ps1";
+                        break;
+                    default:
+                        extension = "script";
+                        break;
+                }
+
+                var scriptBody = action.Properties
+                    .FirstOrDefault(property => property.Key == "Octopus.Action.Script.ScriptBody");
+                if (scriptBody == null)
+                {
+                    return;
+                }
+
+                string path = Path.Combine(directory, "Script_" + projectName + "_" + action.Name + "." + extension);
+                File.WriteAllText(path, scriptBody.Value);
+                scriptBody.Value = null;
+                scriptBody.File = path;
+            }
+            else if (action.ActionType == "Octopus.TentaclePackage")
+            {
+                foreach (var postDeploy in action.Properties
+                    .Where(property => property.Key.StartsWith("Octopus.Action.CustomScripts.")))
+                {
+                    string path = Path.Combine(directory, "Script_" + projectName + "_" + action.Name + "." +
+                                                          postDeploy.Key.Substring("Octopus.Action.CustomScripts.".Length));
+                    File.WriteAllText(path, postDeploy.Value);
+                    postDeploy.Value = null;
+                    postDeploy.File = path;
+                }
+            }
+        }
+
         private static async Task<OctopusAsyncRepository> BuildRepository(Options options)
         {
             return new OctopusAsyncRepository(
@@ -71,8 +239,10 @@ public static Options ReadOptions(string[] args)
             var parser = new FluentCommandLineParser<Options>();
             parser.Setup(o => o.Action).As('a', "action").Required().WithDescription($"Action to perform: {string.Join(", ", Enum.GetValues(typeof(Options.Verb)).Cast<object>())}");
             parser.Setup(o => o.DefinitionsDir).As('d', "definitions").Required().WithDescription("Definitions directory");
-            parser.Setup(o => o.OctopusUrl).As('u', "octopusUrl").Required().WithDescription("Octopus Url");
-            parser.Setup(o => o.OctopusApiKey).As('k', "octopusApiKey").Required().WithDescription("Octopus API key");
+            parser.Setup(o => o.OctopusUrl).As('u', "octopusUrl").WithDescription("Octopus Url");
+            parser.Setup(o => o.OctopusApiKey).As('k', "octopusApiKey").WithDescription("Octopus API key");
+            parser.Setup(o => o.ProjectName).As('p', "projectName").WithDescription("Project Name");
+            parser.Setup(o => o.Normalize).As('n', "normalize").SetDefault(true).WithDescription("Project Name");
             parser.SetupHelp("?", "help").Callback(text => System.Console.WriteLine(text));
 
             var result = parser.Parse(args);

OctopusProjectBuilder.DocGen/DocGenerator.cs

@@ -94,7 +94,14 @@ private static string GetPropertyDefaultValueText(PropertyInfo propertyInfo)
 
         private static string GetDefaultValueText(Type type)
         {
-            return type.IsValueType ? Activator.CreateInstance(type).ToString() : "null";
+            if (Nullable.GetUnderlyingType(type) == null)
+            {
+                return type.IsValueType ? Activator.CreateInstance(type).ToString() : "null";
+            }
+            else
+            {
+                return "null";
+            }
         }
 
         private static string GetDescription(MemberInfo memberInfo)

OctopusProjectBuilder.Model/Channel.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OctopusProjectBuilder.Model
+{
+    public class Channel
+    {
+        public Channel(ElementIdentifier identifier, string description, string projectName, bool? isDefault,
+            string lifecycleName, IEnumerable<ChannelVersionRule> versionRules, IEnumerable<ElementReference> tenantTags)
+        {
+            if (identifier == null)
+                throw new ArgumentNullException(nameof(identifier));
+
+            Identifier = identifier;
+            Description = description;
+            ProjectName = projectName;
+            IsDefault = isDefault;
+            LifecycleName = lifecycleName;
+            VersionRules = versionRules;
+            TenantTags = tenantTags.ToArray();
+        }
+
+        public ElementIdentifier Identifier { get; }
+        public string Description { get; set; }
+        public string ProjectName { get; set; }
+        public bool? IsDefault { get; set; }
+        public string LifecycleName { get; set; }
+        public IEnumerable<ChannelVersionRule> VersionRules { get; set; }
+        public IEnumerable<ElementReference> TenantTags { get; }
+
+        public override string ToString()
+        {
+            return Identifier.ToString();
+        }
+    }
+}

OctopusProjectBuilder.Model/ChannelVersionRule.cs

@@ -0,0 +1,19 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace OctopusProjectBuilder.Model
+{
+    public class ChannelVersionRule
+    {
+        public ChannelVersionRule(string tag, string versionRange, IEnumerable<ChannelVersionRulePackage> actionPackages)
+        {
+            Tag = tag;
+            VersionRange = versionRange;
+            ActionPackages = actionPackages;
+        }
+
+        public string Tag { get; set; }
+        public string VersionRange { get; set; }
+        public IEnumerable<ChannelVersionRulePackage> ActionPackages { get; set; }
+    }
+}

OctopusProjectBuilder.Model/ChannelVersionRulePackage.cs

@@ -0,0 +1,16 @@
+using Octopus.Client.Model;
+
+namespace OctopusProjectBuilder.Model
+{
+    public class ChannelVersionRulePackage
+    {
+        public string DeploymentAction { get; set; }
+        public string PackageReference { get; set; }
+
+        public ChannelVersionRulePackage(string deploymentAction, string packageReference)
+        {
+            DeploymentAction = deploymentAction;
+            PackageReference = packageReference;
+        }
+    }
+}