chore: update project structure with contracts and services for CaddyManager, including configuration and Docker integration

CaddyManager.Services/Caddy/CaddyConfigurationParsingService.cs

@@ -0,0 +1,83 @@
+using System.Text.RegularExpressions;
+using CaddyManager.Contracts.Caddy;
+
+namespace CaddyManager.Services.Caddy;
+
+/// <inheritdoc />
+public partial class CaddyConfigurationParsingService: ICaddyConfigurationParsingService
+{
+    /// <summary>
+    /// Regex to help parse hostnames from a Caddyfile.
+    /// </summary>
+    /// <returns></returns>
+    [GeneratedRegex(@"(?m)^[\w.-]+(?:\s*,\s*[\w.-]+)*(?=\s*\{)", RegexOptions.Multiline)]
+    private static partial Regex HostnamesRegex();
+    
+    /// <summary>
+    /// Regex to help parse hostnames being used in reverse proxy directives.
+    /// </summary>
+    /// <returns></returns>
+    [GeneratedRegex(@"(?m)reverse_proxy .*", RegexOptions.Multiline)]
+    private static partial Regex ReverseProxyRegex();
+
+    /// <inheritdoc />
+    public List<string> GetHostnamesFromCaddyfileContent(string caddyfileContent)
+    {
+        var hostnamesRegex = HostnamesRegex();
+        var matches = hostnamesRegex.Matches(caddyfileContent);
+        var hostnames = new List<string>();
+        foreach (Match match in matches)
+        {
+            // Split the matched string by commas and trim whitespace
+            var splitHostnames = match.Value.Split(',')
+                .Select(h => h.Trim())
+                .Where(h => !string.IsNullOrWhiteSpace(h))
+                .ToList();
+
+            hostnames.AddRange(splitHostnames);
+        }
+        // Remove duplicates and return the list
+        return hostnames.Distinct().ToList();
+    }
+
+    /// <inheritdoc />
+    public string GetReverseProxyTargetFromCaddyfileContent(string caddyfileContent)
+    {
+        var reverseProxyRegex = ReverseProxyRegex();
+        var match = reverseProxyRegex.Match(caddyfileContent);
+        if (!match.Success) return string.Empty;
+
+        var parts = match.Value.TrimEnd('}').Trim().Split(' ');
+        var targetPart = parts.LastOrDefault(string.Empty);
+        if (string.IsNullOrEmpty(targetPart)) return string.Empty;
+
+        var targetComponents = targetPart.Split(':');
+        if (targetComponents.Length <= 1) return targetPart;
+
+        // Handle cases like http://backend:9000, 192.168.1.100:3000
+        return targetComponents[0];
+    }
+
+    /// <inheritdoc />
+    public List<int> GetReverseProxyPortsFromCaddyfileContent(string caddyfileContent)
+    {
+        var reverseProxyRegex = ReverseProxyRegex();
+        var matches = reverseProxyRegex.Matches(caddyfileContent);
+        var results = new List<int>();
+
+        foreach (Match match in matches)
+        {
+            var parts = match.Value.TrimEnd('}').Trim().Split(' ');
+            var targetPart = parts.LastOrDefault(string.Empty);
+            if (string.IsNullOrEmpty(targetPart)) continue;
+
+            var targetComponents = targetPart.Split(':');
+            if (targetComponents.Length > 1 && int.TryParse(targetComponents.Last(), out int port))
+            {
+                results.Add(port);
+            }
+        }
+
+        return results.Distinct().ToList();
+    }
+}

CaddyManager.Services/Caddy/CaddyService.cs

