confctl 1.0.0

data/nix/evaluator.nix

@@ -0,0 +1,160 @@
+{ jsonArg }:
+let
+  arg = builtins.fromJSON (builtins.readFile jsonArg);
+
+  hasCorePkgs = (builtins.hasAttr "coreSwpins" arg) && (builtins.hasAttr "nixpkgs" arg.coreSwpins);
+
+  nixpkgs =
+    if hasCorePkgs then
+      import arg.coreSwpins.nixpkgs {}
+    else
+      import <nixpkgs> {};
+
+  machines = import ./machines.nix {
+    inherit (arg) confDir;
+    inherit corePkgs coreLib;
+  };
+
+  nameValuePairs = builtins.map (m: {
+    name = m.name;
+    value = {
+      inherit (m) name;
+    } // m.config;
+  }) machines;
+
+  machinesAttrs = builtins.listToAttrs nameValuePairs;
+
+  fullMachinesAttrs = builtins.listToAttrs (builtins.map (m: {
+    name = m.name;
+    value = m;
+  }) machines);
+
+  coreSwpins =
+    import ./lib/swpins/eval.nix {
+      inherit (arg) confDir;
+      name = "core";
+      dir = "";
+      channels = evalConfctl.config.confctl.swpins.core.channels;
+      pkgs = nixpkgs.pkgs;
+      lib = nixpkgs.lib;
+    };
+
+  corePkgs =
+    if hasCorePkgs then
+      nixpkgs
+    else if builtins.hasAttr "nixpkgs" coreSwpins.evaluated then
+      import coreSwpins.evaluated.nixpkgs {}
+    else
+      abort "Core swpins not set, run `confctl swpins core update`";
+
+  coreLib = corePkgs.lib;
+
+  machineSwpins = m:
+    import ./lib/swpins/eval.nix {
+      inherit (arg) confDir;
+      name = m.name;
+      channels = m.config.swpins.channels;
+      pkgs = corePkgs.pkgs;
+      lib = corePkgs.lib;
+    };
+
+  coreSwpinsAttrs = coreSwpins.evaluated;
+
+  selectedSwpinsAttrs = builtins.listToAttrs (builtins.map (host: {
+    name = host;
+    value = (machineSwpins fullMachinesAttrs.${host}).evaluated;
+  }) arg.machines);
+
+  selectedToplevels = builtins.listToAttrs (builtins.map (host: {
+    name = host;
+    value = buildToplevel fullMachinesAttrs.${host};
+  }) arg.machines);
+
+  buildToplevel = m: (evalMachine m).config.system.build.toplevel;
+
+  evalMachine = m:
+    let
+      importPath = {
+        nixos = <nixpkgs/nixos/lib/eval-config.nix>;
+        vpsadminos = <vpsadminos/os/default.nix>;
+      };
+
+      evalConfig = import importPath.${m.config.spin} {
+        modules = [ m.build.toplevel ];
+      };
+    in evalConfig;
+
+  evalConfctl =
+    let
+      cfg = "${toString arg.confDir}/configs/confctl.nix";
+    in evalNixosModules ([
+      ./modules/confctl/generations.nix
+      ./modules/confctl/cli.nix
+      ./modules/confctl/nix.nix
+      ./modules/confctl/swpins.nix
+      "${toString arg.confDir}/configs/swpins.nix"
+    ] ++ nixpkgs.lib.optional (builtins.pathExists cfg) cfg);
+
+  docToplevels = [
+    "cluster."
+    "confctl."
+  ];
+
+  filterOption = o:
+    !o.internal && builtins.any (top: nixpkgs.lib.hasPrefix top o.name) docToplevels;
+
+  docModules =
+    let
+      userModules = "${toString arg.confDir}/modules/cluster/default.nix";
+    in evalNixosModules (
+      (import ./modules/module-list.nix).all
+      ++
+      (nixpkgs.lib.optional (builtins.pathExists userModules) userModules)
+    );
+
+  docOptions =
+    builtins.filter filterOption (nixpkgs.lib.optionAttrSetToDocList docModules.options);
+
+  evalNixosModules = modules:
+    import <nixpkgs/nixos/lib/eval-config.nix> {
+      modules = modules ++ [
+        ({ ... }:
+        {
+          _module.args = {
+            confLib = import ./lib {
+              confDir = "${toString arg.confDir}";
+              coreLib = nixpkgs.lib;
+              corePkgs = nixpkgs.pkgs;
+            };
+          };
+        })
+      ];
+    };
+
+  build = {
+    # confctl settings
+    confctl = nixpkgs.writeText "confctl-settings.json" (builtins.toJSON { confctl = evalConfctl.config.confctl; });
+
+    # List available nixos module options for documentation purposes
+    moduleOptions = docOptions;
+
+    # List of machines
+    list = { machines = builtins.map (m: m.name) machines; };
+
+    # List of machines in an attrset: host => config
+    info = corePkgs.writeText "machine-list.json" (builtins.toJSON machinesAttrs);
+
+    # Nix configuration of swpins channels
+    listSwpinsChannels = evalConfctl.config.confctl.swpins.channels;
+
+    # JSON file with core swpins
+    evalCoreSwpins = corePkgs.writeText "swpins.json" (builtins.toJSON coreSwpinsAttrs);
+
+    # JSON file with swpins for selected machines
+    evalHostSwpins = corePkgs.writeText "swpins.json" (builtins.toJSON selectedSwpinsAttrs);
+
+    # JSON file with system.build.toplevel for selected machines, this must
+    # be run with proper NIX_PATH with swpins
+    toplevel = corePkgs.writeText "toplevels.json" (builtins.toJSON selectedToplevels);
+  };
+in build.${arg.build}

