3 krebs: make dns.providers part of api

3modules/krebs/default.nix

@@ -34,6 +34,14 @@ let
       default = {};
     };
 
+    dns = {
+      providers = mkOption {
+        # TODO with types; tree dns.label dns.provider, so we can merge.
+        # Currently providers can only be merged if aliases occur just once.
+        type = with types; attrsOf unspecified;
+      };
+    };
+
     hosts = mkOption {
       type = with types; attrsOf host;
     };
@@ -56,38 +64,26 @@ let
     { krebs = makefu-imp; }
     { krebs = tv-imp; }
     {
+      krebs.dns.providers = {
+        de.krebsco = "ovh";
+        internet = "hosts";
+        retiolum = "hosts";
+      };
+
       # XXX This overlaps with krebs.retiolum
-      networking.extraHosts =
+      networking.extraHosts = concatStringsSep "\n" (flatten (
-        let
+        mapAttrsToList (hostname: host:
-          # TODO move domain name providers to a dedicated module
+          mapAttrsToList (netname: net:
-          # providers : tree label providername
+            let
-          providers = {
+              aliases = toString (unique (longs ++ shorts));
-            internet = "hosts";
+              providers = dns.split-by-provider net.aliases cfg.dns.providers;
-            retiolum = "hosts";
+              longs = providers.hosts;
-            de.viljetic = "regfish";
+              shorts = map (removeSuffix ".${cfg.search-domain}") longs;
-            de.krebsco = "ovh";
+            in
-          };
+            map (addr: "${addr} ${aliases}") net.addrs
-
+          ) host.nets
-          # splitByProvider : [alias] -> listset providername alias
+        ) cfg.hosts
-          splitByProvider = foldl (acc: alias: listset-insert (providerOf alias) alias acc) {};
+      ));
-
-          # providerOf : alias -> providername
-          providerOf = alias:
-            tree-get (splitString "." alias) providers;
-        in
-        concatStringsSep "\n" (flatten (
-          # TODO deepMap ["hosts" "nets"] (hostname: host: netname: net:
-          mapAttrsToList (hostname: host:
-            mapAttrsToList (netname: net:
-              let
-                aliases = toString (unique (longs ++ shorts));
-                longs = (splitByProvider net.aliases).hosts;
-                shorts = map (removeSuffix ".${cfg.search-domain}") longs;
-              in
-              map (addr: "${addr} ${aliases}") net.addrs
-            ) host.nets
-          ) config.krebs.hosts
-        ));
     }
   ];
 
@@ -139,6 +135,9 @@ let
   };
 
   tv-imp = {
+    dns.providers = {
+      de.viljetic = "regfish";
+    };
     hosts = addNames {
       cd = {
         cores = 2;

4lib/krebs/default.nix

@@ -12,22 +12,7 @@ builtins // lib // rec {
 
   types = import ./types.nix { inherit lib; };
 
-
+  dns = import ./dns.nix { inherit lib; };
-  # listset k v = set k [v]
+  listset = import ./listset.nix { inherit lib; };
-
+  tree = import ./tree.nix { inherit lib; };
-  # listset-insert : k -> v -> listset k v -> listset k v
-  listset-insert = name: value: set:
-    set // { ${name} = set.${name} or [] ++ [value]; };
-
-  # tree k v = set k (either v (tree k v))
-
-  # tree-get : [k] -> tree k v -> v
-  tree-get = path: x:
-    let
-      y = x.${last path};
-    in
-    if typeOf y != "set"
-      then y
-      else tree-get (init path) y;
-
 }

4lib/krebs/dns.nix

@@ -0,0 +1,31 @@
+{ lib, ... }:
+
+let
+  listset = import ./listset.nix { inherit lib; };
+in
+
+with builtins;
+with lib;
+
+rec {
+  # label = string
+
+  # TODO does it make sense to have alias = list label?
+
+  # split-by-provider :
+  #   [[label]] -> tree label provider -> listset provider alias
+  split-by-provider = as: providers:
+    foldl (m: a: listset.insert (provider-of a providers) a m) {} as;
+
+  # provider-of : alias -> tree label provider -> provider
+  # Note that we cannot use tree.get here, because path can be longer
+  # than the tree depth.
+  provider-of = a:
+    let
+      go = path: tree:
+        if typeOf tree == "string"
+          then tree
+          else go (tail path) tree.${head path};
+    in
+    go (reverseList (splitString "." a));
+}

4lib/krebs/listset.nix

@@ -0,0 +1,11 @@
+{ lib, ... }:
+
+with lib;
+
+rec {
+  # listset k v = set k [v]
+
+  # insert : k -> v -> listset k v -> listset k v
+  insert = name: value: set:
+    set // { ${name} = set.${name} or [] ++ [value]; };
+}

4lib/krebs/tree.nix

@@ -0,0 +1,13 @@
+{ lib, ... }:
+
+with lib;
+
+rec {
+  # tree k v = set k (either v (tree k v))
+
+  # get : [k] -> tree k v -> v
+  get = path: tree:
+    if length path > 0
+      then get (tail path) tree.${head path} # TODO check if elem exists
+      else tree;
+}