commit fec543436d4d35dacde01a9e8b69a2781841f901 · pyrox.dev/nixpkgs

+1 -1

nixos/modules/config/zram.nix

···

       93
       93
        
                   serviceConfig = {

     

       94
       94
        
                     Type = "oneshot";

     

       95
       95
        
                     RemainAfterExit = true;

     

       96
       96
       -
                     ExecStop = "${pkgs.stdenv.shell} -c 'echo 1 > /sys/class/block/${dev}/reset'";

     

       96
       96
       +
                     ExecStop = "${pkgs.runtimeShell} -c 'echo 1 > /sys/class/block/${dev}/reset'";

     

       97
       97
        
                   };

     

       98
       98
        
                   script = ''

     

       99
       99
        
                     set -u

+4 -4

nixos/modules/hardware/video/nvidia.nix

···

       75
       75
        
           # Create /dev/nvidia-uvm when the nvidia-uvm module is loaded.

     

       76
       76
        
           services.udev.extraRules =

     

       77
       77
        
             ''

     

       78
       78
       -
               KERNEL=="nvidia", RUN+="${pkgs.stdenv.shell} -c 'mknod -m 666 /dev/nvidiactl c $(grep nvidia-frontend /proc/devices | cut -d \  -f 1) 255'"

     

       79
       79
       -
               KERNEL=="nvidia_modeset", RUN+="${pkgs.stdenv.shell} -c 'mknod -m 666 /dev/nvidia-modeset c $(grep nvidia-frontend /proc/devices | cut -d \  -f 1) 254'"

     

       80
       80
       -
               KERNEL=="card*", SUBSYSTEM=="drm", DRIVERS=="nvidia", RUN+="${pkgs.stdenv.shell} -c 'mknod -m 666 /dev/nvidia%n c $(grep nvidia-frontend /proc/devices | cut -d \  -f 1) %n'"

     

       81
       81
       -
               KERNEL=="nvidia_uvm", RUN+="${pkgs.stdenv.shell} -c 'mknod -m 666 /dev/nvidia-uvm c $(grep nvidia-uvm /proc/devices | cut -d \  -f 1) 0'"

     

       78
       78
       +
               KERNEL=="nvidia", RUN+="${pkgs.runtimeShell} -c 'mknod -m 666 /dev/nvidiactl c $(grep nvidia-frontend /proc/devices | cut -d \  -f 1) 255'"

     

       79
       79
       +
               KERNEL=="nvidia_modeset", RUN+="${pkgs.runtimeShell} -c 'mknod -m 666 /dev/nvidia-modeset c $(grep nvidia-frontend /proc/devices | cut -d \  -f 1) 254'"

     

       80
       80
       +
               KERNEL=="card*", SUBSYSTEM=="drm", DRIVERS=="nvidia", RUN+="${pkgs.runtimeShell} -c 'mknod -m 666 /dev/nvidia%n c $(grep nvidia-frontend /proc/devices | cut -d \  -f 1) %n'"

     

       81
       81
       +
               KERNEL=="nvidia_uvm", RUN+="${pkgs.runtimeShell} -c 'mknod -m 666 /dev/nvidia-uvm c $(grep nvidia-uvm /proc/devices | cut -d \  -f 1) 0'"

     

       82
       82
        
             '';

     

       83
       83
        
       

     

       84
       84
        
           boot.blacklistedKernelModules = [ "nouveau" "nvidiafb" ];

+1 -1

nixos/modules/programs/rootston.nix

···

       6
       6
        
         cfg = config.programs.rootston;

     

       7
       7
        
       

     

       8
       8
        
         rootstonWrapped = pkgs.writeScriptBin "rootston" ''

     

       9
       9
       -
           #! ${pkgs.stdenv.shell}

     

       9
       9
       +
           #! ${pkgs.runtimeShell}

     

       10
       10
        
           if [[ "$#" -ge 1 ]]; then

     

       11
       11
        
             exec ${pkgs.rootston}/bin/rootston "$@"

     

       12
       12
        
           else

+1 -1

nixos/modules/programs/ssh.nix

···

       13
       13
        
       

     

       14
       14
        
         askPasswordWrapper = pkgs.writeScript "ssh-askpass-wrapper"

     

       15
       15
        
           ''

     

       16
       16
       -
             #! ${pkgs.stdenv.shell} -e

     

       16
       16
       +
             #! ${pkgs.runtimeShell} -e

     

       17
       17
        
             export DISPLAY="$(systemctl --user show-environment | ${pkgs.gnused}/bin/sed 's/^DISPLAY=\(.*\)/\1/; t; d')"

     

       18
       18
        
             exec ${askPassword}

     

       19
       19
        
           '';

