commit 971f0b45ef7129073a6e996f1c63a1f2b470a7e0 · pyrox.dev/nixpkgs

+18

nixos/modules/tasks/network-interfaces.nix

···

       394
       394
        
             '';

     

       395
       395
        
           };

     

       396
       396
        
       

     

       397
       397
       +
           networking.fqdn = mkOption {

     

       398
       398
       +
             readOnly = true;

     

       399
       399
       +
             type = types.str;

     

       400
       400
       +
             default = if (cfg.hostName != "" && cfg.domain != null)

     

       401
       401
       +
               then "${cfg.hostName}.${cfg.domain}"

     

       402
       402
       +
               else throw ''

     

       403
       403
       +
                 The FQDN is required but cannot be determined. Please make sure that

     

       404
       404
       +
                 both networking.hostName and networking.domain are set properly.

     

       405
       405
       +
               '';

     

       406
       406
       +
             defaultText = literalExample ''''${networking.hostName}.''${networking.domain}'';

     

       407
       407
       +
             description = ''

     

       408
       408
       +
               The fully qualified domain name (FQDN) of this host. It is the result

     

       409
       409
       +
               of combining networking.hostName and networking.domain. Using this

     

       410
       410
       +
               option will result in an evaluation error if the hostname is empty or

     

       411
       411
       +
               no domain is specified.

     

       412
       412
       +
             '';

     

       413
       413
       +
           };

     

       414
       414
       +
       

     

       397
       415
        
           networking.hostId = mkOption {

     

       398
       416
        
             default = null;

     

       399
       417
        
             example = "4e98920d";

+10 -4

nixos/tests/hostname.nix

···

       7
       7
        
       with pkgs.lib;

     

       8
       8
        
       

     

       9
       9
        
       let

     

       10
       10
       -
         makeHostNameTest = hostName: domain:

     

       10
       10
       +
         makeHostNameTest = hostName: domain: fqdnOrNull:

     

       11
       11
        
           let

     

       12
       12
        
             fqdn = hostName + (optionalString (domain != null) ".${domain}");

     

       13
       13
       +
             getStr = str: # maybeString2String

     

       14
       14
       +
               let res = builtins.tryEval str;

     

       15
       15
       +
               in if (res.success && res.value != null) then res.value else "null";

     

       13
       16
        
           in

     

       14
       17
        
             makeTest {

     

       15
       18
        
               name = "hostname-${fqdn}";

     
···

       26
       29
        
                 ];

     

       27
       30
        
               };

     

       28
       31
        
       

     

       29
       29
       -
               testScript = ''

     

       32
       32
       +
               testScript = { nodes, ... }: ''

     

       30
       33
        
                 start_all()

     

       31
       34
        
       

     

       32
       35
        
                 machine = ${hostName}

     

       33
       36
        
       

     

       34
       37
        
                 machine.wait_for_unit("network-online.target")

     

       35
       38
        
       

     

       39
       39
       +
                 # Test if NixOS computes the correct FQDN (either a FQDN or an error/null):

     

       40
       40
       +
                 assert "${getStr nodes.machine.config.networking.fqdn}" == "${getStr fqdnOrNull}"

     

       41
       41
       +
       

     

       36
       42
        
                 # The FQDN, domain name, and hostname detection should work as expected:

     

       37
       43
        
                 assert "${fqdn}" == machine.succeed("hostname --fqdn").strip()

     

       38
       44
        
                 assert "${optionalString (domain != null) domain}" == machine.succeed("dnsdomainname").strip()

     
···

       60
       66
        
       

     

       61
       67
        
       in

     

       62
       68
        
       {

     

       63
       63
       -
         noExplicitDomain = makeHostNameTest "ahost" null;

     

       69
       69
       +
         noExplicitDomain = makeHostNameTest "ahost" null null;

     

       64
       70
        
       

     

       65
       65
       -
         explicitDomain = makeHostNameTest "ahost" "adomain";

     

       71
       71
       +
         explicitDomain = makeHostNameTest "ahost" "adomain" "ahost.adomain";

     

       66
       72
        
       }