commit 37ee6ba681f133e76532b51320032896831b5d9f · pyrox.dev/nixpkgs

+4 -4

nixos/doc/manual/administration/rollback.section.md

···

       12
       12
        
       for subsequent boots:

     

       13
       13
        
       

     

       14
       14
        
       ```ShellSession

     

       15
       15
       -
       # /run/current-system/bin/apply boot

     

       15
       15
       +
       # /run/current-system/bin/switch-to-configuration boot

     

       16
       16
        
       ```

     

       17
       17
        
       

     

       18
       18
        
       Second, you can switch to the previous configuration in a running

     
···

       25
       25
        
       This is equivalent to running:

     

       26
       26
        
       

     

       27
       27
        
       ```ShellSession

     

       28
       28
       -
       # /nix/var/nix/profiles/system-N-link/bin/apply switch

     

       28
       28
       +
       # /nix/var/nix/profiles/system-N-link/bin/switch-to-configuration switch

     

       29
       29
        
       ```

     

       30
       30
        
       

     

       31
       31
       -
       where `N` is the number of the NixOS system configuration to roll back to.

     

       32
       32
       -
       To get a list of the available configurations, run:

     

       31
       31
       +
       where `N` is the number of the NixOS system configuration. To get a

     

       32
       32
       +
       list of the available configurations, do:

     

       33
       33
        
       

     

       34
       34
        
       ```ShellSession

     

       35
       35
        
       $ ls -l /nix/var/nix/profiles/system-*-link

+1 -1

nixos/doc/manual/development/non-switchable-systems.section.md

···

       16
       16
        
       The most notable deviation of this profile from a standard NixOS configuration

     

       17
       17
        
       is that after building it, you cannot switch *to* the configuration anymore.

     

       18
       18
        
       The profile sets `config.system.switch.enable = false;`, which excludes

     

       19
       19
       -
       `apply` and `switch-to-configuration`, the central scripts called by `nixos-rebuild`, from

     

       19
       19
       +
       `switch-to-configuration`, the central script called by `nixos-rebuild`, from

     

       20
       20
        
       your system. Removing this script makes the image lighter and slightly more

     

       21
       21
        
       secure.

+2 -2

nixos/doc/manual/development/what-happens-during-a-system-switch.chapter.md

···

       5
       5
        
       for new module developers to configure their units correctly and to make it

     

       6
       6
        
       easier to understand what is happening and why for curious administrators.

     

       7
       7
        
       

     

       8
       8
       -
       `nixos-rebuild`, like many deployment solutions, calls `apply` (or for NixOS older than 24.11, `switch-to-configuration`)

     

       9
       9
       -
       which resides in a NixOS system at `$out/bin/apply`. The

     

       8
       8
       +
       `nixos-rebuild`, like many deployment solutions, calls `switch-to-configuration`

     

       9
       9
       +
       which resides in a NixOS system at `$out/bin/switch-to-configuration`. The

     

       10
       10
        
       script is called with the action that is to be performed like `switch`, `test`,

     

       11
       11
        
       `boot`. There is also the `dry-activate` action which does not really perform

     

       12
       12
        
       the actions but rather prints what it would do if you called it with `test`.

+1 -1

nixos/doc/manual/installation/installing-from-other-distro.section.md

···

       247
       247
        
       

     

       248
       248
        
           ```ShellSession

     

       249
       249
        
           $ sudo mv -v /boot /boot.bak &&

     

       250
       250
       -
           sudo /nix/var/nix/profiles/system/bin/apply boot

     

       250
       250
       +
           sudo /nix/var/nix/profiles/system/bin/switch-to-configuration boot

     

       251
       251
        
           ```

     

       252
       252
        
       

     

       253
       253
        
           Cross your fingers, reboot, hopefully you should get a NixOS prompt!

-10

nixos/doc/manual/release-notes/rl-2411.section.md

···

       54
       54
        
         If you experience any issues, please report them.

     

       55
       55
        
         The original Perl script is deprecated and is planned for removal in the 25.05 release. It will remain accessible until then by setting `system.switch.enableNg` to `false`.

     

       56
       56
        
       

     

       57
       57
       -
       - Built NixOS configurations now have a `$toplevel/bin/apply` script.

     

       58
       58
       -
         Unlike `switch-to-configuration`, it is capable of performing a complete `switch` operation.

     

       59
       59
       -
         If you call `switch-to-configuration` directly, you are recommended to use `apply` instead, and remove your call to `nix-env --profile /nix/var/nix/profiles/system --set $toplevel` or similar.

     

       60
       60
       -
         It will run the switch operation as a systemd unit if available, as `nixos-rebuild switch` would.

     

       61
       61
       -
       

     

       62
       62
       -
         Benefits include:

     

       63
       63
       -
         - The `apply` script reduces the roundtrips required when performing a remote deployment with `nixos-rebuild switch --target-host HOST`.

     

       64
       64
       -
         - Developers and power users can now update NixOS in a single call.

     

       65
       65
       -
         - Alternative NixOS deployment methods have feature parity with `nixos-rebuild`, and NixOS can evolve all of its switching logic in one place.

     

       66
       66
       -
       

     

       67
       57
        
       - Support for mounting filesystems from block devices protected with [dm-verity](https://docs.kernel.org/admin-guide/device-mapper/verity.html)

     

       68
       58
        
         was added through the `boot.initrd.systemd.dmVerity` option.

     

       69
       59

+1 -1

nixos/lib/testing/nixos-test-base.nix

···

       23
       23
        
             };

     

       24
       24
        
           }

     

       25
       25
        
           ({ config, ... }: {

     

       26
       26
       -
             # Don't pull in apply and switch-to-configuration by default, except when specialisations or early boot shenanigans are involved.

     

       26
       26
       +
             # Don't pull in switch-to-configuration by default, except when specialisations or early boot shenanigans are involved.

     

       27
       27
        
             # This is mostly a Hydra optimization, so we don't rebuild all the tests every time switch-to-configuration-ng changes.

     

       28
       28
        
             key = "no-switch-to-configuration";

     

       29
       29
        
             system.switch.enable = mkDefault (config.isSpecialisation || config.specialisation != {} || config.virtualisation.installBootLoader);

-163

nixos/modules/system/activation/apply/apply.sh

···

       1
       1
       -
       #!@bash@

     

       2
       2
       -
       

     

       3
       3
       -
       

     

       4
       4
       -
       # This is the NixOS apply script, typically located at

     

       5
       5
       -
       #

     

       6
       6
       -
       # ${config.system.build.toplevel}/bin/apply

     

       7
       7
       -
       #

     

       8
       8
       -
       # This script is responsible for managing the profile link and calling the

     

       9
       9
       -
       # appropriate scripts for its subcommands, such as switch, boot, and test.

     

       10
       10
       -
       

     

       11
       11
       -
       

     

       12
       12
       -
       set -euo pipefail

     

       13
       13
       -
       

     

       14
       14
       -
       toplevel=@toplevel@

     

       15
       15
       -
       

     

       16
       16
       -
       subcommand=

     

       17
       17
       -
       

     

       18
       18
       -
       installBootloader=

     

       19
       19
       -
       specialisation=

     

       20
       20
       -
       profile=/nix/var/nix/profiles/system

     

       21
       21
       -
       

     

       22
       22
       -
       log() {

     

       23
       23
       -
           echo "$@" >&2

     

       24
       24
       -
       }

     

       25
       25
       -
       

     

       26
       26
       -
       die() {

     

       27
       27
       -
           log "NixOS apply error: $*"

     

       28
       28
       -
           exit 1

     

       29
       29
       -
       }

     

       30
       30
       -
       

     

       31
       31
       -
       usage() {

     

       32
       32
       -
           log "NixOS apply invocation error: $*"

     

       33
       33
       -
       cat >&2 <<EOF

     

       34
       34
       -
       Usage: apply [switch|boot|test|dry-activate] [OPTIONS]

     

       35
       35
       -
       Subcommands:

     

       36
       36
       -
           switch        make the configuration the boot default and activate it

     

       37
       37
       -
           boot          make the configuration the boot default

     

       38
       38
       -
           test          activate the configuration, but don\'t make it the boot default

     

       39
       39
       -
           dry-activate  show what would be done if this configuration were activated

     

       40
       40
       -
       Options:

     

       41
       41
       -
           --install-bootloader    install the bootloader

     

       42
       42
       -
           --profile PROFILE       use PROFILE as the target profile (if applicable)

     

       43
       43
       -
           --specialisation NAME   use the specialisation NAME

     

       44
       44
       -
       EOF

     

       45
       45
       -
       }

     

       46
       46
       -
       

     

       47
       47
       -
       

     

       48
       48
       -
       parse_args() {

     

       49
       49
       -
           while [[ $# -gt 0 ]]; do

     

       50
       50
       -
               case "$1" in

     

       51
       51
       -
                   switch|boot|test|dry-activate)

     

       52
       52
       -
                       subcommand="$1"

     

       53
       53
       -
                       ;;

     

       54
       54
       -
                   --install-bootloader)

     

       55
       55
       -
                       installBootloader=1

     

       56
       56
       -
                       ;;

     

       57
       57
       -
                   --profile)

     

       58
       58
       -
                       if [[ $# -lt 2 ]]; then

     

       59
       59
       -
                           die "missing argument for --profile"

     

       60
       60
       -
                       fi

     

       61
       61
       -
                       profile="$2"

     

       62
       62
       -
                       shift

     

       63
       63
       -
                       ;;

     

       64
       64
       -
                   # --rollback is not an `apply` responsibility, and it should be

     

       65
       65
       -
                   # implemented by the caller of `apply` instead.

     

       66
       66
       -
                   --specialisation)

     

       67
       67
       -
                       if [[ $# -lt 2 ]]; then

     

       68
       68
       -
                           die "missing argument for --specialisation"

     

       69
       69
       -
                       fi

     

       70
       70
       -
                       specialisation="$2"

     

       71
       71
       -
                       shift

     

       72
       72
       -
                       ;;

     

       73
       73
       -
                   *)

     

       74
       74
       -
                       if [[ -n "$subcommand" ]]; then

     

       75
       75
       -
                           die "unexpected argument or flag: $1"

     

       76
       76
       -
                       else

     

       77
       77
       -
                           die "unexpected subcommand or flag: $1"

     

       78
       78
       -
                       fi

     

       79
       79
       -
                       ;;

     

       80
       80
       -
               esac

     

       81
       81
       -
               shift

     

       82
       82
       -
           done

     

       83
       83
       -
       

     

       84
       84
       -
           if [ -z "$subcommand" ]; then

     

       85
       85
       -
               die "no subcommand specified"

     

       86
       86
       -
           fi

     

       87
       87
       -
       }

     

       88
       88
       -
       

     

       89
       89
       -
       main() {

     

       90
       90
       -
           local cmd activity

     

       91
       91
       -
       

     

       92
       92
       -
           case "$subcommand" in

     

       93
       93
       -
               boot|switch)

     

       94
       94
       -
                   nix-env -p "$profile" --set "$toplevel"

     

       95
       95
       -
                   ;;

     

       96
       96
       -
           esac

     

       97
       97
       -
       

     

       98
       98
       -
           # Using systemd-run here to protect against PTY failures/network

     

       99
       99
       -
           # disconnections during rebuild.

     

       100
       100
       -
           # See: https://github.com/NixOS/nixpkgs/issues/39118

     

       101
       101
       -
           cmd=(

     

       102
       102
       -
               "systemd-run"

     

       103
       103
       -
               "-E" "LOCALE_ARCHIVE" # Will be set to new value early in switch-to-configuration script, but interpreter starts out with old value

     

       104
       104
       -
               "-E" "NIXOS_INSTALL_BOOTLOADER=$installBootloader"

     

       105
       105
       -
               "--collect"

     

       106
       106
       -
               "--no-ask-password"

     

       107
       107
       -
               "--pipe"

     

       108
       108
       -
               "--quiet"

     

       109
       109
       -
               "--same-dir"

     

       110
       110
       -
               "--service-type=exec"

     

       111
       111
       -
               "--unit=nixos-rebuild-switch-to-configuration"

     

       112
       112
       -
               "--wait"

     

       113
       113
       -
           )

     

       114
       114
       -
           # Check if we have a working systemd-run. In chroot environments we may have

     

       115
       115
       -
           # a non-working systemd, so we fallback to not using systemd-run.

     

       116
       116
       -
           if ! "${cmd[@]}" true; then

     

       117
       117
       -
               log "Skipping systemd-run to switch configuration since it is not working in target host."

     

       118
       118
       -
               cmd=(

     

       119
       119
       -
                   "env"

     

       120
       120
       -
                   "-i"

     

       121
       121
       -
                   "LOCALE_ARCHIVE=${LOCALE_ARCHIVE:-}"

     

       122
       122
       -
                   "NIXOS_INSTALL_BOOTLOADER=$installBootloader"

     

       123
       123
       -
               )

     

       124
       124
       -
           fi

     

       125
       125
       -
           if [[ -z "$specialisation" ]]; then

     

       126
       126
       -
               cmd+=("$toplevel/bin/switch-to-configuration")

     

       127
       127
       -
           else

     

       128
       128
       -
               cmd+=("$toplevel/specialisation/$specialisation/bin/switch-to-configuration")

     

       129
       129
       -
       

     

       130
       130
       -
               if ! [[ -f "${cmd[-1]}" ]]; then

     

       131
       131
       -
                   log "error: specialisation not found: $specialisation"

     

       132
       132
       -
                   exit 1

     

       133
       133
       -
               fi

     

       134
       134
       -
           fi

     

       135
       135
       -
       

     

       136
       136
       -
           if ! "${cmd[@]}" "$subcommand"; then

     

       137
       137
       -
               case "$subcommand" in

     

       138
       138
       -
                   switch)

     

       139
       139
       -
                       activity="switching to the new configuration"

     

       140
       140
       -
                       ;;

     

       141
       141
       -
                   boot)

     

       142
       142
       -
                       activity="switching the boot entry to the new configuration"

     

       143
       143
       -
                       ;;

     

       144
       144
       -
                   test)

     

       145
       145
       -
                       activity="switching to the new configuration (in test mode)"

     

       146
       146
       -
                       ;;

     

       147
       147
       -
                   dry-activate)

     

       148
       148
       -
                       activity="switching to the new configuration (in dry-activate mode)"

     

       149
       149
       -
                       ;;

     

       150
       150
       -
                   *)  # Should never happen

     

       151
       151
       -
                       activity="running $subcommand"

     

       152
       152
       -
                       ;;

     

       153
       153
       -
               esac

     

       154
       154
       -
               log "warning: error(s) occurred while $activity"

     

       155
       155
       -
               exit 1

     

       156
       156
       -
           fi

     

       157
       157
       -
       }

     

       158
       158
       -
       

     

       159
       159
       -
       if ! type test_run_tests &>/dev/null; then

     

       160
       160
       -
           # We're not loaded into the test.sh, so we run main.

     

       161
       161
       -
           parse_args "$@"

     

       162
       162
       -
           main

     

       163
       163
       -
       fi

-51

nixos/modules/system/activation/apply/checks.nix

···

       1
       1
       -
       # Run:

     

       2
       2
       -
       #   nix-build -A nixosTests.apply

     

       3
       3
       -
       #

     

       4
       4
       -
       # These are not all tests. See also nixosTests.

     

       5
       5
       -
       

     

       6
       6
       -
       {

     

       7
       7
       -
         lib,

     

       8
       8
       -
         stdenvNoCC,

     

       9
       9
       -
         testers,

     

       10
       10
       -
         ...

     

       11
       11
       -
       }:

     

       12
       12
       -
       

     

       13
       13
       -
       let

     

       14
       14
       -
         fileset = lib.fileset.unions [

     

       15
       15
       -
           ./test.sh

     

       16
       16
       -
           ./apply.sh

     

       17
       17
       -
         ];

     

       18
       18
       -
       in

     

       19
       19
       -
       

     

       20
       20
       -
       {

     

       21
       21
       -
         unitTests = stdenvNoCC.mkDerivation {

     

       22
       22
       -
           name = "nixos-apply-unit-tests";

     

       23
       23
       -
           src = lib.fileset.toSource {

     

       24
       24
       -
             root = ./.;

     

       25
       25
       -
             inherit fileset;

     

       26
       26
       -
           };

     

       27
       27
       -
           dontBuild = true;

     

       28
       28
       -
           checkPhase = ''

     

       29
       29
       -
             ./test.sh

     

       30
       30
       -
           '';

     

       31
       31
       -
           installPhase = ''

     

       32
       32
       -
             touch $out

     

       33
       33
       -
           '';

     

       34
       34
       -
         };

     

       35
       35
       -
       

     

       36
       36
       -
         shellcheck =

     

       37
       37
       -
           (testers.shellcheck {

     

       38
       38
       -
             src = lib.fileset.toSource {

     

       39
       39
       -
               # This makes the error messages include the full path

     

       40
       40
       -
               root = ../../../../..;

     

       41
       41
       -
               inherit fileset;

     

       42
       42
       -
             };

     

       43
       43
       -
           }).overrideAttrs

     

       44
       44
       -
             {

     

       45
       45
       -
               postUnpack = ''

     

       46
       46
       -
                 for f in $(find . -type f); do

     

       47
       47
       -
                   substituteInPlace $f --replace @bash@ /usr/bin/bash

     

       48
       48
       -
                 done

     

       49
       49
       -
               '';

     

       50
       50
       -
             };

     

       51
       51
       -
       }

-176

nixos/modules/system/activation/apply/test.sh

···

       1
       1
       -
       #!/usr/bin/env bash

     

       2
       2
       -
       # shellcheck disable=SC2317 disable=SC2031

     

       3
       3
       -
       # False positives:

     

       4
       4
       -
       # SC2317: Unreachable code: TEST_*

     

       5
       5
       -
       # SC2031: <variable> was modified in a subshell. That change might be lost.

     

       6
       6
       -
       #         We have a lot of that, and that's expected.

     

       7
       7
       -
       

     

       8
       8
       -
       # This is a unit test script for the NixOS apply script.

     

       9
       9
       -
       # It can be run quickly with the following command:

     

       10
       10
       -
       #

     

       11
       11
       -
       #     ./test.sh

     

       12
       12
       -
       #

     

       13
       13
       -
       # Alternatively, run the following to run all tests and checks

     

       14
       14
       -
       #

     

       15
       15
       -
       #     TODO

     

       16
       16
       -
       #

     

       17
       17
       -
       

     

       18
       18
       -
       set -euo pipefail

     

       19
       19
       -
       # set -x

     

       20
       20
       -
       

     

       21
       21
       -
       apply="${BASH_SOURCE[0]%/*}/apply.sh"

     

       22
       22
       -
       # source_apply() {

     

       23
       23
       -
       

     

       24
       24
       -
       run_parse_args() {

     

       25
       25
       -
         bash -c "source $apply;"' parse_args "$@"' -- "$@"

     

       26
       26
       -
       }

     

       27
       27
       -
       

     

       28
       28
       -
       TEST_parse_args_none() {

     

       29
       29
       -
         if errout="$(run_parse_args 2>&1)"; then

     

       30
       30
       -
           test_fail "apply without arguments should fail"

     

       31
       31
       -
         elif [[ $? -ne 1 ]]; then

     

       32
       32
       -
           test_fail "apply without arguments should exit with code 1"

     

       33
       33
       -
         fi

     

       34
       34
       -
         grep -F "no subcommand specified" <<<"$errout" >/dev/null

     

       35
       35
       -
       }

     

       36
       36
       -
       

     

       37
       37
       -
       TEST_parse_args_switch() {

     

       38
       38
       -
         (

     

       39
       39
       -
           # shellcheck source=nixos/modules/system/activation/apply/apply.sh

     

       40
       40
       -
           source "$apply";

     

       41
       41
       -
           parse_args switch;

     

       42
       42
       -
           [[ $subcommand == switch ]]

     

       43
       43
       -
           [[ $specialisation == "" ]]

     

       44
       44
       -
           [[ $profile == "" ]]

     

       45
       45
       -
         )

     

       46
       46
       -
       }

     

       47
       47
       -
       

     

       48
       48
       -
       TEST_parse_args_boot() {

     

       49
       49
       -
         (

     

       50
       50
       -
           # shellcheck source=nixos/modules/system/activation/apply/apply.sh

     

       51
       51
       -
           source "$apply";

     

       52
       52
       -
           parse_args boot;

     

       53
       53
       -
           [[ $subcommand == boot ]]

     

       54
       54
       -
           [[ $specialisation == "" ]]

     

       55
       55
       -
           [[ $profile == "" ]]

     

       56
       56
       -
         )

     

       57
       57
       -
       }

     

       58
       58
       -
       

     

       59
       59
       -
       TEST_parse_args_test() {

     

       60
       60
       -
         (

     

       61
       61
       -
           # shellcheck source=nixos/modules/system/activation/apply/apply.sh

     

       62
       62
       -
           source "$apply";

     

       63
       63
       -
           parse_args test;

     

       64
       64
       -
           [[ $subcommand == test ]]

     

       65
       65
       -
           [[ $specialisation == "" ]]

     

       66
       66
       -
           [[ $profile == "" ]]

     

       67
       67
       -
         )

     

       68
       68
       -
       }

     

       69
       69
       -
       

     

       70
       70
       -
       TEST_parse_args_dry_activate() {

     

       71
       71
       -
         (

     

       72
       72
       -
           # shellcheck source=nixos/modules/system/activation/apply/apply.sh

     

       73
       73
       -
           source "$apply";

     

       74
       74
       -
           parse_args dry-activate;

     

       75
       75
       -
           [[ $subcommand == dry-activate ]]

     

       76
       76
       -
           [[ $specialisation == "" ]]

     

       77
       77
       -
           [[ $profile == "" ]]

     

       78
       78
       -
         )

     

       79
       79
       -
       }

     

       80
       80
       -
       

     

       81
       81
       -
       TEST_parse_args_unknown() {

     

       82
       82
       -
         if errout="$(run_parse_args foo 2>&1)"; then

     

       83
       83
       -
           test_fail "apply with unknown subcommand should fail"

     

       84
       84
       -
         fi

     

       85
       85
       -
         grep -F "unexpected argument or flag: foo" <<<"$errout" >/dev/null

     

       86
       86
       -
       }

     

       87
       87
       -
       

     

       88
       88
       -
       TEST_parse_args_switch_specialisation_no_arg() {

     

       89
       89
       -
         if errout="$(run_parse_args switch --specialisation 2>&1)"; then

     

       90
       90
       -
           test_fail "apply with --specialisation without argument should fail"

     

       91
       91
       -
         fi

     

       92
       92
       -
         grep -F "missing argument for --specialisation" <<<"$errout" >/dev/null

     

       93
       93
       -
       }

     

       94
       94
       -
       

     

       95
       95
       -
       TEST_parse_args_switch_specialisation() {

     

       96
       96
       -
         (

     

       97
       97
       -
           # shellcheck source=nixos/modules/system/activation/apply/apply.sh

     

       98
       98
       -
           source "$apply";

     

       99
       99
       -
           parse_args switch --specialisation low-power;

     

       100
       100
       -
           [[ $subcommand == switch ]]

     

       101
       101
       -
           [[ $specialisation == low-power ]]

     

       102
       102
       -
           [[ $profile == "" ]]

     

       103
       103
       -
         )

     

       104
       104
       -
       }

     

       105
       105
       -
       

     

       106
       106
       -
       TEST_parse_args_switch_profile() {

     

       107
       107
       -
         (

     

       108
       108
       -
           # shellcheck source=nixos/modules/system/activation/apply/apply.sh

     

       109
       109
       -
           source "$apply";

     

       110
       110
       -
           parse_args switch --profile /nix/var/nix/profiles/system;

     

       111
       111
       -
           [[ $subcommand == switch ]]

     

       112
       112
       -
           [[ $specialisation == "" ]]

     

       113
       113
       -
           [[ $profile == /nix/var/nix/profiles/system ]]

     

       114
       114
       -
         )

     

       115
       115
       -
       }

     

       116
       116
       -
       

     

       117
       117
       -
       

     

       118
       118
       -
       

     

       119
       119
       -
       # Support code

     

       120
       120
       -
       

     

       121
       121
       -
       test_fail() {

     

       122
       122
       -
         echo "TEST FAILURE: $*" >&2

     

       123
       123
       -
         exit 1

     

       124
       124
       -
       }

     

       125
       125
       -
       

     

       126
       126
       -
       test_print_trace() {

     

       127
       127
       -
         local frame=${1:0}

     

       128
       128
       -
         local caller

     

       129
       129
       -
         # shellcheck disable=SC2207 disable=SC2086

     

       130
       130
       -
         while caller=( $(caller $frame) ); do

     

       131
       131
       -
           echo "  in ${caller[1]} at ${caller[2]}:${caller[0]}"

     

       132
       132
       -
           frame=$((frame+1));

     

       133
       133
       -
         done

     

       134
       134
       -
       }

     

       135
       135
       -
       test_on_err() {

     

       136
       136
       -
         echo "ERROR running: ${BASH_COMMAND}" >&2

     

       137
       137
       -
         test_print_trace 1 >&2

     

       138
       138
       -
       }

     

       139
       139
       -
       

     

       140
       140
       -
       test_init() {

     

       141
       141
       -
         trap 'test_on_err' ERR

     

       142
       142
       -
       }

     

       143
       143
       -
       

     

       144
       144
       -
       test_find() {

     

       145
       145
       -
         declare -F | grep -o 'TEST_.*' | sort

     

       146
       146
       -
       }

     

       147
       147
       -
       

     

       148
       148
       -
       test_run_tests() {

     

       149
       149
       -
         local status=0

     

       150
       150
       -
         for test in $(test_find); do

     

       151
       151
       -
           set +e

     

       152
       152
       -
           (

     

       153
       153
       -
             set -eEuo pipefail

     

       154
       154
       -
             trap 'test_on_err' ERR

     

       155
       155
       -
             $test

     

       156
       156
       -
           )

     

       157
       157
       -
           r=$?

     

       158
       158
       -
           set -e

     

       159
       159
       -
           if [[ $r == 0 ]]; then

     

       160
       160
       -
             echo "ok: $test"

     

       161
       161
       -
           else

     

       162
       162
       -
             echo "TEST FAIL: $test"; status=1;

     

       163
       163
       -
           fi

     

       164
       164
       -
         done

     

       165
       165
       -
         if [[ $status == 0 ]]; then

     

       166
       166
       -
           echo "All good"

     

       167
       167
       -
         else

     

       168
       168
       -
           echo

     

       169
       169
       -
           echo "TEST SUITE FAILED"

     

       170
       170
       -
         fi

     

       171
       171
       -
         exit $status

     

       172
       172
       -
       }

     

       173
       173
       -
       

     

       174
       174
       -
       # Main

     

       175
       175
       -
       test_init

     

       176
       176
       -
       test_run_tests

+1 -1

nixos/modules/system/activation/specialisation.nix

···

       42
       42
        
               (e.g. `fewJobsManyCores`) at runtime, run:

     

       43
       43
        
       

     

       44
       44
        
               ```

     

       45
       45
       -
               sudo /run/current-system/specialisation/fewJobsManyCores/bin/apply test

     

       45
       45
       +
               sudo /run/current-system/specialisation/fewJobsManyCores/bin/switch-to-configuration test

     

       46
       46
        
               ```

     

       47
       47
        
             '';

     

       48
       48
        
             type = types.attrsOf (types.submodule (

+5 -2

nixos/modules/system/activation/switch-to-configuration.pl

···

       80
       80
        
       

     

       81
       81
        
       if (!defined($action) || ($action ne "switch" && $action ne "boot" && $action ne "test" && $action ne "dry-activate")) {

     

       82
       82
        
           print STDERR <<"EOF";

     

       83
       83
       -
       error: Unknown action $action

     

       84
       83
        
       Usage: $0 [switch|boot|test|dry-activate]

     

       85
       85
       -
       Consider calling `apply` instead of `switch-to-configuration`.

     

       84
       84
       +
       

     

       85
       85
       +
       switch:       make the configuration the boot default and activate now

     

       86
       86
       +
       boot:         make the configuration the boot default

     

       87
       87
       +
       test:         activate the configuration, but don\'t make it the boot default

     

       88
       88
       +
       dry-activate: show what would be done if this configuration were activated

     

       86
       89
        
       EOF

     

       87
       90
        
           exit(1);

     

       88
       91
        
       }

+2 -25

nixos/modules/system/activation/switchable-system.nix

···

       40
       40
        
           };

     

       41
       41
        
         };

     

       42
       42
        
       

     

       43
       43
       -
         options.system.apply.enable = lib.mkOption {

     

       44
       44
       -
           type = lib.types.bool;

     

       45
       45
       -
           default = config.system.switch.enable;

     

       46
       46
       -
           internal = true;

     

       47
       47
       -
           description = ''

     

       48
       48
       -
             Whether to include the `bin/apply` script.

     

       49
       49
       -
       

     

       50
       50
       -
             Disabling puts `nixos-rebuild` in a legacy mode that won't be maintained

     

       51
       51
       -
             and removes cheap and useful functionality. It's also slower over ssh.

     

       52
       52
       -
             This should only be used for testing the `nixos-rebuild` command, to

     

       53
       53
       -
             pretend that the configuration is an old NixOS.

     

       54
       54
       -
           '';

     

       55
       55
       -
         };

     

       56
       56
       -
       

     

       57
       43
        
         config = lib.mkMerge [

     

       58
       58
       -
           (lib.mkIf config.system.apply.enable {

     

       59
       59
       -
             system.activatableSystemBuilderCommands = ''

     

       60
       60
       -
               mkdir -p $out/bin

     

       61
       61
       -
               substitute ${./apply/apply.sh} $out/bin/apply \

     

       62
       62
       -
                 --subst-var-by bash ${lib.getExe pkgs.bash} \

     

       63
       63
       -
                 --subst-var-by toplevel ''${!toplevelVar}

     

       64
       64
       -
               chmod +x $out/bin/apply

     

       65
       65
       -
             '';

     

       66
       66
       -
           })

     

       67
       44
        
           (lib.mkIf (config.system.switch.enable && !config.system.switch.enableNg) {

     

       68
       45
        
             warnings = [

     

       69
       46
        
               ''

     
···

       77
       54
        
             ];

     

       78
       55
        
       

     

       79
       56
        
             system.activatableSystemBuilderCommands = ''

     

       80
       80
       -
               mkdir -p $out/bin

     

       57
       57
       +
               mkdir $out/bin

     

       81
       58
        
               substitute ${./switch-to-configuration.pl} $out/bin/switch-to-configuration \

     

       82
       59
        
                 --subst-var out \

     

       83
       60
        
                 --subst-var-by toplevel ''${!toplevelVar} \

     
···

       109
       86
        
               (

     

       110
       87
        
                 source ${pkgs.buildPackages.makeWrapper}/nix-support/setup-hook

     

       111
       88
        
       

     

       112
       112
       -
                 mkdir -p $out/bin

     

       89
       89
       +
                 mkdir $out/bin

     

       113
       90
        
                 ln -sf ${lib.getExe pkgs.switch-to-configuration-ng} $out/bin/switch-to-configuration

     

       114
       91
        
                 wrapProgram $out/bin/switch-to-configuration \

     

       115
       92
        
                   --set OUT $out \

+2 -2

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

···

       49
       49
        
         # Putting it all together.  This builds a store path containing

     

       50
       50
        
         # symlinks to the various parts of the built configuration (the

     

       51
       51
        
         # kernel, systemd units, init scripts, etc.) as well as a script

     

       52
       52
       -
         # `bin/apply` that activates the configuration and

     

       53
       53
       -
         # makes it bootable. See `activatable-system.nix` and `switchable-system.nix`.

     

       52
       52
       +
         # `switch-to-configuration' that activates the configuration and

     

       53
       53
       +
         # makes it bootable. See `activatable-system.nix`.

     

       54
       54
        
         baseSystem = pkgs.stdenvNoCC.mkDerivation ({

     

       55
       55
        
           name = "nixos-system-${config.system.name}-${config.system.nixos.label}";

     

       56
       56
        
           preferLocalBuild = true;

-11

nixos/tests/all-tests.nix

···

       129
       129
        
         apfs = runTest ./apfs.nix;

     

       130
       130
        
         appliance-repart-image = runTest ./appliance-repart-image.nix;

     

       131
       131
        
         appliance-repart-image-verity-store = runTest ./appliance-repart-image-verity-store.nix;

     

       132
       132
       -
         apply = pkgs.callPackage ../modules/system/activation/apply/checks.nix { };

     

       133
       132
        
         apparmor = handleTest ./apparmor.nix {};

     

       134
       133
        
         archi = handleTest ./archi.nix {};

     

       135
       134
        
         aria2 = handleTest ./aria2.nix {};

     
···

       704
       703
        
         nixos-generate-config = handleTest ./nixos-generate-config.nix {};

     

       705
       704
        
         nixos-rebuild-install-bootloader = handleTestOn ["x86_64-linux"] ./nixos-rebuild-install-bootloader.nix {};

     

       706
       705
        
         nixos-rebuild-specialisations = runTestOn ["x86_64-linux"] ./nixos-rebuild-specialisations.nix;

     

       707
       707
       -
         nixos-rebuild-specialisations-legacy = runTestOn ["x86_64-linux"] {

     

       708
       708
       -
           name = mkForce "nixos-rebuild-specialisations-legacy";

     

       709
       709
       -
           imports = [ ./nixos-rebuild-specialisations.nix ];

     

       710
       710
       -
           extraBaseModules = { system.apply.enable = false; };

     

       711
       711
       -
         };

     

       712
       706
        
         nixos-rebuild-target-host = runTest ./nixos-rebuild-target-host.nix;

     

       713
       713
       -
         nixos-rebuild-target-host-legacy = runTest {

     

       714
       714
       -
           name = mkForce "nixos-rebuild-target-host-legacy";

     

       715
       715
       -
           imports = [ ./nixos-rebuild-target-host.nix ];

     

       716
       716
       -
           extraBaseModules = { system.apply.enable = false; };

     

       717
       717
       -
         };

     

       718
       707
        
         nixpkgs = pkgs.callPackage ../modules/misc/nixpkgs/test.nix { inherit evalMinimalConfig; };

     

       719
       708
        
         nixseparatedebuginfod = handleTest ./nixseparatedebuginfod.nix {};

     

       720
       709
        
         node-red = handleTest ./node-red.nix {};

+4 -1

pkgs/by-name/sw/switch-to-configuration-ng/src/src/main.rs

···

       940
       940
        
       fn usage(argv0: &str) -> ! {

     

       941
       941
        
           eprintln!(

     

       942
       942
        
               r#"Usage: {} [switch|boot|test|dry-activate]

     

       943
       943
       -
       Consider calling `apply` instead of `switch-to-configuration`.

     

       943
       943
       +
       switch:       make the configuration the boot default and activate now

     

       944
       944
       +
       boot:         make the configuration the boot default

     

       945
       945
       +
       test:         activate the configuration, but don't make it the boot default

     

       946
       946
       +
       dry-activate: show what would be done if this configuration were activated

     

       944
       947
        
       "#,

     

       945
       948
        
               argv0

     

       946
       949
        
           );

+8 -51

pkgs/os-specific/linux/nixos-rebuild/nixos-rebuild.sh

···

       220
       220
        
           if [ -z "$buildHost" ]; then

     

       221
       221
        
               runCmd "$@"

     

       222
       222
        
           elif [ -n "$remoteNix" ]; then

     

       223
       223
       -
               runCmd ssh $SSHOPTS "$buildHost" "${c[@]}" env PATH="$remoteNix":'$PATH' "${@@Q}"

     

       223
       223
       +
               runCmd ssh $SSHOPTS "$buildHost" "${c[@]}" env PATH="$remoteNix":'$PATH' "$@"

     

       224
       224
        
           else

     

       225
       225
       -
               runCmd ssh $SSHOPTS "$buildHost" "${c[@]}" "${@@Q}"

     

       225
       225
       +
               runCmd ssh $SSHOPTS "$buildHost" "${c[@]}" "$@"

     

       226
       226
        
           fi

     

       227
       227
        
       }

     

       228
       228
        
       

     
···

       237
       237
        
           if [ -z "$targetHost" ]; then

     

       238
       238
        
               runCmd "${c[@]}" "$@"

     

       239
       239
        
           else

     

       240
       240
       -
               runCmd ssh $SSHOPTS "$targetHost" "${c[@]}" "${@@Q}"

     

       240
       240
       +
               runCmd ssh $SSHOPTS "$targetHost" "${c[@]}" "$@"

     

       241
       241
        
           fi

     

       242
       242
        
       }

     

       243
       243
        
       

     
···

       790
       790
        
                   pathToConfig="$(nixFlakeBuild "$flake#$flakeAttr.config.system.build.toplevel" "${extraBuildFlags[@]}" "${lockFlags[@]}")"

     

       791
       791
        
               fi

     

       792
       792
        
               copyToTarget "$pathToConfig"

     

       793
       793
       +
               targetHostSudoCmd nix-env -p "$profile" --set "$pathToConfig"

     

       793
       794
        
           elif [[ "$action" = test || "$action" = build || "$action" = dry-build || "$action" = dry-activate ]]; then

     

       794
       795
        
               if [[ -z $buildingAttribute ]]; then

     

       795
       796
        
                   pathToConfig="$(nixBuild $buildFile -A "${attr:+$attr.}config.system.build.toplevel" "${extraBuildFlags[@]}")"

     
···

       840
       841
        
       fi

     

       841
       842
        
       

     

       842
       843
        
       

     

       843
       843
       -
       hasApplyScript=

     

       844
       844
       -
       # If we're doing a deployment-like action, we need to know whether the config has

     

       845
       845
       -
       # an apply script. NixOS versions >= 24.11 should be deployed with toplevel/bin/apply.

     

       846
       846
       -
       if [[ "$action" = switch || "$action" = boot || "$action" = test || "$action" = dry-activate ]]; then

     

       847
       847
       -
           hasApplyScriptOut="$(targetHostCmd sh -c "if test -e $pathToConfig/bin/apply; then echo __has-apply-script__; elif test -e $pathToConfig/bin; then echo __has-no-apply-script__; else echo $pathToConfig is gone; fi

     

       848
       848
       -
           ")"

     

       849
       849
       -
           # SSH can be messy (e.g. when user has a shell rc file that prints to stdout)

     

       850
       850
       -
           # So we only check for the substring

     

       851
       851
       -
           case "$hasApplyScriptOut" in

     

       852
       852
       -
               *__has-apply-script__*)

     

       853
       853
       -
                   hasApplyScript=1

     

       854
       854
       -
                   ;;

     

       855
       855
       -
               *__has-no-apply-script__*)

     

       856
       856
       -
                   hasApplyScript=

     

       857
       857
       -
                   ;;

     

       858
       858
       -
               *)

     

       859
       859
       -
                   # Unlikely

     

       860
       860
       -
                   echo "$hasApplyScriptOut" 1>&2

     

       861
       861
       -
                   log "error: $pathToConfig could not be read"

     

       862
       862
       -
                   exit 1

     

       863
       863
       -
                   ;;

     

       864
       864
       -
           esac

     

       865
       865
       -
       fi

     

       866
       866
       -
       

     

       867
       867
       -
       # switch|boot|test|dry-activate

     

       868
       868
       -
       #

     

       869
       844
        
       # If we're not just building, then make the new configuration the boot

     

       870
       845
        
       # default and/or activate it now.

     

       871
       871
       -
       if [[ -n "$hasApplyScript" ]] \

     

       872
       872
       -
           && [[ "$action" = switch || "$action" = boot || "$action" = test || "$action" = dry-activate ]]; then

     

       873
       873
       -
           cmd=("$pathToConfig/bin/apply" "$action" "--profile" "$profile")

     

       874
       874
       -
           if [[ -n "$specialisation" ]]; then

     

       875
       875
       -
               cmd+=("--specialisation" "$specialisation")

     

       876
       876
       -
           fi

     

       877
       877
       -
           if [[ -n "$installBootloader" ]]; then

     

       878
       878
       -
               cmd+=("--install-bootloader")

     

       879
       879
       -
           fi

     

       880
       880
       -
           targetHostSudoCmd "${cmd[@]}"

     

       881
       881
       -
       elif [[ "$action" = switch || "$action" = boot || "$action" = test || "$action" = dry-activate ]]; then

     

       882
       882
       -
           # Legacy, without apply script, NixOS < 24.11

     

       883
       883
       -
       

     

       884
       884
       -
           if [[ "$action" = switch || "$action" = boot ]]; then

     

       885
       885
       -
               if [[ -z "$rollback" ]]; then

     

       886
       886
       -
                   : # We've already switched it so that hasApplyScript would check the right $pathToConfig

     

       887
       887
       -
               else

     

       888
       888
       -
                   targetHostSudoCmd nix-env -p "$profile" --set "$pathToConfig"

     

       889
       889
       -
               fi

     

       890
       890
       -
           fi

     

       891
       891
       -
       

     

       892
       892
       -
           # Legacy logic to support deploying NixOS <24.11; see hasApplyScript

     

       846
       846
       +
       if [[ "$action" = switch || "$action" = boot || "$action" = test || "$action" = dry-activate ]]; then

     

       847
       847
       +
           # Using systemd-run here to protect against PTY failures/network

     

       848
       848
       +
           # disconnections during rebuild.

     

       849
       849
       +
           # See: https://github.com/NixOS/nixpkgs/issues/39118

     

       893
       850
        
           cmd=(

     

       894
       851
        
               "systemd-run"

     

       895
       852
        
               "-E" "LOCALE_ARCHIVE" # Will be set to new value early in switch-to-configuration script, but interpreter starts out with old value