+3 -3

nixos/modules/security/audit.nix

···

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         disableScript = pkgs.writeScript "audit-disable" ''

     

       16
       16
       -
           #!${pkgs.stdenv.shell} -eu

     

       16
       16
       +
           #!${pkgs.runtimeShell} -eu

     

       17
       17
        
           # Explicitly disable everything, as otherwise journald might start it.

     

       18
       18
        
           auditctl -D

     

       19
       19
        
           auditctl -e 0 -a task,never

     
···

       23
       23
        
         # put in the store like this. At the same time, it doesn't feel like a huge deal and working

     

       24
       24
        
         # around that is a pain so I'm leaving it like this for now.

     

       25
       25
        
         startScript = pkgs.writeScript "audit-start" ''

     

       26
       26
       -
           #!${pkgs.stdenv.shell} -eu

     

       26
       26
       +
           #!${pkgs.runtimeShell} -eu

     

       27
       27
        
           # Clear out any rules we may start with

     

       28
       28
        
           auditctl -D

     

       29
       29
        
       

     
···

       43
       43
        
         '';

     

       44
       44
        
       

     

       45
       45
        
         stopScript = pkgs.writeScript "audit-stop" ''

     

       46
       46
       -
           #!${pkgs.stdenv.shell} -eu

     

       46
       46
       +
           #!${pkgs.runtimeShell} -eu

     

       47
       47
        
           # Clear the rules

     

       48
       48
        
           auditctl -D

     

       49
       49

+1 -1

nixos/modules/services/continuous-integration/buildkite-agent.nix

···

       18
       18
        
         hooksDir = let

     

       19
       19
        
           mkHookEntry = name: value: ''

     

       20
       20
        
             cat > $out/${name} <<EOF

     

       21
       21
       -
             #! ${pkgs.stdenv.shell}

     

       21
       21
       +
             #! ${pkgs.runtimeShell}

     

       22
       22
        
             set -e

     

       23
       23
        
             ${value}

     

       24
       24
        
             EOF

+1 -1

nixos/modules/services/databases/4store-endpoint.nix

···

       2
       2
        
       let

     

       3
       3
        
         cfg = config.services.fourStoreEndpoint;

     

       4
       4
        
         endpointUser = "fourstorehttp";

     

       5
       5
       -
         run = "${pkgs.su}/bin/su -s ${pkgs.stdenv.shell} ${endpointUser} -c";

     

       5
       5
       +
         run = "${pkgs.su}/bin/su -s ${pkgs.runtimeShell} ${endpointUser} -c";

     

       6
       6
        
       in

     

       7
       7
        
       with lib;

     

       8
       8
        
       {

+1 -1

nixos/modules/services/databases/4store.nix

···

       3
       3
        
         cfg = config.services.fourStore;

     

       4
       4
        
         stateDir = "/var/lib/4store";

     

       5
       5
        
         fourStoreUser = "fourstore";

     

       6
       6
       -
         run = "${pkgs.su}/bin/su -s ${pkgs.stdenv.shell} ${fourStoreUser}";

     

       6
       6
       +
         run = "${pkgs.su}/bin/su -s ${pkgs.runtimeShell} ${fourStoreUser}";

     

       7
       7
        
       in

     

       8
       8
        
       with lib;

     

       9
       9
        
       {

+1 -1

nixos/modules/services/editors/emacs.nix

···

       7
       7
        
         cfg = config.services.emacs;

     

       8
       8
        
       

     

       9
       9
        
         editorScript = pkgs.writeScriptBin "emacseditor" ''

     

       10
       10
       -
           #!${pkgs.stdenv.shell}

     

       10
       10
       +
           #!${pkgs.runtimeShell}

     

       11
       11
        
           if [ -z "$1" ]; then

     

       12
       12
        
             exec ${cfg.package}/bin/emacsclient --create-frame --alternate-editor ${cfg.package}/bin/emacs

     

       13
       13
        
           else

+1 -1

nixos/modules/services/misc/folding-at-home.nix

···

       57
       57
        
               chown ${fahUser} ${stateDir}

     

       58
       58
        
               cp -f ${pkgs.writeText "client.cfg" cfg.config} ${stateDir}/client.cfg

     

       59
       59
        
             '';

     

       60
       60
       -
             script = "${pkgs.su}/bin/su -s ${pkgs.stdenv.shell} ${fahUser} -c 'cd ${stateDir}; ${pkgs.foldingathome}/bin/fah6'";

     

       60
       60
       +
             script = "${pkgs.su}/bin/su -s ${pkgs.runtimeShell} ${fahUser} -c 'cd ${stateDir}; ${pkgs.foldingathome}/bin/fah6'";

     

       61
       61
        
           };

     

       62
       62
        
       

     

       63
       63
        
           services.foldingAtHome.config = ''

+1 -1

nixos/modules/services/misc/geoip-updater.nix

···

       14
       14
        
         # ExecStart= command with '@' doesn't work because we start a shell (new

     

       15
       15
        
         # process) that creates a new argv[0].)

     

       16
       16
        
         geoip-updater = pkgs.writeScriptBin "geoip-updater" ''

     

       17
       17
       -
           #!${pkgs.stdenv.shell}

     

       17
       17
       +
           #!${pkgs.runtimeShell}

     

       18
       18
        
           skipExisting=0

     

       19
       19
        
           debug()

     

       20
       20
        
           {

+1 -1

nixos/modules/services/misc/gitit.nix

···

       17
       17
        
         gititSh = hsPkgs: extras: with pkgs; let

     

       18
       18
        
           env = gititWithPkgs hsPkgs extras;

     

       19
       19
        
         in writeScript "gitit" ''

     

       20
       20
       -
           #!${stdenv.shell}

     

       20
       20
       +
           #!${runtimeShell}

     

       21
       21
        
           cd $HOME

     

       22
       22
        
           export NIX_GHC="${env}/bin/ghc"

     

       23
       23
        
           export NIX_GHCPKG="${env}/bin/ghc-pkg"

+1 -1

nixos/modules/services/misc/ihaskell.nix

···

       55
       55
        
             serviceConfig = {

     

       56
       56
        
               User = config.users.extraUsers.ihaskell.name;

     

       57
       57
        
               Group = config.users.extraGroups.ihaskell.name;

     

       58
       58
       -
               ExecStart = "${pkgs.stdenv.shell} -c \"cd $HOME;${ihaskell}/bin/ihaskell-notebook\"";

     

       58
       58
       +
               ExecStart = "${pkgs.runtimeShell} -c \"cd $HOME;${ihaskell}/bin/ihaskell-notebook\"";

     

       59
       59
        
             };

     

       60
       60
        
           };

     

       61
       61
        
         };

