refactor(registry): add stable uid registry

lib/default.nix

@@ -13,7 +13,6 @@ let
     mapAttrsToList
     ;
 
-  serviceIdentityRegistry = import ./service-identities.nix { inherit lib; };
   registry = import ./registry.nix { inherit lib self; };
 
   collectNixFiles =
@@ -90,6 +89,4 @@ in
 
   inherit (guests) deriveMac guest;
 
-  inherit (serviceIdentityRegistry) serviceUid;
-  serviceIdentities = serviceIdentityRegistry.identities;
 }

lib/registry.nix

@@ -1,10 +1,17 @@
 { lib, self }:
 let
   inherit (lib)
+    all
+    concatLists
+    concatMapStringsSep
+    filter
     filterAttrs
+    foldl'
+    hasAttr
     hasSuffix
     mapAttrs
     mapAttrs'
+    mapAttrsToList
     mkOption
     nameValuePair
     removeSuffix
@@ -28,6 +35,67 @@ let
     in
     nameValuePair (registryName name) (import path { inherit lib; })
   ) (filterAttrs (name: type: type == "regular" && hasSuffix ".nix" name) (builtins.readDir (self + "/registry")));
+
+  rawDeclarations = registryName: hosts:
+    mapAttrs (_hostName: host: host.config.registry.${registryName} or { }) hosts;
+
+  replicatedEntries = registryName: raw:
+    let
+      entries = concatLists (
+        concatLists (
+          mapAttrsToList (
+            _evalHost: hostDeclarations:
+            mapAttrsToList (
+              hostName: declarations:
+              mapAttrsToList (entryName: value: {
+                path = "registry.${registryName}.${hostName}.${entryName}";
+                inherit entryName value;
+              }) declarations
+            ) hostDeclarations
+          ) raw
+        )
+      );
+    in
+    foldl' (
+      acc: entry:
+      if hasAttr entry.entryName acc then
+        if acc.${entry.entryName}.value == entry.value then
+          acc
+        else
+          throw "conflicting replicated registry entry ${entry.path} does not match ${acc.${entry.entryName}.path}"
+      else
+        acc // {
+          ${entry.entryName} = entry;
+        }
+    ) { } entries;
+
+  replicatedData = registryName: hosts: raw:
+    let
+      entries = mapAttrs (_entryName: entry: entry.value) (replicatedEntries registryName raw);
+    in
+    mapAttrs (_hostName: _host: entries) hosts;
+
+  validationAssertions = raw:
+    concatLists (
+      mapAttrsToList (
+        registryName: registry:
+        let
+          validate = registry.validate or (_raw: [ ]);
+        in
+        validate raw.${registryName}
+      ) definitions
+    );
+
+  assertValid = raw: value:
+    let
+      assertions = validationAssertions raw;
+      failures = filter (assertion: !assertion.assertion) assertions;
+    in
+    assert lib.assertMsg (all (assertion: assertion.assertion) assertions) (
+      concatMapStringsSep "\n" (assertion: assertion.message) failures
+    );
+    value;
+
   join = registry: host: entry:
     filterAttrs (_name: value: value != null) (
       mapAttrs (registryName: _registry: (registry.${registryName}.${host} or { }).${entry} or null) definitions
@@ -35,10 +103,17 @@ let
 
   collectData =
     { hosts }:
-    mapAttrs (
-      registryName: _registry:
-      mapAttrs (hostName: host: host.config.registry.${registryName}.${hostName} or { }) hosts
-    ) definitions;
+    let
+      raw = mapAttrs (registryName: _registry: rawDeclarations registryName hosts) definitions;
+      data = mapAttrs (
+        registryName: registry:
+        if registry.replicate or false then
+          replicatedData registryName hosts raw.${registryName}
+        else
+          mapAttrs (hostName: host: host.config.registry.${registryName}.${hostName} or { }) hosts
+      ) definitions;
+    in
+    assertValid raw data;
 
   withOperations = registry:
     registry

lib/service-identities.nix

@@ -1,59 +0,0 @@
-{ lib }:
-let
-  defaultIdentities = {
-    actualbudget = 20001;
-    copyparty = 20002;
-  };
-
-  duplicateUidMessage = duplicates: ''
-    Duplicate stable service UID allocation(s): ${lib.concatStringsSep ", " (
-      map (entry: "${toString entry.uid} is assigned to ${lib.concatStringsSep ", " entry.names}") duplicates
-    )}
-  '';
-
-  mk = identities:
-    let
-      names = lib.attrNames identities;
-      namesByUid = lib.foldl' (
-        acc: name:
-        let
-          uid = toString identities.${name};
-        in
-        acc // {
-          ${uid} = (acc.${uid} or [ ]) ++ [ name ];
-        }
-      ) { } names;
-      duplicates = lib.mapAttrsToList (uid: namesForUid: {
-        uid = lib.toInt uid;
-        names = namesForUid;
-      }) (lib.filterAttrs (_uid: namesForUid: builtins.length namesForUid > 1) namesByUid);
-      checkedIdentities =
-        assert lib.assertMsg (duplicates == [ ]) (duplicateUidMessage duplicates);
-        identities;
-    in
-    rec {
-      inherit checkedIdentities;
-
-      serviceUid = name:
-        if builtins.hasAttr name checkedIdentities then
-          checkedIdentities.${name}
-        else
-          throw "Unknown stable service identity `${name}`. Known identities: ${lib.concatStringsSep ", " (lib.attrNames checkedIdentities)}";
-    };
-
-  default = mk defaultIdentities;
-
-  tests = {
-    actualbudgetUid = default.serviceUid "actualbudget" == 20001;
-    copypartyUid = default.serviceUid "copyparty" == 20002;
-    missingLookupFails = !(builtins.tryEval (default.serviceUid "missing-service")).success;
-    duplicateUidFails = !(builtins.tryEval (mk {
-      first = 20003;
-      second = 20003;
-    }).checkedIdentities).success;
-  };
-in
-default // {
-  identities = default.checkedIdentities;
-  inherit tests;
-}