FtpServer provider support + runtime variables (#104)

* Added ftpserver implementation

Author: Carael

README.md

@@ -26,6 +26,7 @@ To get more detailed information about Squadron, go to the [Squadron Docs](https
 - [x] MariaDB
 - [x] Neo4j
 - [x] S3 with [Minio](https://github.com/minio/minio)
+- [x] FtpServer with [fauria/vsftpd](https://github.com/fauria/docker-vsftpd)
 
 ### Cloud Providers
 

src/Core/ContainerPortMapping.cs

@@ -10,12 +10,22 @@ public class ContainerPortMapping
         /// </summary>
         public int InternalPort { get; internal set; }
 
+        /// <summary>
+        /// Internal port that value will be resolved from variable
+        /// </summary>
+        public string InternalPortVariableName { get; internal set; }
+
         /// <summary>
         /// Gets the external port (Static).
         /// </summary>
         /// <value>
         /// The external port.
         /// </value>
         public int ExternalPort { get; internal set; }
+
+        /// <summary>
+        /// External port that value will be resolved from variable
+        /// </summary>
+        public string ExternalPortVariableName { get; internal set; }
     }
 }

src/Core/ContainerResourceBuilder.cs

@@ -181,11 +181,115 @@ public ContainerResourceBuilder AddPortMapping(int internalPort, int externalPor
             _options.AdditionalPortMappings.Add(
                 new ContainerPortMapping()
                 {
-                    ExternalPort = externalPort, InternalPort = internalPort
+                    ExternalPort = externalPort,
+                    InternalPort = internalPort
                 });
             return this;
         }
 
+        /// <summary>
+        /// If you only want to expose one port, please use <see cref="InternalPort"/> and
+        /// <see cref="ExternalPort"/> to so do!
+        /// Exposes additional port mappings for this container.
+        /// </summary>
+        /// <param name="internalPort">
+        /// The internal port of a container that shall be exposed.
+        /// </param>
+        /// <param name="externalPortVariableName">
+        /// The external port number will be resolved before the container creation and stored in
+        /// variable.
+        /// Only provide an external port if a static external port is required.
+        /// When the given external port is already in use by a container, the creation will fail.
+        /// </param>
+        /// <returns></returns>
+        public ContainerResourceBuilder AddPortMapping(
+            int internalPort,
+            string externalPortVariableName)
+        {
+            _options.AdditionalPortMappings.Add(
+                new ContainerPortMapping()
+                {
+                    InternalPort = internalPort,
+                    ExternalPortVariableName = externalPortVariableName,
+                });
+            return this;
+        }
+
+
+        /// <summary>
+        /// If you only want to expose one port, please use <see cref="InternalPort"/> and
+        /// <see cref="ExternalPort"/> to so do!
+        /// Exposes additional port mappings for this container.
+        /// </summary>
+        /// <param name="internalPortVariableName">
+        /// The internal port number will be resolved before the container creation and stored
+        /// in variable.
+        /// </param>
+        /// <param name="externalPort">
+        /// The external static port of a container that the internal port will be mapped to.
+        /// Defaults to 0, which will let the OS choose a free port for you.
+        ///
+        /// Only provide an external port if a static external port is required.
+        /// When the given external port is already in use by a container, the creation will fail.
+        /// </param>
+        /// <returns></returns>
+        public ContainerResourceBuilder AddPortMapping(
+            string internalPortVariableName,
+            int externalPort = 0)
+        {
+            _options.AdditionalPortMappings.Add(
+                new ContainerPortMapping()
+                {
+                    InternalPortVariableName = internalPortVariableName,
+                    ExternalPort = externalPort,
+                });
+            return this;
+        }
+
+        /// <summary>
+        /// If you only want to expose one port, please use <see cref="InternalPort"/> and
+        /// <see cref="ExternalPort"/> to so do!
+        /// Exposes additional port mappings for this container.
+        /// </summary>
+        /// <param name="internalPortVariableName">
+        /// The internal port number will be resolved before the container creation and stored
+        /// in variable.
+        /// </param>
+        /// <param name="externalPortVariableName">
+        /// The external port number will be resolved before the container creation and stored in
+        /// variable.
+        /// Only provide an external port if a static external port is required.
+        /// When the given external port is already in use by a container, the creation will fail.
+        /// </param>
+        /// <returns></returns>
+        public ContainerResourceBuilder AddPortMapping(
+            string internalPortVariableName,
+            string externalPortVariableName)
+        {
+            _options.AdditionalPortMappings.Add(
+                new ContainerPortMapping()
+                {
+                    InternalPortVariableName = internalPortVariableName,
+                    ExternalPortVariableName = externalPortVariableName
+                });
+            return this;
+        }
+
+        /// <summary>
+        /// Variables that will be resolved before container is created. They can be then
+        /// used in port AdditionalPortMappings and EnvironmentVariables (referenced between
+        /// '{}' brackets eg. {RUNTIME_VARIABLE_1}.)
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public ContainerResourceBuilder AddVariable(string name, VariableType type)
+        {
+            _options.Variables.Add(new Variable(name, type));
+
+            return this;
+        }
+
         /// <summary>
         /// Wait timeout in seconds
         /// </summary>

src/Core/ContainerResourceSettings.cs

@@ -37,6 +37,12 @@ public class ContainerResourceSettings
         public IList<ContainerPortMapping> AdditionalPortMappings { get; internal set; } =
             new List<ContainerPortMapping>();
 
+        /// <summary>
+        /// A list of variables resolved dynamically
+        /// </summary>
+        public IList<Variable> Variables { get; internal set; } =
+            new List<Variable>();
+
         /// <summary>
         /// Docker image tag
         /// </summary>

src/Core/DockerContainerManager.cs

@@ -34,6 +34,8 @@ public class DockerContainerManager : IDockerContainerManager
             .Handle<TimeoutException>()
             .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2));
 
