Allow Sashimi to contribute well-known variables

source/Sashimi.Aws.Accounts/AmazonWebServicesAccountDetails.cs

@@ -30,8 +30,8 @@ public override IEnumerable<Variable> ExpandVariable(Variable variable)
 
         public override IEnumerable<Variable> ContributeVariables()
         {
-            yield return new Variable(SpecialVariables.Action.Amazon.AccessKey, AccessKey);
-            yield return new Variable(SpecialVariables.Action.Amazon.SecretKey, SecretKey);
+            yield return new Variable(KnownVariables.Action.Aws.AccessKey, AccessKey);
+            yield return new Variable(KnownVariables.Action.Aws.SecretKey, SecretKey);
         }
 
         public bool CanExpand(string id, string referencedEntityId)

source/Sashimi.Aws.Accounts/AmazonWebServicesAccountModule.cs

@@ -1,14 +1,19 @@
 using Autofac;
 using Octopus.Server.Extensibility.Extensions.Mappings;
 using Sashimi.Server.Contracts.Accounts;
+using Sashimi.Server.Contracts.Variables;
 
 namespace Sashimi.Aws.Accounts
 {
     public class AmazonWebServicesAccountModule : Module
     {
         protected override void Load(ContainerBuilder builder)
         {
-            builder.RegisterType<AmazonWebServicesAccountTypeProvider>().As<IAccountTypeProvider>().As<IContributeMappings>().SingleInstance();
+            builder.RegisterType<AmazonWebServicesAccountTypeProvider>()
+                   .As<IAccountTypeProvider>()
+                   .As<IContributeMappings>()
+                   .As<IContributeWellKnownVariables>()
+                   .SingleInstance();
         }
     }
 }

source/Sashimi.Aws.Accounts/AmazonWebServicesAccountTypeProvider.cs

@@ -5,6 +5,7 @@
 using Octopus.Server.Extensibility.HostServices.Mapping;
 using Sashimi.Server.Contracts.Accounts;
 using Sashimi.Server.Contracts.ServiceMessages;
+using Sashimi.Server.Contracts.Variables;
 
 namespace Sashimi.Aws.Accounts
 {
@@ -28,5 +29,16 @@ public void BuildMappings(IResourceMappingsBuilder builder)
         {
             builder.Map<AmazonWebServicesAccountResource, AmazonWebServicesAccountDetails>();
         }
+
+        public IEnumerable<string> GetUserVisibleWellKnownVariables()
+        {
+            yield return KnownVariables.Action.Aws.AccessKey;
+            yield return KnownVariables.Action.Aws.SecretKey;
+        }
+
+        public IEnumerable<WellKnownVariableAliasMapping> GetVariablesWithAliases()
+        {
+            yield break;
+        }
     }
 }

source/Sashimi.Aws.Accounts/SpecialVariables.cs → source/Sashimi.Aws.Accounts/KnownVariables.cs