+1 -1

nixos/modules/services/misc/mesos-slave.nix

···

       188
       188
        
             description = "Mesos Slave";

     

       189
       189
        
             wantedBy = [ "multi-user.target" ];

     

       190
       190
        
             after = [ "network.target" ];

     

       191
       191
       -
             path = [ pkgs.stdenv.shellPackage ];

     

       191
       191
       +
             path = [ pkgs.runtimeShellPackage ];

     

       192
       192
        
             serviceConfig = {

     

       193
       193
        
               ExecStart = ''

     

       194
       194
        
                 ${pkgs.mesos}/bin/mesos-slave \

+1 -1

nixos/modules/services/misc/nix-daemon.nix

···

       30
       30
        
             # /bin/sh in the sandbox as a bind-mount to bash. This means we

     

       31
       31
        
             # also need to include the entire closure of bash. Nix >= 2.0

     

       32
       32
        
             # provides a /bin/sh by default.

     

       33
       33
       -
             sh = pkgs.stdenv.shell;

     

       33
       33
       +
             sh = pkgs.runtimeShell;

     

       34
       34
        
             binshDeps = pkgs.writeReferencesToFile sh;

     

       35
       35
        
           in

     

       36
       36
        
             pkgs.runCommand "nix.conf" { extraOptions = cfg.extraOptions; inherit binshDeps; } ''

+1 -1

nixos/modules/services/misc/nixos-manual.nix

···

       43
       43
        
       

     

       44
       44
        
         helpScript = pkgs.writeScriptBin "nixos-help"

     

       45
       45
        
           ''

     

       46
       46
       -
             #! ${pkgs.stdenv.shell} -e

     

       46
       46
       +
             #! ${pkgs.runtimeShell} -e

     

       47
       47
        
             browser="$BROWSER"

     

       48
       48
        
             if [ -z "$browser" ]; then

     

       49
       49
        
               browser="$(type -P xdg-open || true)"

+1 -1

nixos/modules/services/misc/ssm-agent.nix

···

       8
       8
        
         # in nixpkgs doesn't seem to work properly on NixOS, so let's just fake the two fields SSM

     

       9
       9
        
         # looks for. See https://github.com/aws/amazon-ssm-agent/issues/38 for upstream fix.

     

       10
       10
        
         fake-lsb-release = pkgs.writeScriptBin "lsb_release" ''

     

       11
       11
       -
           #!${pkgs.stdenv.shell}

     

       11
       11
       +
           #!${pkgs.runtimeShell}

     

       12
       12
        
       

     

       13
       13
        
           case "$1" in

     

       14
       14
        
             -i) echo "nixos";;