data/nix/lib/default.nix

@@ -0,0 +1,83 @@
+{ confDir, coreLib, corePkgs }:
+with coreLib;
+let
+  machine = import ./machine { inherit confDir corePkgs coreLib findConfig; };
+
+  findConfig =
+    { cluster, name }:
+    cluster.${name};
+
+  makeMachine =
+    { name, config }:
+    {
+      inherit name config;
+      build.toplevel = buildConfig { inherit name config; };
+    };
+
+  buildConfig =
+    { name, config }:
+    if !config.managed then
+      null
+    else if config.spin == "nixos" then
+      machine.nixos { inherit name config; }
+    else if config.spin == "vpsadminos" then
+      machine.vpsadminos { inherit name config; }
+    else
+      null;
+in rec {
+  inherit corePkgs coreLib;
+
+  mkNetUdevRule = name: mac: ''
+  ACTION=="add", SUBSYSTEM=="net", DRIVERS=="?*", KERNEL=="eth*", ATTR{address}=="${mac}", NAME="${name}"
+  '';
+
+  mkNetUdevRules = rs: concatStringsSep "\n" (mapAttrsToList (name: mac:
+    mkNetUdevRule name mac
+  ) rs);
+
+  inherit findConfig;
+
+  # Return all configured machines in a list
+  getClusterMachines = cluster:
+    mapAttrsToList (name: config:
+      makeMachine { inherit name config; }
+    ) cluster;
+
+  # Get IP version addresses from all machines in a cluster
+  getAllAddressesOf = cluster: v:
+    let
+      machines = getClusterMachines cluster;
+      addresses = flatten (map (machine:
+        map (addr: machine // addr) machine.config.addresses.${"v${toString v}"}
+      ) machines);
+    in addresses;
+
+  mkOptions = {
+    addresses = v:
+      { config, ... }:
+      {
+        options = {
+          address = mkOption {
+            type = types.str;
+            description = "IPv${toString v} address";
+          };
+
+          prefix = mkOption {
+            type = types.ints.positive;
+            description = "Prefix length";
+          };
+
+          string = mkOption {
+            type = types.nullOr types.str;
+            default = null;
+            apply = v:
+              if isNull v then
+                "${config.address}/${toString config.prefix}"
+              else
+                v;
+            description = "Address with prefix as string";
+          };
+        };
+      };
+  };
+}

data/nix/lib/machine/default.nix

@@ -0,0 +1,74 @@
+{ confDir, corePkgs, coreLib, findConfig }:
+let
+  swpinsFor =
+    { name, config }:
+    import ../swpins/eval.nix {
+      inherit confDir name;
+      channels = config.swpins.channels;
+      pkgs = corePkgs;
+      lib = coreLib;
+    };
+
+  makeModuleArgs =
+    { config, swpins, spin, name }@args: {
+      swpins = swpins.evaluated;
+      swpinsInfo = swpins.infos;
+      confMachine = import ./info.nix (args // { inherit findConfig; });
+    };
+
+  makeImports = spin: extraImports: [
+    ({ config, pkgs, lib, confMachine, ... }:
+    {
+      _file = "confctl/nix/lib/machine/default.nix";
+
+      _module.args = {
+        inherit confDir;
+        confLib = import ../../lib { inherit confDir coreLib corePkgs; };
+        confData = import "${toString confDir}/data/default.nix" { inherit lib; };
+      };
+
+      networking.hostName =
+        lib.mkIf (confMachine.host != null && confMachine.host.name != null) (lib.mkDefault confMachine.host.name);
+
+      networking.domain =
+        lib.mkIf (confMachine.host != null) (lib.mkDefault confMachine.host.fullDomain);
+    })
+  ] ++ (import ../../modules/module-list.nix).${spin}
+    ++ (import "${toString confDir}/modules/module-list.nix").${spin}
+    ++ (import "${toString confDir}/cluster/module-list.nix")
+    ++ extraImports;
+in rec {
+  nixos = { name, config }:
+    let
+      swpins = swpinsFor { inherit name config; };
+    in
+      { config, pkgs, ... }@args:
+      {
+        _module.args = makeModuleArgs {
+          inherit config swpins;
+          spin = "nixos";
+          inherit name;
+        };
+
+        imports = makeImports "nixos" [
+          "${toString confDir}/cluster/${name}/config.nix"
+        ];
+      };
+
+  vpsadminos = { name, config }:
+    let
+      swpins = swpinsFor { inherit name config; };
+    in
+      { config, pkgs, ... }@args:
+      {
+        _module.args = makeModuleArgs {
+          inherit config swpins;
+          spin = "vpsadminos";
+          inherit name;
+        };
+
+        imports = makeImports "vpsadminos" [
+          "${toString confDir}/cluster/${name}/config.nix"
+        ];
+      };
+}

data/nix/lib/machine/info.nix

@@ -0,0 +1,5 @@
+{ config, spin, name, findConfig, ... }:
+({ inherit name; } // findConfig {
+  inherit (config) cluster;
+  inherit name;
+})

data/nix/lib/swpins/eval.nix

@@ -0,0 +1,71 @@
+{ confDir, name, dir ? "cluster", channels, pkgs, lib }:
+let
+  pinFileName = builtins.replaceStrings [ "/" ] [ ":" ] name;
+
+  pinFilePath = "${toString confDir}/swpins/${dir}/${pinFileName}.json";
+
+  pinFileJson = builtins.readFile pinFilePath;
+
+  pinFileSpecs =
+    if builtins.pathExists pinFilePath then
+      builtins.fromJSON pinFileJson
+    else
+      {};
+
+  pinFileSwpins = lib.mapAttrs (k: v: swpin v) pinFileSpecs;
+
+  channelPath = chan: "${toString confDir}/swpins/channels/${chan}.json";
+
+  channelJson = chan: builtins.readFile (channelPath chan);
+
+  channelSpecs = chan: builtins.fromJSON (channelJson chan);
+
+  channelSwpins = chan: lib.mapAttrs (k: v: swpin v) (channelSpecs chan);
+
+  allChannelSwpins = map channelSwpins channels;
+
+  allSwpins = (lib.foldl (a: b: a // b) {} allChannelSwpins) // pinFileSwpins;
+
+  swpin = { fetcher, ... }:
+    fetchers.${fetcher.type} fetcher.options;
+
+  fetchers = rec {
+    directory = opts:
+      opts.path;
+
+    git = opts:
+      let
+        filter = lib.filterAttrs (k: v: builtins.elem k [
+          "url" "rev" "sha256" "fetchSubmodules"
+        ]);
+      in pkgs.fetchgit (filter opts);
+
+    zip = opts:
+      pkgs.fetchzip opts;
+
+    git-rev = opts:
+      let
+        repo = fetchers.${opts.wrapped_fetcher.type} opts.wrapped_fetcher.options;
+        shortRev = lib.substring 0 9 (opts.rev);
+      in
+        pkgs.runCommand "git-${shortRev}" {} ''
+          cp -a ${repo} $out
+          chmod 700 $out
+          echo "${opts.rev}" > $out/.git-revision
+          echo ".git.${shortRev}" > $out/.version-suffix
+        '';
+  };
+
+  pinFileInfos = lib.mapAttrs (k: v: v.info or {}) pinFileSpecs;
+
+  channelInfos = chan: lib.mapAttrs (k: v: v.info or {}) (channelSpecs chan);
+
+  allChannelInfos = map channelInfos channels;
+
+  allInfos = (lib.foldl (a: b: a // b) {} allChannelInfos) // pinFileInfos;
+
+in {
+  evaluated = allSwpins;
+
+  infos = allInfos;
+}

data/nix/lib/swpins/options.nix

@@ -0,0 +1,94 @@
+{ lib }:
+with lib;
+rec {
+  specModule =
+    { config, ... }:
+    {
+      options = {
+        type = mkOption {
+          type = types.enum [ "directory" "git" "git-rev" ];
+          default = "git";
+        };
+
+        directory = mkOption {
+          type = types.nullOr (types.submodule directorySpec);
+          default = null;
+        };
+
+        git = mkOption {
+          type = types.nullOr (types.submodule gitSpec);
+          default = null;
+        };
+
+        git-rev = mkOption {
+          type = types.nullOr (types.submodule gitSpec);
+          default = null;
+        };
+      };
+    };
+
+  directorySpec =
+    { config, ... }:
+    {
+      options = {
+        path = mkOption {
+          type = types.str;
+          description = ''
+            Absolute path to the directory
+          '';
+          example = "/opt/my-swpin";
+        };
+      };
+    };
+
+  gitSpec =
+    { config, ... }:
+    {
+      options = {
+        url = mkOption {
+          type = types.str;
+          description = ''
+            URL of the git repository
+          '';
+          example = "https://github.com/vpsfreecz/vpsadminos";
+        };
+
+        fetchSubmodules = mkOption {
+          type = types.bool;
+          default = false;
+          description = ''
+            Fetch git submodules
+          '';
+        };
+
+        update = {
+          ref = mkOption {
+            type = types.nullOr types.str;
+            default = null;
+            description = ''
+              Implicit git reference to use for both manual and automatic updates
+            '';
+            example = "refs/heads/master";
+          };
+
+          auto = mkOption {
+            type = types.bool;
+            default = false;
+            description = ''
+              When enabled, the pin is automatically updated to
+              <literal>ref</literal> before building machines.
+            '';
+          };
+
+          interval = mkOption {
+            type = types.int;
+            default = 60*60;
+            description = ''
+              Number of seconds from the last update to trigger the next
+              auto-update, if auto-update is enabled.
+            '';
+          };
+        };
+      };
+    };
+}

data/nix/machines.nix

@@ -0,0 +1,31 @@
+{ confDir, corePkgs, coreLib }:
+let
+  confLib = import ./lib { inherit confDir coreLib corePkgs; };
+
+  userModules = "${toString confDir}/modules/cluster/default.nix";
+
+  baseModules = [
+    ({ ... }:
+    {
+      _module.args = {
+        pkgs = corePkgs;
+        inherit confLib;
+        swpins = {};
+        swpinsInfo = {};
+        confMachine = null;
+      };
+    })
+
+    ./modules/cluster
+  ] ++ (import "${toString confDir}/cluster/module-list.nix")
+    ++ (coreLib.optional (builtins.pathExists userModules) userModules);
+
+  evalConfig = corePkgs.lib.evalModules {
+    prefix = [];
+    modules = baseModules;
+  };
+
+  cluster = evalConfig.config.cluster;
+
+  allMachines = confLib.getClusterMachines cluster;
+in allMachines