commit c03fe792656b506b40e18d9c070d0bad8f7f1c3e · pyrox.dev/nixpkgs

+1 -1

nixos/modules/installer/cd-dvd/installation-cd-base.nix

···

       16
       16
        
           ];

     

       17
       17
        
       

     

       18
       18
        
         # ISO naming.

     

       19
       19
       -
         isoImage.isoName = "${config.isoImage.isoBaseName}-${config.system.nixosVersion}-${pkgs.stdenv.system}.iso";

     

       19
       19
       +
         isoImage.isoName = "${config.isoImage.isoBaseName}-${config.system.nixosLabel}-${pkgs.stdenv.system}.iso";

     

       20
       20
        
       

     

       21
       21
        
         isoImage.volumeID = substring 0 11 "NIXOS_ISO";

     

       22
       22

+1 -1

nixos/modules/installer/cd-dvd/iso-image.nix

···

       39
       39
        
           DEFAULT boot

     

       40
       40
        
       

     

       41
       41
        
           LABEL boot

     

       42
       42
       -
           MENU LABEL NixOS ${config.system.nixosVersion}${config.isoImage.appendToMenuLabel}

     

       42
       42
       +
           MENU LABEL NixOS ${config.system.nixosLabel}${config.isoImage.appendToMenuLabel}

     

       43
       43
        
           LINUX /boot/bzImage

     

       44
       44
        
           APPEND init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams}

     

       45
       45
        
           INITRD /boot/initrd

+51 -21

nixos/modules/misc/version.nix

