commit 78be7f5a53e3945b72482a99c639f5fe8cc75fd6 · pyrox.dev/nixpkgs

+27 -160
nixos/modules/installer/tools/nixos-rebuild.sh
···

       19
       19
        
       upgrade=

     

       20
       20
        
       repair=

     

       21
       21
        
       profile=/nix/var/nix/profiles/system

     

       22
       22
       -
       buildHost=

     

       23
       23
       -
       targetHost=

     

       24
       22
        
       

     

       25
       23
        
       while [ "$#" -gt 0 ]; do

     

       26
       24
        
           i="$1"; shift 1

     
···

       75
       73
        
               fi

     

       76
       74
        
               shift 1

     

       77
       75
        
               ;;

     

       78
       78
       -
             --build-host|h)

     

       79
       79
       -
               buildHost="$1"

     

       80
       80
       -
               shift 1

     

       81
       81
       -
               ;;

     

       82
       82
       -
             --target-host|t)

     

       83
       83
       -
               targetHost="$1"

     

       84
       84
       -
               shift 1

     

       85
       85
       -
               ;;

     

       86
       76
        
             *)

     

       87
       77
        
               echo "$0: unknown option \`$i'"

     

       88
       78
        
               exit 1

     

       89
       79
        
               ;;

     

       90
       80
        
           esac

     

       91
       81
        
       done

     

       92
       92
       -
       

     

       93
       93
       -
       

     

       94
       94
       -
       if [ -z "$buildHost" -a -n "$targetHost" ]; then

     

       95
       95
       -
           buildHost="$targetHost"

     

       96
       96
       -
       fi

     

       97
       97
       -
       if [ "$targetHost" = localhost ]; then

     

       98
       98
       -
           targetHost=

     

       99
       99
       -
       fi

     

       100
       100
       -
       if [ "$buildHost" = localhost ]; then

     

       101
       101
       -
           buildHost=

     

       102
       102
       -
       fi

     

       103
       103
       -
       

     

       104
       104
       -
       buildHostCmd() {

     

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

     

       106
       106
       -
               "$@"

     

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

     

       108
       108
       -
               ssh $SSHOPTS "$buildHost" PATH="$remoteNix:$PATH" "$@"

     

       109
       109
       -
           else

     

       110
       110
       -
               ssh $SSHOPTS "$buildHost" "$@"

     

       111
       111
       -
           fi

     

       112
       112
       -
       }

     

       113
       113
       -
       

     

       114
       114
       -
       targetHostCmd() {

     

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

     

       116
       116
       -
               "$@"

     

       117
       117
       -
           else

     

       118
       118
       -
               ssh $SSHOPTS "$targetHost" "$@"

     

       119
       119
       -
           fi

     

       120
       120
       -
       }

     

       121
       121
       -
       

     

       122
       122
       -
       copyToTarget() {

     

       123
       123
       -
           if ! [ "$targetHost" = "$buildHost" ]; then

     

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

     

       125
       125
       -
                   NIX_SSHOPTS=$SSH_OPTS nix-copy-closure --from "$buildHost" "$1"

     

       126
       126
       -
               elif [ -z "$buildHost" ]; then

     

       127
       127
       -
                   NIX_SSHOPTS=$SSH_OPTS nix-copy-closure --to "$targetHost" "$1"

     

       128
       128
       -
               else

     

       129
       129
       -
                   buildHostCmd nix-copy-closure --to "$targetHost" "$1"

     

       130
       130
       -
               fi

     

       131
       131
       -
           fi

     

       132
       132
       -
       }

     

       133
       133
       -
       

     

       134
       134
       -
       nixBuild() {

     

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

     

       136
       136
       -
               nix-build "$@"

     

       137
       137
       -
           else

     

       138
       138
       -
               local instArgs=()

     

       139
       139
       -
               local buildArgs=()

     

       140
       140
       -
       

     

       141
       141
       -
               while [ "$#" -gt 0 ]; do

     

       142
       142
       -
                   local i="$1"; shift 1

     

       143
       143
       -
                   case "$i" in

     

       144
       144
       -
                     -o)

     

       145
       145
       -
                       local out="$1"; shift 1

     

       146
       146
       -
                       buildArgs+=("--add-root" "$out" "--indirect")

     

       147
       147
       -
                       ;;

     

       148
       148
       -
                     -A)

     

       149
       149
       -
                       local j="$1"; shift 1

     

       150
       150
       -
                       instArgs+=("$i" "$j")

     

       151
       151
       -
                       ;;

     

       152
       152
       -
                     -I)

     

       153
       153
       -
                       # We don't want this in buildArgs

     

       154
       154
       -
                       shift 1

     

       155
       155
       -
                       ;;

     

       156
       156
       -
                     "<"*) # nix paths

     

       157
       157
       -
                       instArgs+=("$i")

     

       158
       158
       -
                       ;;

     

       159
       159
       -
                     *)

     

       160
       160
       -
                       buildArgs+=("$i")

     

       161
       161
       -
                       ;;

     

       162
       162
       -
                   esac

     

       163
       163
       -
               done

     

       164
       164
       -
       

     

       165
       165
       -
               local drv="$(nix-instantiate "${instArgs[@]}" "${extraBuildFlags[@]}")"

     

       166
       166
       -
               if [ -a "$drv" ]; then

     

       167
       167
       -
                   NIX_SSHOPTS=$SSH_OPTS nix-copy-closure --to "$buildHost" "$drv"

     

       168
       168
       -
                   buildHostCmd nix-store -r "$drv" "${buildArgs[@]}"

     

       169
       169
       -
               else

     

       170
       170
       -
                   echo "nix-instantiate failed"

     

       171
       171
       -
                   exit 1

     

       172
       172
       -
               fi

     

       173
       173
       -
         fi

     

       174
       174
       -
       }

     

       175
       175
       -
       

     

       176
       82
        
       

     

       177
       83
        
       if [ -z "$action" ]; then showSyntax; fi

     

       178
       84
        
       

     
