pull to main

README.md

@@ -6,7 +6,7 @@ Tilework is a fully integrated reverse proxying and load balancing platform, usi
 
 
 ## Features
-- Deployment of HTTP/TCP/UDP load balancers with multiple backends
+- Deployment of HTTP/TCP load balancers with multiple backends
 - HTTP rules based routing, including hostname, URL path, query string
 - Certificate issuing via popular services, lifecycle management, auto-renewal
 - Realtime and historical service statistics

tilework.core/Enums/LoadBalancing/LoadBalancerActionRules.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Tilework.LoadBalancing.Enums;
+
+public static class LoadBalancerActionRules
+{
+    private static readonly RuleActionType[] ApplicationActions =
+    {
+        RuleActionType.Forward,
+        RuleActionType.Redirect,
+        RuleActionType.FixedResponse
+    };
+
+    private static readonly RuleActionType[] NetworkActions =
+    {
+        RuleActionType.Forward,
+        RuleActionType.Reject
+    };
+
+    public static IReadOnlyList<RuleActionType> GetAllowedActions(LoadBalancerType type)
+    {
+        return type == LoadBalancerType.NETWORK ? NetworkActions : ApplicationActions;
+    }
+
+    public static bool IsAllowed(LoadBalancerType type, RuleActionType action)
+    {
+        return GetAllowedActions(type).Contains(action);
+    }
+}

tilework.core/Enums/LoadBalancing/LoadBalancerProtocolRules.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Linq;
 
 namespace Tilework.LoadBalancing.Enums;
@@ -13,8 +14,8 @@ public static class LoadBalancerProtocolRules
     private static readonly LoadBalancerProtocol[] NetworkProtocols =
     {
         LoadBalancerProtocol.TCP,
-        LoadBalancerProtocol.UDP,
-        LoadBalancerProtocol.TCP_UDP,
+        // LoadBalancerProtocol.UDP,
+        // LoadBalancerProtocol.TCP_UDP,
         LoadBalancerProtocol.TLS
     };
 

tilework.core/Enums/LoadBalancing/RuleActionType.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel;
+
+namespace Tilework.LoadBalancing.Enums;
+
+public enum RuleActionType
+{
+    [Description("Forward to target group")]
+    Forward,
+    [Description("HTTP redirect")]
+    Redirect,
+    [Description("HTTP fixed response")]
+    FixedResponse,
+    [Description("Reject connection")]
+    Reject
+}

tilework.core/Enums/LoadBalancing/TargetGroupProtocolRules.cs

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

tilework.core/Mappers/LoadBalancingMappingProfile.cs

@@ -27,10 +27,12 @@ public LoadBalancingMappingProfile()
 
         CreateMap<Rule, RuleDTO>()
             .ForMember(dest => dest.LoadBalancer, opt => opt.MapFrom(src => src.LoadBalancerId))
-            .ForMember(dest => dest.TargetGroup, opt => opt.MapFrom(src => src.TargetGroupId));
+            .ForMember(dest => dest.TargetGroup, opt => opt.MapFrom(src => src.TargetGroupId))
+            .ForMember(dest => dest.Action, opt => opt.MapFrom(src => src.Action ?? new RuleAction()));
         CreateMap<RuleDTO, Rule>()
             .ForMember(dest => dest.LoadBalancerId, opt => opt.MapFrom(src => src.LoadBalancer))
             .ForMember(dest => dest.TargetGroupId, opt => opt.MapFrom(src => src.TargetGroup))
+            .ForMember(dest => dest.Action, opt => opt.MapFrom(src => src.Action ?? new RuleAction()))
             .ForMember(dest => dest.LoadBalancer, opt => opt.Ignore())
             .ForMember(dest => dest.TargetGroup, opt => opt.Ignore());
     }