Develop

README.md

@@ -47,4 +47,10 @@ docker-compose up -d
 docker compose up -d
 ```
 
-4. Navigate your browser to http://\<host>:5180
+4. Create an initial user
+```
+docker compose exec -it tileworkui dotnet tilework.ui.dll CreateUser
+```
+Follow the interactive prompts to set the username, email, and password.
+
+5. Navigate your browser to http://\<host>:5180

tilework.core/Enums/LoadBalancing/ConditionType.cs

@@ -9,6 +9,8 @@ public enum ConditionType
     [Description("Path")]
     Path,
     [Description("Query string")]
-    QueryString
+    QueryString,
+    [Description("SNI FQDN")]
+    SNI
 }
 

tilework.core/Enums/LoadBalancing/LoadBalancerConditionRules.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Linq;
+
+namespace Tilework.LoadBalancing.Enums;
+
+public static class LoadBalancerConditionRules
+{
+    private static readonly ConditionType[] HttpConditions =
+    {
+        ConditionType.HostHeader,
+        ConditionType.Path,
+        ConditionType.QueryString
+    };
+
+    private static readonly ConditionType[] HttpsConditions =
+    {
+        ConditionType.HostHeader,
+        ConditionType.Path,
+        ConditionType.QueryString,
+        ConditionType.SNI
+    };
+
+    private static readonly ConditionType[] TlsConditions =
+    {
+        ConditionType.SNI
+    };
+
+    public static IReadOnlyList<ConditionType> GetAllowedConditions(LoadBalancerProtocol protocol)
+    {
+        return protocol switch
+        {
+            LoadBalancerProtocol.HTTP => HttpConditions,
+            LoadBalancerProtocol.HTTPS => HttpsConditions,
+            LoadBalancerProtocol.TLS => TlsConditions,
+            _ => Array.Empty<ConditionType>()
+        };
+    }
+
+    public static bool IsAllowed(LoadBalancerProtocol protocol, ConditionType condition)
+    {
+        return GetAllowedConditions(protocol).Contains(condition);
+    }
+}

tilework.core/Enums/LoadBalancing/NlbProtocol.cs → tilework.core/Enums/LoadBalancing/LoadBalancerProtocol.cs

@@ -2,8 +2,12 @@
 
 namespace Tilework.LoadBalancing.Enums;
 
-public enum NlbProtocol
+public enum LoadBalancerProtocol
 {
+    [Description("HTTP")]
+    HTTP,
+    [Description("HTTPS")]
+    HTTPS,
     [Description("TCP")]
     TCP,
     [Description("UDP")]

tilework.core/Enums/LoadBalancing/LoadBalancerProtocolRules.cs

@@ -0,0 +1,30 @@
+using System.Linq;
+
+namespace Tilework.LoadBalancing.Enums;
+
+public static class LoadBalancerProtocolRules
+{
+    private static readonly LoadBalancerProtocol[] ApplicationProtocols =
+    {
+        LoadBalancerProtocol.HTTP,
+        LoadBalancerProtocol.HTTPS
+    };
+
+    private static readonly LoadBalancerProtocol[] NetworkProtocols =
+    {
+        LoadBalancerProtocol.TCP,
+        LoadBalancerProtocol.UDP,
+        LoadBalancerProtocol.TCP_UDP,
+        LoadBalancerProtocol.TLS
+    };
+
+    public static IReadOnlyList<LoadBalancerProtocol> GetAllowedProtocols(LoadBalancerType type)
+    {
+        return type == LoadBalancerType.NETWORK ? NetworkProtocols : ApplicationProtocols;
+    }
+
+    public static bool IsAllowed(LoadBalancerType type, LoadBalancerProtocol protocol)
+    {
+        return GetAllowedProtocols(type).Contains(protocol);
+    }
+}

tilework.core/Enums/LoadBalancing/LoadBalancerStatus.cs

@@ -0,0 +1,8 @@
+namespace Tilework.LoadBalancing.Enums;
+
+public enum LoadBalancerStatus
+{
+    UP,
+    DOWN,
+    UNKNOWN
+}

tilework.core/Interfaces/LoadBalancing/ILoadBalancerService.cs

@@ -1,35 +1,34 @@
 using Tilework.LoadBalancing.Models;
 using Tilework.CertificateManagement.Models;
+using Tilework.LoadBalancing.Enums;
 
 namespace Tilework.LoadBalancing.Interfaces;
 
 public interface ILoadBalancerService
 {
-    public Task<List<BaseLoadBalancerDTO>> GetLoadBalancers();
-    public Task<BaseLoadBalancerDTO?> GetLoadBalancer(Guid Id);
-    public Task<BaseLoadBalancerDTO> AddLoadBalancer(BaseLoadBalancerDTO balancer);
-    public Task<BaseLoadBalancerDTO> UpdateLoadBalancer(BaseLoadBalancerDTO balancer);
+    public Task<List<LoadBalancerDTO>> GetLoadBalancers();
+    public Task<LoadBalancerDTO?> GetLoadBalancer(Guid Id);
+    public Task<LoadBalancerDTO> AddLoadBalancer(LoadBalancerDTO balancer);
+    public Task<LoadBalancerDTO> UpdateLoadBalancer(LoadBalancerDTO balancer);
     public Task DeleteLoadBalancer(Guid Id);
 
     public Task EnableLoadBalancer(Guid Id);
     public Task DisableLoadBalancer(Guid Id);
 
 
 
-    public Task<List<RuleDTO>> GetRules(ApplicationLoadBalancerDTO balancer);
-    public Task AddRule(ApplicationLoadBalancerDTO balancer, RuleDTO rule);
-    public Task UpdateRule(ApplicationLoadBalancerDTO balancer, RuleDTO rule);
-    public Task RemoveRule(ApplicationLoadBalancerDTO balancer, RuleDTO rule);
+    public Task<List<RuleDTO>> GetRules(LoadBalancerDTO balancer);
+    public Task AddRule(LoadBalancerDTO balancer, RuleDTO rule);
+    public Task UpdateRule(LoadBalancerDTO balancer, RuleDTO rule);
+    public Task RemoveRule(LoadBalancerDTO balancer, RuleDTO rule);
 
 
-    public Task<List<CertificateDTO>> GetCertificates(BaseLoadBalancerDTO balancer);
-    public Task AddCertificate(BaseLoadBalancerDTO balancer, Guid certificateId);
-    public Task RemoveCertificate(BaseLoadBalancerDTO balancer, Guid certificateId);
+    public Task<List<CertificateDTO>> GetCertificates(LoadBalancerDTO balancer);
+    public Task AddCertificate(LoadBalancerDTO balancer, Guid certificateId);
+    public Task RemoveCertificate(LoadBalancerDTO balancer, Guid certificateId);
 
 
     public Task<List<TargetGroupDTO>> GetTargetGroups();
-    public Task<List<TargetGroupDTO>> GetNlbTargetGroups();
-    public Task<List<TargetGroupDTO>> GetAlbTargetGroups();
 
     public Task<TargetGroupDTO?> GetTargetGroup(Guid Id);
     public Task<TargetGroupDTO> AddTargetGroup(TargetGroupDTO group);
@@ -38,9 +37,11 @@ public interface ILoadBalancerService
 
 
     public Task<List<TargetDTO>> GetTargets(TargetGroupDTO group);
+    public Task<TargetDTO> GetTarget(Guid Id);
     public Task AddTarget(TargetGroupDTO group, TargetDTO target);
     public Task UpdateTarget(TargetGroupDTO group, TargetDTO target);
     public Task RemoveTarget(TargetGroupDTO group, TargetDTO target);
+    public Task<LoadBalancerStatus> GetTargetHealth(Guid id);
 
     public Task<List<LoadBalancingMonitorData>> GetLoadBalancerMonitoringData(Guid Id, TimeSpan interval, DateTimeOffset start, DateTimeOffset end);
 

tilework.core/Interfaces/LoadBalancing/ILoadBalancingConfigurator.cs

@@ -4,8 +4,8 @@ namespace Tilework.LoadBalancing.Interfaces;
 
 public interface ILoadBalancingConfigurator
 {
-    List<BaseLoadBalancer> LoadConfiguration();
-    Task ApplyConfiguration(List<BaseLoadBalancer> loadBalancers);
-    Task ApplyConfiguration(BaseLoadBalancer loadBalancer);
+    List<LoadBalancer> LoadConfiguration();
+    Task ApplyConfiguration(List<LoadBalancer> loadBalancers);
+    Task ApplyConfiguration(LoadBalancer loadBalancer);
     Task Shutdown();
 }

tilework.core/Interfaces/Monitoring/IDataPersistenceConfigurator.cs

@@ -5,8 +5,8 @@ namespace Tilework.Monitoring.Interfaces;
 public interface IDataPersistenceConfigurator
 {
     Task<MonitoringTarget> GetTarget(MonitoringSource source);
-    Task<List<T>> GetData<T>(string module, Dictionary<string, string> filters, TimeSpan interval, DateTimeOffset start, DateTimeOffset end) where T : BaseMonitorData, new();
+    Task<List<T>> GetData<T>(string module, Dictionary<string, string> filters, TimeSpan? interval, DateTimeOffset start, DateTimeOffset end) where T : BaseMonitorData, new();
 
     Task ApplyConfiguration();
     Task Shutdown();
-}
+}

tilework.core/Mappers/EnumMappers.cs

@@ -0,0 +1,25 @@
+using System;
+
+using Tilework.LoadBalancing.Enums;
+
+namespace Tilework.Core.Mappers;
+
+public static class EnumMappers
+{
+    public static LoadBalancerStatus FromHaproxyStatus(string? status)
+    {
+        if (string.IsNullOrWhiteSpace(status))
+        {
+            return LoadBalancerStatus.DOWN;
+        }
+
+        var normalized = status.Trim();
+        if (normalized.StartsWith("UP", StringComparison.OrdinalIgnoreCase) ||
+            normalized.StartsWith("OPEN", StringComparison.OrdinalIgnoreCase))
+        {
+            return LoadBalancerStatus.UP;
+        }
+
+        return LoadBalancerStatus.DOWN;
+    }
+}

tilework.core/Mappers/LoadBalancingMappingProfile.cs

@@ -2,6 +2,8 @@
 
 using Tilework.Persistence.LoadBalancing.Models;
 using Tilework.Core.Models;
+using Tilework.Core.Mappers;
+using Tilework.LoadBalancing.Enums;
 using Tilework.LoadBalancing.Models;
 
 namespace Tilework.LoadBalancing.Mappers;
@@ -10,18 +12,13 @@ public class LoadBalancingMappingProfile : Profile
 {
     public LoadBalancingMappingProfile()
     {
-        CreateMap<ApplicationLoadBalancer, ApplicationLoadBalancerDTO>();
-        CreateMap<ApplicationLoadBalancerDTO, ApplicationLoadBalancer>()
-            .ForMember(dest => dest.Enabled, opt => opt.Ignore());
-
+        CreateMap<string, LoadBalancerStatus>()
+            .ConvertUsing(status => EnumMappers.FromHaproxyStatus(status));
 
-        CreateMap<NetworkLoadBalancer, NetworkLoadBalancerDTO>()
-            .ForMember(dest => dest.TargetGroup, opt => opt.MapFrom(src => src.TargetGroupId));
-        CreateMap<NetworkLoadBalancerDTO, NetworkLoadBalancer>()
-            .ForMember(dest => dest.TargetGroupId, opt => opt.MapFrom(src => src.TargetGroup))
-            .ForMember(dest => dest.TargetGroup, opt => opt.Ignore())
+        CreateMap<LoadBalancer, LoadBalancerDTO>();
+        CreateMap<LoadBalancerDTO, LoadBalancer>()
             .ForMember(dest => dest.Enabled, opt => opt.Ignore());
-
+        
         CreateMap<TargetGroupDTO, TargetGroup>();
         CreateMap<TargetGroup, TargetGroupDTO>();