···

       222
       128
        
       

     

       223
       129
        
       

     

       224
       130
        
       tmpDir=$(mktemp -t -d nixos-rebuild.XXXXXX)

     

       225
       225
       -
       SSHOPTS="$NIX_SSHOPTS -o ControlMaster=auto -o ControlPath=$tmpDir/ssh-%n -o ControlPersist=60"

     

       226
       226
       -
       

     

       227
       227
       -
       cleanup() {

     

       228
       228
       -
           for ctrl in "$tmpDir"/ssh-*; do

     

       229
       229
       -
               ssh -o ControlPath="$ctrl" -O exit dummyhost 2>/dev/null || true

     

       230
       230
       -
           done

     

       231
       231
       -
           rm -rf "$tmpDir"

     

       232
       232
       -
       }

     

       233
       233
       -
       trap cleanup EXIT

     

       234
       234
       -
       

     

       131
       131
       +
       trap 'rm -rf "$tmpDir"' EXIT

     

       235
       132
        
       

     

       236
       133
        
       

     

       237
       134
        
       # If the Nix daemon is running, then use it.  This allows us to use

     
···

       253
       150
        
           buildNix=

     

       254
       151
        
       fi

     

       255
       152
        
       

     

       256
       256
       -
       prebuiltNix() {

     

       257
       257
       -
           machine="$1"

     

       258
       258
       -
           if [ "$machine" = x86_64 ]; then

     

       259
       259
       -
               return /nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10

     

       260
       260
       -
           elif [[ "$machine" =~ i.86 ]]; then

     

       261
       261
       -
               return /nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10

     

       262
       262
       -
           else

     

       263
       263
       -
               echo "$0: unsupported platform"

     

       264
       264
       -
               exit 1

     

       265
       265
       -
           fi

     

       266
       266
       -
       }

     

       267
       267
       -
       

     

       268
       268
       -
       remotePATH=

     

       269
       269
       -
       

     

       270
       153
        
       if [ -n "$buildNix" ]; then

     

       271
       154
        
           echo "building Nix..." >&2

     

       272
       272
       -
           nixDrv=

     

       273
       273
       -
           if ! nixDrv="$(nix-instantiate '<nixpkgs/nixos>' --add-root $tmpDir/nixdrv --indirect -A config.nix.package "${extraBuildFlags[@]}")"; then

     

       274
       274
       -
               if ! nixDrv="$(nix-instantiate '<nixpkgs/nixos>' --add-root $tmpDir/nixdrv --indirect -A nixFallback "${extraBuildFlags[@]}")"; then

     

       275
       275
       -
                   if ! nixDrv="$(nix-instantiate '<nixpkgs>' --add-root $tmpDir/nixdrv --indirect -A nix "${extraBuildFlags[@]}")"; then

     

       276
       276
       -
                       nixStorePath="$(prebuiltNix "$(uname -m)")"

     

       155
       155
       +
           if ! nix-build '<nixpkgs/nixos>' -A config.nix.package -o $tmpDir/nix "${extraBuildFlags[@]}" > /dev/null; then

     

       156
       156
       +
               if ! nix-build '<nixpkgs/nixos>' -A nixFallback -o $tmpDir/nix "${extraBuildFlags[@]}" > /dev/null; then

     

       157
       157
       +
                   if ! nix-build '<nixpkgs>' -A nix -o $tmpDir/nix "${extraBuildFlags[@]}" > /dev/null; then

     

       158
       158
       +
                       machine="$(uname -m)"

     

       159
       159
       +
                       if [ "$machine" = x86_64 ]; then

     

       160
       160
       +
                           nixStorePath=/nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10

     

       161
       161
       +
                       elif [[ "$machine" =~ i.86 ]]; then

     

       162
       162
       +
                           nixStorePath=/nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10

     

       163
       163
       +
                       else

     

       164
       164
       +
                           echo "$0: unsupported platform"

     

       165
       165
       +
                           exit 1

     

       166
       166
       +
                       fi

     

       277
       167
        
                       if ! nix-store -r $nixStorePath --add-root $tmpDir/nix --indirect \

     

       278
       168
        
                           --option extra-binary-caches https://cache.nixos.org/; then

     

       279
       169
        
                           echo "warning: don't know how to get latest Nix" >&2

     

       280
       170
        
                       fi

     

       281
       171
        
                       # Older version of nix-store -r don't support --add-root.

     

       282
       172
        
                       [ -e $tmpDir/nix ] || ln -sf $nixStorePath $tmpDir/nix

     

       283
       283
       -
                       if [ -n "$buildHost" ]; then

     

       284
       284
       -
                           remoteNixStorePath="$(prebuiltNix "$(buildHostCmd uname -m)")"

     

       285
       285
       -
                           remoteNix="$remoteNixStorePath/bin"

     

       286
       286
       -
                           if ! buildHostCmd nix-store -r $remoteNixStorePath \

     

       287
       287
       -
                             --option extra-binary-caches https://cache.nixos.org/ >/dev/null; then

     

       288
       288
       -
                               remoteNix=

     

       289
       289
       -
                               echo "warning: don't know how to get latest Nix" >&2

     

       290
       290
       -
                           fi

     

       291
       291
       -
                       fi

     

       292
       173
        
                   fi

     

       293
       174
        
               fi

     

       294
       175
        
           fi

     

       295
       295
       -
           if [ -a "$nixDrv" ]; then

     

       296
       296
       -
               nix-store -r "$nixDrv" --add-root $tmpDir/nix --indirect >/dev/null

     

       297
       297
       -
               if [ -n "$buildHost" ]; then

     

       298
       298
       -
                   nix-copy-closure --to "$buildHost" "$nixDrv"

     

       299
       299
       -
                   # The nix build produces multiple outputs, we add them all to the remote path

     

       300
       300
       -
                   for p in $(buildHostCmd nix-store -r "$(readlink "$nixDrv")" "${buildArgs[@]}"); do

     

       301
       301
       -
                       remoteNix="$remoteNix${remoteNix:+:}$p/bin"

     

       302
       302
       -
                   done

     

       303
       303
       -
               fi

     

       304
       304
       -
           fi

     

       305
       305
       -
           PATH="$tmpDir/nix/bin:$PATH"

     

       176
       176
       +
           PATH=$tmpDir/nix/bin:$PATH

     

       306
       177
        
       fi

     

       307
       178
        
       

     

       308
       179
        
       

     