···

       2
       2
        
       

     

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.system;

     

       7
       7
       +
       

     

       8
       8
       +
         releaseFile = "${toString pkgs.path}/.version";

     

       9
       9
       +
         suffixFile = "${toString pkgs.path}/.version-suffix";

     

       10
       10
       +
         revisionFile = "${toString pkgs.path}/.git-revision";

     

       11
       11
       +
       in

     

       12
       12
       +
       

     

       5
       13
        
       {

     

       6
       14
        
       

     

       7
       7
       -
         options = {

     

       15
       15
       +
         options.system = {

     

       8
       16
        
       

     

       9
       9
       -
           system.stateVersion = mkOption {

     

       17
       17
       +
           stateVersion = mkOption {

     

       10
       18
        
             type = types.str;

     

       11
       11
       -
             default = config.system.nixosRelease;

     

       19
       19
       +
             default = cfg.nixosRelease;

     

       12
       20
        
             description = ''

     

       13
       21
        
               Every once in a while, a new NixOS release may change

     

       14
       22
        
               configuration defaults in a way incompatible with stateful

     
···

       22
       30
        
             '';

     

       23
       31
        
           };

     

       24
       32
        
       

     

       25
       25
       -
           system.nixosVersion = mkOption {

     

       33
       33
       +
           nixosLabel = mkOption {

     

       34
       34
       +
             type = types.str;

     

       35
       35
       +
             description = ''

     

       36
       36
       +
               NixOS version name to be used in the names of generated

     

       37
       37
       +
               outputs and boot labels.

     

       38
       38
       +
       

     

       39
       39
       +
               If you ever wanted to influence the labels in your GRUB menu,

     

       40
       40
       +
               this is option is for you.

     

       41
       41
       +
       

     

       42
       42
       +
               Can be set directly or with <envar>NIXOS_LABEL</envar>

     

       43
       43
       +
               environment variable for <command>nixos-rebuild</command>,

     

       44
       44
       +
               e.g.:

     

       45
       45
       +
       

     

       46
       46
       +
               <screen>

     

       47
       47
       +
               #!/bin/sh

     

       48
       48
       +
               today=`date +%Y%m%d`

     

       49
       49
       +
               branch=`(cd nixpkgs ; git branch 2>/dev/null | sed -n '/^\* / { s|^\* ||; p; }')`

     

       50
       50
       +
               revision=`(cd nixpkgs ; git rev-parse HEAD)`

     

       51
       51
       +
               export NIXOS_LABEL="$today.$branch-''${revision:0:7}"

     

       52
       52
       +
               nixos-rebuild switch</screen>

     

       53
       53
       +
             '';

     

       54
       54
       +
           };

     

       55
       55
       +
       

     

       56
       56
       +
           nixosVersion = mkOption {

     

       26
       57
        
             internal = true;

     

       27
       58
        
             type = types.str;

     

       28
       59
        
             description = "NixOS version.";

     

       29
       60
        
           };

     

       30
       61
        
       

     

       31
       31
       -
           system.nixosRelease = mkOption {

     

       62
       62
       +
           nixosRelease = mkOption {

     

       32
       63
        
             readOnly = true;

     

       33
       64
        
             type = types.str;

     

       34
       34
       -
             default = readFile "${toString pkgs.path}/.version";

     

       65
       65
       +
             default = readFile releaseFile;

     

       35
       66
        
             description = "NixOS release.";

     

       36
       67
        
           };

     

       37
       68
        
       

     

       38
       38
       -
           system.nixosVersionSuffix = mkOption {

     

       69
       69
       +
           nixosVersionSuffix = mkOption {

     

       39
       70
        
             internal = true;

     

       40
       71
        
             type = types.str;

     

       72
       72
       +
             default = if pathExists suffixFile then readFile suffixFile else "pre-git";

     

       41
       73
        
             description = "NixOS version suffix.";

     

       42
       74
        
           };

     

       43
       75
        
       

     

       44
       44
       -
           system.nixosRevision = mkOption {

     

       76
       76
       +
           nixosRevision = mkOption {

     

       45
       77
        
             internal = true;

     

       46
       78
        
             type = types.str;

     

       79
       79
       +
             default = if pathExists revisionFile then readFile revisionFile else "master";

     

       47
       80
        
             description = "NixOS Git revision hash.";

     

       48
       81
        
           };

     

       49
       82
        
       

     

       50
       50
       -
           system.nixosCodeName = mkOption {

     

       83
       83
       +
           nixosCodeName = mkOption {

     

       51
       84
        
             readOnly = true;

     

       52
       85
        
             type = types.str;

     

       53
       86
        
             description = "NixOS release code name.";

     

       54
       87
        
           };

     

       55
       88
        
       

     

       56
       56
       -
           system.defaultChannel = mkOption {

     

       89
       89
       +
           defaultChannel = mkOption {

     

       57
       90
        
             internal = true;

     

       58
       91
        
             type = types.str;

     

       59
       92
        
             default = https://nixos.org/channels/nixos-unstable;

     
···

       64
       97
        
       

     

       65
       98
        
         config = {

     

       66
       99
        
       

     

       67
       67
       -
           system.nixosVersion = mkDefault (config.system.nixosRelease + config.system.nixosVersionSuffix);

     

       68
       68
       -
       

     

       69
       69
       -
           system.nixosVersionSuffix =

     

       70
       70
       -
             let suffixFile = "${toString pkgs.path}/.version-suffix"; in

     

       71
       71
       -
             mkDefault (if pathExists suffixFile then readFile suffixFile else "pre-git");

     

       72
       72
       -
       

     

       73
       73
       -
           system.nixosRevision =

     

       74
       74
       -
             let fn = "${toString pkgs.path}/.git-revision"; in

     

       75
       75
       -
             mkDefault (if pathExists fn then readFile fn else "master");

     

       100
       100
       +
           system = {

     

       101
       101
       +
             # These defaults are set here rather than up there so that

     

       102
       102
       +
             # changing them would not rebuild the manual

     

       103
       103
       +
             nixosLabel   = mkDefault (maybeEnv "NIXOS_LABEL" cfg.nixosVersion);

     

       104
       104
       +
             nixosVersion = mkDefault (maybeEnv "NIXOS_VERSION" (cfg.nixosRelease + cfg.nixosVersionSuffix));

     

       76
       105
        
       

     

       77
       77
       -
           # Note: code names must only increase in alphabetical order.

     

       78
       78
       -
           system.nixosCodeName = "Emu";

     

       106
       106
       +
             # Note: code names must only increase in alphabetical order.

     

       107
       107
       +
             nixosCodeName = "Emu";

     

       108
       108
       +
           };

     

       79
       109
        
       

     

       80
       110
        
           # Generate /etc/os-release.  See

     

       81
       111
        
           # http://0pointer.de/public/systemd-man/os-release.html for the

+14 -6

nixos/modules/services/ttys/agetty.nix

···

       2
       2
        
       

     

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
       +
       let

     

       6
       6
       +
       

     

       7
       7
       +
         autologinArg = optionalString (config.services.mingetty.autologinUser != null) "--autologin ${config.services.mingetty.autologinUser}";

     

       8
       8
       +
         gettyCmd = extraArgs: "@${pkgs.utillinux}/sbin/agetty agetty --login-program ${pkgs.shadow}/bin/login ${autologinArg} ${extraArgs}";

     

       9
       9
       +
       

     

       10
       10
       +
       in

     

       11
       11
       +
       

     

       5
       12
        
       {

     

       6
       13
        
       

     

       7
       14
        
         ###### interface

     
···

       21
       28
        
       

     

       22
       29
        
             greetingLine = mkOption {

     

       23
       30
        
               type = types.str;

     

       24
       24
       -
               default = ''<<< Welcome to NixOS ${config.system.nixosVersion} (\m) - \l >>>'';

     

       25
       31
        
               description = ''

     

       26
       32
        
                 Welcome line printed by mingetty.

     

       33
       33
       +
                 The default shows current NixOS version label, machine type and tty.

     

       27
       34
        
               '';

     

       28
       35
        
             };

     

       29
       36
        
       

     
···

       55
       62
        
       

     

       56
       63
        
         ###### implementation

     

       57
       64
        
       

     

       58
       58
       -
         config = let

     

       59
       59
       -
           autologinArg = optionalString (config.services.mingetty.autologinUser != null) "--autologin ${config.services.mingetty.autologinUser}";

     

       60
       60
       -
           gettyCmd = extraArgs: "@${pkgs.utillinux}/sbin/agetty agetty --login-program ${pkgs.shadow}/bin/login ${autologinArg} ${extraArgs}";

     

       61
       61
       -
         in {

     

       65
       65
       +
         config = {

     

       66
       66
       +
           # Note: this is set here rather than up there so that changing

     

       67
       67
       +
           # nixosLabel would not rebuild manual pages

     

       68
       68
       +
           services.mingetty.greetingLine = mkDefault ''<<< Welcome to NixOS ${config.system.nixosLabel} (\m) - \l >>>'';

     

       69
       69
       +
       

     

       62
       70
        
           systemd.services."getty@" =

     

       63
       71
        
             { serviceConfig.ExecStart = gettyCmd "--noclear --keep-baud %I 115200,38400,9600 $TERM";

     

       64
       72
        
               restartIfChanged = false;

     
···

       81
       89
        
             { serviceConfig.ExecStart = gettyCmd "--noclear --keep-baud console 115200,38400,9600 $TERM";

     

       82
       90
        
               serviceConfig.Restart = "always";

     

       83
       91
        
               restartIfChanged = false;

     

       84
       84
       -
       	enable = mkDefault config.boot.isContainer;

     

       92
       92
       +
               enable = mkDefault config.boot.isContainer;

     

       85
       93
        
             };

     

       86
       94
        
       

     

       87
       95
        
           environment.etc = singleton

+3 -3

nixos/modules/system/activation/top-level.nix

···

       67
       67
        
       

     

       68
       68
        
             echo -n "$configurationName" > $out/configuration-name

     

       69
       69
        
             echo -n "systemd ${toString config.systemd.package.interfaceVersion}" > $out/init-interface-version

     

       70
       70
       -
             echo -n "$nixosVersion" > $out/nixos-version

     

       70
       70
       +
             echo -n "$nixosLabel" > $out/nixos-version

     

       71
       71
        
             echo -n "$system" > $out/system

     

       72
       72
        
       

     

       73
       73
        
             mkdir $out/fine-tune

     
···

       101
       101
        
           if [] == failed then pkgs.stdenv.mkDerivation {

     

       102
       102
        
             name = let hn = config.networking.hostName;

     

       103
       103
        
                        nn = if (hn != "") then hn else "unnamed";

     

       104
       104
       -
                 in "nixos-system-${nn}-${config.system.nixosVersion}";

     

       104
       104
       +
                 in "nixos-system-${nn}-${config.system.nixosLabel}";

     

       105
       105
        
             preferLocalBuild = true;

     

       106
       106
        
             allowSubstitutes = false;

     

       107
       107
        
             buildCommand = systemBuilder;

     
···

       115
       115
        
               config.system.build.installBootLoader

     

       116
       116
        
               or "echo 'Warning: do not know how to make this configuration bootable; please enable a boot loader.' 1>&2; true";

     

       117
       117
        
             activationScript = config.system.activationScripts.script;

     

       118
       118
       -
             nixosVersion = config.system.nixosVersion;

     

       118
       118
       +
             nixosLabel = config.system.nixosLabel;

     

       119
       119
        
       

     

       120
       120
        
             configurationName = config.boot.loader.grub.configurationName;

     

       121
       121

+2 -2

nixos/modules/system/boot/loader/generic-extlinux-compatible/extlinux-conf-builder.sh

···

       83
       83
        
           timestampEpoch=$(stat -L -c '%Z' $path)

     

       84
       84
        
       

     

       85
       85
        
           timestamp=$(date "+%Y-%m-%d %H:%M" -d @$timestampEpoch)

     

       86
       86
       -
           nixosVersion="$(cat $path/nixos-version)"

     

       86
       86
       +
           nixosLabel="$(cat $path/nixos-version)"

     

       87
       87
        
           extraParams="$(cat $path/kernel-params)"

     

       88
       88
        
       

     

       89
       89
        
           echo

     
···

       91
       91
        
           if [ "$tag" = "default" ]; then

     

       92
       92
        
               echo "  MENU LABEL NixOS - Default"

     

       93
       93
        
           else

     

       94
       94
       -
               echo "  MENU LABEL NixOS - Configuration $tag ($timestamp - $nixosVersion)"

     

       94
       94
       +
               echo "  MENU LABEL NixOS - Configuration $tag ($timestamp - $nixosLabel)"

     

       95
       95
        
           fi

     

       96
       96
        
           echo "  LINUX ../nixos/$(basename $kernel)"

     

       97
       97
        
           echo "  INITRD ../nixos/$(basename $initrd)"

+1 -1

nixos/modules/virtualisation/azure-image.nix

···

       26
       26
        
                     ${pkgs.vmTools.qemu}/bin/qemu-img convert -f raw -O vpc $diskImage $out/disk.vhd

     

       27
       27
        
                     rm $diskImage

     

       28
       28
        
                   '';

     

       29
       29
       -
                 diskImageBase = "nixos-image-${config.system.nixosVersion}-${pkgs.stdenv.system}.raw";

     

       29
       29
       +
                 diskImageBase = "nixos-image-${config.system.nixosLabel}-${pkgs.stdenv.system}.raw";

     

       30
       30
        
                 buildInputs = [ pkgs.utillinux pkgs.perl ];

     

       31
       31
        
                 exportReferencesGraph =

     

       32
       32
        
                   [ "closure" config.system.build.toplevel ];

+1 -1

nixos/modules/virtualisation/brightbox-image.nix

···

       26
       26
        
                     rm $diskImageBase

     

       27
       27
        
                     popd

     

       28
       28
        
                   '';

     

       29
       29
       -
                 diskImageBase = "nixos-image-${config.system.nixosVersion}-${pkgs.stdenv.system}.raw";

     

       29
       29
       +
                 diskImageBase = "nixos-image-${config.system.nixosLabel}-${pkgs.stdenv.system}.raw";

     

       30
       30
        
                 buildInputs = [ pkgs.utillinux pkgs.perl ];

     

       31
       31
        
                 exportReferencesGraph =

     

       32
       32
        
                   [ "closure" config.system.build.toplevel ];

+1 -1

nixos/modules/virtualisation/google-compute-image.nix

···

       30
       30
        
                     rm $out/disk.raw

     

       31
       31
        
                     popd

     

       32
       32
        
                   '';

     

       33
       33
       -
                 diskImageBase = "nixos-image-${config.system.nixosVersion}-${pkgs.stdenv.system}.raw";

     

       33
       33
       +
                 diskImageBase = "nixos-image-${config.system.nixosLabel}-${pkgs.stdenv.system}.raw";

     

       34
       34
        
                 buildInputs = [ pkgs.utillinux pkgs.perl ];

     

       35
       35
        
                 exportReferencesGraph =

     

       36
       36
        
                   [ "closure" config.system.build.toplevel ];

+2 -2

nixos/modules/virtualisation/virtualbox-image.nix

···

       44
       44
        
       

     

       45
       45
        
           system.build.virtualBoxOVA = pkgs.runCommand "virtualbox-ova"

     

       46
       46
        
             { buildInputs = [ pkgs.linuxPackages.virtualbox ];

     

       47
       47
       -
               vmName = "NixOS ${config.system.nixosVersion} (${pkgs.stdenv.system})";

     

       48
       48
       -
               fileName = "nixos-image-${config.system.nixosVersion}-${pkgs.stdenv.system}.ova";

     

       47
       47
       +
               vmName = "NixOS ${config.system.nixosLabel} (${pkgs.stdenv.system})";

     

       48
       48
       +
               fileName = "nixos-image-${config.system.nixosLabel}-${pkgs.stdenv.system}.ova";

     

       49
       49
        
             }

     

       50
       50
        
             ''

     

       51
       51
        
               echo "creating VirtualBox VM..."