@@ -0,0 +1,162 @@
+using CaddyManager.Contracts.Configurations.Caddy;
+using CaddyManager.Contracts.Caddy;
+using CaddyManager.Contracts.Configurations;
+using CaddyManager.Contracts.Models.Caddy;
+
+namespace CaddyManager.Services.Caddy;
+
+/// <inheritdoc />
+public class CaddyService(
+    IConfigurationsService configurationsService,
+    ICaddyConfigurationParsingService parsingService) : ICaddyService
+{
+    /// <summary>
+    /// File name of the global configuration Caddyfile
+    /// </summary>
+    private const string CaddyGlobalConfigName = "Caddyfile";
+
+    private CaddyServiceConfigurations Configurations => configurationsService.Get<CaddyServiceConfigurations>();
+
+    /// <inheritdoc />
+    public List<CaddyConfigurationInfo> GetExistingCaddyConfigurations()
+    {
+        if (!Directory.Exists(Configurations.ConfigDir))
+        {
+            Directory.CreateDirectory(Configurations.ConfigDir);
+        }
+
+        return [.. Directory.GetFiles(Configurations.ConfigDir)
+            .Where(filePath => Path.GetFileName(filePath) != CaddyGlobalConfigName)
+            .Select(filePath =>
+            {
+                var fileName = Path.GetFileNameWithoutExtension(filePath);
+                var info = GetCaddyConfigurationInfo(fileName);
+                info.FileName = fileName;
+                return info;
+            })
+            .OrderBy(info => info.FileName)];
+    }
+
+    /// <inheritdoc />
+    public string GetCaddyConfigurationContent(string configurationName)
+    {
+        var path = configurationName == CaddyGlobalConfigName
+            ? Path.Combine(Configurations.ConfigDir, CaddyGlobalConfigName)
+            : Path.Combine(Configurations.ConfigDir, $"{configurationName}.caddy");
+
+        if (File.Exists(path))
+        {
+            return File.ReadAllText(path);
+        }
+
+        return string.Empty;
+    }
+
+    /// <inheritdoc />
+    public string GetCaddyGlobalConfigurationContent() => GetCaddyConfigurationContent(CaddyGlobalConfigName);
+
+    /// <inheritdoc />
+    public CaddyOperationResponse SaveCaddyConfiguration(CaddySaveConfigurationRequest request)
+    {
+        if (string.IsNullOrWhiteSpace(request.FileName))
+        {
+            return new CaddyOperationResponse
+            {
+                Success = false,
+                Message = "The configuration file name is required"
+            };
+        }
+
+        var filePath = Path.Combine(Configurations.ConfigDir,
+            request.FileName == CaddyGlobalConfigName ? CaddyGlobalConfigName : $"{request.FileName}.caddy");
+        // if in the new mode, we would have to check if the file already exists
+        if (request.IsNew && File.Exists(filePath))
+        {
+            return new CaddyOperationResponse
+            {
+                Success = false,
+                Message = "The configuration file already exists"
+            };
+        }
+
+        try
+        {
+            File.WriteAllText(filePath, request.Content);
+            return new CaddyOperationResponse
+            {
+                Success = true,
+                Message = "Configuration file saved successfully"
+            };
+        }
+        catch (Exception e)
+        {
+            return new CaddyOperationResponse
+            {
+                Success = false,
+                Message = e.Message
+            };
+        }
+    }
+
+    /// <inheritdoc />
+    public CaddyOperationResponse SaveCaddyGlobalConfiguration(string content) => SaveCaddyConfiguration(
+        new CaddySaveConfigurationRequest
+        {
+            FileName = CaddyGlobalConfigName,
+            Content = content
+        });
+
+    /// <inheritdoc />
+    public CaddyDeleteOperationResponse DeleteCaddyConfigurations(List<string> configurationNames)
+    {
+        var failed = new List<string>();
+
+        foreach (var configurationName in configurationNames)
+        {
+            var filePath = Path.Combine(Configurations.ConfigDir,
+                configurationName == CaddyGlobalConfigName ? CaddyGlobalConfigName : $"{configurationName}.caddy");
+
+            if (File.Exists(filePath))
+            {
+                try
+                {
+                    File.Delete(filePath);
+                }
+                catch
+                {
+                    failed.Add(configurationName);
+                }
+            }
+            else
+            {
+                failed.Add(configurationName);
+            }
+        }
+
+        return new CaddyDeleteOperationResponse
+        {
+            Success = failed.Count == 0,
+            Message = failed.Count == 0
+                ? "Configuration(s) deleted successfully"
+                : $"Failed to delete the following configuration(s): {string.Join(", ", failed)}",
+            DeletedConfigurations = configurationNames.Except(failed).ToList()
+        };
+    }
+
+    /// <inheritdoc />
+    public CaddyConfigurationInfo GetCaddyConfigurationInfo(string configurationName)
+    {
+        var result = new CaddyConfigurationInfo();
+        var content = GetCaddyConfigurationContent(configurationName);
+        if (string.IsNullOrWhiteSpace(content))
+        {
+            return result;
+        }
+        
+        result.Hostnames = parsingService.GetHostnamesFromCaddyfileContent(content);
+        result.ReverseProxyHostname = parsingService.GetReverseProxyTargetFromCaddyfileContent(content);
+        result.ReverseProxyPorts  = parsingService.GetReverseProxyPortsFromCaddyfileContent(content);
+
+        return result;
+    }
+}