Anonymous NixOS modules (e.g. from flakes) cannot be disabled

[jorsn]

Describe the bug

An anonymous NixOS module (not included in imports by path but as a function/attr set) cannot be disabled, both because on import the module key is not specific to a module but to an import and because filterModules tries to convert all non-string elements of disabledModules to strings, probably expecting them to be paths.

This defeats the standardized nixosModules api of flakes, since one must rely on the file structure for importing and disabling for disabledModules to work.

To Reproduce

1. add disabledModules = [ {} ]; to configuration.nix
2. try to nixos-rebuild build
3. Result:

[root@longitude-j:/etc/nixos]# nixos-rebuild build
building Nix...
error: --- TypeError ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nix-instantiate
at: (200:81) in file: /nix/var/nix/profiles/per-user/root/channels/nixos/lib/modules.nix

   199|         let
   200|           moduleKey = m: if isString m then toString modulesPath + "/" + m else toString m;
      |                                                                                 ^
   201|           disabledKeys = map moduleKey disabled;

cannot coerce a set to a string

Expected behavior

If possible, modules should probably get a unique key, regardless of how they are given. This should also be used in disabledModules.

[SCOTT-HAMILTON]

I know that it's quite straightforward but I still think that it's better to rely on a test machine than to rebuild your own config.

import ./make-test-python.nix ({ pkgs, ... }: {
  name = "test";

  nodes.test = { pkgs, ... }: { disabledModules = [ {} ]; };

  testScript = ''
  '';
})

[bqv]

So surely the answer is don't use anonymous modules?

Edit: oh, for what it's worth, just because the module isn't in nixpkgs, doesn't mean it's de-facto anonymous. None of the ones in my flake are - I had to ensure that to make manual building work

[jorsn]

@bqv: Every module you access over the flake API (the attr nixosModules) is anonymous, as is every module you access over the NUR. To not use it anonymously, you have to utilize the underlying file structure, which defeats one main purpose of flakes, namely a consistent Nix API for different projects.

What do you mean by “manual building”?

[bqv]

Yes. Caring about file structure is not against the flake api imo, hence why flakes can be coerced to paths like any other derivation.

Manual building = the act of building the manual...

[jorsn]

It's not against the flake api, but it circumvents it. It doesn't use the flake API, so it defeats the reason for using flakes. You can simply use any fixed-output derivation for fetching or declare a non-flake input to a flake, if you don't want to use a consistent api.

Why are you using Nix in the first place if you can use Linux From Scratch? What do you need Linux for if you can write your own kernel and directly access hardware? Because of abstraction. Imagine a flake whose file tree is littered with modules in 50 different places but exposing the standardized flake API. You have to look at every file to know if it's a module. You don't want to include every single one by path, do you?

[bqv]

You can't be serious...

[Pacman99]

I've been running into this and it is pretty frustrating. disabledModules becomes very hard to use with flakes. Not really sure how this could be solved though, I don't think it's possible to compare anonymous functions.

[jorsn]

You can still override modules by path, but you must rely on the file system structure of the flakes. The store dir of an input flake foo is "${foo}".

The modules aren't necessarily anonymous functions. They can be attrsets, functions or functors (i.e. attrsets containing an attr __functor = self: f for some function f). Functions and functors are treated equally, but functors could carry metadata like a module key. One could e.g. derive the key from an attribute path of a module, but lib.evalModules would have to be adapted to make use of this information.

[noonien]

Edit: The issue was my lack of understanding of how nixos modules work, coupled with how declarative nixos containers work. disabledModules are not passed into the declared containers (which should be expected).

I think I bumped into this issue, is there a workaround?

Neither

disabledModules = [ "${modulesPath}/services/web-apps/restya-board.nix" ];

disabledModules = [ "services/web-apps/restya-board.nix" ];

seem to work, and there doesn't seem to be any examples or documentation on how to replace a module in a flaked configuration.

Any ideas?

[mvnetbiz]

filterModules does not convert all non-string elements. The cause is that since #49401 eval-config.nix passes modulesPath as a string, causing filterModules to always append modulesPath an extra time. You can fix it in your config by turning it back into a path like this. You should be able to add a path referencing a Flake's nixosModules to disabledModules.

{ config, pkgs, lib, modulesPath, ... }:

{
  imports = [
    "${modulesPath}/installer/sd-card/sd-image.nix"
  ];

  disabledModules = map (m: /. + "${modulesPath}/${m}") [
    "profiles/all-hardware.nix"
  ];
}

[stale]

I marked this as stale due to inactivity. → More info

[vikanezrimaya]

Still important.

(I use all of my custom modules via flake attributes, and if I were to need to disable a module pulled by another module, that would be a major source of pain.)

[Lyndeno]

Still important to me as well. Had to reference a flake module by path to get my config to work.