+        private readonly VariableResolver _variableResolver;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="DockerContainerManager"/> class.
         /// </summary>
@@ -51,6 +53,7 @@ public DockerContainerManager(ContainerResourceSettings settings,
                  )
              .CreateClient(Version.Parse("1.25"));
             _authConfig = GetAuthConfig();
+            _variableResolver = new VariableResolver(_settings.Variables);
         }
 
         private AuthConfig GetAuthConfig()
@@ -278,6 +281,8 @@ await _retryPolicy
 
         private async Task CreateContainerAsync()
         {
+            ResolveAndReplaceVariables();
+
             var hostConfig = new HostConfig
             {
                 PublishAllPorts = true,
@@ -325,7 +330,8 @@ private async Task CreateContainerAsync()
                 Tty = false,
                 HostConfig = hostConfig,
                 Env = _settings.EnvironmentVariables,
-                Cmd = _settings.Cmd
+                Cmd = _settings.Cmd,
+                ExposedPorts = allPorts.ToDictionary(k => $"{k.InternalPort}/tcp", v => new EmptyStruct()),
             };
 
             try
@@ -362,6 +368,42 @@ await _retryPolicy
             }
         }
 
+        private void ResolveAndReplaceVariables()
+        {
+            ResolveAdditionalPortsVariables();
+            ReplaceVariablesInEnvironmentalVariables();
+        }
+
+        private void ReplaceVariablesInEnvironmentalVariables()
+        {
+            foreach (Variable variable in _settings.Variables)
+            {
+                _settings.EnvironmentVariables = _settings.EnvironmentVariables
+                    .Select(p => p.Replace(
+                        $"{{{variable.Name}}}",
+                        _variableResolver.Resolve<string>(variable.Name)))
+                    .ToList();
+            }
+        }
+
+        private void ResolveAdditionalPortsVariables()
+        {
+            foreach (ContainerPortMapping additionalPort in _settings.AdditionalPortMappings)
+            {
+                if (!string.IsNullOrEmpty(additionalPort.InternalPortVariableName))
+                {
+                    additionalPort.InternalPort = _variableResolver.Resolve<int>(
+                        additionalPort.InternalPortVariableName);
+                }
+
+                if (!string.IsNullOrEmpty(additionalPort.ExternalPortVariableName))
+                {
+                    additionalPort.ExternalPort = _variableResolver.Resolve<int>(
+                        additionalPort.ExternalPortVariableName);
+                }
+            }
+        }
+
         public async Task<bool> ImageExists()
         {
             try

src/Core/DynamicPortRuntimeVariableResolver.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Squadron
+{
+    internal class DynamicPortVariableResolver: IVariableResolver
+    {
+        private static readonly IPEndPoint DefaultLoopbackEndpoint =
+            new IPEndPoint(IPAddress.Loopback, port: 0);
+
+        public IDictionary<string, int> _resolvedPorts;
+
+        public DynamicPortVariableResolver()
+        {
+            _resolvedPorts = new Dictionary<string, int>();
+        }
+
+        public bool CanHandle(VariableType type)
+        {
+            return type == VariableType.DynamicPort;
+        }
+
+        public T Resolve<T>(string dynamicVariableName)
+        {
+            if (typeof(T) != typeof(int) && typeof(T) != typeof(string))
+            {
+                throw new NotSupportedException(
+                    $"The resolver {nameof(DynamicPortVariableResolver)} cannot " +
+                    $"resolve the type '{nameof(T)}'. Only the type 'int' is supported");
+            }
+
+            int resolvedPort = GetOrResolvePort(dynamicVariableName);
+
+            return (T)Convert.ChangeType(resolvedPort, typeof(T));
+        }
+
+        private int GetOrResolvePort(string dynamicVariableName)
+        {
+            if (_resolvedPorts.ContainsKey(dynamicVariableName))
+            {
+                return _resolvedPorts[dynamicVariableName];
+
+            }
+
+            var resolvedPort = GetAvailablePort();
+
+            _resolvedPorts.Add(dynamicVariableName, resolvedPort);
+
+            return resolvedPort;
+        }
+
+        public static int GetAvailablePort()
+        {
+            using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            {
+                socket.Bind(DefaultLoopbackEndpoint);
+                return ((IPEndPoint)socket.LocalEndPoint).Port;
+            }
+        }
+    }
+}

src/Core/IRuntimeVariableResolver.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Squadron
+{
+    internal interface IVariableResolver
+    {
+        T Resolve<T>(string dynamicVariableName);
+        bool CanHandle(VariableType type);
+    }
+}

src/Core/RuntimeVariable.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Squadron
+{
+    public class Variable
+    {
+        public Variable
+            (
+            string name,
+            VariableType type)
+        {
+            Name = name;
+            Type = type;
+        }
+
+        public string Name { get; }
+        public VariableType Type { get; }
+    }
+}

src/Core/RuntimeVariableType.cs

@@ -0,0 +1,7 @@
+namespace Squadron
+{
+    public enum VariableType
+    {
+        DynamicPort
+    }
+}