+1 -1

nixos/modules/services/monitoring/apcupsd.nix

···

       38
       38
        
         ];

     

       39
       39
        
       

     

       40
       40
        
         shellCmdsForEventScript = eventname: commands: ''

     

       41
       41
       -
           echo "#!${pkgs.stdenv.shell}" > "$out/${eventname}"

     

       41
       41
       +
           echo "#!${pkgs.runtimeShell}" > "$out/${eventname}"

     

       42
       42
        
           echo '${commands}' >> "$out/${eventname}"

     

       43
       43
        
           chmod a+x "$out/${eventname}"

     

       44
       44
        
         '';

+1 -1

nixos/modules/services/monitoring/smartd.nix

···

       14
       14
        
         nx = cfg.notifications.x11;

     

       15
       15
        
       

     

       16
       16
        
         smartdNotify = pkgs.writeScript "smartd-notify.sh" ''

     

       17
       17
       -
           #! ${pkgs.stdenv.shell}

     

       17
       17
       +
           #! ${pkgs.runtimeShell}

     

       18
       18
        
           ${optionalString nm.enable ''

     

       19
       19
        
             {

     

       20
       20
        
             ${pkgs.coreutils}/bin/cat << EOF

+1 -1

nixos/modules/services/network-filesystems/xtreemfs.nix

···

       11
       11
        
         home = cfg.homeDir;

     

       12
       12
        
       

     

       13
       13
        
         startupScript = class: configPath: pkgs.writeScript "xtreemfs-osd.sh" ''

     

       14
       14
       -
           #! ${pkgs.stdenv.shell}

     

       14
       14
       +
           #! ${pkgs.runtimeShell}

     

       15
       15
        
           JAVA_HOME="${pkgs.jdk}"

     

       16
       16
        
           JAVADIR="${xtreemfs}/share/java"

     

       17
       17
        
           JAVA_CALL="$JAVA_HOME/bin/java -ea -cp $JAVADIR/XtreemFS.jar:$JAVADIR/BabuDB.jar:$JAVADIR/Flease.jar:$JAVADIR/protobuf-java-2.5.0.jar:$JAVADIR/Foundation.jar:$JAVADIR/jdmkrt.jar:$JAVADIR/jdmktk.jar:$JAVADIR/commons-codec-1.3.jar"

+2 -2

nixos/modules/services/network-filesystems/yandex-disk.nix

···

       99
       99
        
                   exit 1

     

       100
       100
        
               fi

     

       101
       101
        
       

     

       102
       102
       -
               ${pkgs.su}/bin/su -s ${pkgs.stdenv.shell} ${u} \

     

       102
       102
       +
               ${pkgs.su}/bin/su -s ${pkgs.runtimeShell} ${u} \

     

       103
       103
        
                 -c '${pkgs.yandex-disk}/bin/yandex-disk token -p ${cfg.password} ${cfg.username} ${dir}/token'

     

       104
       104
        
       

     

       105
       105
       -
               ${pkgs.su}/bin/su -s ${pkgs.stdenv.shell} ${u} \

     

       105
       105
       +
               ${pkgs.su}/bin/su -s ${pkgs.runtimeShell} ${u} \

     

       106
       106
        
                 -c '${pkgs.yandex-disk}/bin/yandex-disk start --no-daemon -a ${dir}/token -d ${cfg.directory} --exclude-dirs=${cfg.excludes}'

     

       107
       107
        
             '';

     

       108
       108

+1 -1

nixos/modules/services/networking/amuled.nix

···

       68
       68
        
             '';

     

       69
       69
        
       

     

       70
       70
        
             script = ''

     

       71
       71
       -
               ${pkgs.su}/bin/su -s ${pkgs.stdenv.shell} ${user} \

     

       71
       71
       +
               ${pkgs.su}/bin/su -s ${pkgs.runtimeShell} ${user} \

     

       72
       72
        
                   -c 'HOME="${cfg.dataDir}" ${pkgs.amuleDaemon}/bin/amuled'

     

       73
       73
        
             '';

     

       74
       74
        
           };

+1 -1

nixos/modules/services/networking/firewall.nix

···

       54
       54
        
           '';

     

       55
       55
        
       

     

       56
       56
        
         writeShScript = name: text: let dir = pkgs.writeScriptBin name ''

     

       57
       57
       -
           #! ${pkgs.stdenv.shell} -e

     

       57
       57
       +
           #! ${pkgs.runtimeShell} -e

     

       58
       58
        
           ${text}

     

       59
       59
        
         ''; in "${dir}/bin/${name}";

     

       60
       60

+1 -1

nixos/modules/services/networking/flashpolicyd.nix

···

       22
       22
        
       

     

       23
       23
        
         flashpolicydWrapper = pkgs.writeScriptBin "flashpolicyd"

     

       24
       24
        
           ''

     

       25
       25
       -
             #! ${pkgs.stdenv.shell}

     

       25
       25
       +
             #! ${pkgs.runtimeShell}

     

       26
       26
        
             exec ${flashpolicyd}/Perl_xinetd/in.flashpolicyd.pl \

     

       27
       27
        
               --file=${pkgs.writeText "flashpolixy.xml" cfg.policy} \

     

       28
       28
        
               2> /dev/null

+1 -1

nixos/modules/services/networking/nftables.nix

···

       116
       116
        
                 include "${cfg.rulesetFile}"

     

       117
       117
        
               '';

     

       118
       118
        
               checkScript = pkgs.writeScript "nftables-check" ''

     

       119
       119
       -
                 #! ${pkgs.stdenv.shell} -e

     

       119
       119
       +
                 #! ${pkgs.runtimeShell} -e

     

       120
       120
        
                 if $(${pkgs.kmod}/bin/lsmod | grep -q ip_tables); then

     

       121
       121
        
                   echo "Unload ip_tables before using nftables!" 1>&2

     

       122
       122
        
                   exit 1

+1 -1

nixos/modules/services/networking/rdnssd.nix

···

       6
       6
        
       with lib;

     

       7
       7
        
       let

     

       8
       8
        
         mergeHook = pkgs.writeScript "rdnssd-merge-hook" ''

     

       9
       9
       -
           #! ${pkgs.stdenv.shell} -e

     

       9
       9
       +
           #! ${pkgs.runtimeShell} -e

     

       10
       10
        
           ${pkgs.openresolv}/bin/resolvconf -u

     

       11
       11
        
         '';

     

       12
       12
        
       in

+1 -1

nixos/modules/services/security/torify.nix

···

       7
       7
        
         torify = pkgs.writeTextFile {

     

       8
       8
        
           name = "tsocks";

     

       9
       9
        
           text = ''

     

       10
       10
       -
               #!${pkgs.stdenv.shell}

     

       10
       10
       +
               #!${pkgs.runtimeShell}

     

       11
       11
        
               TSOCKS_CONF_FILE=${pkgs.writeText "tsocks.conf" cfg.tsocks.config} LD_PRELOAD="${pkgs.tsocks}/lib/libtsocks.so $LD_PRELOAD" "$@"

     

       12
       12
        
           '';

     

       13
       13
        
           executable = true;

+1 -1

nixos/modules/services/security/torsocks.nix

···

       23
       23
        
         wrapTorsocks = name: server: pkgs.writeTextFile {

     

       24
       24
        
           name = name;

     

       25
       25
        
           text = ''

     

       26
       26
       -
               #!${pkgs.stdenv.shell}

     

       26
       26
       +
               #!${pkgs.runtimeShell}

     

       27
       27
        
               TORSOCKS_CONF_FILE=${pkgs.writeText "torsocks.conf" (configFile server)} ${pkgs.torsocks}/bin/torsocks "$@"

     

       28
       28
        
           '';

     

       29
       29
        
           executable = true;

+1 -1

nixos/modules/services/torrent/transmission.nix

···

       90
       90
        
             # 1) Only the "transmission" user and group have access to torrents.

     

       91
       91
        
             # 2) Optionally update/force specific fields into the configuration file.

     

       92
       92
        
             serviceConfig.ExecStartPre = ''

     

       93
       93
       -
                 ${pkgs.stdenv.shell} -c "mkdir -p ${homeDir} ${settingsDir} ${fullSettings.download-dir} ${fullSettings.incomplete-dir} && chmod 770 ${homeDir} ${settingsDir} ${fullSettings.download-dir} ${fullSettings.incomplete-dir} && rm -f ${settingsDir}/settings.json && cp -f ${settingsFile} ${settingsDir}/settings.json"

     

       93
       93
       +
                 ${pkgs.runtimeShell} -c "mkdir -p ${homeDir} ${settingsDir} ${fullSettings.download-dir} ${fullSettings.incomplete-dir} && chmod 770 ${homeDir} ${settingsDir} ${fullSettings.download-dir} ${fullSettings.incomplete-dir} && rm -f ${settingsDir}/settings.json && cp -f ${settingsFile} ${settingsDir}/settings.json"

     

       94
       94
        
             '';

     

       95
       95
        
             serviceConfig.ExecStart = "${pkgs.transmission}/bin/transmission-daemon -f --port ${toString config.services.transmission.port}";

     

       96
       96
        
             serviceConfig.ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

+1 -1

nixos/modules/services/web-servers/apache-httpd/owncloud.nix

···

       346
       346
        
         postgresql = serverInfo.fullConfig.services.postgresql.package;

     

       347
       347
        
       

     

       348
       348
        
         setupDb = pkgs.writeScript "setup-owncloud-db" ''

     

       349
       349
       -
           #!${pkgs.stdenv.shell}

     

       349
       349
       +
           #!${pkgs.runtimeShell}

     

       350
       350
        
           PATH="${postgresql}/bin"

     

       351
       351
        
           createuser --no-superuser --no-createdb --no-createrole "${config.dbUser}" || true

     

       352
       352
        
           createdb "${config.dbName}" -O "${config.dbUser}" || true

+1 -1

nixos/modules/services/x11/desktop-managers/xfce.nix

···

       128
       128
        
               # Set GTK_DATA_PREFIX so that GTK+ can find the Xfce themes.

     

       129
       129
        
               export GTK_DATA_PREFIX=${config.system.path}

     

       130
       130
        
       

     

       131
       131
       -
               ${pkgs.stdenv.shell} ${pkgs.xfce.xinitrc} &

     

       131
       131
       +
               ${pkgs.runtimeShell} ${pkgs.xfce.xinitrc} &

     

       132
       132
        
               waitPID=$!

     

       133
       133
        
             '';

     

       134
       134
        
           }];

+1 -1

nixos/modules/services/x11/display-managers/slim.nix

···

       14
       14
        
             default_xserver ${dmcfg.xserverBin}

     

       15
       15
        
             xserver_arguments ${toString dmcfg.xserverArgs}

     

       16
       16
        
             sessiondir ${dmcfg.session.desktops}

     

       17
       17
       -
             login_cmd exec ${pkgs.stdenv.shell} ${dmcfg.session.script} "%session"

     

       17
       17
       +
             login_cmd exec ${pkgs.runtimeShell} ${dmcfg.session.script} "%session"

     

       18
       18
        
             halt_cmd ${config.systemd.package}/sbin/shutdown -h now

     

       19
       19
        
             reboot_cmd ${config.systemd.package}/sbin/shutdown -r now

     

       20
       20
        
             logfile /dev/stderr

+1 -1

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

···

       61
       61
        
             apply = set: {

     

       62
       62
        
               script =

     

       63
       63
        
                 ''

     

       64
       64
       -
                   #! ${pkgs.stdenv.shell}

     

       64
       64
       +
                   #! ${pkgs.runtimeShell}

     

       65
       65
        
       

     

       66
       66
        
                   systemConfig=@out@

     

       67
       67

+2 -2

nixos/modules/system/boot/loader/grub/grub.nix

···

       40
       40
        
           { splashImage = f cfg.splashImage;

     

       41
       41
        
             grub = f grub;

     

       42
       42
        
             grubTarget = f (grub.grubTarget or "");

     

       43
       43
       -
             shell = "${pkgs.stdenv.shell}";

     

       43
       43
       +
             shell = "${pkgs.runtimeShell}";

     

       44
       44
        
             fullName = (builtins.parseDrvName realGrub.name).name;

     

       45
       45
        
             fullVersion = (builtins.parseDrvName realGrub.name).version;

     

       46
       46
        
             grubEfi = f grubEfi;

     
···

       536
       536
        
                   btrfsprogs = pkgs.btrfs-progs;

     

       537
       537
        
                 };

     

       538
       538
        
               in pkgs.writeScript "install-grub.sh" (''

     

       539
       539
       -
               #!${pkgs.stdenv.shell}

     

       539
       539
       +
               #!${pkgs.runtimeShell}

     

       540
       540
        
               set -e

     

       541
       541
        
               export PERL5LIB=${makePerlPath (with pkgs.perlPackages; [ FileSlurp XMLLibXML XMLSAX ListCompare ])}

     

       542
       542
        
               ${optionalString cfg.enableCryptodisk "export GRUB_ENABLE_CRYPTODISK=y"}

+6 -6

nixos/modules/system/boot/systemd.nix

···

       241
       241
        
               }

     

       242
       242
        
               (mkIf (config.preStart != "")

     

       243
       243
        
                 { serviceConfig.ExecStartPre = makeJobScript "${name}-pre-start" ''

     

       244
       244
       -
                     #! ${pkgs.stdenv.shell} -e

     

       244
       244
       +
                     #! ${pkgs.runtimeShell} -e

     

       245
       245
        
                     ${config.preStart}

     

       246
       246
        
                   '';

     

       247
       247
        
                 })

     

       248
       248
        
               (mkIf (config.script != "")

     

       249
       249
        
                 { serviceConfig.ExecStart = makeJobScript "${name}-start" ''

     

       250
       250
       -
                     #! ${pkgs.stdenv.shell} -e

     

       250
       250
       +
                     #! ${pkgs.runtimeShell} -e

     

       251
       251
        
                     ${config.script}

     

       252
       252
        
                   '' + " " + config.scriptArgs;

     

       253
       253
        
                 })

     

       254
       254
        
               (mkIf (config.postStart != "")

     

       255
       255
        
                 { serviceConfig.ExecStartPost = makeJobScript "${name}-post-start" ''

     

       256
       256
       -
                     #! ${pkgs.stdenv.shell} -e

     

       256
       256
       +
                     #! ${pkgs.runtimeShell} -e

     

       257
       257
        
                     ${config.postStart}

     

       258
       258
        
                   '';

     

       259
       259
        
                 })

     

       260
       260
        
               (mkIf (config.reload != "")

     

       261
       261
        
                 { serviceConfig.ExecReload = makeJobScript "${name}-reload" ''

     

       262
       262
       -
                     #! ${pkgs.stdenv.shell} -e

     

       262
       262
       +
                     #! ${pkgs.runtimeShell} -e

     

       263
       263
        
                     ${config.reload}

     

       264
       264
        
                   '';

     

       265
       265
        
                 })

     

       266
       266
        
               (mkIf (config.preStop != "")

     

       267
       267
        
                 { serviceConfig.ExecStop = makeJobScript "${name}-pre-stop" ''

     

       268
       268
       -
                     #! ${pkgs.stdenv.shell} -e

     

       268
       268
       +
                     #! ${pkgs.runtimeShell} -e

     

       269
       269
        
                     ${config.preStop}

     

       270
       270
        
                   '';

     

       271
       271
        
                 })

     

       272
       272
        
               (mkIf (config.postStop != "")

     

       273
       273
        
                 { serviceConfig.ExecStopPost = makeJobScript "${name}-post-stop" ''

     

       274
       274
       -
                     #! ${pkgs.stdenv.shell} -e

     

       274
       274
       +
                     #! ${pkgs.runtimeShell} -e

     

       275
       275
        
                     ${config.postStop}

     

       276
       276
        
                   '';

     

       277
       277
        
                 })

+4 -4

nixos/modules/tasks/network-interfaces.nix

···

       26
       26
        
           executable = true;

     

       27
       27
        
           destination = "/bin/bridge-stp";

     

       28
       28
        
           text = ''

     

       29
       29
       -
             #!${pkgs.stdenv.shell} -e

     

       29
       29
       +
             #!${pkgs.runtimeShell} -e

     

       30
       30
        
             export PATH="${pkgs.mstpd}/bin"

     

       31
       31
        
       

     

       32
       32
        
             BRIDGES=(${concatStringsSep " " (attrNames rstpBridges)})

     
···

       64
       64
        
       

     

       65
       65
        
         # udev script that configures a physical wlan device and adds virtual interfaces

     

       66
       66
        
         wlanDeviceUdevScript = device: interfaceList: pkgs.writeScript "wlan-${device}-udev-script" ''

     

       67
       67
       -
           #!${pkgs.stdenv.shell}

     

       67
       67
       +
           #!${pkgs.runtimeShell}

     

       68
       68
        
       

     

       69
       69
        
           # Change the wireless phy device to a predictable name.

     

       70
       70
        
           if [ -e "/sys/class/net/${device}/phy80211/name" ]; then

     
···

       1158
       1158
        
                   # The script creates the required, new WLAN interfaces interfaces and configures the

     

       1159
       1159
        
                   # existing, default interface.

     

       1160
       1160
        
                   curInterfaceScript = device: current: new: pkgs.writeScript "udev-run-script-wlan-interfaces-${device}.sh" ''

     

       1161
       1161
       -
                     #!${pkgs.stdenv.shell}

     

       1161
       1161
       +
                     #!${pkgs.runtimeShell}

     

       1162
       1162
        
                     # Change the wireless phy device to a predictable name.

     

       1163
       1163
        
                     ${pkgs.iw}/bin/iw phy `${pkgs.coreutils}/bin/cat /sys/class/net/$INTERFACE/phy80211/name` set name ${device}

     

       1164
       1164
        
       

     
···

       1177
       1177
        
       

     

       1178
       1178
        
                   # Udev script to execute for a new WLAN interface. The script configures the new WLAN interface.

     

       1179
       1179
        
                   newInterfaceScript = device: new: pkgs.writeScript "udev-run-script-wlan-interfaces-${new._iName}.sh" ''

     

       1180
       1180
       -
                     #!${pkgs.stdenv.shell}

     

       1180
       1180
       +
                     #!${pkgs.runtimeShell}

     

       1181
       1181
        
                     # Configure the new interface

     

       1182
       1182
        
                     ${pkgs.iw}/bin/iw dev ${new._iName} set type ${new.type}

     

       1183
       1183
        
                     ${optionalString (new.type == "mesh" && new.meshID!=null) "${pkgs.iw}/bin/iw dev ${device} set meshid ${new.meshID}"}

+1 -1

nixos/modules/virtualisation/amazon-init.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         script = ''

     

       5
       5
       -
           #!${pkgs.stdenv.shell} -eu

     

       5
       5
       +
           #!${pkgs.runtimeShell} -eu

     

       6
       6
        
       

     

       7
       7
        
           echo "attempting to fetch configuration from EC2 user data..."

     

       8
       8

+1 -1

nixos/modules/virtualisation/azure-agent.nix

···

       47
       47
        
         };

     

       48
       48
        
       

     

       49
       49
        
         provisionedHook = pkgs.writeScript "provisioned-hook" ''

     

       50
       50
       -
           #!${pkgs.stdenv.shell}

     

       50
       50
       +
           #!${pkgs.runtimeShell}

     

       51
       51
        
           ${config.systemd.package}/bin/systemctl start provisioned.target

     

       52
       52
        
         '';

     

       53
       53

+2 -2

nixos/modules/virtualisation/containers.nix

···

       33
       33
        
           in

     

       34
       34
        
             pkgs.writeScript "container-init"

     

       35
       35
        
             ''

     

       36
       36
       -
               #! ${pkgs.stdenv.shell} -e

     

       36
       36
       +
               #! ${pkgs.runtimeShell} -e

     

       37
       37
        
       

     

       38
       38
        
               # Initialise the container side of the veth pair.

     

       39
       39
        
               if [ "$PRIVATE_NETWORK" = 1 ]; then

     
···

       223
       223
        
         serviceDirectives = cfg: {

     

       224
       224
        
           ExecReload = pkgs.writeScript "reload-container"

     

       225
       225
        
             ''

     

       226
       226
       -
               #! ${pkgs.stdenv.shell} -e

     

       226
       226
       +
               #! ${pkgs.runtimeShell} -e

     

       227
       227
        
               ${pkgs.nixos-container}/bin/nixos-container run "$INSTANCE" -- \

     

       228
       228
        
                 bash --login -c "''${SYSTEM_PATH:-/nix/var/nix/profiles/system}/bin/switch-to-configuration test"

     

       229
       229
        
             '';

+1 -1

nixos/modules/virtualisation/openvswitch.nix

···

       169
       169
        
               mkdir -p ${runDir}/ipsec/{etc/racoon,etc/init.d/,usr/sbin/}

     

       170
       170
        
               ln -fs ${pkgs.ipsecTools}/bin/setkey ${runDir}/ipsec/usr/sbin/setkey

     

       171
       171
        
               ln -fs ${pkgs.writeScript "racoon-restart" ''

     

       172
       172
       -
               #!${pkgs.stdenv.shell}

     

       172
       172
       +
               #!${pkgs.runtimeShell}

     

       173
       173
        
               /var/run/current-system/sw/bin/systemctl $1 racoon

     

       174
       174
        
               ''} ${runDir}/ipsec/etc/init.d/racoon

     

       175
       175
        
             '';

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       30
       30
        
         # Shell script to start the VM.

     

       31
       31
        
         startVM =

     

       32
       32
        
           ''

     

       33
       33
       -
             #! ${pkgs.stdenv.shell}

     

       33
       33
       +
             #! ${pkgs.runtimeShell}

     

       34
       34
        
       

     

       35
       35
        
             NIX_DISK_IMAGE=$(readlink -f ''${NIX_DISK_IMAGE:-${config.virtualisation.diskImage}})

     

       36
       36