···

       329
       200
        
       if [ -z "$rollback" ]; then

     

       330
       201
        
           echo "building the system configuration..." >&2

     

       331
       202
        
           if [ "$action" = switch -o "$action" = boot ]; then

     

       332
       332
       -
               pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A system "${extraBuildFlags[@]}")"

     

       333
       333
       -
               copyToTarget "$pathToConfig"

     

       334
       334
       -
               targetHostCmd nix-env -p "$profile" --set "$pathToConfig"

     

       203
       203
       +
               nix-env "${extraBuildFlags[@]}" -p "$profile" -f '<nixpkgs/nixos>' --set -A system

     

       204
       204
       +
               pathToConfig="$profile"

     

       335
       205
        
           elif [ "$action" = test -o "$action" = build -o "$action" = dry-build -o "$action" = dry-activate ]; then

     

       336
       336
       -
               pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A system -k "${extraBuildFlags[@]}")"

     

       206
       206
       +
               nix-build '<nixpkgs/nixos>' -A system -k "${extraBuildFlags[@]}" > /dev/null

     

       207
       207
       +
               pathToConfig=./result

     

       337
       208
        
           elif [ "$action" = build-vm ]; then

     

       338
       338
       -
               pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A vm -k "${extraBuildFlags[@]}")"

     

       209
       209
       +
               nix-build '<nixpkgs/nixos>' -A vm -k "${extraBuildFlags[@]}" > /dev/null

     

       210
       210
       +
               pathToConfig=./result

     

       339
       211
        
           elif [ "$action" = build-vm-with-bootloader ]; then

     

       340
       340
       -
               pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A vmWithBootLoader -k "${extraBuildFlags[@]}")"

     

       212
       212
       +
               nix-build '<nixpkgs/nixos>' -A vmWithBootLoader -k "${extraBuildFlags[@]}" > /dev/null

     

       213
       213
       +
               pathToConfig=./result

     

       341
       214
        
           else

     

       342
       215
        
               showSyntax

     

       343
       216
        
           fi

     

       344
       344
       -
           # Copy build to target host if we haven't already done it

     

       345
       345
       -
           if ! [ "$action" = switch -o "$action" = boot ]; then

     

       346
       346
       -
               copyToTarget "$pathToConfig"

     

       347
       347
       -
           fi

     

       348
       217
        
       else # [ -n "$rollback" ]

     

       349
       218
        
           if [ "$action" = switch -o "$action" = boot ]; then

     

       350
       350
       -
               targetHostCmd nix-env --rollback -p "$profile"

     

       219
       219
       +
               nix-env --rollback -p "$profile"

     

       351
       220
        
               pathToConfig="$profile"

     

       352
       221
        
           elif [ "$action" = test -o "$action" = build ]; then

     

       353
       222
        
               systemNumber=$(

     

       354
       354
       -
                   targetHostCmd nix-env -p "$profile" --list-generations |

     

       223
       223
       +
                   nix-env -p "$profile" --list-generations |

     

       355
       224
        
                   sed -n '/current/ {g; p;}; s/ *\([0-9]*\).*/\1/; h'

     

       356
       225
        
               )

     

       357
       357
       -
               pathToConfig="$profile"-${systemNumber}-link

     

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

     

       359
       359
       -
                   ln -sT "$pathToConfig" ./result

     

       360
       360
       -
               fi

     

       226
       226
       +
               ln -sT "$profile"-${systemNumber}-link ./result

     

       227
       227
       +
               pathToConfig=./result

     

       361
       228
        
           else

     

       362
       229
        
               showSyntax

     

       363
       230
        
           fi

     
···

       367
       234
        
       # If we're not just building, then make the new configuration the boot

     

       368
       235
        
       # default and/or activate it now.

     

       369
       236
        
       if [ "$action" = switch -o "$action" = boot -o "$action" = test -o "$action" = dry-activate ]; then

     

       370
       370
       -
           if ! targetHostCmd $pathToConfig/bin/switch-to-configuration "$action"; then

     

       237
       237
       +
           if ! $pathToConfig/bin/switch-to-configuration "$action"; then

     

       371
       238
        
               echo "warning: error(s) occurred while switching to the new configuration" >&2

     

       372
       239
        
               exit 1

     

       373
       240
        
           fi