eval-machine-info.nix

{ system ? builtins.currentSystem
, networkExprs
, flakeReference ? null
, flakeAttribute
, checkConfigurationOptions ? true
, uuid
, deploymentName
, args
, pluginNixExprs
}:

let
  /* Return an attribute from nested attribute sets.
     Example:
       x = { a = { b = 3; }; }
       attrByPath ["a" "b"] x
       => 3
       x = { a = { b = 3; }; }
       attrByPath ["a" "c"] x
       error: can't found `a.c` in the set
  */
  attrByPath = attrPath: e:
    let
      attrByPathRec  = attrPath: e:
        # if it's the end return the element it's self
        if attrPath == [] then
          {inherit e; found = true;}
        else
          let attr = builtins.head attrPath; in
          if e ? ${attr} then
            attrByPathRec (builtins.tail attrPath) e.${attr}
          else
            {e=null; found = false;};
          result = attrByPathRec attrPath e;
      in
        # Check result
        if result.found then
          # If found return the value
          result.e
        else
          # Not found, Create the searching path
          let path = builtins.concatStringsSep "." attrPath; in
            # Throw an exception
            throw "can't found `${path}` in the set";

  call = x: if builtins.isFunction x then x args else x;

  # Copied from nixpkgs to avoid <nixpkgs> import
  optional = cond: elem: if cond then [elem] else [];

  zipAttrs = set: builtins.listToAttrs (
    map (name: { inherit name; value = builtins.catAttrs name set; }) (builtins.concatMap builtins.attrNames set));

  # the flake expresion
  flakeExpr =
    let
      # Get the flake config
      flake = builtins.getFlake flakeReference;
      # get the chosen deployement.
      deploy = attrByPath flakeAttribute flake.outputs.nixopsConfigurations;
    in
      # Return the deployement found.
      deploy;

  networks =
    let
      getNetworkFromExpr = networkExpr:
        (call (import networkExpr)) // { _file = networkExpr; };

      exprToKey = key: { key = toString key; };

      networkExprClosure = builtins.genericClosure {
        startSet = map exprToKey networkExprs;
        operator = { key }: map exprToKey ((getNetworkFromExpr key).require or []);
      };
    in
      map ({ key }: getNetworkFromExpr key) networkExprClosure
      ++ optional (flakeReference != null)
        ((call flakeExpr) // { _file = "<${flakeReference}>"; });

  network = zipAttrs networks;

  evalConfig =
    if flakeReference != null
    then
      if network ? nixpkgs
      then (builtins.head (network.nixpkgs)).lib.nixosSystem
      else throw "NixOps network must have a 'nixpkgs' attribute"
    else import (pkgs.path + "/nixos/lib/eval-config.nix");

  pkgs = if flakeReference != null
    then
      if network ? nixpkgs
      then (builtins.head network.nixpkgs).legacyPackages.${system}
      else throw "NixOps network must have a 'nixpkgs' attribute"
    else (builtins.head (network.network)).nixpkgs or (import <nixpkgs> { inherit system; });

  inherit (pkgs) lib;

  # Expose path to imported nixpkgs (currently only used to find version suffix)
  nixpkgs = builtins.unsafeDiscardStringContext pkgs.path;

in rec {

  inherit networks network;
  inherit nixpkgs;

  importedPluginNixExprs = map
    (expr: import expr)
    pluginNixExprs;
  pluginOptions = { imports = (lib.foldl (a: e: a ++ e.options) [] importedPluginNixExprs); };
  pluginResources = map (e: e.resources) importedPluginNixExprs;
  pluginDeploymentConfigExporters = (lib.foldl (a: e: a ++ (e.config_exporters {
    inherit pkgs;
    inherit (lib) optionalAttrs;
  })) [] importedPluginNixExprs);

  defaults = network.defaults or [];

  # Compute the definitions of the machines.
  nodes =
    lib.listToAttrs (map (machineName:
      let
        # Get the configuration of this machine from each network
        # expression, attaching _file attributes so the NixOS module
        # system can give sensible error messages.
        modules =
          lib.concatMap (n: lib.optional (lib.hasAttr machineName n)
            { imports = [(lib.getAttr machineName n)]; inherit (n) _file; })
          networks;
      in
      { name = machineName;
        value = evalConfig {
          modules =
            modules ++
            defaults ++
            [ deploymentInfoModule ] ++
            [ { key = "nixops-stuff";
                # Make NixOps's deployment.* options available.
                imports = [ ./options.nix ./resource.nix pluginOptions ];
                # Provide a default hostname and deployment target equal
                # to the attribute name of the machine in the model.
                networking.hostName = lib.mkOverride 900 machineName;
                deployment.targetHost = lib.mkOverride 900 machineName;
                environment.checkConfigurationOptions = lib.mkOverride 900 checkConfigurationOptions;

                nixpkgs.system = lib.mkDefault system;

                _module.args = { inherit nodes resources uuid deploymentName; name = machineName; };
              }
            ];
        };
      }
    ) (lib.attrNames (removeAttrs network [ "network" "defaults" "resources" "require" "nixpkgs" "_file" ])));

  # Compute the definitions of the non-machine resources.
  resourcesByType = lib.zipAttrs (network.resources or []);

  deploymentInfoModule = {
    deployment = {
      name = deploymentName;
      arguments = args;
      inherit uuid;
    };
  };

  evalResources = mainModule: _resources:
    lib.mapAttrs
      (name: defs:
        let
          # Arguments fed to all modules
          moduleArgs = {
            _module.args = {
              inherit pkgs uuid name resources;

              # inherit nodes, essentially
              nodes =
                lib.mapAttrs
                  (nodeName: node:
                    lib.mapAttrs
                      (key: lib.warn "Resource ${name} accesses nodes.${nodeName}.${key}, which is deprecated. Use the equivalent option instead: nodes.${nodeName}.${newOpt key}.")
                      info.machines.${nodeName}
                    // node)
                  nodes;
            };
          };
          modules = [
            moduleArgs
            mainModule
            deploymentInfoModule
            ./resource.nix
          ] ++ defs;
        in
          builtins.removeAttrs
            (lib.evalModules { inherit modules; }).config
            ["_module"])
      _resources;

  newOpt = key: {
    nixosRelease = "config.system.nixos.release and make sure it is set properly";
    publicIPv4 = "config.networking.publicIPv4";
  }.${key} or "config.deployment.${key}";

  resources = lib.foldl
    (a: b: a // (b {
      inherit evalResources resourcesByType;
      inherit (lib) zipAttrs;
    }))
    {
      sshKeyPairs = evalResources ./ssh-keypair.nix (lib.zipAttrs resourcesByType.sshKeyPairs or []);
      commandOutput = evalResources ./command-output.nix (lib.zipAttrs resourcesByType.commandOutput or []);
      machines = lib.mapAttrs (n: v: v.config) nodes;
    }
    pluginResources;

  # check if there are duplicate elements in a sorted list
  noDups = l:
    if lib.length l > 1
    then
      if (lib.head l) == (lib.head (lib.tail l))
      then throw "found resources with duplicate names: ${lib.head l}"
      else noDups (lib.tail l)
    else true;

  # Phase 1: evaluate only the deployment attributes.
  info =
    let
      network' = network;
      resources' = resources;
    in rec {

    machines =
      lib.flip lib.mapAttrs nodes (n: v': let v = lib.scrubOptionValue v'; in
      lib.foldr (a: b: a // b)
        {
          inherit (v.config.deployment)
            targetEnv
            targetPort
            targetHost
            targetUser
            sshOptions
            privilegeEscalationCommand
            alwaysActivate
            owners
            keys
            hasFastConnection
            provisionSSHKey
            ;
          nixosRelease = v.config.system.nixos.release or v.config.system.nixosRelease or (lib.removeSuffix v.config.system.nixosVersionSuffix v.config.system.nixosVersion);
          publicIPv4 = v.config.networking.publicIPv4;
        }
      (map
        (f: f v.config)
        pluginDeploymentConfigExporters
      ));

    network =
      builtins.removeAttrs
      (lib.fold (as: bs: as // bs) {} (network'.network or []))
      [ "nixpkgs" ]  # Not serialisable
      ;

    resources =
    let
      resource_referenced = list: check: recurse:
          lib.any lib.id (map (value: (check value) ||
                              ((lib.isAttrs value) && (!(value ? _type) || recurse)
                                               && (resource_referenced (lib.attrValues value) check false)))
                      list);

      flatten_resources = resources: lib.flatten ( map lib.attrValues (lib.attrValues resources) );

      resource_used = res_set: resource:
          resource_referenced
              (flatten_resources res_set)
              (value: value == resource )
              true;

      resources_without_defaults = res_class: defaults: res_set:
        let
          missing = lib.filter (res: !(resource_used (removeAttrs res_set [res_class])
                                                  res_set."${res_class}"."${res}"))
                           (lib.attrNames defaults);
        in
        res_set // { "${res_class}" = ( removeAttrs res_set."${res_class}" missing ); };

    in (removeAttrs resources' [ "machines" ]);

  };

  # Phase 2: build complete machine configurations.
  machines = { names }:
    let nodes' = lib.filterAttrs (n: v: lib.elem n names) nodes; in
    pkgs.runCommand "nixops-machines"
      { preferLocalBuild = true; }
      ''
        mkdir -p $out
        ${toString (lib.attrValues (lib.mapAttrs (n: v: ''
          ln -s ${v.config.system.build.toplevel} $out/${n}
        '') nodes'))}
      '';


  # Function needed to calculate the nixops arguments. This should work even when arguments
  # are not set yet, so we fake arguments to be able to evaluate the require attribute of
  # the nixops network expressions.

  dummyArgs = f: builtins.listToAttrs (map (a: lib.nameValuePair a false) (builtins.attrNames (builtins.functionArgs f)));

  getNixOpsExprs = l: lib.unique (lib.flatten (map getRequires l));

  getRequires = f:
    let
      nixopsExpr = import f;
      requires =
        if builtins.isFunction nixopsExpr then
          ((nixopsExpr (dummyArgs nixopsExpr)).require or [])
        else
          (nixopsExpr.require or []);
    in
      [ f ] ++ map getRequires requires;

  exprToArgs = nixopsExpr: f:
    if builtins.isFunction nixopsExpr then
      map (a: { "${a}" = builtins.toString f; } ) (builtins.attrNames (builtins.functionArgs nixopsExpr))
    else [];

  fileToArgs = f:
    let
      nixopsExpr = import f;
    in
      if builtins.isFunction nixopsExpr then
        map (a: { "${a}" = builtins.toString f; } ) (builtins.attrNames (builtins.functionArgs nixopsExpr))
      else [];

  getNixOpsArgs = fs: lib.zipAttrs (lib.unique (lib.concatMap fileToArgs (getNixOpsExprs fs)));

  nixopsArguments =
    if flakeReference == null then getNixOpsArgs networkExprs
    else lib.listToAttrs (builtins.map (a: {name = a; value = [ flakeReference ];}) (lib.attrNames (builtins.functionArgs flakeExpr)));

}