@@ -1,18 +1,16 @@
+using Sashimi.Server.Contracts.Variables;
+
 namespace Sashimi.Aws.Accounts
 {
-    public class SpecialVariables
+    public class KnownVariables
     {
         public static class Action
         {
-            //We will make this public once we remove the Server version (we need to contribute these special variables via IContributeSpecialVariables)
-            internal static class Amazon
+            public static class Aws
             {
                 public static readonly string AccessKey = "Octopus.Action.Amazon.AccessKey";
                 public static readonly string SecretKey = "Octopus.Action.Amazon.SecretKey";
-            }
 
-            public static class Aws
-            {
                 public static readonly string AccountId = "Octopus.Action.AwsAccount.Variable";
                 public static readonly string UseInstanceRole = "Octopus.Action.AwsAccount.UseInstanceRole";
                 public static readonly string AwsRegion = "Octopus.Action.Aws.Region";

source/Sashimi.Azure.Accounts/AzureServicePrincipalAccountTypeProvider.cs

@@ -6,6 +6,7 @@
 using Octopus.Server.Extensibility.HostServices.Mapping;
 using Sashimi.Server.Contracts.Accounts;
 using Sashimi.Server.Contracts.ServiceMessages;
+using Sashimi.Server.Contracts.Variables;
 
 namespace Sashimi.Azure.Accounts
 {
@@ -34,5 +35,15 @@ public void BuildMappings(IResourceMappingsBuilder builder)
         {
             builder.Map<AzureServicePrincipalAccountResource, AzureServicePrincipalAccountDetails>();
         }
+
+        public IEnumerable<string> GetUserVisibleWellKnownVariables()
+        {
+            yield break;
+        }
+
+        public IEnumerable<WellKnownVariableAliasMapping> GetVariablesWithAliases()
+        {
+            yield break;
+        }
     }
 }

source/Sashimi.Azure.Accounts/SpecialVariables.cs

@@ -1,3 +1,5 @@
+using Sashimi.Server.Contracts.Variables;
+
 namespace Sashimi.Azure.Accounts
 {
     class SpecialVariables

source/Sashimi.AzureCloudService/AzureSubscriptionTypeProvider.cs

@@ -5,6 +5,7 @@
 using Octopus.Server.Extensibility.HostServices.Mapping;
 using Sashimi.Server.Contracts.Accounts;
 using Sashimi.Server.Contracts.ServiceMessages;
+using Sashimi.Server.Contracts.Variables;
 
 namespace Sashimi.AzureCloudService
 {
@@ -28,5 +29,15 @@ public void BuildMappings(IResourceMappingsBuilder builder)
         {
             builder.Map<AzureSubscriptionAccountResource, AzureSubscriptionDetails>();
         }
+
+        public IEnumerable<string> GetUserVisibleWellKnownVariables()
+        {
+            yield break;
+        }
+
+        public IEnumerable<WellKnownVariableAliasMapping> GetVariablesWithAliases()
+        {
+            yield break;
+        }
     }
 }

source/Server.Contracts/Accounts/IAccountTypeProvider.cs

@@ -3,10 +3,11 @@
 using FluentValidation;
 using Octopus.Server.Extensibility.Extensions.Mappings;
 using Sashimi.Server.Contracts.ServiceMessages;
+using Sashimi.Server.Contracts.Variables;
 
 namespace Sashimi.Server.Contracts.Accounts
 {
-    public interface IAccountTypeProvider: IContributeMappings
+    public interface IAccountTypeProvider: IContributeMappings, IContributeWellKnownVariables
     {
         AccountType AccountType { get; }
         Type ModelType { get; }

source/Server.Contracts/Variables/IContributeWellKnownVariables.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Sashimi.Server.Contracts.Variables
+{
+    public interface IContributeWellKnownVariables
+    {
+        //IEnumerable<WellKnownVariable> GetWellKnownVariables();
+        IEnumerable<string> GetUserVisibleWellKnownVariables();
+        IEnumerable<WellKnownVariableAliasMapping> GetVariablesWithAliases();
+    }
+
+    public class WellKnownVariableAliasMapping
+    {
+        public WellKnownVariableAliasMapping(string currentName, params string[] aliases)
+        {
+            CurrentName = currentName;
+            Aliases = aliases;
+        }
+
+        public string CurrentName { get; }
+        public IEnumerable<string> Aliases { get; }
+
+        protected bool Equals(WellKnownVariableAliasMapping other)
+        {
+            return CurrentName == other.CurrentName && Aliases.SequenceEqual(other.Aliases); //Strict
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj))
+                return false;
+            if (ReferenceEquals(this, obj))
+                return true;
+            if (obj.GetType() != this.GetType())
+                return false;
+            return Equals((WellKnownVariableAliasMapping) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(CurrentName, Aliases);
+        }
+
+        public static bool operator ==(WellKnownVariableAliasMapping? left, WellKnownVariableAliasMapping? right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(WellKnownVariableAliasMapping? left, WellKnownVariableAliasMapping? right)
+        {
+            return !Equals(left, right);
+        }
+    }
+}

source/Server.Contracts/Variables/Variable.cs

@@ -4,18 +4,33 @@ namespace Sashimi.Server.Contracts.Variables
 {
     public class Variable
     {
+        public Variable(WellKnownVariable wellKnownVariable, string? value)
+            : this(wellKnownVariable.Name, value, VariableType.String)
+        {
+        }
+
         public Variable(string name, string? value)
             : this(name, value, VariableType.String)
         {
         }
 
+        public Variable(WellKnownVariable wellKnownVariable, string? value, VariableType type)
+            : this(wellKnownVariable.Name, value, type)
+        {
+        }
+
         public Variable(string name, string? value, VariableType type)
         {
             Name = name;
             Value = value;
             Type = type;
         }
 
+        public Variable(WellKnownVariable wellKnownVariable, SensitiveString? value)
+            : this(wellKnownVariable.Name, value)
+        {
+        }
+
         public Variable(string name, SensitiveString? value)
         {
             Name = name;

source/Server.Contracts/Variables/WellKnownVariable.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Sashimi.Server.Contracts.Variables
+{
+    public class WellKnownVariable
+    {
+        public WellKnownVariable(string name, Visibility visibility = Visibility.Hidden, params string[] aliases)
+        {
+            Name = name;
+            Aliases = aliases;
+            Visibility = visibility;
+        }
+
+        public string Name { get; }
+        public IEnumerable<string> Aliases { get; }
+        public Visibility Visibility { get; }
+
+        protected bool Equals(WellKnownVariable other)
+        {
+            return Name == other.Name
+                   && Aliases.SequenceEqual(other.Aliases) //This is stricter than it needs to be but we're unlikely to even have more than 1 alias
+                   && Visibility == other.Visibility;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj))
+                return false;
+            if (ReferenceEquals(this, obj))
+                return true;
+            if (obj.GetType() != this.GetType())
+                return false;
+            return Equals((WellKnownVariable)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Name, Aliases, (int)Visibility);
+        }
+
+        public static bool operator ==(WellKnownVariable? left, WellKnownVariable? right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(WellKnownVariable? left, WellKnownVariable? right)
+        {
+            return !Equals(left, right);
+        }
+
+        public static implicit operator string?(WellKnownVariable? wellKnownVariable)
+        {
+            return wellKnownVariable?.Name;
+        }
+
+        //Override ToString() because these used to be constants, so we want to retain this behaviour in case we are constructing a string somewhere
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+
+    public enum Visibility
+    {
+        Visible,
+        Hidden
+    }
+}