alexion/dotfiles
Archived
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(reverse-proxy): use route registry

Browse Source
This commit is contained in:
alexion
2026-08-23 23:44:22 -04:00
parent c267a2ec5c
commit 8252b6a42b
8 changed files with 89 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
flake.nix
View File

@@ -202,7 +202,7 @@
{
modules.reverse-proxy = {
enable = true;
routes."budget.alexion.dev" = {
routes.test."budget.alexion.dev" = {
path = "/";
backend = "http://10.23.20.42:5006";
};
@@ -224,7 +224,7 @@
reverse-proxy-actualbudget-guest-route =
let
testConfig = self.nixosConfigurations.pikachu.config;
route = testConfig.modules.reverse-proxy.routes.actualbudget;
route = testConfig.registry.route.pikachu.actualbudget;
vhost = testConfig.containers.reverse-proxy.config.services.nginx.virtualHosts."budget.alexion.dev";
in
pkgs.runCommand "reverse-proxy-actualbudget-guest-route-check" { } ''
@@ -233,7 +233,6 @@
!(
route.host == "budget.alexion.dev"
&& route.backend == null
&& route.endpoint == "pikachu-actualbudget"
&& route.port == 5006
&& route.tls
&& route.aliases == [ ]
@@ -361,25 +360,25 @@
system = "x86_64-linux";
specialArgs.my = self.lib;
modules = [
./modules/reverse-proxy.nix
self.lib.registry.module
{
modules.reverse-proxy.routes.app = {
registry.route.routeHost.app = {
host = "worker.alexion.dev";
backend = "http://10.23.20.126:3923";
};
system.stateVersion = "26.11";
}
];
};
endpoints = self.lib.networkEndpoints.collectFleetEndpoints {
pikachu = self.nixosConfigurations.pikachu;
registry = self.lib.registry.collect {
hosts = {
inherit routeHost;
pikachu = self.nixosConfigurations.pikachu;
};
};
fleetRoutes = self.lib.reverseProxyRoutes.collectFleetRoutes {
inherit routeHost;
pikachu = self.nixosConfigurations.pikachu;
} endpoints;
testConfig =
(self.nixosConfigurations.pikachu.extendModules {
specialArgs.reverseProxyFleetRoutes = fleetRoutes;
specialArgs.registry = registry;
}).config;
vhosts = testConfig.containers.reverse-proxy.config.services.nginx.virtualHosts;
in
@@ -387,8 +386,9 @@
${
lib.optionalString (
!(
fleetRoutes ? routeHost-app
&& fleetRoutes ? pikachu-actualbudget
registry.route ? routeHost
&& registry.route.routeHost ? app
&& registry.route.pikachu ? actualbudget
&& vhosts."worker.alexion.dev".locations."/".proxyPass == "http://10.23.20.126:3923"
&& vhosts."budget.alexion.dev".locations."/".proxyPass == "http://10.23.20.42:5006"
&& vhosts."files.alexion.dev".locations."/".proxyPass == "http://10.23.20.126:3923"
@@ -398,9 +398,9 @@
touch $out
'';
reverse-proxy-endpoint-backends =
reverse-proxy-address-backends =
let
endpointHost =
workerHost =
lib.nixosSystem {
system = "x86_64-linux";
specialArgs.my = self.lib;
@@ -408,22 +408,11 @@
self.lib.registry.module
{
registry.address.worker.self = "10.23.50.146";
system.stateVersion = "26.11";
}
];
};
routeHost =
lib.nixosSystem {
system = "x86_64-linux";
specialArgs.my = self.lib;
modules = [
./modules/reverse-proxy.nix
{
modules.reverse-proxy.routes.app = {
registry.route.worker.self = {
host = "worker.alexion.dev";
endpoint = "worker";
port = 8080;
};
system.stateVersion = "26.11";
}
];
};
@@ -454,36 +443,40 @@
}
];
};
endpoints = self.lib.networkEndpoints.collectFleetEndpoints {
worker = endpointHost;
pikachu = guestRouteHost;
registry = self.lib.registry.collect {
hosts = {
worker = workerHost;
pikachu = guestRouteHost;
};
};
fleetRoutes = self.lib.reverseProxyRoutes.collectFleetRoutes {
inherit routeHost;
pikachu = guestRouteHost;
} endpoints;
testConfig =
(lib.nixosSystem {
system = "x86_64-linux";
specialArgs.my = self.lib;
specialArgs = {
my = self.lib;
inherit registry;
};
modules = [
./modules/reverse-proxy.nix
{
modules.reverse-proxy = {
enable = true;
routes = fleetRoutes;
routes = registry.route;
};
}
];
}).config;
vhosts = testConfig.services.nginx.virtualHosts;
workerFacts = self.lib.registry.lookup registry "worker" "self";
in
pkgs.runCommand "reverse-proxy-endpoint-backends-check" { } ''
pkgs.runCommand "reverse-proxy-address-backends-check" { } ''
${
lib.optionalString (
!(
vhosts."worker.alexion.dev".locations."/".proxyPass == "http://10.23.50.146:8080"
&& fleetRoutes."pikachu-files".endpoint == "pikachu-files"
workerFacts.address == "10.23.50.146"
&& workerFacts.route.host == "worker.alexion.dev"
&& vhosts."worker.alexion.dev".locations."/".proxyPass == "http://10.23.50.146:8080"
&& registry.route.pikachu.files.port == 3923
&& vhosts."files.alexion.dev".locations."/".proxyPass == "http://10.23.20.126:3923"
)
) "exit 1"
@@ -502,7 +495,7 @@
{
modules.reverse-proxy = {
enable = true;
routes.raichu-files = {
routes.raichu.files = {
host = "files.alexion.dev";
path = "/raichu";
backend = "http://10.23.20.10:3923";

4
guests/reverse-proxy.nix
View File

@@ -2,7 +2,7 @@
config,
lib,
my,
reverseProxyFleetRoutes ? config.modules.reverse-proxy.routes,
registry,
...
}:
let
@@ -35,7 +35,7 @@ in
interior = {
modules.reverse-proxy = {
enable = true;
routes = reverseProxyFleetRoutes // legacyRoutes;
routes = registry.route // { legacy = legacyRoutes; };
};
networking.firewall.allowedTCPPorts = [ 2022 ];

15
lib/default.nix
View File

@@ -35,16 +35,11 @@ let
) (builtins.readDir dir)
);
specialArgs =
let
networkFleetEndpoints = self.lib.networkEndpoints.collectFleetEndpoints self.nixosConfigurations;
in
{
inherit inputs networkFleetEndpoints self;
my = self.lib;
registry = self.lib.registry.collect { hosts = self.nixosConfigurations; };
reverseProxyFleetRoutes = self.lib.reverseProxyRoutes.collectFleetRoutes self.nixosConfigurations networkFleetEndpoints;
};
specialArgs = {
inherit inputs self;
my = self.lib;
registry = self.lib.registry.collect { hosts = self.nixosConfigurations; };
};
bridgeName = id: "br-vlan${toString id}";

9
lib/guests.nix
View File

@@ -279,13 +279,8 @@ let
registry.address.${config.networking.hostName}.${machineName} = lib.mkIf (cfg.address != null) cfg.address;
modules.reverse-proxy.routes.${machineName} = lib.mkIf cfg.reverseProxy.enable (
reverseProxyRoutes.routeFields (
cfg.reverseProxy
// lib.optionalAttrs (cfg.reverseProxy.backend == null && cfg.reverseProxy.endpoint == null) {
endpoint = "${config.networking.hostName}-${machineName}";
}
)
registry.route.${config.networking.hostName}.${machineName} = lib.mkIf cfg.reverseProxy.enable (
reverseProxyRoutes.routeFields cfg.reverseProxy
);
assertions = [

5
lib/registry.nix
View File

@@ -32,6 +32,11 @@ in
{
inherit definitions;
lookup = registry: hostName: entryName:
filterAttrs (_name: value: value != null) (
mapAttrs (_name: hostEntriesByName: (hostEntriesByName.${hostName} or { }).${entryName} or null) registry
);
module = {
options.registry = mapAttrs (_name: registry: registryOption registry) definitions;
};

42
lib/reverse-proxy-routes.nix
View File

@@ -42,23 +42,17 @@ let
description = "Full HTTP backend URL that receives proxied traffic.";
};
endpoint = lib.mkOption {
type = lib.types.nullOr lib.types.str;
default = null;
description = "Fleet network endpoint key used to derive the backend URL.";
};
port = lib.mkOption {
type = lib.types.nullOr (lib.types.ints.between 1 65535);
default = null;
example = 3923;
description = "Backend TCP port used with the fleet network endpoint.";
description = "Backend TCP port used with the matching address registry entry.";
};
scheme = lib.mkOption {
type = lib.types.str;
default = "http";
description = "Backend URL scheme used with the fleet network endpoint.";
description = "Backend URL scheme used with the matching address registry entry.";
};
tls = lib.mkOption {
@@ -80,45 +74,15 @@ let
aliases
path
backend
endpoint
port
scheme
tls
websockets
;
};
endpointBackend = endpoints: route:
let
endpoint = endpoints.${route.endpoint} or (
throw "Unknown reverse-proxy endpoint `${route.endpoint}`. Known endpoints: ${lib.concatStringsSep ", " (lib.attrNames endpoints)}"
);
in
"${route.scheme}://${endpoint.address}:${toString route.port}";
resolvedRouteFields = endpoints: route:
let
routeWithBackend =
if route.backend != null then
route
else if route.endpoint != null && route.port != null then
route // { backend = endpointBackend endpoints route; }
else
throw "Reverse-proxy route `${route.host}${route.path}` needs either backend or endpoint plus port.";
in
routeFields routeWithBackend;
collectFleetRoutes =
hosts: endpoints:
lib.concatMapAttrs (
hostName: host:
lib.mapAttrs' (
routeName: route: lib.nameValuePair "${hostName}-${routeName}" (resolvedRouteFields endpoints route)
) host.config.modules.reverse-proxy.routes
) hosts;
in
{
inherit collectFleetRoutes mkRouteOptions resolvedRouteFields routeFields;
inherit mkRouteOptions routeFields;
routeType = lib.types.submodule (
{ name, ... }:

36
modules/reverse-proxy.nix
View File

@@ -1,10 +1,34 @@
{ config, lib, my, ... }:
{
config,
lib,
my,
registry ? config.registry,
...
}:
let
cfg = config.modules.reverse-proxy;
inherit (my) reverseProxyRoutes;
enabledRoutes = lib.filterAttrs (_: route: route.enable) cfg.routes;
routesByHost = lib.groupBy (route: route.host) (lib.attrValues enabledRoutes);
routeWithBackend = hostName: routeName: route:
let
facts = my.registry.lookup registry hostName routeName;
in
if route.backend != null then
route
else if facts ? address && route.port != null then
route // { backend = "${route.scheme}://${facts.address}:${toString route.port}"; }
else
route;
allRoutes = lib.concatLists (
lib.mapAttrsToList (
hostName: routes:
lib.mapAttrsToList (routeName: route: routeWithBackend hostName routeName route) routes
) cfg.routes
);
enabledRoutes = builtins.filter (route: route.enable) allRoutes;
routesByHost = lib.groupBy (route: route.host) enabledRoutes;
rootRoutesByHost = lib.mapAttrs (
host: routes:
@@ -47,9 +71,9 @@ in
enable = lib.mkEnableOption "the Nginx reverse proxy route realizer";
routes = lib.mkOption {
type = lib.types.attrsOf reverseProxyRoutes.routeType;
type = lib.types.attrsOf (lib.types.attrsOf reverseProxyRoutes.routeType);
default = { };
description = "Reverse-proxy route declarations keyed by stable route name.";
description = "Reverse-proxy route declarations keyed by source host and stable route name.";
};
};
@@ -66,7 +90,7 @@ in
++ map (route: {
assertion = !hasUnresolvedBackend route;
message = "modules.reverse-proxy.routes for ${route.host}${route.path} must resolve to a backend URL before actualization.";
}) (builtins.filter hasUnresolvedBackend (lib.attrValues enabledRoutes));
}) (builtins.filter hasUnresolvedBackend enabledRoutes);
networking.firewall.allowedTCPPorts = [
80

7
registry/route.nix Normal file
View File

@@ -0,0 +1,7 @@
{ lib }:
let
reverseProxyRoutes = import ../lib/reverse-proxy-routes.nix { inherit lib; };
in
{
type = reverseProxyRoutes.routeType;
}