commit 0184a255d7a71b285022e93c2ba69ff8f38d9d7f · pyrox.dev/nixpkgs

+1 -1

.github/workflows/backport.yml

···

       20
       20
        
           if: github.repository_owner == 'NixOS' && github.event.pull_request.merged == true && (github.event_name != 'labeled' || startsWith('backport', github.event.label.name))

     

       21
       21
        
           runs-on: ubuntu-latest

     

       22
       22
        
           steps:

     

       23
       23
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       23
       23
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       24
       24
        
               with:

     

       25
       25
        
                 ref: ${{ github.event.pull_request.head.sha }}

     

       26
       26
        
             - name: Create backport PRs

+1 -1

.github/workflows/basic-eval.yml

···

       18
       18
        
           runs-on: ubuntu-latest

     

       19
       19
        
           # we don't limit this action to only NixOS repo since the checks are cheap and useful developer feedback

     

       20
       20
        
           steps:

     

       21
       21
       -
           - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       21
       21
       +
           - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       22
       22
        
           - uses: cachix/install-nix-action@8887e596b4ee1134dae06b98d573bd674693f47c # v26

     

       23
       23
        
           - uses: cachix/cachix-action@18cf96c7c98e048e10a83abd92116114cd8504be # v14

     

       24
       24
        
             with:

+1 -1

.github/workflows/check-by-name.yml

···

       91
       91
        
                   exit 1

     

       92
       92
        
                 fi

     

       93
       93
        
                 echo "mergedSha=$mergedSha" >> "$GITHUB_ENV"

     

       94
       94
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       94
       94
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       95
       95
        
               with:

     

       96
       96
        
                 # pull_request_target checks out the base branch by default

     

       97
       97
        
                 ref: ${{ env.mergedSha }}

+1 -1

.github/workflows/check-cherry-picks.yml

···

       12
       12
        
           runs-on: ubuntu-latest

     

       13
       13
        
           if: github.repository_owner == 'NixOS'

     

       14
       14
        
           steps:

     

       15
       15
       -
           - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       15
       15
       +
           - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       16
       16
        
             with:

     

       17
       17
        
               fetch-depth: 0

     

       18
       18
        
               filter: blob:none

+1 -1

.github/workflows/check-maintainers-sorted.yaml

···

       12
       12
        
           runs-on: ubuntu-latest

     

       13
       13
        
           if: github.repository_owner == 'NixOS'

     

       14
       14
        
           steps:

     

       15
       15
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       15
       15
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       16
       16
        
               with:

     

       17
       17
        
                 # pull_request_target checks out the base branch by default

     

       18
       18
        
                 ref: refs/pull/${{ github.event.pull_request.number }}/merge

+1 -1

.github/workflows/check-nix-format.yml

···

       15
       15
        
           runs-on: ubuntu-latest

     

       16
       16
        
           if: github.repository_owner == 'NixOS'

     

       17
       17
        
           steps:

     

       18
       18
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       18
       18
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       19
       19
        
               with:

     

       20
       20
        
                 # pull_request_target checks out the base branch by default

     

       21
       21
        
                 ref: refs/pull/${{ github.event.pull_request.number }}/merge

+1 -1

.github/workflows/editorconfig.yml

···

       24
       24
        
           - name: print list of changed files

     

       25
       25
        
             run: |

     

       26
       26
        
               cat "$HOME/changed_files"

     

       27
       27
       -
           - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       27
       27
       +
           - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       28
       28
        
             with:

     

       29
       29
        
               # pull_request_target checks out the base branch by default

     

       30
       30
        
               ref: refs/pull/${{ github.event.pull_request.number }}/merge

+1 -1

.github/workflows/manual-nixos.yml

···

       14
       14
        
           runs-on: ubuntu-latest

     

       15
       15
        
           if: github.repository_owner == 'NixOS'

     

       16
       16
        
           steps:

     

       17
       17
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       17
       17
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       18
       18
        
               with:

     

       19
       19
        
                 # pull_request_target checks out the base branch by default

     

       20
       20
        
                 ref: refs/pull/${{ github.event.pull_request.number }}/merge

+1 -1

.github/workflows/manual-nixpkgs.yml

···

       16
       16
        
           runs-on: ubuntu-latest

     

       17
       17
        
           if: github.repository_owner == 'NixOS'

     

       18
       18
        
           steps:

     

       19
       19
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       19
       19
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       20
       20
        
               with:

     

       21
       21
        
                 # pull_request_target checks out the base branch by default

     

       22
       22
        
                 ref: refs/pull/${{ github.event.pull_request.number }}/merge

+1 -1

.github/workflows/nix-parse.yml

···

       24
       24
        
               if [[ -s "$HOME/changed_files" ]]; then

     

       25
       25
        
                 echo "CHANGED_FILES=$HOME/changed_files" > "$GITHUB_ENV"

     

       26
       26
        
               fi

     

       27
       27
       -
           - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       27
       27
       +
           - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       28
       28
        
             with:

     

       29
       29
        
               # pull_request_target checks out the base branch by default

     

       30
       30
        
               ref: refs/pull/${{ github.event.pull_request.number }}/merge

+1 -1

.github/workflows/periodic-merge-24h.yml

···

       41
       41
        
                   into: staging-23.11

     

       42
       42
        
           name: ${{ matrix.pairs.from }} → ${{ matrix.pairs.into }}

     

       43
       43
        
           steps:

     

       44
       44
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       44
       44
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       45
       45
        
       

     

       46
       46
        
             - name: ${{ matrix.pairs.from }} → ${{ matrix.pairs.into }}

     

       47
       47
        
               uses: devmasx/merge-branch@854d3ac71ed1e9deb668e0074781b81fdd6e771f # 1.4.0

+1 -1

.github/workflows/periodic-merge-6h.yml

···

       39
       39
        
                   into: staging

     

       40
       40
        
           name: ${{ matrix.pairs.from }} → ${{ matrix.pairs.into }}

     

       41
       41
        
           steps:

     

       42
       42
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       42
       42
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       43
       43
        
       

     

       44
       44
        
             - name: ${{ matrix.pairs.from }} → ${{ matrix.pairs.into }}

     

       45
       45
        
               uses: devmasx/merge-branch@854d3ac71ed1e9deb668e0074781b81fdd6e771f # 1.4.0

+1 -1

.github/workflows/update-terraform-providers.yml

···

       16
       16
        
           if: github.repository_owner == 'NixOS' && github.ref == 'refs/heads/master' # ensure workflow_dispatch only runs on master

     

       17
       17
        
           runs-on: ubuntu-latest

     

       18
       18
        
           steps:

     

       19
       19
       -
             - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4

     

       19
       19
       +
             - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b # v4.1.5

     

       20
       20
        
             - uses: cachix/install-nix-action@8887e596b4ee1134dae06b98d573bd674693f47c # v26

     

       21
       21
        
               with:

     

       22
       22
        
                 nix_path: nixpkgs=channel:nixpkgs-unstable

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

···

       209
       209
        
       

     

       210
       210
        
       - [isolate](https://github.com/ioi/isolate), a sandbox for securely executing untrusted programs. Available as [security.isolate](#opt-security.isolate.enable).

     

       211
       211
        
       

     

       212
       212
       +
       - [ydotool](https://github.com/ReimuNotMoe/ydotool), a generic command-line automation tool now has a module. Available as [programs.ydotool](#opt-programs.ydotool.enable).

     

       213
       213
       +
       

     

       212
       214
        
       - [private-gpt](https://github.com/zylon-ai/private-gpt), a service to interact with your documents using the power of LLMs, 100% privately, no data leaks. Available as [services.private-gpt](#opt-services.private-gpt.enable).

     

       213
       215
        
       

     

       214
       216
        
       - [keto](https://www.ory.sh/keto/), a permission & access control server, the first open source implementation of ["Zanzibar: Google's Consistent, Global Authorization System"](https://research.google/pubs/zanzibar-googles-consistent-global-authorization-system/).

nixos/modules/module-list.nix

···

       308
       308
        
         ./programs/xwayland.nix

     

       309
       309
        
         ./programs/yabar.nix

     

       310
       310
        
         ./programs/yazi.nix

     

       311
       311
       +
         ./programs/ydotool.nix

     

       311
       312
        
         ./programs/yubikey-touch-detector.nix

     

       312
       313
        
         ./programs/zmap.nix

     

       313
       314
        
         ./programs/zsh/oh-my-zsh.nix

+83

nixos/modules/programs/ydotool.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         config,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         pkgs,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         cfg = config.programs.ydotool;

     

       9
       9
       +
       in

     

       10
       10
       +
       {

     

       11
       11
       +
         meta = {

     

       12
       12
       +
           maintainers = with lib.maintainers; [ quantenzitrone ];

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         options.programs.ydotool = {

     

       16
       16
       +
           enable = lib.mkEnableOption ''

     

       17
       17
       +
             ydotoold system service and install ydotool.

     

       18
       18
       +
             Add yourself to the 'ydotool' group to be able to use it.

     

       19
       19
       +
           '';

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         config = lib.mkIf cfg.enable {

     

       23
       23
       +
           users.groups.ydotool = { };

     

       24
       24
       +
       

     

       25
       25
       +
           systemd.services.ydotoold = {

     

       26
       26
       +
             description = "ydotoold - backend for ydotool";

     

       27
       27
       +
             wantedBy = [ "multi-user.target" ];

     

       28
       28
       +
             partOf = [ "multi-user.target" ];

     

       29
       29
       +
             serviceConfig = {

     

       30
       30
       +
               Group = "ydotool";

     

       31
       31
       +
               RuntimeDirectory = "ydotoold";

     

       32
       32
       +
               RuntimeDirectoryMode = "0750";

     

       33
       33
       +
               ExecStart = "${lib.getExe' pkgs.ydotool "ydotoold"} --socket-path=/run/ydotoold/socket --socket-perm=0660";

     

       34
       34
       +
       

     

       35
       35
       +
               # hardening

     

       36
       36
       +
       

     

       37
       37
       +
               ## allow access to uinput

     

       38
       38
       +
               DeviceAllow = [ "/dev/uinput" ];

     

       39
       39
       +
               DevicePolicy = "closed";

     

       40
       40
       +
       

     

       41
       41
       +
               ## allow creation of unix sockets

     

       42
       42
       +
               RestrictAddressFamilies = [ "AF_UNIX" ];

     

       43
       43
       +
       

     

       44
       44
       +
               CapabilityBoundingSet = "";

     

       45
       45
       +
               IPAddressDeny = "any";

     

       46
       46
       +
               LockPersonality = true;

     

       47
       47
       +
               MemoryDenyWriteExecute = true;

     

       48
       48
       +
               NoNewPrivileges = true;

     

       49
       49
       +
               PrivateNetwork = true;

     

       50
       50
       +
               PrivateTmp = true;

     

       51
       51
       +
               PrivateUsers = true;

     

       52
       52
       +
               ProcSubset = "pid";

     

       53
       53
       +
               ProtectClock = true;

     

       54
       54
       +
               ProtectControlGroups = true;

     

       55
       55
       +
               ProtectHome = true;

     

       56
       56
       +
               ProtectHostname = true;

     

       57
       57
       +
               ProtectKernelLogs = true;

     

       58
       58
       +
               ProtectKernelModules = true;

     

       59
       59
       +
               ProtectKernelTunables = true;

     

       60
       60
       +
               ProtectProc = "invisible";

     

       61
       61
       +
               ProtectSystem = "strict";

     

       62
       62
       +
               ProtectUser = true;

     

       63
       63
       +
               RestrictNamespaces = true;

     

       64
       64
       +
               RestrictRealtime = true;

     

       65
       65
       +
               RestrictSUIDSGID = true;

     

       66
       66
       +
               SystemCallArchitectures = "native";

     

       67
       67
       +
               SystemCallFilter = [

     

       68
       68
       +
                 "@system-service"

     

       69
       69
       +
                 "~@privileged"

     

       70
       70
       +
                 "~@resources"

     

       71
       71
       +
               ];

     

       72
       72
       +
               UMask = "0077";

     

       73
       73
       +
       

     

       74
       74
       +
               # -> systemd-analyze security score 0.7 SAFE 😀

     

       75
       75
       +
             };

     

       76
       76
       +
           };

     

       77
       77
       +
       

     

       78
       78
       +
           environment.variables = {

     

       79
       79
       +
             YDOTOOL_SOCKET = "/run/ydotoold/socket";

     

       80
       80
       +
           };

     

       81
       81
       +
           environment.systemPackages = with pkgs; [ ydotool ];

     

       82
       82
       +
         };

     

       83
       83
       +
       }

+13 -1

nixos/modules/services/display-managers/greetd.nix

···

       27
       27
        
             '';

     

       28
       28
        
           };

     

       29
       29
        
       

     

       30
       30
       +
           greeterManagesPlymouth = mkOption {

     

       31
       31
       +
             type = types.bool;

     

       32
       32
       +
             internal = true;

     

       33
       33
       +
             default = false;

     

       34
       34
       +
             description = ''

     

       35
       35
       +
               Don't configure the greetd service to wait for Plymouth to exit.

     

       36
       36
       +
       

     

       37
       37
       +
               Enable this if the greeter you're using can manage Plymouth itself to provide a smoother handoff.

     

       38
       38
       +
             '';

     

       39
       39
       +
           };

     

       40
       40
       +
       

     

       30
       41
        
           vt = mkOption {

     

       31
       42
        
             type = types.int;

     

       32
       43
        
             default = 1;

     
···

       72
       83
        
               ];

     

       73
       84
        
               After = [

     

       74
       85
        
                 "systemd-user-sessions.service"

     

       86
       86
       +
                 "getty@${tty}.service"

     

       87
       87
       +
               ] ++ lib.optionals (!cfg.greeterManagesPlymouth) [

     

       75
       88
        
                 "plymouth-quit-wait.service"

     

       76
       76
       -
                 "getty@${tty}.service"

     

       77
       89
        
               ];

     

       78
       90
        
               Conflicts = [

     

       79
       91
        
                 "getty@${tty}.service"

-3

nixos/modules/services/x11/xserver.nix

···

       728
       728
        
                   rm -f /tmp/.X0-lock

     

       729
       729
        
                 '';

     

       730
       730
        
       

     

       731
       731
       -
               # TODO: move declaring the systemd service to its own mkIf

     

       732
       732
       -
               script = mkIf (config.systemd.services.display-manager.enable == true) "${config.services.displayManager.execCmd}";

     

       733
       733
       -
       

     

       734
       731
        
               # Stop restarting if the display manager stops (crashes) 2 times

     

       735
       732
        
               # in one minute. Starting X typically takes 3-4s.

     

       736
       733
        
               startLimitIntervalSec = 30;

+74 -33

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

···

       4
       4
        
       

     

       5
       5
        
         perlWrapped = pkgs.perl.withPackages (p: with p; [ ConfigIniFiles FileSlurp ]);

     

       6
       6
        
       

     

       7
       7
       +
         description = extra: ''

     

       8
       8
       +
           Whether to include the capability to switch configurations.

     

       9
       9
       +
       

     

       10
       10
       +
           Disabling this makes the system unable to be reconfigured via `nixos-rebuild`.

     

       11
       11
       +
       

     

       12
       12
       +
           ${extra}

     

       13
       13
       +
         '';

     

       14
       14
       +
       

     

       7
       15
        
       in

     

       8
       16
        
       

     

       9
       17
        
       {

     

       10
       18
        
       

     

       11
       11
       -
         options = {

     

       12
       12
       -
           system.switch.enable = lib.mkOption {

     

       19
       19
       +
         options.system.switch = {

     

       20
       20
       +
           enable = lib.mkOption {

     

       13
       21
        
             type = lib.types.bool;

     

       14
       22
        
             default = true;

     

       15
       15
       -
             description = ''

     

       16
       16
       -
               Whether to include the capability to switch configurations.

     

       17
       17
       -
       

     

       18
       18
       -
               Disabling this makes the system unable to be reconfigured via `nixos-rebuild`.

     

       19
       19
       -
       

     

       23
       23
       +
             description = description ''

     

       20
       24
        
               This is good for image based appliances where updates are handled

     

       21
       25
        
               outside the image. Reducing features makes the image lighter and

     

       22
       26
        
               slightly more secure.

     

       23
       27
        
             '';

     

       24
       28
        
           };

     

       29
       29
       +
       

     

       30
       30
       +
           enableNg = lib.mkOption {

     

       31
       31
       +
             type = lib.types.bool;

     

       32
       32
       +
             default = false;

     

       33
       33
       +
             description = description ''

     

       34
       34
       +
               Whether to use `switch-to-configuration-ng`, an experimental

     

       35
       35
       +
               re-implementation of `switch-to-configuration` with the goal of

     

       36
       36
       +
               replacing the original.

     

       37
       37
       +
             '';

     

       38
       38
       +
           };

     

       25
       39
        
         };

     

       26
       40
        
       

     

       27
       27
       -
         config = lib.mkIf config.system.switch.enable {

     

       28
       28
       -
           system.activatableSystemBuilderCommands = ''

     

       29
       29
       -
             mkdir $out/bin

     

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

     

       31
       31
       -
               --subst-var out \

     

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

     

       33
       33
       -
               --subst-var-by coreutils "${pkgs.coreutils}" \

     

       34
       34
       -
               --subst-var-by distroId ${lib.escapeShellArg config.system.nixos.distroId} \

     

       35
       35
       -
               --subst-var-by installBootLoader ${lib.escapeShellArg config.system.build.installBootLoader} \

     

       36
       36
       -
               --subst-var-by localeArchive "${config.i18n.glibcLocales}/lib/locale/locale-archive" \

     

       37
       37
       -
               --subst-var-by perl "${perlWrapped}" \

     

       38
       38
       -
               --subst-var-by shell "${pkgs.bash}/bin/sh" \

     

       39
       39
       -
               --subst-var-by su "${pkgs.shadow.su}/bin/su" \

     

       40
       40
       -
               --subst-var-by systemd "${config.systemd.package}" \

     

       41
       41
       -
               --subst-var-by utillinux "${pkgs.util-linux}" \

     

       42
       42
       -
               ;

     

       41
       41
       +
         config = lib.mkMerge [

     

       42
       42
       +
           {

     

       43
       43
       +
             assertions = [{

     

       44
       44
       +
               assertion = with config.system.switch; enable -> !enableNg;

     

       45
       45
       +
               message = "Only one of system.switch.enable and system.switch.enableNg may be enabled at a time";

     

       46
       46
       +
             }];

     

       47
       47
       +
           }

     

       48
       48
       +
           (lib.mkIf config.system.switch.enable {

     

       49
       49
       +
             system.activatableSystemBuilderCommands = ''

     

       50
       50
       +
               mkdir $out/bin

     

       51
       51
       +
               substitute ${./switch-to-configuration.pl} $out/bin/switch-to-configuration \

     

       52
       52
       +
                 --subst-var out \

     

       53
       53
       +
                 --subst-var-by toplevel ''${!toplevelVar} \

     

       54
       54
       +
                 --subst-var-by coreutils "${pkgs.coreutils}" \

     

       55
       55
       +
                 --subst-var-by distroId ${lib.escapeShellArg config.system.nixos.distroId} \

     

       56
       56
       +
                 --subst-var-by installBootLoader ${lib.escapeShellArg config.system.build.installBootLoader} \

     

       57
       57
       +
                 --subst-var-by localeArchive "${config.i18n.glibcLocales}/lib/locale/locale-archive" \

     

       58
       58
       +
                 --subst-var-by perl "${perlWrapped}" \

     

       59
       59
       +
                 --subst-var-by shell "${pkgs.bash}/bin/sh" \

     

       60
       60
       +
                 --subst-var-by su "${pkgs.shadow.su}/bin/su" \

     

       61
       61
       +
                 --subst-var-by systemd "${config.systemd.package}" \

     

       62
       62
       +
                 --subst-var-by utillinux "${pkgs.util-linux}" \

     

       63
       63
       +
                 ;

     

       64
       64
       +
       

     

       65
       65
       +
               chmod +x $out/bin/switch-to-configuration

     

       66
       66
       +
               ${lib.optionalString (pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform) ''

     

       67
       67
       +
                 if ! output=$(${perlWrapped}/bin/perl -c $out/bin/switch-to-configuration 2>&1); then

     

       68
       68
       +
                   echo "switch-to-configuration syntax is not valid:"

     

       69
       69
       +
                   echo "$output"

     

       70
       70
       +
                   exit 1

     

       71
       71
       +
                 fi

     

       72
       72
       +
               ''}

     

       73
       73
       +
             '';

     

       74
       74
       +
           })

     

       75
       75
       +
           (lib.mkIf config.system.switch.enableNg {

     

       76
       76
       +
             # Use a subshell so we can source makeWrapper's setup hook without

     

       77
       77
       +
             # affecting the rest of activatableSystemBuilderCommands.

     

       78
       78
       +
             system.activatableSystemBuilderCommands = ''

     

       79
       79
       +
               (

     

       80
       80
       +
                 source ${pkgs.buildPackages.makeWrapper}/nix-support/setup-hook

     

       43
       81
        
       

     

       44
       44
       -
             chmod +x $out/bin/switch-to-configuration

     

       45
       45
       -
             ${lib.optionalString (pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform) ''

     

       46
       46
       -
               if ! output=$(${perlWrapped}/bin/perl -c $out/bin/switch-to-configuration 2>&1); then

     

       47
       47
       -
                 echo "switch-to-configuration syntax is not valid:"

     

       48
       48
       -
                 echo "$output"

     

       49
       49
       -
                 exit 1

     

       50
       50
       -
               fi

     

       51
       51
       -
             ''}

     

       52
       52
       -
           '';

     

       53
       53
       -
         };

     

       82
       82
       +
                 mkdir $out/bin

     

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

     

       84
       84
       +
                 wrapProgram $out/bin/switch-to-configuration \

     

       85
       85
       +
                   --set OUT $out \

     

       86
       86
       +
                   --set TOPLEVEL ''${!toplevelVar} \

     

       87
       87
       +
                   --set DISTRO_ID ${lib.escapeShellArg config.system.nixos.distroId} \

     

       88
       88
       +
                   --set INSTALL_BOOTLOADER ${lib.escapeShellArg config.system.build.installBootLoader} \

     

       89
       89
       +
                   --set LOCALE_ARCHIVE ${config.i18n.glibcLocales}/lib/locale/locale-archive \

     

       90
       90
       +
                   --set SYSTEMD ${config.systemd.package}

     

       91
       91
       +
               )

     

       92
       92
       +
             '';

     

       93
       93
       +
           })

     

       94
       94
       +
         ];

     

       54
       95
        
       

     

       55
       96
        
       }

+3 -1

nixos/tests/all-tests.nix

···

       873
       873
        
         swap-random-encryption = handleTest ./swap-random-encryption.nix {};

     

       874
       874
        
         sway = handleTest ./sway.nix {};

     

       875
       875
        
         swayfx = handleTest ./swayfx.nix {};

     

       876
       876
       -
         switchTest = handleTest ./switch-test.nix {};

     

       876
       876
       +
         switchTest = handleTest ./switch-test.nix { ng = false; };

     

       877
       877
       +
         switchTestNg = handleTest ./switch-test.nix { ng = true; };

     

       877
       878
        
         sympa = handleTest ./sympa.nix {};

     

       878
       879
        
         syncthing = handleTest ./syncthing.nix {};

     

       879
       880
        
         syncthing-no-settings = handleTest ./syncthing-no-settings.nix {};

     
···

       1039
       1040
        
         xterm = handleTest ./xterm.nix {};

     

       1040
       1041
        
         xxh = handleTest ./xxh.nix {};

     

       1041
       1042
        
         yabar = handleTest ./yabar.nix {};

     

       1043
       1043
       +
         ydotool = handleTest ./ydotool.nix {};

     

       1042
       1044
        
         yggdrasil = handleTest ./yggdrasil.nix {};

     

       1043
       1045
        
         zammad = handleTest ./zammad.nix {};

     

       1044
       1046
        
         zeronet-conservancy = handleTest ./zeronet-conservancy.nix {};

nixos/tests/fcitx5/default.nix

···

       89
       89
        
                   machine.succeed("xauth merge ${xauth}")

     

       90
       90
        
                   machine.sleep(5)

     

       91
       91
        
       

     

       92
       92
       +
                   machine.wait_until_succeeds("pgrep fcitx5")

     

       92
       93
        
                   machine.succeed("su - ${user.name} -c 'kill $(pgrep fcitx5)'")

     

       93
       94
        
                   machine.sleep(1)

     

       94
       95
        
       

     

       95
       96
        
                   machine.succeed("su - ${user.name} -c 'alacritty >&2 &'")

     

       97
       97
       +
                   machine.wait_for_window("alice@machine")

     

       98
       98
       +
       

     

       96
       99
        
                   machine.succeed("su - ${user.name} -c 'fcitx5 >&2 &'")

     

       97
       100
        
                   machine.sleep(10)

     

       98
       101

+6 -1

nixos/tests/switch-test.nix

···

       1
       1
        
       # Test configuration switching.

     

       2
       2
        
       

     

       3
       3
       -
       import ./make-test-python.nix ({ lib, pkgs, ...} : let

     

       3
       3
       +
       import ./make-test-python.nix ({ lib, pkgs, ng, ...} : let

     

       4
       4
        
       

     

       5
       5
        
         # Simple service that can either be socket-activated or that will

     

       6
       6
        
         # listen on port 1234 if not socket-activated.

     
···

       48
       48
        
       

     

       49
       49
        
         nodes = {

     

       50
       50
        
           machine = { pkgs, lib, ... }: {

     

       51
       51
       +
             system.switch = {

     

       52
       52
       +
               enable = !ng;

     

       53
       53
       +
               enableNg = ng;

     

       54
       54
       +
             };

     

       55
       55
       +
       

     

       51
       56
        
             environment.systemPackages = [ pkgs.socat ]; # for the socket activation stuff

     

       52
       57
        
             users.mutableUsers = false;

     

       53
       58

+115

nixos/tests/ydotool.nix

···

       1
       1
       +
       import ./make-test-python.nix (

     

       2
       2
       +
         { pkgs, lib, ... }:

     

       3
       3
       +
         let

     

       4
       4
       +
           textInput = "This works.";

     

       5
       5
       +
           inputBoxText = "Enter input";

     

       6
       6
       +
           inputBox = pkgs.writeShellScript "zenity-input" ''

     

       7
       7
       +
             ${lib.getExe pkgs.gnome.zenity} --entry --text '${inputBoxText}:' > /tmp/output &

     

       8
       8
       +
           '';

     

       9
       9
       +
         in

     

       10
       10
       +
         {

     

       11
       11
       +
           name = "ydotool";

     

       12
       12
       +
       

     

       13
       13
       +
           meta = {

     

       14
       14
       +
             maintainers = with lib.maintainers; [

     

       15
       15
       +
               OPNA2608

     

       16
       16
       +
               quantenzitrone

     

       17
       17
       +
             ];

     

       18
       18
       +
           };

     

       19
       19
       +
       

     

       20
       20
       +
           nodes = {

     

       21
       21
       +
             headless =

     

       22
       22
       +
               { config, ... }:

     

       23
       23
       +
               {

     

       24
       24
       +
                 imports = [ ./common/user-account.nix ];

     

       25
       25
       +
       

     

       26
       26
       +
                 users.users.alice.extraGroups = [ "ydotool" ];

     

       27
       27
       +
       

     

       28
       28
       +
                 programs.ydotool.enable = true;

     

       29
       29
       +
       

     

       30
       30
       +
                 services.getty.autologinUser = "alice";

     

       31
       31
       +
               };

     

       32
       32
       +
       

     

       33
       33
       +
             x11 =

     

       34
       34
       +
               { config, ... }:

     

       35
       35
       +
               {

     

       36
       36
       +
                 imports = [

     

       37
       37
       +
                   ./common/user-account.nix

     

       38
       38
       +
                   ./common/auto.nix

     

       39
       39
       +
                   ./common/x11.nix

     

       40
       40
       +
                 ];

     

       41
       41
       +
       

     

       42
       42
       +
                 users.users.alice.extraGroups = [ "ydotool" ];

     

       43
       43
       +
       

     

       44
       44
       +
                 programs.ydotool.enable = true;

     

       45
       45
       +
       

     

       46
       46
       +
                 test-support.displayManager.auto = {

     

       47
       47
       +
                   enable = true;

     

       48
       48
       +
                   user = "alice";

     

       49
       49
       +
                 };

     

       50
       50
       +
       

     

       51
       51
       +
                 services.xserver.windowManager.dwm.enable = true;

     

       52
       52
       +
                 services.displayManager.defaultSession = lib.mkForce "none+dwm";

     

       53
       53
       +
               };

     

       54
       54
       +
       

     

       55
       55
       +
             wayland =

     

       56
       56
       +
               { config, ... }:

     

       57
       57
       +
               {

     

       58
       58
       +
                 imports = [ ./common/user-account.nix ];

     

       59
       59
       +
       

     

       60
       60
       +
                 services.cage = {

     

       61
       61
       +
                   enable = true;

     

       62
       62
       +
                   user = "alice";

     

       63
       63
       +
                 };

     

       64
       64
       +
       

     

       65
       65
       +
                 programs.ydotool.enable = true;

     

       66
       66
       +
       

     

       67
       67
       +
                 services.cage.program = inputBox;

     

       68
       68
       +
               };

     

       69
       69
       +
           };

     

       70
       70
       +
       

     

       71
       71
       +
           enableOCR = true;

     

       72
       72
       +
       

     

       73
       73
       +
           testScript =

     

       74
       74
       +
             { nodes, ... }:

     

       75
       75
       +
             ''

     

       76
       76
       +
               def as_user(cmd: str):

     

       77
       77
       +
                 """

     

       78
       78
       +
                 Return a shell command for running a shell command as a specific user.

     

       79
       79
       +
                 """

     

       80
       80
       +
                 return f"sudo -u alice -i {cmd}"

     

       81
       81
       +
       

     

       82
       82
       +
               start_all()

     

       83
       83
       +
       

     

       84
       84
       +
               # Headless

     

       85
       85
       +
               headless.wait_for_unit("multi-user.target")

     

       86
       86
       +
               headless.wait_for_text("alice")

     

       87
       87
       +
               headless.succeed(as_user("ydotool type 'echo ${textInput} > /tmp/output'")) # text input

     

       88
       88
       +
               headless.succeed(as_user("ydotool key 28:1 28:0")) # text input

     

       89
       89
       +
               headless.screenshot("headless_input")

     

       90
       90
       +
               headless.wait_for_file("/tmp/output")

     

       91
       91
       +
               headless.wait_until_succeeds("grep '${textInput}' /tmp/output") # text input

     

       92
       92
       +
       

     

       93
       93
       +
               # X11

     

       94
       94
       +
               x11.wait_for_x()

     

       95
       95
       +
               x11.execute(as_user("${inputBox}"))

     

       96
       96
       +
               x11.wait_for_text("${inputBoxText}")

     

       97
       97
       +
               x11.succeed(as_user("ydotool type '${textInput}'")) # text input

     

       98
       98
       +
               x11.screenshot("x11_input")

     

       99
       99
       +
               x11.succeed(as_user("ydotool mousemove -a 400 110")) # mouse input

     

       100
       100
       +
               x11.succeed(as_user("ydotool click 0xC0")) # mouse input

     

       101
       101
       +
               x11.wait_for_file("/tmp/output")

     

       102
       102
       +
               x11.wait_until_succeeds("grep '${textInput}' /tmp/output") # text input

     

       103
       103
       +
       

     

       104
       104
       +
               # Wayland

     

       105
       105
       +
               wayland.wait_for_unit("graphical.target")

     

       106
       106
       +
               wayland.wait_for_text("${inputBoxText}")

     

       107
       107
       +
               wayland.succeed("ydotool type '${textInput}'") # text input

     

       108
       108
       +
               wayland.screenshot("wayland_input")

     

       109
       109
       +
               wayland.succeed("ydotool mousemove -a 100 100") # mouse input

     

       110
       110
       +
               wayland.succeed("ydotool click 0xC0") # mouse input

     

       111
       111
       +
               wayland.wait_for_file("/tmp/output")

     

       112
       112
       +
               wayland.wait_until_succeeds("grep '${textInput}' /tmp/output") # text input

     

       113
       113
       +
             '';

     

       114
       114
       +
         }

     

       115
       115
       +
       )

+3 -3

pkgs/applications/audio/go-musicfox/default.nix

···

       9
       9
        
       

     

       10
       10
        
       buildGoModule rec {

     

       11
       11
        
         pname = "go-musicfox";

     

       12
       12
       -
         version = "4.3.3";

     

       12
       12
       +
         version = "4.4.0";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "go-musicfox";

     

       16
       16
        
           repo = "go-musicfox";

     

       17
       17
        
           rev = "v${version}";

     

       18
       18
       -
           hash = "sha256-J6R3T92cHFUkKwc+GKm612tVjglP2Tc/kDUmzUMhvio=";

     

       18
       18
       +
           hash = "sha256-11N3dykuEDKAryieNVaPfb3G7E/a4A7Znx9rBvFTHC4=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         deleteVendor = true;

     

       22
       22
        
       

     

       23
       23
       -
         vendorHash = "sha256-KSIdBEEvYaYcDIDmzfRO857I8FSN4Ajw6phAPQLYEqg=";

     

       23
       23
       +
         vendorHash = "sha256-ey78zeCSEuRgteG5ZRb4uO88E6lwEgqSxKfjJg3NGT4=";

     

       24
       24
        
       

     

       25
       25
        
         subPackages = [ "cmd/musicfox.go" ];

     

       26
       26

+3 -3

pkgs/applications/audio/squeezelite/default.nix

···

       45
       45
        
         pname = binName;

     

       46
       46
        
         # versions are specified in `squeezelite.h`

     

       47
       47
        
         # see https://github.com/ralph-irving/squeezelite/issues/29

     

       48
       48
       -
         version = "2.0.0.1486";

     

       48
       48
       +
         version = "2.0.0.1488";

     

       49
       49
        
       

     

       50
       50
        
         src = fetchFromGitHub {

     

       51
       51
        
           owner = "ralph-irving";

     

       52
       52
        
           repo = "squeezelite";

     

       53
       53
       -
           rev = "fd4a82e7d0e53124d9618320f3c115d90654509d";

     

       54
       54
       -
           hash = "sha256-nR2Px7VYjAktUsueEyBAV2392+/dX6JYIy7YSMh05c0=";

     

       53
       53
       +
           rev = "0e85ddfd79337cdc30b7d29922b1d790600bb6b4";

     

       54
       54
       +
           hash = "sha256-FGqo/c74JN000w/iRnvYUejqnYGDzHNZu9pEmR7yR3s=";

     

       55
       55
        
         };

     

       56
       56
        
       

     

       57
       57
        
         buildInputs = [ flac libmad libvorbis mpg123 ]

-63

pkgs/applications/graphics/cq-editor/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , mkDerivationWith

     

       3
       3
       -
       , python3Packages

     

       4
       4
       -
       , fetchFromGitHub

     

       5
       5
       -
       , wrapQtAppsHook

     

       6
       6
       -
       }:

     

       7
       7
       -
       

     

       8
       8
       -
       mkDerivationWith python3Packages.buildPythonApplication rec {

     

       9
       9
       -
         pname = "cq-editor";

     

       10
       10
       -
         version = "0.1.1";

     

       11
       11
       -
       

     

       12
       12
       -
         src = fetchFromGitHub {

     

       13
       13
       -
           owner = "CadQuery";

     

       14
       14
       -
           repo = "CQ-editor";

     

       15
       15
       -
           rev = version;

     

       16
       16
       -
           sha256 = "1970izjaa60r5cg9i35rzz9lk5c5d8q1vw1rh2skvfbf63z1hnzv";

     

       17
       17
       -
         };

     

       18
       18
       -
       

     

       19
       19
       -
         patches = [

     

       20
       20
       -
           ./spyder4.patch

     

       21
       21
       -
         ];

     

       22
       22
       -
       

     

       23
       23
       -
         propagatedBuildInputs = with python3Packages; [

     

       24
       24
       -
           cadquery

     

       25
       25
       -
           logbook

     

       26
       26
       -
           pyqt5

     

       27
       27
       -
           pyparsing

     

       28
       28
       -
           pyqtgraph

     

       29
       29
       -
           spyder

     

       30
       30
       -
           path

     

       31
       31
       -
           qtconsole

     

       32
       32
       -
           requests

     

       33
       33
       -
         ];

     

       34
       34
       -
       

     

       35
       35
       -
         nativeBuildInputs = [ wrapQtAppsHook ];

     

       36
       36
       -
         preFixup = ''

     

       37
       37
       -
           makeWrapperArgs+=("''${qtWrapperArgs[@]}")

     

       38
       38
       -
         '';

     

       39
       39
       -
       

     

       40
       40
       -
         nativeCheckInputs = with python3Packages; [

     

       41
       41
       -
           pytest

     

       42
       42
       -
           pytest-xvfb

     

       43
       43
       -
           pytest-mock

     

       44
       44
       -
           pytest-cov

     

       45
       45
       -
           pytest-repeat

     

       46
       46
       -
           pytest-qt

     

       47
       47
       -
         ];

     

       48
       48
       -
       

     

       49
       49
       -
         checkPhase = ''

     

       50
       50
       -
           pytest --no-xvfb

     

       51
       51
       -
         '';

     

       52
       52
       -
       

     

       53
       53
       -
         # requires X server

     

       54
       54
       -
         doCheck = false;

     

       55
       55
       -
       

     

       56
       56
       -
         meta = with lib; {

     

       57
       57
       -
           description = "CadQuery GUI editor based on PyQT";

     

       58
       58
       -
           homepage = "https://github.com/CadQuery/CQ-editor";

     

       59
       59
       -
           license = licenses.asl20;

     

       60
       60
       -
           maintainers = with maintainers; [ costrouc marcus7070 ];

     

       61
       61
       -
         };

     

       62
       62
       -
       

     

       63
       63
       -
       }

+5 -5

pkgs/applications/networking/cluster/krane/Gemfile.lock

···

       14
       14
        
           addressable (2.8.6)

     

       15
       15
        
             public_suffix (>= 2.0.2, < 6.0)

     

       16
       16
        
           base64 (0.2.0)

     

       17
       17
       -
           bigdecimal (3.1.7)

     

       17
       17
       +
           bigdecimal (3.1.8)

     

       18
       18
        
           colorize (0.8.1)

     

       19
       19
        
           concurrent-ruby (1.2.3)

     

       20
       20
        
           connection_pool (2.4.1)

     
···

       48
       48
        
           http-cookie (1.0.5)

     

       49
       49
        
             domain_name (~> 0.5)

     

       50
       50
        
           http-form_data (2.3.0)

     

       51
       51
       -
           i18n (1.14.4)

     

       51
       51
       +
           i18n (1.14.5)

     

       52
       52
        
             concurrent-ruby (~> 1.0)

     

       53
       53
        
           jsonpath (1.1.5)

     

       54
       54
        
             multi_json

     

       55
       55
        
           jwt (2.8.1)

     

       56
       56
        
             base64

     

       57
       57
       -
           krane (3.5.2)

     

       57
       57
       +
           krane (3.5.3)

     

       58
       58
        
             activesupport (>= 5.0)

     

       59
       59
        
             colorize (~> 0.8)

     

       60
       60
        
             concurrent-ruby (~> 1.1)

     
···

       75
       75
        
             rake (~> 13.0)

     

       76
       76
        
           mime-types (3.5.2)

     

       77
       77
        
             mime-types-data (~> 3.2015)

     

       78
       78
       -
           mime-types-data (3.2024.0305)

     

       78
       78
       +
           mime-types-data (3.2024.0507)

     

       79
       79
        
           minitest (5.22.3)

     

       80
       80
        
           multi_json (1.15.0)

     

       81
       81
        
           mutex_m (0.2.0)

     
···

       109
       109
        
         krane

     

       110
       110
        
       

     

       111
       111
        
       BUNDLED WITH

     

       112
       112
       -
          2.5.7

     

       112
       112
       +
          2.5.9

+8 -8

pkgs/applications/networking/cluster/krane/gemset.nix

···

       36
       36
        
           platforms = [];

     

       37
       37
        
           source = {

     

       38
       38
        
             remotes = ["https://rubygems.org"];

     

       39
       39
       -
             sha256 = "0cq1c29zbkcxgdihqisirhcw76xc768z2zpd5vbccpq0l1lv76g7";

     

       39
       39
       +
             sha256 = "1gi7zqgmqwi5lizggs1jhc3zlwaqayy9rx2ah80sxy24bbnng558";

     

       40
       40
        
             type = "gem";

     

       41
       41
        
           };

     

       42
       42
       -
           version = "3.1.7";

     

       42
       42
       +
           version = "3.1.8";

     

       43
       43
        
         };

     

       44
       44
        
         colorize = {

     

       45
       45
        
           groups = ["default"];

     
···

       214
       214
        
           platforms = [];

     

       215
       215
        
           source = {

     

       216
       216
        
             remotes = ["https://rubygems.org"];

     

       217
       217
       -
             sha256 = "0lbm33fpb3w06wd2231sg58dwlwgjsvym93m548ajvl6s3mfvpn7";

     

       217
       217
       +
             sha256 = "1ffix518y7976qih9k1lgnc17i3v6yrlh0a3mckpxdb4wc2vrp16";

     

       218
       218
        
             type = "gem";

     

       219
       219
        
           };

     

       220
       220
       -
           version = "1.14.4";

     

       220
       220
       +
           version = "1.14.5";

     

       221
       221
        
         };

     

       222
       222
        
         jsonpath = {

     

       223
       223
        
           dependencies = ["multi_json"];

     
···

       247
       247
        
           platforms = [];

     

       248
       248
        
           source = {

     

       249
       249
        
             remotes = ["https://rubygems.org"];

     

       250
       250
       -
             sha256 = "1s2xc5igk3yg3jpl3abakvrsf4xl6hljhgyddjsrp2g05sksa9x6";

     

       250
       250
       +
             sha256 = "11jj5fpfsb1sfwgc356xv1vxl8yq65wbbshmawpagk555y0pzbpb";

     

       251
       251
        
             type = "gem";

     

       252
       252
        
           };

     

       253
       253
       -
           version = "3.5.2";

     

       253
       253
       +
           version = "3.5.3";

     

       254
       254
        
         };

     

       255
       255
        
         kubeclient = {

     

       256
       256
        
           dependencies = ["http" "jsonpath" "recursive-open-struct" "rest-client"];

     
···

       290
       290
        
           platforms = [];

     

       291
       291
        
           source = {

     

       292
       292
        
             remotes = ["https://rubygems.org"];

     

       293
       293
       -
             sha256 = "00x7w5xqsj9m33v3vkmy23wipkkysafksib53ypzn27p5g81w455";

     

       293
       293
       +
             sha256 = "0kybw1a6f7d1ipyawnpi5cwiy05rkz9qwglgfvhmd1z0l2gcigmm";

     

       294
       294
        
             type = "gem";

     

       295
       295
        
           };

     

       296
       296
       -
           version = "3.2024.0305";

     

       296
       296
       +
           version = "3.2024.0507";

     

       297
       297
        
         };

     

       298
       298
        
         minitest = {

     

       299
       299
        
           groups = ["default"];

+11

pkgs/applications/office/gnucash/0005-disable-test-lots.patch

···

       1
       1
       +
       --- a/libgnucash/engine/test/CMakeLists.txt	2024-02-23 09:05:19.000000000 +0900

     

       2
       2
       +
       +++ b/libgnucash/engine/test/CMakeLists.txt	2024-05-08 22:08:04.572060359 +0900

     

       3
       3
       +
       @@ -57,7 +57,6 @@

     

       4
       4
       +
        

     

       5
       5
       +
        add_engine_test(test-account-object test-account-object.cpp)

     

       6
       6
       +
        add_engine_test(test-group-vs-book test-group-vs-book.cpp)

     

       7
       7
       +
       -add_engine_test(test-lots test-lots.cpp)

     

       8
       8
       +
        add_engine_test(test-querynew test-querynew.c)

     

       9
       9
       +
        add_engine_test(test-query test-query.cpp)

     

       10
       10
       +
        add_engine_test(test-split-vs-account test-split-vs-account.cpp)

     

       11
       11
       +

pkgs/applications/office/gnucash/default.nix

···

       76
       76
        
           ./0003-remove-valgrind.patch

     

       77
       77
        
           # this patch makes gnucash exec the Finance::Quote wrapper directly

     

       78
       78
        
           ./0004-exec-fq-wrapper.patch

     

       79
       79
       +
           # this patch disables a flaky test

     

       80
       80
       +
           # see https://bugs.gnucash.org/show_bug.cgi?id=799289

     

       81
       81
       +
           ./0005-disable-test-lots.patch

     

       79
       82
        
           # Fix importing QIF by backporting a fix. remove on next release

     

       80
       83
        
           # https://bugs.gnucash.org/show_bug.cgi?id=799262

     

       81
       84
        
           (fetchpatch {

pkgs/applications/office/planify/default.nix

···

       10
       10
        
       , evolution-data-server

     

       11
       11
        
       , glib

     

       12
       12
        
       , glib-networking

     

       13
       13
       +
       , gst_all_1

     

       13
       14
        
       , gtk4

     

       14
       15
        
       , gtksourceview5

     

       15
       16
        
       , gxml

     
···

       49
       50
        
           evolution-data-server

     

       50
       51
        
           glib

     

       51
       52
        
           glib-networking

     

       53
       53
       +
           # Needed for GtkMediaStream creation with success.ogg, see #311295.

     

       54
       54
       +
           gst_all_1.gst-plugins-base

     

       55
       55
       +
           gst_all_1.gst-plugins-good

     

       52
       56
        
           gtk4

     

       53
       57
        
           gtksourceview5

     

       54
       58
        
           gxml

+3 -3

pkgs/applications/radio/chirp/default.nix

···

       10
       10
        
       

     

       11
       11
        
       python3.pkgs.buildPythonApplication rec {

     

       12
       12
        
         pname = "chirp";

     

       13
       13
       -
         version = "0.4.0-unstable-2024-05-03";

     

       13
       13
       +
         version = "0.4.0-unstable-2024-05-10";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "kk7ds";

     

       17
       17
        
           repo = "chirp";

     

       18
       18
       -
           rev = "e95140ff433b805ca16df04cba501b7332a9ec95";

     

       19
       19
       -
           hash = "sha256-UU3Ve6Yb7UK2nOLTfJasrlMX4iu1cpLBLScvhRhTUJ0=";

     

       18
       18
       +
           rev = "d5dc5c8e053dbcf87c8b0ccf03109c0870c22bfb";

     

       19
       19
       +
           hash = "sha256-Tqq1dTjtzHTgaHUAio5B8V4Bo+P8EPa3s/kG181TrCc=";

     

       20
       20
        
         };

     

       21
       21
        
         buildInputs = [

     

       22
       22
        
           glib

+2 -2

pkgs/applications/radio/cloudlog/default.nix

···

       8
       8
        
       

     

       9
       9
        
       stdenvNoCC.mkDerivation rec {

     

       10
       10
        
         pname = "cloudlog";

     

       11
       11
       -
         version = "2.6.10";

     

       11
       11
       +
         version = "2.6.11";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "magicbug";

     

       15
       15
        
           repo = "Cloudlog";

     

       16
       16
        
           rev = version;

     

       17
       17
       -
           hash = "sha256-VPiv/Df4dasiYUBA6UHrxBczmGAqzhQkPrknzSYJxAE=";

     

       17
       17
       +
           hash = "sha256-9JGhMCypoKOh1Gy1DdK7nrma+L4sJsYN/iuNhBPmHPA=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         postPatch = ''

+3 -3

pkgs/applications/science/math/eigenmath/default.nix

···

       7
       7
        
       

     

       8
       8
        
       stdenv.mkDerivation rec {

     

       9
       9
        
         pname = "eigenmath";

     

       10
       10
       -
         version = "0-unstable-2024-05-03";

     

       10
       10
       +
         version = "0-unstable-2024-05-12";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "georgeweigt";

     

       14
       14
        
           repo = pname;

     

       15
       15
       -
           rev = "69ebfbaa7f328ddc9d97b7c404369818a5febe4a";

     

       16
       16
       -
           hash = "sha256-lHxVyUXIY9+YIStA6202Bhy/b0xaxJbW/VPI7FbNJk0=";

     

       15
       15
       +
           rev = "978b3bd582a90c8e82079f2e4e4a3a5038cbbe08";

     

       16
       16
       +
           hash = "sha256-DoGX8nUcWcioTq8ymB+HLsCnt9V6HTKSX4Zs2CQz78Q=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         checkPhase = let emulator = stdenv.hostPlatform.emulator buildPackages; in ''

+2 -2

pkgs/applications/version-management/git-cola/default.nix

···

       10
       10
        
       

     

       11
       11
        
       python3Packages.buildPythonApplication rec {

     

       12
       12
        
         pname = "git-cola";

     

       13
       13
       -
         version = "4.7.0";

     

       13
       13
       +
         version = "4.7.1";

     

       14
       14
        
         pyproject = true;

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "git-cola";

     

       18
       18
        
           repo = "git-cola";

     

       19
       19
        
           rev = "v${version}";

     

       20
       20
       -
           hash = "sha256-BiSs3vWJacCtGthHi/nFJm4Hqt0uO6XXZi/Zqvjb928=";

     

       20
       20
       +
           hash = "sha256-93aayGGMgkSghTpx8M5Cfbxf2szAwrSzuoWK6GCTqZ8=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         buildInputs = lib.optionals stdenv.isLinux [

+2 -2

pkgs/applications/video/kodi/addons/visualization-projectm/default.nix

···

       3
       3
        
       buildKodiBinaryAddon rec {

     

       4
       4
        
         pname = "visualization-projectm";

     

       5
       5
        
         namespace = "visualization.projectm";

     

       6
       6
       -
         version = "20.2.0";

     

       6
       6
       +
         version = "21.0.1";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "xbmc";

     

       10
       10
        
           repo = namespace;

     

       11
       11
        
           rev = "${version}-${rel}";

     

       12
       12
       -
           hash = "sha256-Kcl1ep+RJlofFmxkrGT3T+XXdwiCofq1hggwU0PAd0E=";

     

       12
       12
       +
           hash = "sha256-wjSQmOtQb4KjY3iH3Xh7AdQwE6ked+cpW6/gdNYS+NA=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         extraBuildInputs = [ pkg-config libGL projectm ];

pkgs/build-support/php/builders/v1/build-composer-project.nix

···

       1
       1
        
       {

     

       2
       2
        
         callPackage,

     

       3
       3
       +
         nix-update-script,

     

       3
       4
        
         stdenvNoCC,

     

       4
       5
        
         lib,

     

       5
       6
        
         php,

     
···

       88
       89
        
                 composerNoScripts = previousAttrs.composerNoScripts or true;

     

       89
       90
        
                 composerStrictValidation = previousAttrs.composerStrictValidation or true;

     

       90
       91
        
               });

     

       92
       92
       +
       

     

       93
       93
       +
             # Projects providing a lockfile from upstream can be automatically updated.

     

       94
       94
       +
             passthru = previousAttrs.passthru or { } // {

     

       95
       95
       +
               updateScript =

     

       96
       96
       +
                 previousAttrs.passthru.updateScript

     

       97
       97
       +
                   or (if finalAttrs.composerRepository.composerLock == null then nix-update-script { } else null);

     

       98
       98
       +
             };

     

       91
       99
        
       

     

       92
       100
        
             env = {

     

       93
       101
        
               COMPOSER_CACHE_DIR = "/dev/null";

pkgs/by-name/ad/adafruit-nrfutil/package.nix

···

       19
       19
        
         patches = [

     

       20
       20
        
           # Pull a patch which fixes the tests, but is not yet released in a new version:

     

       21
       21
        
           # https://github.com/adafruit/Adafruit_nRF52_nrfutil/pull/38

     

       22
       22
       +
           # https://github.com/adafruit/Adafruit_nRF52_nrfutil/pull/42

     

       22
       23
        
           (fetchpatch {

     

       23
       24
        
             name = "fix-tests.patch";

     

       24
       25
        
             url = "https://github.com/adafruit/Adafruit_nRF52_nrfutil/commit/e5fbcc8ee5958041db38c04139ba686bf7d1b845.patch";

     

       25
       26
        
             sha256 = "sha256-0tbJldGtYcDdUzA3wZRv0lenXVn6dqV016U9nMpQ6/w=";

     

       27
       27
       +
           })

     

       28
       28
       +
           (fetchpatch {

     

       29
       29
       +
             name = "fix-test-test_get_vk_pem.patch";

     

       30
       30
       +
             url = "https://github.com/adafruit/Adafruit_nRF52_nrfutil/commit/f42cee3c2d7c8d0911f27ba24d6a140083cb85cf.patch";

     

       31
       31
       +
             sha256 = "sha256-7WoRqPKc8O5EYK7Fj1WrMJREwhueiVpkEizIfVnEPBU=";

     

       26
       32
        
           })

     

       27
       33
        
         ];

     

       28
       34

+2 -2

pkgs/by-name/ad/adwsteamgtk/package.nix

···

       12
       12
        
       

     

       13
       13
        
       python3Packages.buildPythonApplication rec {

     

       14
       14
        
         pname = "adwsteamgtk";

     

       15
       15
       -
         version = "0.6.10";

     

       15
       15
       +
         version = "0.6.11";

     

       16
       16
        
         # built with meson, not a python format

     

       17
       17
        
         format = "other";

     

       18
       18
        
       

     
···

       20
       20
        
           owner = "Foldex";

     

       21
       21
        
           repo = "AdwSteamGtk";

     

       22
       22
        
           rev = "refs/tags/v${version}";

     

       23
       23
       -
           hash = "sha256-sh4FLXG78i20Bt8pCCbhO6Sx815stjAZRLCD+X5Zk40=";

     

       23
       23
       +
           hash = "sha256-f7+2gTpG5Ntgq+U2AkQihzSTrO+oMsLWxgxe4dVyz8A=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         buildInputs = [

+2 -10

pkgs/by-name/fr/freefilesync/package.nix

···

       18
       18
        
       

     

       19
       19
        
       stdenv.mkDerivation (finalAttrs: {

     

       20
       20
        
         pname = "freefilesync";

     

       21
       21
       -
         version = "13.5";

     

       21
       21
       +
         version = "13.6";

     

       22
       22
        
       

     

       23
       23
        
         src = fetchurl {

     

       24
       24
        
           url = "https://freefilesync.org/download/FreeFileSync_${finalAttrs.version}_Source.zip";

     
···

       27
       27
        
             rm -f $out

     

       28
       28
        
             tryDownload "$url"

     

       29
       29
        
           '';

     

       30
       30
       -
           hash = "sha256-8At8QobAQR2mQnFjFSPTkEuxmP9M8gINP0qH28J3ynY=";

     

       30
       30
       +
           hash = "sha256-lJ4LiisUy8w6OPd44wJufH+ol1YwjOfFQfqzj3HWb2w=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         sourceRoot = ".";

     
···

       55
       55
        
             debianRevision = "1";

     

       56
       56
        
             patch = "Disable_wxWidgets_uncaught_exception_handling.patch";

     

       57
       57
        
             hash = "sha256-Fem7eDDKSqPFU/t12Jco8OmYC8FM9JgB4/QVy/ouvbI=";

     

       58
       58
       -
           })

     

       59
       59
       -
           # Disable update patch

     

       60
       60
       -
           (fetchDebianPatch {

     

       61
       61
       -
             pname = "freefilesync";

     

       62
       62
       -
             version = "13.3";

     

       63
       63
       -
             debianRevision = "1";

     

       64
       64
       -
             patch = "ffs_no_check_updates.patch";

     

       65
       65
       -
             hash = "sha256-lPyHpxhZz8BSnDI8QfAzKpKwVkp2jiF49RWjKNuZGII=";

     

       66
       58
        
           })

     

       67
       59
        
         ];

     

       68
       60

+2 -2

pkgs/by-name/gm/gmetronome/package.nix

···

       10
       10
        
       

     

       11
       11
        
       stdenv.mkDerivation rec {

     

       12
       12
        
         pname = "gmetronome";

     

       13
       13
       -
         version = "0.3.3";

     

       13
       13
       +
         version = "0.3.4";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitLab {

     

       16
       16
        
           domain = "gitlab.gnome.org";

     

       17
       17
        
           owner = "dqpb";

     

       18
       18
        
           repo = "gmetronome";

     

       19
       19
        
           rev = version;

     

       20
       20
       -
           hash = "sha256-ilFO1HwleWIQ51Bkzck1sm1Yu3ugqkvZrpxPOYzXydM=";

     

       20
       20
       +
           hash = "sha256-fjtdM2/LMZx0dFt78Ih4BG5+NZoocPknh5INA+2e5qk=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [

+3 -3

pkgs/by-name/li/libui-ng/package.nix

···

       12
       12
        
       

     

       13
       13
        
       stdenv.mkDerivation rec {

     

       14
       14
        
         pname = "libui-ng";

     

       15
       15
       -
         version = "4.1-unstable-2024-02-05";

     

       15
       15
       +
         version = "4.1-unstable-2024-05-03";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "libui-ng";

     

       19
       19
        
           repo = "libui-ng";

     

       20
       20
       -
           rev = "4d46de31eafad84c88b939356bcd64e6c5ee3821";

     

       21
       21
       -
           hash = "sha256-Yb8VdJe75uBzRnsfTOVxUXstZmu6dJ9nBuOrf86KO5s=";

     

       20
       20
       +
           rev = "56f1ad65f0f32bb1eb67a268cca4658fbe4567c1";

     

       21
       21
       +
           hash = "sha256-wo4iS/a1ErdipFDPYKvaGpO/JGtk6eU/qMLC4eUoHnA=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         postPatch = lib.optionalString (stdenv.isDarwin && stdenv.isx86_64) ''

+39

pkgs/by-name/ma/maxfetch/package.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenvNoCC

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , makeBinaryWrapper

     

       5
       5
       +
       , gnused

     

       6
       6
       +
       , ncurses

     

       7
       7
       +
       , procps

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       stdenvNoCC.mkDerivation {

     

       11
       11
       +
         pname = "maxfetch";

     

       12
       12
       +
         version = "unstable-2023-07-31";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchFromGitHub {

     

       15
       15
       +
           owner = "jobcmax";

     

       16
       16
       +
           repo = "maxfetch";

     

       17
       17
       +
           rev = "17baa4047073e20572403b70703c69696af6b68d";

     

       18
       18
       +
           hash = "sha256-LzOhrFFjGs9GIDjk1lUFKhlnzJuEUrKjBcv1eT3kaY8=";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         nativeBuildInputs = [ makeBinaryWrapper ];

     

       22
       22
       +
       

     

       23
       23
       +
         installPhase = ''

     

       24
       24
       +
           runHook preInstall

     

       25
       25
       +
           install -Dm755 maxfetch $out/bin/maxfetch

     

       26
       26
       +
           wrapProgram $out/bin/maxfetch \

     

       27
       27
       +
            --prefix PATH : ${lib.makeBinPath [ gnused ncurses procps ]}

     

       28
       28
       +
           runHook postInstall

     

       29
       29
       +
         '';

     

       30
       30
       +
       

     

       31
       31
       +
         meta = with lib; {

     

       32
       32
       +
           description = "Nice fetching program written in sh";

     

       33
       33
       +
           homepage = "https://github.com/jobcmax/maxfetch";

     

       34
       34
       +
           license = licenses.gpl2Plus;

     

       35
       35
       +
           mainProgram = "maxfetch";

     

       36
       36
       +
           maintainers = with maintainers; [ jtbx ];

     

       37
       37
       +
           platforms = platforms.unix;

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+2 -2

pkgs/by-name/me/megapixels/package.nix

···

       29
       29
        
       in

     

       30
       30
        
       stdenv.mkDerivation (finalAttrs: {

     

       31
       31
        
         pname = "megapixels";

     

       32
       32
       -
         version = "1.8.1";

     

       32
       32
       +
         version = "1.8.2";

     

       33
       33
        
       

     

       34
       34
        
         src = fetchFromGitLab {

     

       35
       35
        
           owner = "megapixels-org";

     

       36
       36
        
           repo = "Megapixels";

     

       37
       37
        
           rev = finalAttrs.version;

     

       38
       38
       -
           hash = "sha256-TXiPJbd4TPpsEvmD97F7xkm4rS1g+ViTVTNlxeXrQaw=";

     

       38
       38
       +
           hash = "sha256-odsOYrk//ZhodsumLpJjhPDcwF1gkE/no166u+IDxSY=";

     

       39
       39
        
         };

     

       40
       40
        
       

     

       41
       41
        
         nativeBuildInputs = [

+2 -3

pkgs/by-name/nr/nrfconnect/package.nix

···

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
        
         pname = "nrfconnect";

     

       8
       8
       -
         version = "4.3.0";

     

       8
       8
       +
         version = "4.4.1";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "https://nsscprodmedia.blob.core.windows.net/prod/software-and-other-downloads/desktop-software/nrf-connect-for-desktop/${lib.versions.major version}-${lib.versions.minor version}-${lib.versions.patch version}/nrfconnect-${version}-x86_64.appimage";

     

       12
       12
       -
           hash = "sha256-G8//dZqPxn6mR8Bjzf/bAn9Gv7t2AFWIF9twCGbqMd8=";

     

       12
       12
       +
           hash = "sha256-x/vVSOEajuQtLATRXk8DVLlXHegCqP+acecaOFNeBb8=";

     

       13
       13
        
           name = "${pname}-${version}.AppImage";

     

       14
       14
        
         };

     

       15
       15
        
       

     
···

       25
       25
        
         ];

     

       26
       26
        
       

     

       27
       27
        
         extraInstallCommands = ''

     

       28
       28
       -
           mv $out/bin/nrfconnect-* $out/bin/nrfconnect

     

       29
       28
        
           install -Dm444 ${appimageContents}/nrfconnect.desktop -t $out/share/applications

     

       30
       29
        
           install -Dm444 ${appimageContents}/usr/share/icons/hicolor/512x512/apps/nrfconnect.png \

     

       31
       30
        
             -t $out/share/icons/hicolor/512x512/apps

+3 -3

pkgs/by-name/re/renode-dts2repl/package.nix

···

       6
       6
        
       

     

       7
       7
        
       python3.pkgs.buildPythonApplication {

     

       8
       8
        
         pname = "renode-dts2repl";

     

       9
       9
       -
         version = "0-unstable-2024-04-30";

     

       9
       9
       +
         version = "0-unstable-2024-05-09";

     

       10
       10
        
         pyproject = true;

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "antmicro";

     

       14
       14
        
           repo = "dts2repl";

     

       15
       15
       -
           rev = "dc2212318aec6c2aa6920795e16fab7dfcb8796e";

     

       16
       16
       -
           hash = "sha256-XY2rQqu2CSKRImx0GmC5ggTZTyvrtX+LvqkYj0sEBuU=";

     

       15
       15
       +
           rev = "b95c930c2122e227bbacee42f35933a4c2d40771";

     

       16
       16
       +
           hash = "sha256-Sax+ckln+R6ll/UPztESJEjO8dtq8THmi309CaFTv0I=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [

+2 -2

pkgs/by-name/sp/spicetify-cli/package.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "spicetify-cli";

     

       5
       5
       -
         version = "2.36.10";

     

       5
       5
       +
         version = "2.36.11";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "spicetify";

     

       9
       9
        
           repo = "spicetify-cli";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           hash = "sha256-lwbd5sXqzC3H2GwmVqxAdt6Qcic00wh39l5Kp1UIYAs=";

     

       11
       11
       +
           hash = "sha256-ZqWGKuYDxuKVqz6cNxZ3cTcKTxkxuu42b48hlAialKc=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         vendorHash = "sha256-UPrLXzAdvCOmLm1tekzKyulQ4+2BSyPUF1k66GwKS88=";

pkgs/by-name/sw/switch-to-configuration-ng/.gitignore

···

       1
       1
       +
       /target

+527

pkgs/by-name/sw/switch-to-configuration-ng/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 3

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "aho-corasick"

     

       7
       7
       +
       version = "1.1.3"

     

       8
       8
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       9
       9
       +
       checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"

     

       10
       10
       +
       dependencies = [

     

       11
       11
       +
        "memchr",

     

       12
       12
       +
       ]

     

       13
       13
       +
       

     

       14
       14
       +
       [[package]]

     

       15
       15
       +
       name = "ansi_term"

     

       16
       16
       +
       version = "0.12.1"

     

       17
       17
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       18
       18
       +
       checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"

     

       19
       19
       +
       dependencies = [

     

       20
       20
       +
        "winapi",

     

       21
       21
       +
       ]

     

       22
       22
       +
       

     

       23
       23
       +
       [[package]]

     

       24
       24
       +
       name = "anyhow"

     

       25
       25
       +
       version = "1.0.82"

     

       26
       26
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       27
       27
       +
       checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519"

     

       28
       28
       +
       

     

       29
       29
       +
       [[package]]

     

       30
       30
       +
       name = "atty"

     

       31
       31
       +
       version = "0.2.14"

     

       32
       32
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       33
       33
       +
       checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"

     

       34
       34
       +
       dependencies = [

     

       35
       35
       +
        "hermit-abi",

     

       36
       36
       +
        "libc",

     

       37
       37
       +
        "winapi",

     

       38
       38
       +
       ]

     

       39
       39
       +
       

     

       40
       40
       +
       [[package]]

     

       41
       41
       +
       name = "bitflags"

     

       42
       42
       +
       version = "1.3.2"

     

       43
       43
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       44
       44
       +
       checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

     

       45
       45
       +
       

     

       46
       46
       +
       [[package]]

     

       47
       47
       +
       name = "bitflags"

     

       48
       48
       +
       version = "2.5.0"

     

       49
       49
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       50
       50
       +
       checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"

     

       51
       51
       +
       

     

       52
       52
       +
       [[package]]

     

       53
       53
       +
       name = "cfg-if"

     

       54
       54
       +
       version = "1.0.0"

     

       55
       55
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       56
       56
       +
       checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

     

       57
       57
       +
       

     

       58
       58
       +
       [[package]]

     

       59
       59
       +
       name = "cfg_aliases"

     

       60
       60
       +
       version = "0.1.1"

     

       61
       61
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       62
       62
       +
       checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"

     

       63
       63
       +
       

     

       64
       64
       +
       [[package]]

     

       65
       65
       +
       name = "clap"

     

       66
       66
       +
       version = "2.34.0"

     

       67
       67
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       68
       68
       +
       checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"

     

       69
       69
       +
       dependencies = [

     

       70
       70
       +
        "ansi_term",

     

       71
       71
       +
        "atty",

     

       72
       72
       +
        "bitflags 1.3.2",

     

       73
       73
       +
        "strsim",

     

       74
       74
       +
        "textwrap",

     

       75
       75
       +
        "unicode-width",

     

       76
       76
       +
        "vec_map",

     

       77
       77
       +
       ]

     

       78
       78
       +
       

     

       79
       79
       +
       [[package]]

     

       80
       80
       +
       name = "const-random"

     

       81
       81
       +
       version = "0.1.18"

     

       82
       82
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       83
       83
       +
       checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"

     

       84
       84
       +
       dependencies = [

     

       85
       85
       +
        "const-random-macro",

     

       86
       86
       +
       ]

     

       87
       87
       +
       

     

       88
       88
       +
       [[package]]

     

       89
       89
       +
       name = "const-random-macro"

     

       90
       90
       +
       version = "0.1.16"

     

       91
       91
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       92
       92
       +
       checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"

     

       93
       93
       +
       dependencies = [

     

       94
       94
       +
        "getrandom",

     

       95
       95
       +
        "once_cell",

     

       96
       96
       +
        "tiny-keccak",

     

       97
       97
       +
       ]

     

       98
       98
       +
       

     

       99
       99
       +
       [[package]]

     

       100
       100
       +
       name = "crunchy"

     

       101
       101
       +
       version = "0.2.2"

     

       102
       102
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       103
       103
       +
       checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"

     

       104
       104
       +
       

     

       105
       105
       +
       [[package]]

     

       106
       106
       +
       name = "dbus"

     

       107
       107
       +
       version = "0.9.7"

     

       108
       108
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       109
       109
       +
       checksum = "1bb21987b9fb1613058ba3843121dd18b163b254d8a6e797e144cbac14d96d1b"

     

       110
       110
       +
       dependencies = [

     

       111
       111
       +
        "libc",

     

       112
       112
       +
        "libdbus-sys",

     

       113
       113
       +
        "winapi",

     

       114
       114
       +
       ]

     

       115
       115
       +
       

     

       116
       116
       +
       [[package]]

     

       117
       117
       +
       name = "dbus-codegen"

     

       118
       118
       +
       version = "0.11.0"

     

       119
       119
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       120
       120
       +
       checksum = "bcd91775d91fc83c7d526aa7c08078bac0b30f382706689901ac819fe6ddc812"

     

       121
       121
       +
       dependencies = [

     

       122
       122
       +
        "clap",

     

       123
       123
       +
        "dbus",

     

       124
       124
       +
        "xml-rs",

     

       125
       125
       +
       ]

     

       126
       126
       +
       

     

       127
       127
       +
       [[package]]

     

       128
       128
       +
       name = "deranged"

     

       129
       129
       +
       version = "0.3.11"

     

       130
       130
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       131
       131
       +
       checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"

     

       132
       132
       +
       dependencies = [

     

       133
       133
       +
        "powerfmt",

     

       134
       134
       +
       ]

     

       135
       135
       +
       

     

       136
       136
       +
       [[package]]

     

       137
       137
       +
       name = "dlv-list"

     

       138
       138
       +
       version = "0.5.2"

     

       139
       139
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       140
       140
       +
       checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"

     

       141
       141
       +
       dependencies = [

     

       142
       142
       +
        "const-random",

     

       143
       143
       +
       ]

     

       144
       144
       +
       

     

       145
       145
       +
       [[package]]

     

       146
       146
       +
       name = "error-chain"

     

       147
       147
       +
       version = "0.12.4"

     

       148
       148
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       149
       149
       +
       checksum = "2d2f06b9cac1506ece98fe3231e3cc9c4410ec3d5b1f24ae1c8946f0742cdefc"

     

       150
       150
       +
       dependencies = [

     

       151
       151
       +
        "version_check",

     

       152
       152
       +
       ]

     

       153
       153
       +
       

     

       154
       154
       +
       [[package]]

     

       155
       155
       +
       name = "getrandom"

     

       156
       156
       +
       version = "0.2.14"

     

       157
       157
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       158
       158
       +
       checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"

     

       159
       159
       +
       dependencies = [

     

       160
       160
       +
        "cfg-if",

     

       161
       161
       +
        "libc",

     

       162
       162
       +
        "wasi",

     

       163
       163
       +
       ]

     

       164
       164
       +
       

     

       165
       165
       +
       [[package]]

     

       166
       166
       +
       name = "glob"

     

       167
       167
       +
       version = "0.3.1"

     

       168
       168
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       169
       169
       +
       checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"

     

       170
       170
       +
       

     

       171
       171
       +
       [[package]]

     

       172
       172
       +
       name = "hashbrown"

     

       173
       173
       +
       version = "0.14.5"

     

       174
       174
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       175
       175
       +
       checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"

     

       176
       176
       +
       

     

       177
       177
       +
       [[package]]

     

       178
       178
       +
       name = "hermit-abi"

     

       179
       179
       +
       version = "0.1.19"

     

       180
       180
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       181
       181
       +
       checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"

     

       182
       182
       +
       dependencies = [

     

       183
       183
       +
        "libc",

     

       184
       184
       +
       ]

     

       185
       185
       +
       

     

       186
       186
       +
       [[package]]

     

       187
       187
       +
       name = "hostname"

     

       188
       188
       +
       version = "0.3.1"

     

       189
       189
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       190
       190
       +
       checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"

     

       191
       191
       +
       dependencies = [

     

       192
       192
       +
        "libc",

     

       193
       193
       +
        "match_cfg",

     

       194
       194
       +
        "winapi",

     

       195
       195
       +
       ]

     

       196
       196
       +
       

     

       197
       197
       +
       [[package]]

     

       198
       198
       +
       name = "itoa"

     

       199
       199
       +
       version = "1.0.11"

     

       200
       200
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       201
       201
       +
       checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"

     

       202
       202
       +
       

     

       203
       203
       +
       [[package]]

     

       204
       204
       +
       name = "libc"

     

       205
       205
       +
       version = "0.2.154"

     

       206
       206
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       207
       207
       +
       checksum = "ae743338b92ff9146ce83992f766a31066a91a8c84a45e0e9f21e7cf6de6d346"

     

       208
       208
       +
       

     

       209
       209
       +
       [[package]]

     

       210
       210
       +
       name = "libdbus-sys"

     

       211
       211
       +
       version = "0.2.5"

     

       212
       212
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       213
       213
       +
       checksum = "06085512b750d640299b79be4bad3d2fa90a9c00b1fd9e1b46364f66f0485c72"

     

       214
       214
       +
       dependencies = [

     

       215
       215
       +
        "pkg-config",

     

       216
       216
       +
       ]

     

       217
       217
       +
       

     

       218
       218
       +
       [[package]]

     

       219
       219
       +
       name = "log"

     

       220
       220
       +
       version = "0.4.21"

     

       221
       221
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       222
       222
       +
       checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"

     

       223
       223
       +
       

     

       224
       224
       +
       [[package]]

     

       225
       225
       +
       name = "match_cfg"

     

       226
       226
       +
       version = "0.1.0"

     

       227
       227
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       228
       228
       +
       checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"

     

       229
       229
       +
       

     

       230
       230
       +
       [[package]]

     

       231
       231
       +
       name = "memchr"

     

       232
       232
       +
       version = "2.7.2"

     

       233
       233
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       234
       234
       +
       checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"

     

       235
       235
       +
       

     

       236
       236
       +
       [[package]]

     

       237
       237
       +
       name = "nix"

     

       238
       238
       +
       version = "0.28.0"

     

       239
       239
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       240
       240
       +
       checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"

     

       241
       241
       +
       dependencies = [

     

       242
       242
       +
        "bitflags 2.5.0",

     

       243
       243
       +
        "cfg-if",

     

       244
       244
       +
        "cfg_aliases",

     

       245
       245
       +
        "libc",

     

       246
       246
       +
       ]

     

       247
       247
       +
       

     

       248
       248
       +
       [[package]]

     

       249
       249
       +
       name = "num-conv"

     

       250
       250
       +
       version = "0.1.0"

     

       251
       251
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       252
       252
       +
       checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"

     

       253
       253
       +
       

     

       254
       254
       +
       [[package]]

     

       255
       255
       +
       name = "num_threads"

     

       256
       256
       +
       version = "0.1.7"

     

       257
       257
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       258
       258
       +
       checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"

     

       259
       259
       +
       dependencies = [

     

       260
       260
       +
        "libc",

     

       261
       261
       +
       ]

     

       262
       262
       +
       

     

       263
       263
       +
       [[package]]

     

       264
       264
       +
       name = "once_cell"

     

       265
       265
       +
       version = "1.19.0"

     

       266
       266
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       267
       267
       +
       checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"

     

       268
       268
       +
       

     

       269
       269
       +
       [[package]]

     

       270
       270
       +
       name = "ordered-multimap"

     

       271
       271
       +
       version = "0.7.3"

     

       272
       272
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       273
       273
       +
       checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"

     

       274
       274
       +
       dependencies = [

     

       275
       275
       +
        "dlv-list",

     

       276
       276
       +
        "hashbrown",

     

       277
       277
       +
       ]

     

       278
       278
       +
       

     

       279
       279
       +
       [[package]]

     

       280
       280
       +
       name = "pkg-config"

     

       281
       281
       +
       version = "0.3.30"

     

       282
       282
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       283
       283
       +
       checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"

     

       284
       284
       +
       

     

       285
       285
       +
       [[package]]

     

       286
       286
       +
       name = "powerfmt"

     

       287
       287
       +
       version = "0.2.0"

     

       288
       288
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       289
       289
       +
       checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"

     

       290
       290
       +
       

     

       291
       291
       +
       [[package]]

     

       292
       292
       +
       name = "proc-macro2"

     

       293
       293
       +
       version = "1.0.81"

     

       294
       294
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       295
       295
       +
       checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"

     

       296
       296
       +
       dependencies = [

     

       297
       297
       +
        "unicode-ident",

     

       298
       298
       +
       ]

     

       299
       299
       +
       

     

       300
       300
       +
       [[package]]

     

       301
       301
       +
       name = "quote"

     

       302
       302
       +
       version = "1.0.36"

     

       303
       303
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       304
       304
       +
       checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"

     

       305
       305
       +
       dependencies = [

     

       306
       306
       +
        "proc-macro2",

     

       307
       307
       +
       ]

     

       308
       308
       +
       

     

       309
       309
       +
       [[package]]

     

       310
       310
       +
       name = "regex"

     

       311
       311
       +
       version = "1.10.4"

     

       312
       312
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       313
       313
       +
       checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"

     

       314
       314
       +
       dependencies = [

     

       315
       315
       +
        "aho-corasick",

     

       316
       316
       +
        "memchr",

     

       317
       317
       +
        "regex-automata",

     

       318
       318
       +
        "regex-syntax",

     

       319
       319
       +
       ]

     

       320
       320
       +
       

     

       321
       321
       +
       [[package]]

     

       322
       322
       +
       name = "regex-automata"

     

       323
       323
       +
       version = "0.4.6"

     

       324
       324
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       325
       325
       +
       checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"

     

       326
       326
       +
       dependencies = [

     

       327
       327
       +
        "aho-corasick",

     

       328
       328
       +
        "memchr",

     

       329
       329
       +
        "regex-syntax",

     

       330
       330
       +
       ]

     

       331
       331
       +
       

     

       332
       332
       +
       [[package]]

     

       333
       333
       +
       name = "regex-syntax"

     

       334
       334
       +
       version = "0.8.3"

     

       335
       335
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       336
       336
       +
       checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"

     

       337
       337
       +
       

     

       338
       338
       +
       [[package]]

     

       339
       339
       +
       name = "rust-ini"

     

       340
       340
       +
       version = "0.21.0"

     

       341
       341
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       342
       342
       +
       checksum = "0d625ed57d8f49af6cfa514c42e1a71fadcff60eb0b1c517ff82fe41aa025b41"

     

       343
       343
       +
       dependencies = [

     

       344
       344
       +
        "cfg-if",

     

       345
       345
       +
        "ordered-multimap",

     

       346
       346
       +
        "trim-in-place",

     

       347
       347
       +
       ]

     

       348
       348
       +
       

     

       349
       349
       +
       [[package]]

     

       350
       350
       +
       name = "serde"

     

       351
       351
       +
       version = "1.0.200"

     

       352
       352
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       353
       353
       +
       checksum = "ddc6f9cc94d67c0e21aaf7eda3a010fd3af78ebf6e096aa6e2e13c79749cce4f"

     

       354
       354
       +
       dependencies = [

     

       355
       355
       +
        "serde_derive",

     

       356
       356
       +
       ]

     

       357
       357
       +
       

     

       358
       358
       +
       [[package]]

     

       359
       359
       +
       name = "serde_derive"

     

       360
       360
       +
       version = "1.0.200"

     

       361
       361
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       362
       362
       +
       checksum = "856f046b9400cee3c8c94ed572ecdb752444c24528c035cd35882aad6f492bcb"

     

       363
       363
       +
       dependencies = [

     

       364
       364
       +
        "proc-macro2",

     

       365
       365
       +
        "quote",

     

       366
       366
       +
        "syn",

     

       367
       367
       +
       ]

     

       368
       368
       +
       

     

       369
       369
       +
       [[package]]

     

       370
       370
       +
       name = "strsim"

     

       371
       371
       +
       version = "0.8.0"

     

       372
       372
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       373
       373
       +
       checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"

     

       374
       374
       +
       

     

       375
       375
       +
       [[package]]

     

       376
       376
       +
       name = "switch-to-configuration"

     

       377
       377
       +
       version = "0.1.0"

     

       378
       378
       +
       dependencies = [

     

       379
       379
       +
        "anyhow",

     

       380
       380
       +
        "dbus",

     

       381
       381
       +
        "dbus-codegen",

     

       382
       382
       +
        "glob",

     

       383
       383
       +
        "log",

     

       384
       384
       +
        "nix",

     

       385
       385
       +
        "regex",

     

       386
       386
       +
        "rust-ini",

     

       387
       387
       +
        "syslog",

     

       388
       388
       +
       ]

     

       389
       389
       +
       

     

       390
       390
       +
       [[package]]

     

       391
       391
       +
       name = "syn"

     

       392
       392
       +
       version = "2.0.60"

     

       393
       393
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       394
       394
       +
       checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"

     

       395
       395
       +
       dependencies = [

     

       396
       396
       +
        "proc-macro2",

     

       397
       397
       +
        "quote",

     

       398
       398
       +
        "unicode-ident",

     

       399
       399
       +
       ]

     

       400
       400
       +
       

     

       401
       401
       +
       [[package]]

     

       402
       402
       +
       name = "syslog"

     

       403
       403
       +
       version = "6.1.1"

     

       404
       404
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       405
       405
       +
       checksum = "dfc7e95b5b795122fafe6519e27629b5ab4232c73ebb2428f568e82b1a457ad3"

     

       406
       406
       +
       dependencies = [

     

       407
       407
       +
        "error-chain",

     

       408
       408
       +
        "hostname",

     

       409
       409
       +
        "libc",

     

       410
       410
       +
        "log",

     

       411
       411
       +
        "time",

     

       412
       412
       +
       ]

     

       413
       413
       +
       

     

       414
       414
       +
       [[package]]

     

       415
       415
       +
       name = "textwrap"

     

       416
       416
       +
       version = "0.11.0"

     

       417
       417
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       418
       418
       +
       checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"

     

       419
       419
       +
       dependencies = [

     

       420
       420
       +
        "unicode-width",

     

       421
       421
       +
       ]

     

       422
       422
       +
       

     

       423
       423
       +
       [[package]]

     

       424
       424
       +
       name = "time"

     

       425
       425
       +
       version = "0.3.36"

     

       426
       426
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       427
       427
       +
       checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"

     

       428
       428
       +
       dependencies = [

     

       429
       429
       +
        "deranged",

     

       430
       430
       +
        "itoa",

     

       431
       431
       +
        "libc",

     

       432
       432
       +
        "num-conv",

     

       433
       433
       +
        "num_threads",

     

       434
       434
       +
        "powerfmt",

     

       435
       435
       +
        "serde",

     

       436
       436
       +
        "time-core",

     

       437
       437
       +
        "time-macros",

     

       438
       438
       +
       ]

     

       439
       439
       +
       

     

       440
       440
       +
       [[package]]

     

       441
       441
       +
       name = "time-core"

     

       442
       442
       +
       version = "0.1.2"

     

       443
       443
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       444
       444
       +
       checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"

     

       445
       445
       +
       

     

       446
       446
       +
       [[package]]

     

       447
       447
       +
       name = "time-macros"

     

       448
       448
       +
       version = "0.2.18"

     

       449
       449
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       450
       450
       +
       checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"

     

       451
       451
       +
       dependencies = [

     

       452
       452
       +
        "num-conv",

     

       453
       453
       +
        "time-core",

     

       454
       454
       +
       ]

     

       455
       455
       +
       

     

       456
       456
       +
       [[package]]

     

       457
       457
       +
       name = "tiny-keccak"

     

       458
       458
       +
       version = "2.0.2"

     

       459
       459
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       460
       460
       +
       checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"

     

       461
       461
       +
       dependencies = [

     

       462
       462
       +
        "crunchy",

     

       463
       463
       +
       ]

     

       464
       464
       +
       

     

       465
       465
       +
       [[package]]

     

       466
       466
       +
       name = "trim-in-place"

     

       467
       467
       +
       version = "0.1.7"

     

       468
       468
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       469
       469
       +
       checksum = "343e926fc669bc8cde4fa3129ab681c63671bae288b1f1081ceee6d9d37904fc"

     

       470
       470
       +
       

     

       471
       471
       +
       [[package]]

     

       472
       472
       +
       name = "unicode-ident"

     

       473
       473
       +
       version = "1.0.12"

     

       474
       474
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       475
       475
       +
       checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

     

       476
       476
       +
       

     

       477
       477
       +
       [[package]]

     

       478
       478
       +
       name = "unicode-width"

     

       479
       479
       +
       version = "0.1.12"

     

       480
       480
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       481
       481
       +
       checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"

     

       482
       482
       +
       

     

       483
       483
       +
       [[package]]

     

       484
       484
       +
       name = "vec_map"

     

       485
       485
       +
       version = "0.8.2"

     

       486
       486
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       487
       487
       +
       checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"

     

       488
       488
       +
       

     

       489
       489
       +
       [[package]]

     

       490
       490
       +
       name = "version_check"

     

       491
       491
       +
       version = "0.9.4"

     

       492
       492
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       493
       493
       +
       checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

     

       494
       494
       +
       

     

       495
       495
       +
       [[package]]

     

       496
       496
       +
       name = "wasi"

     

       497
       497
       +
       version = "0.11.0+wasi-snapshot-preview1"

     

       498
       498
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       499
       499
       +
       checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

     

       500
       500
       +
       

     

       501
       501
       +
       [[package]]

     

       502
       502
       +
       name = "winapi"

     

       503
       503
       +
       version = "0.3.9"

     

       504
       504
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       505
       505
       +
       checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"

     

       506
       506
       +
       dependencies = [

     

       507
       507
       +
        "winapi-i686-pc-windows-gnu",

     

       508
       508
       +
        "winapi-x86_64-pc-windows-gnu",

     

       509
       509
       +
       ]

     

       510
       510
       +
       

     

       511
       511
       +
       [[package]]

     

       512
       512
       +
       name = "winapi-i686-pc-windows-gnu"

     

       513
       513
       +
       version = "0.4.0"

     

       514
       514
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       515
       515
       +
       checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

     

       516
       516
       +
       

     

       517
       517
       +
       [[package]]

     

       518
       518
       +
       name = "winapi-x86_64-pc-windows-gnu"

     

       519
       519
       +
       version = "0.4.0"

     

       520
       520
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       521
       521
       +
       checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

     

       522
       522
       +
       

     

       523
       523
       +
       [[package]]

     

       524
       524
       +
       name = "xml-rs"

     

       525
       525
       +
       version = "0.8.20"

     

       526
       526
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       527
       527
       +
       checksum = "791978798f0597cfc70478424c2b4fdc2b7a8024aaff78497ef00f24ef674193"

+19

pkgs/by-name/sw/switch-to-configuration-ng/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "switch-to-configuration"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2021"

     

       5
       5
       +
       

     

       6
       6
       +
       # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

     

       7
       7
       +
       

     

       8
       8
       +
       [dependencies]

     

       9
       9
       +
       anyhow = "1.0.82"

     

       10
       10
       +
       dbus = "0.9.7"

     

       11
       11
       +
       glob = "0.3.1"

     

       12
       12
       +
       log = "0.4.21"

     

       13
       13
       +
       nix = { version = "0.28.0", features = ["fs", "signal"] }

     

       14
       14
       +
       regex = "1.10.4"

     

       15
       15
       +
       rust-ini = "0.21.0"

     

       16
       16
       +
       syslog = "6.1.1"

     

       17
       17
       +
       

     

       18
       18
       +
       [build-dependencies]

     

       19
       19
       +
       dbus-codegen = "0.11.0"

+30

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

···

       1
       1
       +
       use std::io::Write;

     

       2
       2
       +
       

     

       3
       3
       +
       fn code_for_dbus_xml(xml: impl AsRef<std::path::Path>) -> String {

     

       4
       4
       +
           dbus_codegen::generate(

     

       5
       5
       +
               &std::fs::read_to_string(xml).unwrap(),

     

       6
       6
       +
               &dbus_codegen::GenOpts {

     

       7
       7
       +
                   methodtype: None,

     

       8
       8
       +
                   connectiontype: dbus_codegen::ConnectionType::Blocking,

     

       9
       9
       +
                   ..Default::default()

     

       10
       10
       +
               },

     

       11
       11
       +
           )

     

       12
       12
       +
           .unwrap()

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       fn main() {

     

       16
       16
       +
           let systemd_dbus_interface_dir = std::env::var("SYSTEMD_DBUS_INTERFACE_DIR").unwrap();

     

       17
       17
       +
           let systemd_dbus_interface_dir = std::path::Path::new(systemd_dbus_interface_dir.as_str());

     

       18
       18
       +
       

     

       19
       19
       +
           let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());

     

       20
       20
       +
       

     

       21
       21
       +
           let systemd_manager_code =

     

       22
       22
       +
               code_for_dbus_xml(systemd_dbus_interface_dir.join("org.freedesktop.systemd1.Manager.xml"));

     

       23
       23
       +
           let mut file = std::fs::File::create(out_path.join("systemd_manager.rs")).unwrap();

     

       24
       24
       +
           file.write_all(systemd_manager_code.as_bytes()).unwrap();

     

       25
       25
       +
       

     

       26
       26
       +
           let logind_manager_code =

     

       27
       27
       +
               code_for_dbus_xml(systemd_dbus_interface_dir.join("org.freedesktop.login1.Manager.xml"));

     

       28
       28
       +
           let mut file = std::fs::File::create(out_path.join("logind_manager.rs")).unwrap();

     

       29
       29
       +
           file.write_all(logind_manager_code.as_bytes()).unwrap();

     

       30
       30
       +
       }

+36

pkgs/by-name/sw/switch-to-configuration-ng/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         buildPackages,

     

       3
       3
       +
         dbus,

     

       4
       4
       +
         lib,

     

       5
       5
       +
         pkg-config,

     

       6
       6
       +
         rustPlatform,

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       rustPlatform.buildRustPackage {

     

       10
       10
       +
         pname = "switch-to-configuration";

     

       11
       11
       +
         version = "0.1.0";

     

       12
       12
       +
       

     

       13
       13
       +
         src = lib.fileset.toSource {

     

       14
       14
       +
           root = ./.;

     

       15
       15
       +
           fileset = lib.fileset.unions [

     

       16
       16
       +
             ./Cargo.lock

     

       17
       17
       +
             ./Cargo.toml

     

       18
       18
       +
             ./build.rs

     

       19
       19
       +
             ./src

     

       20
       20
       +
           ];

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         cargoLock.lockFile = ./Cargo.lock;

     

       24
       24
       +
       

     

       25
       25
       +
         nativeBuildInputs = [ pkg-config ];

     

       26
       26
       +
         buildInputs = [ dbus ];

     

       27
       27
       +
       

     

       28
       28
       +
         env.SYSTEMD_DBUS_INTERFACE_DIR = "${buildPackages.systemd}/share/dbus-1/interfaces";

     

       29
       29
       +
       

     

       30
       30
       +
         meta = {

     

       31
       31
       +
           description = "NixOS switch-to-configuration program";

     

       32
       32
       +
           mainProgram = "switch-to-configuration";

     

       33
       33
       +
           maintainers = with lib.maintainers; [ jmbaur ];

     

       34
       34
       +
           license = lib.licenses.mit;

     

       35
       35
       +
         };

     

       36
       36
       +
       }

+2077

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

···

       1
       1
       +
       use std::{

     

       2
       2
       +
           cell::RefCell,

     

       3
       3
       +
           collections::HashMap,

     

       4
       4
       +
           io::{BufRead, Write},

     

       5
       5
       +
           os::unix::{fs::PermissionsExt, process::CommandExt},

     

       6
       6
       +
           path::{Path, PathBuf},

     

       7
       7
       +
           rc::Rc,

     

       8
       8
       +
           str::FromStr,

     

       9
       9
       +
           sync::OnceLock,

     

       10
       10
       +
           time::Duration,

     

       11
       11
       +
       };

     

       12
       12
       +
       

     

       13
       13
       +
       use anyhow::{anyhow, bail, Context, Result};

     

       14
       14
       +
       use dbus::{

     

       15
       15
       +
           blocking::{stdintf::org_freedesktop_dbus::Properties, LocalConnection, Proxy},

     

       16
       16
       +
           Message,

     

       17
       17
       +
       };

     

       18
       18
       +
       use glob::glob;

     

       19
       19
       +
       use ini::Ini;

     

       20
       20
       +
       use log::LevelFilter;

     

       21
       21
       +
       use nix::{

     

       22
       22
       +
           fcntl::{Flock, FlockArg, OFlag},

     

       23
       23
       +
           sys::{

     

       24
       24
       +
               signal::{self, SigHandler, Signal},

     

       25
       25
       +
               stat::Mode,

     

       26
       26
       +
           },

     

       27
       27
       +
       };

     

       28
       28
       +
       use regex::Regex;

     

       29
       29
       +
       use syslog::Facility;

     

       30
       30
       +
       

     

       31
       31
       +
       mod systemd_manager {

     

       32
       32
       +
           #![allow(non_upper_case_globals)]

     

       33
       33
       +
           #![allow(non_camel_case_types)]

     

       34
       34
       +
           #![allow(non_snake_case)]

     

       35
       35
       +
           #![allow(unused)]

     

       36
       36
       +
           include!(concat!(env!("OUT_DIR"), "/systemd_manager.rs"));

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       mod logind_manager {

     

       40
       40
       +
           #![allow(non_upper_case_globals)]

     

       41
       41
       +
           #![allow(non_camel_case_types)]

     

       42
       42
       +
           #![allow(non_snake_case)]

     

       43
       43
       +
           #![allow(unused)]

     

       44
       44
       +
           include!(concat!(env!("OUT_DIR"), "/logind_manager.rs"));

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       use crate::systemd_manager::OrgFreedesktopSystemd1Manager;

     

       48
       48
       +
       use crate::{

     

       49
       49
       +
           logind_manager::OrgFreedesktopLogin1Manager,

     

       50
       50
       +
           systemd_manager::{

     

       51
       51
       +
               OrgFreedesktopSystemd1ManagerJobRemoved, OrgFreedesktopSystemd1ManagerReloading,

     

       52
       52
       +
           },

     

       53
       53
       +
       };

     

       54
       54
       +
       

     

       55
       55
       +
       type UnitInfo = HashMap<String, HashMap<String, Vec<String>>>;

     

       56
       56
       +
       

     

       57
       57
       +
       const SYSINIT_REACTIVATION_TARGET: &str = "sysinit-reactivation.target";

     

       58
       58
       +
       

     

       59
       59
       +
       // To be robust against interruption, record what units need to be started etc. We read these files

     

       60
       60
       +
       // again every time this program starts to make sure we continue where the old (interrupted) script

     

       61
       61
       +
       // left off.

     

       62
       62
       +
       const START_LIST_FILE: &str = "/run/nixos/start-list";

     

       63
       63
       +
       const RESTART_LIST_FILE: &str = "/run/nixos/restart-list";

     

       64
       64
       +
       const RELOAD_LIST_FILE: &str = "/run/nixos/reload-list";

     

       65
       65
       +
       

     

       66
       66
       +
       // Parse restart/reload requests by the activation script. Activation scripts may write

     

       67
       67
       +
       // newline-separated units to the restart file and switch-to-configuration will handle them. While

     

       68
       68
       +
       // `stopIfChanged = true` is ignored, switch-to-configuration will handle `restartIfChanged =

     

       69
       69
       +
       // false` and `reloadIfChanged = true`. This is the same as specifying a restart trigger in the

     

       70
       70
       +
       // NixOS module.

     

       71
       71
       +
       //

     

       72
       72
       +
       // The reload file asks this program to reload a unit. This is the same as specifying a reload

     

       73
       73
       +
       // trigger in the NixOS module and can be ignored if the unit is restarted in this activation.

     

       74
       74
       +
       const RESTART_BY_ACTIVATION_LIST_FILE: &str = "/run/nixos/activation-restart-list";

     

       75
       75
       +
       const RELOAD_BY_ACTIVATION_LIST_FILE: &str = "/run/nixos/activation-reload-list";

     

       76
       76
       +
       const DRY_RESTART_BY_ACTIVATION_LIST_FILE: &str = "/run/nixos/dry-activation-restart-list";

     

       77
       77
       +
       const DRY_RELOAD_BY_ACTIVATION_LIST_FILE: &str = "/run/nixos/dry-activation-reload-list";

     

       78
       78
       +
       

     

       79
       79
       +
       #[derive(Debug, Clone, PartialEq)]

     

       80
       80
       +
       enum Action {

     

       81
       81
       +
           Switch,

     

       82
       82
       +
           Boot,

     

       83
       83
       +
           Test,

     

       84
       84
       +
           DryActivate,

     

       85
       85
       +
       }

     

       86
       86
       +
       

     

       87
       87
       +
       impl std::str::FromStr for Action {

     

       88
       88
       +
           type Err = anyhow::Error;

     

       89
       89
       +
       

     

       90
       90
       +
           fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {

     

       91
       91
       +
               Ok(match s {

     

       92
       92
       +
                   "switch" => Self::Switch,

     

       93
       93
       +
                   "boot" => Self::Boot,

     

       94
       94
       +
                   "test" => Self::Test,

     

       95
       95
       +
                   "dry-activate" => Self::DryActivate,

     

       96
       96
       +
                   _ => bail!("invalid action {s}"),

     

       97
       97
       +
               })

     

       98
       98
       +
           }

     

       99
       99
       +
       }

     

       100
       100
       +
       

     

       101
       101
       +
       impl Into<&'static str> for &Action {

     

       102
       102
       +
           fn into(self) -> &'static str {

     

       103
       103
       +
               match self {

     

       104
       104
       +
                   Action::Switch => "switch",

     

       105
       105
       +
                   Action::Boot => "boot",

     

       106
       106
       +
                   Action::Test => "test",

     

       107
       107
       +
                   Action::DryActivate => "dry-activate",

     

       108
       108
       +
               }

     

       109
       109
       +
           }

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       // Allow for this switch-to-configuration to remain consistent with the perl implementation.

     

       113
       113
       +
       // Perl's "die" uses errno to set the exit code: https://perldoc.perl.org/perlvar#%24%21

     

       114
       114
       +
       fn die() -> ! {

     

       115
       115
       +
           std::process::exit(std::io::Error::last_os_error().raw_os_error().unwrap_or(1));

     

       116
       116
       +
       }

     

       117
       117
       +
       

     

       118
       118
       +
       fn parse_os_release() -> Result<HashMap<String, String>> {

     

       119
       119
       +
           Ok(std::fs::read_to_string("/etc/os-release")

     

       120
       120
       +
               .context("Failed to read /etc/os-release")?

     

       121
       121
       +
               .lines()

     

       122
       122
       +
               .into_iter()

     

       123
       123
       +
               .fold(HashMap::new(), |mut acc, line| {

     

       124
       124
       +
                   if let Some((k, v)) = line.split_once('=') {

     

       125
       125
       +
                       acc.insert(k.to_string(), v.to_string());

     

       126
       126
       +
                   }

     

       127
       127
       +
       

     

       128
       128
       +
                   acc

     

       129
       129
       +
               }))

     

       130
       130
       +
       }

     

       131
       131
       +
       

     

       132
       132
       +
       fn do_install_bootloader(command: &str, toplevel: &Path) -> Result<()> {

     

       133
       133
       +
           let mut cmd_split = command.split_whitespace();

     

       134
       134
       +
           let Some(argv0) = cmd_split.next() else {

     

       135
       135
       +
               bail!("missing first argument in install bootloader commands");

     

       136
       136
       +
           };

     

       137
       137
       +
       

     

       138
       138
       +
           match std::process::Command::new(argv0)

     

       139
       139
       +
               .args(cmd_split.collect::<Vec<&str>>())

     

       140
       140
       +
               .arg(toplevel)

     

       141
       141
       +
               .spawn()

     

       142
       142
       +
               .map(|mut child| child.wait())

     

       143
       143
       +
           {

     

       144
       144
       +
               Ok(Ok(status)) if status.success() => {}

     

       145
       145
       +
               _ => {

     

       146
       146
       +
                   eprintln!("Failed to install bootloader");

     

       147
       147
       +
                   die();

     

       148
       148
       +
               }

     

       149
       149
       +
           }

     

       150
       150
       +
       

     

       151
       151
       +
           Ok(())

     

       152
       152
       +
       }

     

       153
       153
       +
       

     

       154
       154
       +
       extern "C" fn handle_sigpipe(_signal: nix::libc::c_int) {}

     

       155
       155
       +
       

     

       156
       156
       +
       fn required_env(var: &str) -> anyhow::Result<String> {

     

       157
       157
       +
           std::env::var(var).with_context(|| format!("missing required environment variable ${var}"))

     

       158
       158
       +
       }

     

       159
       159
       +
       

     

       160
       160
       +
       #[derive(Debug)]

     

       161
       161
       +
       struct UnitState {

     

       162
       162
       +
           state: String,

     

       163
       163
       +
           substate: String,

     

       164
       164
       +
       }

     

       165
       165
       +
       

     

       166
       166
       +
       // Asks the currently running systemd instance via dbus which units are active. Returns a hash

     

       167
       167
       +
       // where the key is the name of each unit and the value a hash of load, state, substate.

     

       168
       168
       +
       fn get_active_units<'a>(

     

       169
       169
       +
           systemd_manager: &Proxy<'a, &LocalConnection>,

     

       170
       170
       +
       ) -> Result<HashMap<String, UnitState>> {

     

       171
       171
       +
           let units = systemd_manager

     

       172
       172
       +
               .list_units_by_patterns(Vec::new(), Vec::new())

     

       173
       173
       +
               .context("Failed to list systemd units")?;

     

       174
       174
       +
       

     

       175
       175
       +
           Ok(units

     

       176
       176
       +
               .into_iter()

     

       177
       177
       +
               .filter_map(

     

       178
       178
       +
                   |(

     

       179
       179
       +
                       id,

     

       180
       180
       +
                       _description,

     

       181
       181
       +
                       _load_state,

     

       182
       182
       +
                       active_state,

     

       183
       183
       +
                       sub_state,

     

       184
       184
       +
                       following,

     

       185
       185
       +
                       _unit_path,

     

       186
       186
       +
                       _job_id,

     

       187
       187
       +
                       _job_type,

     

       188
       188
       +
                       _job_path,

     

       189
       189
       +
                   )| {

     

       190
       190
       +
                       if following == "" && active_state != "inactive" {

     

       191
       191
       +
                           Some((id, active_state, sub_state))

     

       192
       192
       +
                       } else {

     

       193
       193
       +
                           None

     

       194
       194
       +
                       }

     

       195
       195
       +
                   },

     

       196
       196
       +
               )

     

       197
       197
       +
               .fold(HashMap::new(), |mut acc, (id, active_state, sub_state)| {

     

       198
       198
       +
                   acc.insert(

     

       199
       199
       +
                       id,

     

       200
       200
       +
                       UnitState {

     

       201
       201
       +
                           state: active_state,

     

       202
       202
       +
                           substate: sub_state,

     

       203
       203
       +
                       },

     

       204
       204
       +
                   );

     

       205
       205
       +
       

     

       206
       206
       +
                   acc

     

       207
       207
       +
               }))

     

       208
       208
       +
       }

     

       209
       209
       +
       

     

       210
       210
       +
       // This function takes a single ini file that specified systemd configuration like unit

     

       211
       211
       +
       // configuration and parses it into a HashMap where the keys are the sections of the unit file and

     

       212
       212
       +
       // the values are HashMaps themselves. These HashMaps have the unit file keys as their keys (left

     

       213
       213
       +
       // side of =) and an array of all values that were set as their values. If a value is empty (for

     

       214
       214
       +
       // example `ExecStart=`), then all current definitions are removed.

     

       215
       215
       +
       //

     

       216
       216
       +
       // Instead of returning the HashMap, this function takes a mutable reference to a HashMap to return

     

       217
       217
       +
       // the data in. This allows calling the function multiple times with the same Hashmap to parse

     

       218
       218
       +
       // override files.

     

       219
       219
       +
       fn parse_systemd_ini(data: &mut UnitInfo, unit_file: &Path) -> Result<()> {

     

       220
       220
       +
           let ini = Ini::load_from_file(unit_file)

     

       221
       221
       +
               .with_context(|| format!("Failed to load unit file {}", unit_file.display()))?;

     

       222
       222
       +
       

     

       223
       223
       +
           // Copy over all sections

     

       224
       224
       +
           for (section, properties) in ini.iter() {

     

       225
       225
       +
               let Some(section) = section else {

     

       226
       226
       +
                   continue;

     

       227
       227
       +
               };

     

       228
       228
       +
       

     

       229
       229
       +
               if section == "Install" {

     

       230
       230
       +
                   // Skip the [Install] section because it has no relevant keys for us

     

       231
       231
       +
                   continue;

     

       232
       232
       +
               }

     

       233
       233
       +
       

     

       234
       234
       +
               let section_map = if let Some(section_map) = data.get_mut(section) {

     

       235
       235
       +
                   section_map

     

       236
       236
       +
               } else {

     

       237
       237
       +
                   data.insert(section.to_string(), HashMap::new());

     

       238
       238
       +
                   data.get_mut(section)

     

       239
       239
       +
                       .ok_or(anyhow!("section name should exist in hashmap"))?

     

       240
       240
       +
               };

     

       241
       241
       +
       

     

       242
       242
       +
               for (ini_key, _) in properties {

     

       243
       243
       +
                   let values = properties.get_all(ini_key);

     

       244
       244
       +
                   let values = values

     

       245
       245
       +
                       .into_iter()

     

       246
       246
       +
                       .map(String::from)

     

       247
       247
       +
                       .collect::<Vec<String>>();

     

       248
       248
       +
       

     

       249
       249
       +
                   // Go over all values

     

       250
       250
       +
                   let mut new_vals = Vec::new();

     

       251
       251
       +
                   let mut clear_existing = false;

     

       252
       252
       +
       

     

       253
       253
       +
                   for val in values {

     

       254
       254
       +
                       // If a value is empty, it's an override that tells us to clean the value

     

       255
       255
       +
                       if val.is_empty() {

     

       256
       256
       +
                           new_vals.clear();

     

       257
       257
       +
                           clear_existing = true;

     

       258
       258
       +
                       } else {

     

       259
       259
       +
                           new_vals.push(val);

     

       260
       260
       +
                       }

     

       261
       261
       +
                   }

     

       262
       262
       +
       

     

       263
       263
       +
                   match (section_map.get_mut(ini_key), clear_existing) {

     

       264
       264
       +
                       (Some(existing_vals), false) => existing_vals.extend(new_vals),

     

       265
       265
       +
                       _ => _ = section_map.insert(ini_key.to_string(), new_vals),

     

       266
       266
       +
                   };

     

       267
       267
       +
               }

     

       268
       268
       +
           }

     

       269
       269
       +
       

     

       270
       270
       +
           Ok(())

     

       271
       271
       +
       }

     

       272
       272
       +
       

     

       273
       273
       +
       // This function takes the path to a systemd configuration file (like a unit configuration) and

     

       274
       274
       +
       // parses it into a UnitInfo structure.

     

       275
       275
       +
       //

     

       276
       276
       +
       // If a directory with the same basename ending in .d exists next to the unit file, it will be

     

       277
       277
       +
       // assumed to contain override files which will be parsed as well and handled properly.

     

       278
       278
       +
       fn parse_unit(unit_file: &Path, base_unit_file: &Path) -> Result<UnitInfo> {

     

       279
       279
       +
           // Parse the main unit and all overrides

     

       280
       280
       +
           let mut unit_data = HashMap::new();

     

       281
       281
       +
       

     

       282
       282
       +
           parse_systemd_ini(&mut unit_data, base_unit_file)?;

     

       283
       283
       +
       

     

       284
       284
       +
           for entry in

     

       285
       285
       +
               glob(&format!("{}.d/*.conf", base_unit_file.display())).context("Invalid glob pattern")?

     

       286
       286
       +
           {

     

       287
       287
       +
               let Ok(entry) = entry else {

     

       288
       288
       +
                   continue;

     

       289
       289
       +
               };

     

       290
       290
       +
       

     

       291
       291
       +
               parse_systemd_ini(&mut unit_data, &entry)?;

     

       292
       292
       +
           }

     

       293
       293
       +
       

     

       294
       294
       +
           // Handle drop-in template-unit instance overrides

     

       295
       295
       +
           if unit_file != base_unit_file {

     

       296
       296
       +
               for entry in

     

       297
       297
       +
                   glob(&format!("{}.d/*.conf", unit_file.display())).context("Invalid glob pattern")?

     

       298
       298
       +
               {

     

       299
       299
       +
                   let Ok(entry) = entry else {

     

       300
       300
       +
                       continue;

     

       301
       301
       +
                   };

     

       302
       302
       +
       

     

       303
       303
       +
                   parse_systemd_ini(&mut unit_data, &entry)?;

     

       304
       304
       +
               }

     

       305
       305
       +
           }

     

       306
       306
       +
       

     

       307
       307
       +
           Ok(unit_data)

     

       308
       308
       +
       }

     

       309
       309
       +
       

     

       310
       310
       +
       // Checks whether a specified boolean in a systemd unit is true or false, with a default that is

     

       311
       311
       +
       // applied when the value is not set.

     

       312
       312
       +
       fn parse_systemd_bool(

     

       313
       313
       +
           unit_data: Option<&UnitInfo>,

     

       314
       314
       +
           section_name: &str,

     

       315
       315
       +
           bool_name: &str,

     

       316
       316
       +
           default: bool,

     

       317
       317
       +
       ) -> bool {

     

       318
       318
       +
           if let Some(Some(Some(Some(b)))) = unit_data.map(|data| {

     

       319
       319
       +
               data.get(section_name).map(|section| {

     

       320
       320
       +
                   section.get(bool_name).map(|vals| {

     

       321
       321
       +
                       vals.last()

     

       322
       322
       +
                           .map(|last| matches!(last.as_str(), "1" | "yes" | "true" | "on"))

     

       323
       323
       +
                   })

     

       324
       324
       +
               })

     

       325
       325
       +
           }) {

     

       326
       326
       +
               b

     

       327
       327
       +
           } else {

     

       328
       328
       +
               default

     

       329
       329
       +
           }

     

       330
       330
       +
       }

     

       331
       331
       +
       

     

       332
       332
       +
       #[derive(Debug, PartialEq)]

     

       333
       333
       +
       enum UnitComparison {

     

       334
       334
       +
           Equal,

     

       335
       335
       +
           UnequalNeedsRestart,

     

       336
       336
       +
           UnequalNeedsReload,

     

       337
       337
       +
       }

     

       338
       338
       +
       

     

       339
       339
       +
       // Compare the contents of two unit files and return whether the unit needs to be restarted or

     

       340
       340
       +
       // reloaded. If the units differ, the service is restarted unless the only difference is

     

       341
       341
       +
       // `X-Reload-Triggers` in the `Unit` section. If this is the only modification, the unit is

     

       342
       342
       +
       // reloaded instead of restarted. If the only difference is `Options` in the `[Mount]` section, the

     

       343
       343
       +
       // unit is reloaded rather than restarted.

     

       344
       344
       +
       fn compare_units(current_unit: &UnitInfo, new_unit: &UnitInfo) -> UnitComparison {

     

       345
       345
       +
           let mut ret = UnitComparison::Equal;

     

       346
       346
       +
       

     

       347
       347
       +
           let unit_section_ignores = HashMap::from(

     

       348
       348
       +
               [

     

       349
       349
       +
                   "X-Reload-Triggers",

     

       350
       350
       +
                   "Description",

     

       351
       351
       +
                   "Documentation",

     

       352
       352
       +
                   "OnFailure",

     

       353
       353
       +
                   "OnSuccess",

     

       354
       354
       +
                   "OnFailureJobMode",

     

       355
       355
       +
                   "IgnoreOnIsolate",

     

       356
       356
       +
                   "StopWhenUnneeded",

     

       357
       357
       +
                   "RefuseManualStart",

     

       358
       358
       +
                   "RefuseManualStop",

     

       359
       359
       +
                   "AllowIsolate",

     

       360
       360
       +
                   "CollectMode",

     

       361
       361
       +
                   "SourcePath",

     

       362
       362
       +
               ]

     

       363
       363
       +
               .map(|name| (name, ())),

     

       364
       364
       +
           );

     

       365
       365
       +
       

     

       366
       366
       +
           let mut section_cmp = new_unit.keys().fold(HashMap::new(), |mut acc, key| {

     

       367
       367
       +
               acc.insert(key.as_str(), ());

     

       368
       368
       +
               acc

     

       369
       369
       +
           });

     

       370
       370
       +
       

     

       371
       371
       +
           // Iterate over the sections

     

       372
       372
       +
           for (section_name, section_val) in current_unit {

     

       373
       373
       +
               // Missing section in the new unit?

     

       374
       374
       +
               if !section_cmp.contains_key(section_name.as_str()) {

     

       375
       375
       +
                   // If the [Unit] section was removed, make sure that only keys were in it that are

     

       376
       376
       +
                   // ignored

     

       377
       377
       +
                   if section_name == "Unit" {

     

       378
       378
       +
                       for (ini_key, _ini_val) in section_val {

     

       379
       379
       +
                           if !unit_section_ignores.contains_key(ini_key.as_str()) {

     

       380
       380
       +
                               return UnitComparison::UnequalNeedsRestart;

     

       381
       381
       +
                           }

     

       382
       382
       +
                       }

     

       383
       383
       +
                       continue; // check the next section

     

       384
       384
       +
                   } else {

     

       385
       385
       +
                       return UnitComparison::UnequalNeedsRestart;

     

       386
       386
       +
                   }

     

       387
       387
       +
               }

     

       388
       388
       +
       

     

       389
       389
       +
               section_cmp.remove(section_name.as_str());

     

       390
       390
       +
       

     

       391
       391
       +
               // Comparison hash for the section contents

     

       392
       392
       +
               let mut ini_cmp = new_unit

     

       393
       393
       +
                   .get(section_name)

     

       394
       394
       +
                   .map(|section_val| {

     

       395
       395
       +
                       section_val.keys().fold(HashMap::new(), |mut acc, ini_key| {

     

       396
       396
       +
                           acc.insert(ini_key.as_str(), ());

     

       397
       397
       +
                           acc

     

       398
       398
       +
                       })

     

       399
       399
       +
                   })

     

       400
       400
       +
                   .unwrap_or_default();

     

       401
       401
       +
       

     

       402
       402
       +
               // Iterate over the keys of the section

     

       403
       403
       +
               for (ini_key, current_value) in section_val {

     

       404
       404
       +
                   ini_cmp.remove(ini_key.as_str());

     

       405
       405
       +
                   let Some(Some(new_value)) = new_unit

     

       406
       406
       +
                       .get(section_name)

     

       407
       407
       +
                       .map(|section| section.get(ini_key))

     

       408
       408
       +
                   else {

     

       409
       409
       +
                       // If the key is missing in the new unit, they are different unless the key that is

     

       410
       410
       +
                       // now missing is one of the ignored keys

     

       411
       411
       +
                       if section_name == "Unit" && unit_section_ignores.contains_key(ini_key.as_str()) {

     

       412
       412
       +
                           continue;

     

       413
       413
       +
                       }

     

       414
       414
       +
                       return UnitComparison::UnequalNeedsRestart;

     

       415
       415
       +
                   };

     

       416
       416
       +
       

     

       417
       417
       +
                   // If the contents are different, the units are different

     

       418
       418
       +
                   if current_value != new_value {

     

       419
       419
       +
                       if section_name == "Unit" {

     

       420
       420
       +
                           if ini_key == "X-Reload-Triggers" {

     

       421
       421
       +
                               ret = UnitComparison::UnequalNeedsReload;

     

       422
       422
       +
                               continue;

     

       423
       423
       +
                           } else if unit_section_ignores.contains_key(ini_key.as_str()) {

     

       424
       424
       +
                               continue;

     

       425
       425
       +
                           }

     

       426
       426
       +
                       }

     

       427
       427
       +
       

     

       428
       428
       +
                       // If this is a mount unit, check if it was only `Options`

     

       429
       429
       +
                       if section_name == "Mount" && ini_key == "Options" {

     

       430
       430
       +
                           ret = UnitComparison::UnequalNeedsReload;

     

       431
       431
       +
                           continue;

     

       432
       432
       +
                       }

     

       433
       433
       +
       

     

       434
       434
       +
                       return UnitComparison::UnequalNeedsRestart;

     

       435
       435
       +
                   }

     

       436
       436
       +
               }

     

       437
       437
       +
       

     

       438
       438
       +
               // A key was introduced that was missing in the previous unit

     

       439
       439
       +
               if !ini_cmp.is_empty() {

     

       440
       440
       +
                   if section_name == "Unit" {

     

       441
       441
       +
                       for (ini_key, _) in ini_cmp {

     

       442
       442
       +
                           if ini_key == "X-Reload-Triggers" {

     

       443
       443
       +
                               ret = UnitComparison::UnequalNeedsReload;

     

       444
       444
       +
                           } else if unit_section_ignores.contains_key(ini_key) {

     

       445
       445
       +
                               continue;

     

       446
       446
       +
                           } else {

     

       447
       447
       +
                               return UnitComparison::UnequalNeedsRestart;

     

       448
       448
       +
                           }

     

       449
       449
       +
                       }

     

       450
       450
       +
                   } else {

     

       451
       451
       +
                       return UnitComparison::UnequalNeedsRestart;

     

       452
       452
       +
                   }

     

       453
       453
       +
               }

     

       454
       454
       +
           }

     

       455
       455
       +
       

     

       456
       456
       +
           // A section was introduced that was missing in the previous unit

     

       457
       457
       +
           if !section_cmp.is_empty() {

     

       458
       458
       +
               if section_cmp.keys().len() == 1 && section_cmp.contains_key("Unit") {

     

       459
       459
       +
                   if let Some(new_unit_unit) = new_unit.get("Unit") {

     

       460
       460
       +
                       for (ini_key, _) in new_unit_unit {

     

       461
       461
       +
                           if !unit_section_ignores.contains_key(ini_key.as_str()) {

     

       462
       462
       +
                               return UnitComparison::UnequalNeedsRestart;

     

       463
       463
       +
                           } else if ini_key == "X-Reload-Triggers" {

     

       464
       464
       +
                               ret = UnitComparison::UnequalNeedsReload;

     

       465
       465
       +
                           }

     

       466
       466
       +
                       }

     

       467
       467
       +
                   }

     

       468
       468
       +
               } else {

     

       469
       469
       +
                   return UnitComparison::UnequalNeedsRestart;

     

       470
       470
       +
               }

     

       471
       471
       +
           }

     

       472
       472
       +
       

     

       473
       473
       +
           ret

     

       474
       474
       +
       }

     

       475
       475
       +
       

     

       476
       476
       +
       // Called when a unit exists in both the old systemd and the new system and the units differ. This

     

       477
       477
       +
       // figures out of what units are to be stopped, restarted, reloaded, started, and skipped.

     

       478
       478
       +
       fn handle_modified_unit(

     

       479
       479
       +
           toplevel: &Path,

     

       480
       480
       +
           unit: &str,

     

       481
       481
       +
           base_name: &str,

     

       482
       482
       +
           new_unit_file: &Path,

     

       483
       483
       +
           new_base_unit_file: &Path,

     

       484
       484
       +
           new_unit_info: Option<&UnitInfo>,

     

       485
       485
       +
           active_cur: &HashMap<String, UnitState>,

     

       486
       486
       +
           units_to_stop: &mut HashMap<String, ()>,

     

       487
       487
       +
           units_to_start: &mut HashMap<String, ()>,

     

       488
       488
       +
           units_to_reload: &mut HashMap<String, ()>,

     

       489
       489
       +
           units_to_restart: &mut HashMap<String, ()>,

     

       490
       490
       +
           units_to_skip: &mut HashMap<String, ()>,

     

       491
       491
       +
       ) -> Result<()> {

     

       492
       492
       +
           let use_restart_as_stop_and_start = new_unit_info.is_none();

     

       493
       493
       +
       

     

       494
       494
       +
           if matches!(

     

       495
       495
       +
               unit,

     

       496
       496
       +
               "sysinit.target" | "basic.target" | "multi-user.target" | "graphical.target"

     

       497
       497
       +
           ) || unit.ends_with(".unit")

     

       498
       498
       +
               || unit.ends_with(".slice")

     

       499
       499
       +
           {

     

       500
       500
       +
               // Do nothing.  These cannot be restarted directly.

     

       501
       501
       +
       

     

       502
       502
       +
               // Slices and Paths don't have to be restarted since properties (resource limits and

     

       503
       503
       +
               // inotify watches) seem to get applied on daemon-reload.

     

       504
       504
       +
           } else if unit.ends_with(".mount") {

     

       505
       505
       +
               // Just restart the unit. We wouldn't have gotten into this subroutine if only `Options`

     

       506
       506
       +
               // was changed, in which case the unit would be reloaded. The only exception is / and /nix

     

       507
       507
       +
               // because it's very unlikely we can safely unmount them so we reload them instead. This

     

       508
       508
       +
               // means that we may not get all changes into the running system but it's better than

     

       509
       509
       +
               // crashing it.

     

       510
       510
       +
               if unit == "-.mount" || unit == "nix.mount" {

     

       511
       511
       +
                   units_to_reload.insert(unit.to_string(), ());

     

       512
       512
       +
                   record_unit(RELOAD_LIST_FILE, unit);

     

       513
       513
       +
               } else {

     

       514
       514
       +
                   units_to_restart.insert(unit.to_string(), ());

     

       515
       515
       +
                   record_unit(RESTART_LIST_FILE, unit);

     

       516
       516
       +
               }

     

       517
       517
       +
           } else if unit.ends_with(".socket") {

     

       518
       518
       +
               // FIXME: do something?

     

       519
       519
       +
               // Attempt to fix this: https://github.com/NixOS/nixpkgs/pull/141192

     

       520
       520
       +
               // Revert of the attempt: https://github.com/NixOS/nixpkgs/pull/147609

     

       521
       521
       +
               // More details: https://github.com/NixOS/nixpkgs/issues/74899#issuecomment-981142430

     

       522
       522
       +
           } else {

     

       523
       523
       +
               let fallback = parse_unit(new_unit_file, new_base_unit_file)?;

     

       524
       524
       +
               let new_unit_info = if new_unit_info.is_some() {

     

       525
       525
       +
                   new_unit_info

     

       526
       526
       +
               } else {

     

       527
       527
       +
                   Some(&fallback)

     

       528
       528
       +
               };

     

       529
       529
       +
       

     

       530
       530
       +
               if parse_systemd_bool(new_unit_info, "Service", "X-ReloadIfChanged", false)

     

       531
       531
       +
                   && !units_to_restart.contains_key(unit)

     

       532
       532
       +
                   && !(if use_restart_as_stop_and_start {

     

       533
       533
       +
                       units_to_restart.contains_key(unit)

     

       534
       534
       +
                   } else {

     

       535
       535
       +
                       units_to_stop.contains_key(unit)

     

       536
       536
       +
                   })

     

       537
       537
       +
               {

     

       538
       538
       +
                   units_to_reload.insert(unit.to_string(), ());

     

       539
       539
       +
                   record_unit(RELOAD_LIST_FILE, unit);

     

       540
       540
       +
               } else if !parse_systemd_bool(new_unit_info, "Service", "X-RestartIfChanged", true)

     

       541
       541
       +
                   || parse_systemd_bool(new_unit_info, "Unit", "RefuseManualStop", false)

     

       542
       542
       +
                   || parse_systemd_bool(new_unit_info, "Unit", "X-OnlyManualStart", false)

     

       543
       543
       +
               {

     

       544
       544
       +
                   units_to_skip.insert(unit.to_string(), ());

     

       545
       545
       +
               } else {

     

       546
       546
       +
                   // It doesn't make sense to stop and start non-services because they can't have

     

       547
       547
       +
                   // ExecStop=

     

       548
       548
       +
                   if !parse_systemd_bool(new_unit_info, "Service", "X-StopIfChanged", true)

     

       549
       549
       +
                       || !unit.ends_with(".service")

     

       550
       550
       +
                   {

     

       551
       551
       +
                       // This unit should be restarted instead of stopped and started.

     

       552
       552
       +
                       units_to_restart.insert(unit.to_string(), ());

     

       553
       553
       +
                       record_unit(RESTART_LIST_FILE, unit);

     

       554
       554
       +
                       // Remove from units to reload so we don't restart and reload

     

       555
       555
       +
                       if units_to_reload.contains_key(unit) {

     

       556
       556
       +
                           units_to_reload.remove(unit);

     

       557
       557
       +
                           unrecord_unit(RELOAD_LIST_FILE, unit);

     

       558
       558
       +
                       }

     

       559
       559
       +
                   } else {

     

       560
       560
       +
                       // If this unit is socket-activated, then stop the socket unit(s) as well, and

     

       561
       561
       +
                       // restart the socket(s) instead of the service.

     

       562
       562
       +
                       let mut socket_activated = false;

     

       563
       563
       +
                       if unit.ends_with(".service") {

     

       564
       564
       +
                           let mut sockets = if let Some(Some(Some(sockets))) = new_unit_info.map(|info| {

     

       565
       565
       +
                               info.get("Service")

     

       566
       566
       +
                                   .map(|service_section| service_section.get("Sockets"))

     

       567
       567
       +
                           }) {

     

       568
       568
       +
                               sockets

     

       569
       569
       +
                                   .join(" ")

     

       570
       570
       +
                                   .split_whitespace()

     

       571
       571
       +
                                   .into_iter()

     

       572
       572
       +
                                   .map(String::from)

     

       573
       573
       +
                                   .collect()

     

       574
       574
       +
                           } else {

     

       575
       575
       +
                               Vec::new()

     

       576
       576
       +
                           };

     

       577
       577
       +
       

     

       578
       578
       +
                           if sockets.is_empty() {

     

       579
       579
       +
                               sockets.push(format!("{}.socket", base_name));

     

       580
       580
       +
                           }

     

       581
       581
       +
       

     

       582
       582
       +
                           for socket in &sockets {

     

       583
       583
       +
                               if active_cur.contains_key(socket) {

     

       584
       584
       +
                                   // We can now be sure this is a socket-activated unit

     

       585
       585
       +
       

     

       586
       586
       +
                                   if use_restart_as_stop_and_start {

     

       587
       587
       +
                                       units_to_restart.insert(socket.to_string(), ());

     

       588
       588
       +
                                   } else {

     

       589
       589
       +
                                       units_to_stop.insert(socket.to_string(), ());

     

       590
       590
       +
                                   }

     

       591
       591
       +
       

     

       592
       592
       +
                                   // Only restart sockets that actually exist in new configuration:

     

       593
       593
       +
                                   if toplevel.join("etc/systemd/system").join(socket).exists() {

     

       594
       594
       +
                                       if use_restart_as_stop_and_start {

     

       595
       595
       +
                                           units_to_restart.insert(socket.to_string(), ());

     

       596
       596
       +
                                           record_unit(RESTART_LIST_FILE, socket);

     

       597
       597
       +
                                       } else {

     

       598
       598
       +
                                           units_to_start.insert(socket.to_string(), ());

     

       599
       599
       +
                                           record_unit(START_LIST_FILE, socket);

     

       600
       600
       +
                                       }

     

       601
       601
       +
       

     

       602
       602
       +
                                       socket_activated = true;

     

       603
       603
       +
                                   }

     

       604
       604
       +
       

     

       605
       605
       +
                                   // Remove from units to reload so we don't restart and reload

     

       606
       606
       +
                                   if units_to_reload.contains_key(unit) {

     

       607
       607
       +
                                       units_to_reload.remove(unit);

     

       608
       608
       +
                                       unrecord_unit(RELOAD_LIST_FILE, unit);

     

       609
       609
       +
                                   }

     

       610
       610
       +
                               }

     

       611
       611
       +
                           }

     

       612
       612
       +
                       }

     

       613
       613
       +
       

     

       614
       614
       +
                       // If the unit is not socket-activated, record that this unit needs to be started

     

       615
       615
       +
                       // below. We write this to a file to ensure that the service gets restarted if

     

       616
       616
       +
                       // we're interrupted.

     

       617
       617
       +
                       if !socket_activated {

     

       618
       618
       +
                           if use_restart_as_stop_and_start {

     

       619
       619
       +
                               units_to_restart.insert(unit.to_string(), ());

     

       620
       620
       +
                               record_unit(RESTART_LIST_FILE, unit);

     

       621
       621
       +
                           } else {

     

       622
       622
       +
                               units_to_start.insert(unit.to_string(), ());

     

       623
       623
       +
                               record_unit(START_LIST_FILE, unit);

     

       624
       624
       +
                           }

     

       625
       625
       +
                       }

     

       626
       626
       +
       

     

       627
       627
       +
                       if use_restart_as_stop_and_start {

     

       628
       628
       +
                           units_to_restart.insert(unit.to_string(), ());

     

       629
       629
       +
                       } else {

     

       630
       630
       +
                           units_to_stop.insert(unit.to_string(), ());

     

       631
       631
       +
                       }

     

       632
       632
       +
                       // Remove from units to reload so we don't restart and reload

     

       633
       633
       +
                       if units_to_reload.contains_key(unit) {

     

       634
       634
       +
                           units_to_reload.remove(unit);

     

       635
       635
       +
                           unrecord_unit(RELOAD_LIST_FILE, unit);

     

       636
       636
       +
                       }

     

       637
       637
       +
                   }

     

       638
       638
       +
               }

     

       639
       639
       +
           }

     

       640
       640
       +
       

     

       641
       641
       +
           Ok(())

     

       642
       642
       +
       }

     

       643
       643
       +
       

     

       644
       644
       +
       // Writes a unit name into a given file to be more resilient against crashes of the script. Does

     

       645
       645
       +
       // nothing when the action is dry-activate.

     

       646
       646
       +
       fn record_unit(p: impl AsRef<Path>, unit: &str) {

     

       647
       647
       +
           if ACTION.get() != Some(&Action::DryActivate) {

     

       648
       648
       +
               if let Ok(mut f) = std::fs::File::options().append(true).create(true).open(p) {

     

       649
       649
       +
                   _ = writeln!(&mut f, "{unit}");

     

       650
       650
       +
               }

     

       651
       651
       +
           }

     

       652
       652
       +
       }

     

       653
       653
       +
       

     

       654
       654
       +
       // The opposite of record_unit, removes a unit name from a file

     

       655
       655
       +
       fn unrecord_unit(p: impl AsRef<Path>, unit: &str) {

     

       656
       656
       +
           if ACTION.get() != Some(&Action::DryActivate) {

     

       657
       657
       +
               if let Ok(contents) = std::fs::read_to_string(&p) {

     

       658
       658
       +
                   if let Ok(mut f) = std::fs::File::options()

     

       659
       659
       +
                       .write(true)

     

       660
       660
       +
                       .truncate(true)

     

       661
       661
       +
                       .create(true)

     

       662
       662
       +
                       .open(&p)

     

       663
       663
       +
                   {

     

       664
       664
       +
                       contents

     

       665
       665
       +
                           .lines()

     

       666
       666
       +
                           .into_iter()

     

       667
       667
       +
                           .filter(|line| line != &unit)

     

       668
       668
       +
                           .for_each(|line| _ = writeln!(&mut f, "{line}"))

     

       669
       669
       +
                   }

     

       670
       670
       +
               }

     

       671
       671
       +
           }

     

       672
       672
       +
       }

     

       673
       673
       +
       

     

       674
       674
       +
       fn map_from_list_file(p: impl AsRef<Path>) -> HashMap<String, ()> {

     

       675
       675
       +
           std::fs::read_to_string(p)

     

       676
       676
       +
               .unwrap_or_default()

     

       677
       677
       +
               .lines()

     

       678
       678
       +
               .filter(|line| !line.is_empty())

     

       679
       679
       +
               .into_iter()

     

       680
       680
       +
               .fold(HashMap::new(), |mut acc, line| {

     

       681
       681
       +
                   acc.insert(line.to_string(), ());

     

       682
       682
       +
                   acc

     

       683
       683
       +
               })

     

       684
       684
       +
       }

     

       685
       685
       +
       

     

       686
       686
       +
       #[derive(Debug)]

     

       687
       687
       +
       struct Filesystem {

     

       688
       688
       +
           device: String,

     

       689
       689
       +
           fs_type: String,

     

       690
       690
       +
           options: String,

     

       691
       691
       +
       }

     

       692
       692
       +
       

     

       693
       693
       +
       #[derive(Debug)]

     

       694
       694
       +
       #[allow(unused)]

     

       695
       695
       +
       struct Swap(String);

     

       696
       696
       +
       

     

       697
       697
       +
       // Parse a fstab file, given its path. Returns a tuple of filesystems and swaps.

     

       698
       698
       +
       //

     

       699
       699
       +
       // Filesystems is a hash of mountpoint and { device, fsType, options } Swaps is a hash of device

     

       700
       700
       +
       // and { options }

     

       701
       701
       +
       fn parse_fstab(fstab: impl BufRead) -> (HashMap<String, Filesystem>, HashMap<String, Swap>) {

     

       702
       702
       +
           let mut filesystems = HashMap::new();

     

       703
       703
       +
           let mut swaps = HashMap::new();

     

       704
       704
       +
       

     

       705
       705
       +
           for line in fstab.lines() {

     

       706
       706
       +
               let Ok(line) = line else {

     

       707
       707
       +
                   break;

     

       708
       708
       +
               };

     

       709
       709
       +
       

     

       710
       710
       +
               if line.contains('#') {

     

       711
       711
       +
                   continue;

     

       712
       712
       +
               }

     

       713
       713
       +
       

     

       714
       714
       +
               let mut split = line.split_whitespace();

     

       715
       715
       +
               let (Some(device), Some(mountpoint), Some(fs_type), options) = (

     

       716
       716
       +
                   split.next(),

     

       717
       717
       +
                   split.next(),

     

       718
       718
       +
                   split.next(),

     

       719
       719
       +
                   split.next().unwrap_or_default(),

     

       720
       720
       +
               ) else {

     

       721
       721
       +
                   continue;

     

       722
       722
       +
               };

     

       723
       723
       +
       

     

       724
       724
       +
               if fs_type == "swap" {

     

       725
       725
       +
                   swaps.insert(device.to_string(), Swap(options.to_string()));

     

       726
       726
       +
               } else {

     

       727
       727
       +
                   filesystems.insert(

     

       728
       728
       +
                       mountpoint.to_string(),

     

       729
       729
       +
                       Filesystem {

     

       730
       730
       +
                           device: device.to_string(),

     

       731
       731
       +
                           fs_type: fs_type.to_string(),

     

       732
       732
       +
                           options: options.to_string(),

     

       733
       733
       +
                       },

     

       734
       734
       +
                   );

     

       735
       735
       +
               }

     

       736
       736
       +
           }

     

       737
       737
       +
       

     

       738
       738
       +
           (filesystems, swaps)

     

       739
       739
       +
       }

     

       740
       740
       +
       

     

       741
       741
       +
       // Converts a path to the name of a systemd mount unit that would be responsible for mounting this

     

       742
       742
       +
       // path.

     

       743
       743
       +
       fn path_to_unit_name(bin_path: &Path, path: &str) -> String {

     

       744
       744
       +
           let Ok(output) = std::process::Command::new(bin_path.join("systemd-escape"))

     

       745
       745
       +
               .arg("--suffix=mount")

     

       746
       746
       +
               .arg("-p")

     

       747
       747
       +
               .arg(path)

     

       748
       748
       +
               .output()

     

       749
       749
       +
           else {

     

       750
       750
       +
               eprintln!("Unable to escape {}!", path);

     

       751
       751
       +
               die();

     

       752
       752
       +
           };

     

       753
       753
       +
       

     

       754
       754
       +
           let Ok(unit) = String::from_utf8(output.stdout) else {

     

       755
       755
       +
               eprintln!("Unable to convert systemd-espape output to valid UTF-8");

     

       756
       756
       +
               die();

     

       757
       757
       +
           };

     

       758
       758
       +
       

     

       759
       759
       +
           unit.trim().to_string()

     

       760
       760
       +
       }

     

       761
       761
       +
       

     

       762
       762
       +
       // Returns a HashMap containing the same contents as the passed in `units`, minus the units in

     

       763
       763
       +
       // `units_to_filter`.

     

       764
       764
       +
       fn filter_units(

     

       765
       765
       +
           units_to_filter: &HashMap<String, ()>,

     

       766
       766
       +
           units: &HashMap<String, ()>,

     

       767
       767
       +
       ) -> HashMap<String, ()> {

     

       768
       768
       +
           let mut res = HashMap::new();

     

       769
       769
       +
       

     

       770
       770
       +
           for (unit, _) in units {

     

       771
       771
       +
               if !units_to_filter.contains_key(unit) {

     

       772
       772
       +
                   res.insert(unit.to_string(), ());

     

       773
       773
       +
               }

     

       774
       774
       +
           }

     

       775
       775
       +
       

     

       776
       776
       +
           res

     

       777
       777
       +
       }

     

       778
       778
       +
       

     

       779
       779
       +
       fn unit_is_active<'a>(conn: &LocalConnection, unit: &str) -> Result<bool> {

     

       780
       780
       +
           let unit_object_path = conn

     

       781
       781
       +
               .with_proxy(

     

       782
       782
       +
                   "org.freedesktop.systemd1",

     

       783
       783
       +
                   "/org/freedesktop/systemd1",

     

       784
       784
       +
                   Duration::from_millis(5000),

     

       785
       785
       +
               )

     

       786
       786
       +
               .get_unit(unit)

     

       787
       787
       +
               .with_context(|| format!("Failed to get unit {unit}"))?;

     

       788
       788
       +
       

     

       789
       789
       +
           let active_state: String = conn

     

       790
       790
       +
               .with_proxy(

     

       791
       791
       +
                   "org.freedesktop.systemd1",

     

       792
       792
       +
                   unit_object_path,

     

       793
       793
       +
                   Duration::from_millis(5000),

     

       794
       794
       +
               )

     

       795
       795
       +
               .get("org.freedesktop.systemd1.Unit", "ActiveState")

     

       796
       796
       +
               .with_context(|| format!("Failed to get ExecMainStatus for {unit}"))?;

     

       797
       797
       +
       

     

       798
       798
       +
           Ok(matches!(active_state.as_str(), "active" | "activating"))

     

       799
       799
       +
       }

     

       800
       800
       +
       

     

       801
       801
       +
       static ACTION: OnceLock<Action> = OnceLock::new();

     

       802
       802
       +
       

     

       803
       803
       +
       #[derive(Debug)]

     

       804
       804
       +
       enum Job {

     

       805
       805
       +
           Start,

     

       806
       806
       +
           Restart,

     

       807
       807
       +
           Reload,

     

       808
       808
       +
           Stop,

     

       809
       809
       +
       }

     

       810
       810
       +
       

     

       811
       811
       +
       impl std::fmt::Display for Job {

     

       812
       812
       +
           fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

     

       813
       813
       +
               write!(

     

       814
       814
       +
                   f,

     

       815
       815
       +
                   "{}",

     

       816
       816
       +
                   match self {

     

       817
       817
       +
                       Job::Start => "start",

     

       818
       818
       +
                       Job::Restart => "restart",

     

       819
       819
       +
                       Job::Reload => "reload",

     

       820
       820
       +
                       Job::Stop => "stop",

     

       821
       821
       +
                   }

     

       822
       822
       +
               )

     

       823
       823
       +
           }

     

       824
       824
       +
       }

     

       825
       825
       +
       

     

       826
       826
       +
       fn new_dbus_proxies<'a>(

     

       827
       827
       +
           conn: &'a LocalConnection,

     

       828
       828
       +
       ) -> (

     

       829
       829
       +
           Proxy<'a, &'a LocalConnection>,

     

       830
       830
       +
           Proxy<'a, &'a LocalConnection>,

     

       831
       831
       +
       ) {

     

       832
       832
       +
           (

     

       833
       833
       +
               conn.with_proxy(

     

       834
       834
       +
                   "org.freedesktop.systemd1",

     

       835
       835
       +
                   "/org/freedesktop/systemd1",

     

       836
       836
       +
                   Duration::from_millis(5000),

     

       837
       837
       +
               ),

     

       838
       838
       +
               conn.with_proxy(

     

       839
       839
       +
                   "org.freedesktop.login1",

     

       840
       840
       +
                   "/org/freedesktop/login1",

     

       841
       841
       +
                   Duration::from_millis(5000),

     

       842
       842
       +
               ),

     

       843
       843
       +
           )

     

       844
       844
       +
       }

     

       845
       845
       +
       

     

       846
       846
       +
       fn block_on_jobs(

     

       847
       847
       +
           conn: &LocalConnection,

     

       848
       848
       +
           submitted_jobs: &Rc<RefCell<HashMap<dbus::Path<'static>, Job>>>,

     

       849
       849
       +
       ) {

     

       850
       850
       +
           while !submitted_jobs.borrow().is_empty() {

     

       851
       851
       +
               _ = conn.process(Duration::from_millis(500));

     

       852
       852
       +
           }

     

       853
       853
       +
       }

     

       854
       854
       +
       

     

       855
       855
       +
       fn remove_file_if_exists(p: impl AsRef<Path>) -> std::io::Result<()> {

     

       856
       856
       +
           match std::fs::remove_file(p) {

     

       857
       857
       +
               Err(err) if err.kind() != std::io::ErrorKind::NotFound => Err(err),

     

       858
       858
       +
               _ => Ok(()),

     

       859
       859
       +
           }

     

       860
       860
       +
       }

     

       861
       861
       +
       

     

       862
       862
       +
       /// Performs switch-to-configuration functionality for a single non-root user

     

       863
       863
       +
       fn do_user_switch(parent_exe: String) -> anyhow::Result<()> {

     

       864
       864
       +
           if Path::new(&parent_exe)

     

       865
       865
       +
               != Path::new("/proc/self/exe")

     

       866
       866
       +
                   .canonicalize()

     

       867
       867
       +
                   .context("Failed to get full path to current executable")?

     

       868
       868
       +
                   .as_path()

     

       869
       869
       +
           {

     

       870
       870
       +
               eprintln!(

     

       871
       871
       +
                   r#"This program is not meant to be called from outside of switch-to-configuration."#

     

       872
       872
       +
               );

     

       873
       873
       +
               die();

     

       874
       874
       +
           }

     

       875
       875
       +
       

     

       876
       876
       +
           let dbus_conn = LocalConnection::new_session().context("Failed to open dbus connection")?;

     

       877
       877
       +
           let (systemd, _) = new_dbus_proxies(&dbus_conn);

     

       878
       878
       +
       

     

       879
       879
       +
           let nixos_activation_done = Rc::new(RefCell::new(false));

     

       880
       880
       +
           let _nixos_activation_done = nixos_activation_done.clone();

     

       881
       881
       +
           let jobs_token = systemd

     

       882
       882
       +
               .match_signal(

     

       883
       883
       +
                   move |signal: OrgFreedesktopSystemd1ManagerJobRemoved,

     

       884
       884
       +
                         _: &LocalConnection,

     

       885
       885
       +
                         _: &Message| {

     

       886
       886
       +
                       if signal.unit.as_str() == "nixos-activation.service" {

     

       887
       887
       +
                           *_nixos_activation_done.borrow_mut() = true;

     

       888
       888
       +
                       }

     

       889
       889
       +
       

     

       890
       890
       +
                       true

     

       891
       891
       +
                   },

     

       892
       892
       +
               )

     

       893
       893
       +
               .context("Failed to add signal match for systemd removed jobs")?;

     

       894
       894
       +
       

     

       895
       895
       +
           // The systemd user session seems to not send a Reloaded signal, so we don't have anything to

     

       896
       896
       +
           // wait on here.

     

       897
       897
       +
           _ = systemd.reexecute();

     

       898
       898
       +
       

     

       899
       899
       +
           systemd

     

       900
       900
       +
               .restart_unit("nixos-activation.service", "replace")

     

       901
       901
       +
               .context("Failed to restart nixos-activation.service")?;

     

       902
       902
       +
       

     

       903
       903
       +
           while !*nixos_activation_done.borrow() {

     

       904
       904
       +
               _ = dbus_conn

     

       905
       905
       +
                   .process(Duration::from_secs(500))

     

       906
       906
       +
                   .context("Failed to process dbus messages")?;

     

       907
       907
       +
           }

     

       908
       908
       +
       

     

       909
       909
       +
           dbus_conn

     

       910
       910
       +
               .remove_match(jobs_token)

     

       911
       911
       +
               .context("Failed to remove jobs token")?;

     

       912
       912
       +
       

     

       913
       913
       +
           Ok(())

     

       914
       914
       +
       }

     

       915
       915
       +
       

     

       916
       916
       +
       /// Performs switch-to-configuration functionality for the entire system

     

       917
       917
       +
       fn do_system_switch() -> anyhow::Result<()> {

     

       918
       918
       +
           let out = PathBuf::from(required_env("OUT")?);

     

       919
       919
       +
           let toplevel = PathBuf::from(required_env("TOPLEVEL")?);

     

       920
       920
       +
           let distro_id = required_env("DISTRO_ID")?;

     

       921
       921
       +
           let install_bootloader = required_env("INSTALL_BOOTLOADER")?;

     

       922
       922
       +
           let locale_archive = required_env("LOCALE_ARCHIVE")?;

     

       923
       923
       +
           let new_systemd = PathBuf::from(required_env("SYSTEMD")?);

     

       924
       924
       +
       

     

       925
       925
       +
           let mut args = std::env::args();

     

       926
       926
       +
           let argv0 = args.next().ok_or(anyhow!("no argv[0]"))?;

     

       927
       927
       +
       

     

       928
       928
       +
           let Some(Ok(action)) = args.next().map(|a| Action::from_str(&a)) else {

     

       929
       929
       +
               eprintln!(

     

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

     

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

     

       932
       932
       +
       boot:         make the configuration the boot default

     

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

     

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

     

       935
       935
       +
       "#,

     

       936
       936
       +
                   argv0

     

       937
       937
       +
                       .split(std::path::MAIN_SEPARATOR_STR)

     

       938
       938
       +
                       .last()

     

       939
       939
       +
                       .unwrap_or("switch-to-configuration")

     

       940
       940
       +
               );

     

       941
       941
       +
               std::process::exit(1);

     

       942
       942
       +
           };

     

       943
       943
       +
       

     

       944
       944
       +
           let action = ACTION.get_or_init(|| action);

     

       945
       945
       +
       

     

       946
       946
       +
           // The action that is to be performed (like switch, boot, test, dry-activate) Also exposed via

     

       947
       947
       +
           // environment variable from now on

     

       948
       948
       +
           std::env::set_var("NIXOS_ACTION", Into::<&'static str>::into(action));

     

       949
       949
       +
       

     

       950
       950
       +
           // Expose the locale archive as an environment variable for systemctl and the activation script

     

       951
       951
       +
           if !locale_archive.is_empty() {

     

       952
       952
       +
               std::env::set_var("LOCALE_ARCHIVE", locale_archive);

     

       953
       953
       +
           }

     

       954
       954
       +
       

     

       955
       955
       +
           let current_system_bin = std::path::PathBuf::from("/run/current-system/sw/bin")

     

       956
       956
       +
               .canonicalize()

     

       957
       957
       +
               .context("/run/current-system/sw/bin is missing")?;

     

       958
       958
       +
       

     

       959
       959
       +
           let os_release = parse_os_release().context("Failed to parse os-release")?;

     

       960
       960
       +
       

     

       961
       961
       +
           let distro_id_re = Regex::new(format!("^\"?{}\"?$", distro_id).as_str())

     

       962
       962
       +
               .context("Invalid regex for distro ID")?;

     

       963
       963
       +
       

     

       964
       964
       +
           // This is a NixOS installation if it has /etc/NIXOS or a proper /etc/os-release.

     

       965
       965
       +
           if !Path::new("/etc/NIXOS").is_file()

     

       966
       966
       +
               && !os_release

     

       967
       967
       +
                   .get("ID")

     

       968
       968
       +
                   .map(|id| distro_id_re.is_match(id))

     

       969
       969
       +
                   .unwrap_or_default()

     

       970
       970
       +
           {

     

       971
       971
       +
               eprintln!("This is not a NixOS installation!");

     

       972
       972
       +
               die();

     

       973
       973
       +
           }

     

       974
       974
       +
       

     

       975
       975
       +
           std::fs::create_dir_all("/run/nixos").context("Failed to create /run/nixos directory")?;

     

       976
       976
       +
           let perms = std::fs::Permissions::from_mode(0o755);

     

       977
       977
       +
           std::fs::set_permissions("/run/nixos", perms)

     

       978
       978
       +
               .context("Failed to set permissions on /run/nixos directory")?;

     

       979
       979
       +
       

     

       980
       980
       +
           let Ok(lock) = std::fs::OpenOptions::new()

     

       981
       981
       +
               .append(true)

     

       982
       982
       +
               .create(true)

     

       983
       983
       +
               .open("/run/nixos/switch-to-configuration.lock")

     

       984
       984
       +
           else {

     

       985
       985
       +
               eprintln!("Could not open lock");

     

       986
       986
       +
               die();

     

       987
       987
       +
           };

     

       988
       988
       +
       

     

       989
       989
       +
           let Ok(_lock) = Flock::lock(lock, FlockArg::LockExclusive) else {

     

       990
       990
       +
               eprintln!("Could not acquire lock");

     

       991
       991
       +
               die();

     

       992
       992
       +
           };

     

       993
       993
       +
       

     

       994
       994
       +
           if syslog::init(Facility::LOG_USER, LevelFilter::Debug, Some("nixos")).is_err() {

     

       995
       995
       +
               bail!("Failed to initialize logger");

     

       996
       996
       +
           }

     

       997
       997
       +
       

     

       998
       998
       +
           // Install or update the bootloader.

     

       999
       999
       +
           if matches!(action, Action::Switch | Action::Boot) {

     

       1000
       1000
       +
               do_install_bootloader(&install_bootloader, &toplevel)?;

     

       1001
       1001
       +
           }

     

       1002
       1002
       +
       

     

       1003
       1003
       +
           // Just in case the new configuration hangs the system, do a sync now.

     

       1004
       1004
       +
           if std::env::var("NIXOS_NO_SYNC")

     

       1005
       1005
       +
               .as_deref()

     

       1006
       1006
       +
               .unwrap_or_default()

     

       1007
       1007
       +
               != "1"

     

       1008
       1008
       +
           {

     

       1009
       1009
       +
               let fd = nix::fcntl::open("/nix/store", OFlag::O_NOCTTY, Mode::S_IROTH)

     

       1010
       1010
       +
                   .context("Failed to open /nix/store")?;

     

       1011
       1011
       +
               nix::unistd::syncfs(fd).context("Failed to sync /nix/store")?;

     

       1012
       1012
       +
           }

     

       1013
       1013
       +
       

     

       1014
       1014
       +
           if *action == Action::Boot {

     

       1015
       1015
       +
               std::process::exit(0);

     

       1016
       1016
       +
           }

     

       1017
       1017
       +
       

     

       1018
       1018
       +
           let current_init_interface_version =

     

       1019
       1019
       +
               std::fs::read_to_string("/run/current-system/init-interface-version").unwrap_or_default();

     

       1020
       1020
       +
       

     

       1021
       1021
       +
           let new_init_interface_version =

     

       1022
       1022
       +
               std::fs::read_to_string(toplevel.join("init-interface-version"))

     

       1023
       1023
       +
                   .context("File init-interface-version should exist")?;

     

       1024
       1024
       +
       

     

       1025
       1025
       +
           // Check if we can activate the new configuration.

     

       1026
       1026
       +
           if current_init_interface_version != new_init_interface_version {

     

       1027
       1027
       +
               eprintln!(

     

       1028
       1028
       +
                   r#"Warning: the new NixOS configuration has an ‘init’ that is

     

       1029
       1029
       +
       incompatible with the current configuration.  The new configuration

     

       1030
       1030
       +
       won't take effect until you reboot the system.

     

       1031
       1031
       +
       "#

     

       1032
       1032
       +
               );

     

       1033
       1033
       +
               std::process::exit(100);

     

       1034
       1034
       +
           }

     

       1035
       1035
       +
       

     

       1036
       1036
       +
           // Ignore SIGHUP so that we're not killed if we're running on (say) virtual console 1 and we

     

       1037
       1037
       +
           // restart the "tty1" unit.

     

       1038
       1038
       +
           let handler = SigHandler::Handler(handle_sigpipe);

     

       1039
       1039
       +
           unsafe { signal::signal(Signal::SIGPIPE, handler) }.context("Failed to set SIGPIPE handler")?;

     

       1040
       1040
       +
       

     

       1041
       1041
       +
           let mut units_to_stop = HashMap::new();

     

       1042
       1042
       +
           let mut units_to_skip = HashMap::new();

     

       1043
       1043
       +
           let mut units_to_filter = HashMap::new(); // units not shown

     

       1044
       1044
       +
       

     

       1045
       1045
       +
           let mut units_to_start = map_from_list_file(START_LIST_FILE);

     

       1046
       1046
       +
           let mut units_to_restart = map_from_list_file(RESTART_LIST_FILE);

     

       1047
       1047
       +
           let mut units_to_reload = map_from_list_file(RELOAD_LIST_FILE);

     

       1048
       1048
       +
       

     

       1049
       1049
       +
           let dbus_conn = LocalConnection::new_system().context("Failed to open dbus connection")?;

     

       1050
       1050
       +
           let (systemd, logind) = new_dbus_proxies(&dbus_conn);

     

       1051
       1051
       +
       

     

       1052
       1052
       +
           let submitted_jobs = Rc::new(RefCell::new(HashMap::new()));

     

       1053
       1053
       +
           let finished_jobs = Rc::new(RefCell::new(HashMap::new()));

     

       1054
       1054
       +
       

     

       1055
       1055
       +
           let systemd_reload_status = Rc::new(RefCell::new(false));

     

       1056
       1056
       +
       

     

       1057
       1057
       +
           systemd

     

       1058
       1058
       +
               .subscribe()

     

       1059
       1059
       +
               .context("Failed to subscribe to systemd dbus messages")?;

     

       1060
       1060
       +
       

     

       1061
       1061
       +
           // Wait for the system to have finished booting.

     

       1062
       1062
       +
           loop {

     

       1063
       1063
       +
               let system_state: String = systemd

     

       1064
       1064
       +
                   .get("org.freedesktop.systemd1.Manager", "SystemState")

     

       1065
       1065
       +
                   .context("Failed to get system state")?;

     

       1066
       1066
       +
       

     

       1067
       1067
       +
               match system_state.as_str() {

     

       1068
       1068
       +
                   "running" | "degraded" | "maintenance" => break,

     

       1069
       1069
       +
                   _ => {

     

       1070
       1070
       +
                       _ = dbus_conn

     

       1071
       1071
       +
                           .process(Duration::from_millis(500))

     

       1072
       1072
       +
                           .context("Failed to process dbus messages")?

     

       1073
       1073
       +
                   }

     

       1074
       1074
       +
               }

     

       1075
       1075
       +
           }

     

       1076
       1076
       +
       

     

       1077
       1077
       +
           let _systemd_reload_status = systemd_reload_status.clone();

     

       1078
       1078
       +
           let reloading_token = systemd

     

       1079
       1079
       +
               .match_signal(

     

       1080
       1080
       +
                   move |signal: OrgFreedesktopSystemd1ManagerReloading,

     

       1081
       1081
       +
                         _: &LocalConnection,

     

       1082
       1082
       +
                         _msg: &Message| {

     

       1083
       1083
       +
                       *_systemd_reload_status.borrow_mut() = signal.active;

     

       1084
       1084
       +
       

     

       1085
       1085
       +
                       true

     

       1086
       1086
       +
                   },

     

       1087
       1087
       +
               )

     

       1088
       1088
       +
               .context("Failed to add systemd Reloading match")?;

     

       1089
       1089
       +
       

     

       1090
       1090
       +
           let _submitted_jobs = submitted_jobs.clone();

     

       1091
       1091
       +
           let _finished_jobs = finished_jobs.clone();

     

       1092
       1092
       +
           let job_removed_token = systemd

     

       1093
       1093
       +
               .match_signal(

     

       1094
       1094
       +
                   move |signal: OrgFreedesktopSystemd1ManagerJobRemoved,

     

       1095
       1095
       +
                         _: &LocalConnection,

     

       1096
       1096
       +
                         _msg: &Message| {

     

       1097
       1097
       +
                       if let Some(old) = _submitted_jobs.borrow_mut().remove(&signal.job) {

     

       1098
       1098
       +
                           let mut finished_jobs = _finished_jobs.borrow_mut();

     

       1099
       1099
       +
                           finished_jobs.insert(signal.job, (signal.unit, old, signal.result));

     

       1100
       1100
       +
                       }

     

       1101
       1101
       +
       

     

       1102
       1102
       +
                       true

     

       1103
       1103
       +
                   },

     

       1104
       1104
       +
               )

     

       1105
       1105
       +
               .context("Failed to add systemd JobRemoved match")?;

     

       1106
       1106
       +
       

     

       1107
       1107
       +
           let current_active_units = get_active_units(&systemd)?;

     

       1108
       1108
       +
       

     

       1109
       1109
       +
           let template_unit_re = Regex::new(r"^(.*)@[^\.]*\.(.*)$")

     

       1110
       1110
       +
               .context("Invalid regex for matching systemd template units")?;

     

       1111
       1111
       +
           let unit_name_re = Regex::new(r"^(.*)\.[[:lower:]]*$")

     

       1112
       1112
       +
               .context("Invalid regex for matching systemd unit names")?;

     

       1113
       1113
       +
       

     

       1114
       1114
       +
           for (unit, unit_state) in &current_active_units {

     

       1115
       1115
       +
               let current_unit_file = Path::new("/etc/systemd/system").join(&unit);

     

       1116
       1116
       +
               let new_unit_file = toplevel.join("etc/systemd/system").join(&unit);

     

       1117
       1117
       +
       

     

       1118
       1118
       +
               let mut base_unit = unit.clone();

     

       1119
       1119
       +
               let mut current_base_unit_file = current_unit_file.clone();

     

       1120
       1120
       +
               let mut new_base_unit_file = new_unit_file.clone();

     

       1121
       1121
       +
       

     

       1122
       1122
       +
               // Detect template instances

     

       1123
       1123
       +
               if let Some((Some(template_name), Some(template_instance))) =

     

       1124
       1124
       +
                   template_unit_re.captures(&unit).map(|captures| {

     

       1125
       1125
       +
                       (

     

       1126
       1126
       +
                           captures.get(1).map(|c| c.as_str()),

     

       1127
       1127
       +
                           captures.get(2).map(|c| c.as_str()),

     

       1128
       1128
       +
                       )

     

       1129
       1129
       +
                   })

     

       1130
       1130
       +
               {

     

       1131
       1131
       +
                   if !current_unit_file.exists() && !new_unit_file.exists() {

     

       1132
       1132
       +
                       base_unit = format!("{}@.{}", template_name, template_instance);

     

       1133
       1133
       +
                       current_base_unit_file = Path::new("/etc/systemd/system").join(&base_unit);

     

       1134
       1134
       +
                       new_base_unit_file = toplevel.join("etc/systemd/system").join(&base_unit);

     

       1135
       1135
       +
                   }

     

       1136
       1136
       +
               }

     

       1137
       1137
       +
       

     

       1138
       1138
       +
               let mut base_name = base_unit.as_str();

     

       1139
       1139
       +
               if let Some(Some(new_base_name)) = unit_name_re

     

       1140
       1140
       +
                   .captures(&base_unit)

     

       1141
       1141
       +
                   .map(|capture| capture.get(1).map(|first| first.as_str()))

     

       1142
       1142
       +
               {

     

       1143
       1143
       +
                   base_name = new_base_name;

     

       1144
       1144
       +
               }

     

       1145
       1145
       +
       

     

       1146
       1146
       +
               if current_base_unit_file.exists()

     

       1147
       1147
       +
                   && (unit_state.state == "active" || unit_state.state == "activating")

     

       1148
       1148
       +
               {

     

       1149
       1149
       +
                   if new_base_unit_file

     

       1150
       1150
       +
                       .canonicalize()

     

       1151
       1151
       +
                       .map(|full_path| full_path == Path::new("/dev/null"))

     

       1152
       1152
       +
                       .unwrap_or(true)

     

       1153
       1153
       +
                   {

     

       1154
       1154
       +
                       let current_unit_info = parse_unit(&current_unit_file, &current_base_unit_file)?;

     

       1155
       1155
       +
                       if parse_systemd_bool(Some(&current_unit_info), "Unit", "X-StopOnRemoval", true) {

     

       1156
       1156
       +
                           _ = units_to_stop.insert(unit.to_string(), ());

     

       1157
       1157
       +
                       }

     

       1158
       1158
       +
                   } else if unit.ends_with(".target") {

     

       1159
       1159
       +
                       let new_unit_info = parse_unit(&new_unit_file, &new_base_unit_file)?;

     

       1160
       1160
       +
       

     

       1161
       1161
       +
                       // Cause all active target units to be restarted below. This should start most

     

       1162
       1162
       +
                       // changed units we stop here as well as any new dependencies (including new mounts

     

       1163
       1163
       +
                       // and swap devices).  FIXME: the suspend target is sometimes active after the

     

       1164
       1164
       +
                       // system has resumed, which probably should not be the case.  Just ignore it.

     

       1165
       1165
       +
                       if !matches!(

     

       1166
       1166
       +
                           unit.as_str(),

     

       1167
       1167
       +
                           "suspend.target" | "hibernate.target" | "hybrid-sleep.target"

     

       1168
       1168
       +
                       ) {

     

       1169
       1169
       +
                           if !(parse_systemd_bool(

     

       1170
       1170
       +
                               Some(&new_unit_info),

     

       1171
       1171
       +
                               "Unit",

     

       1172
       1172
       +
                               "RefuseManualStart",

     

       1173
       1173
       +
                               false,

     

       1174
       1174
       +
                           ) || parse_systemd_bool(

     

       1175
       1175
       +
                               Some(&new_unit_info),

     

       1176
       1176
       +
                               "Unit",

     

       1177
       1177
       +
                               "X-OnlyManualStart",

     

       1178
       1178
       +
                               false,

     

       1179
       1179
       +
                           )) {

     

       1180
       1180
       +
                               units_to_start.insert(unit.to_string(), ());

     

       1181
       1181
       +
                               record_unit(START_LIST_FILE, unit);

     

       1182
       1182
       +
                               // Don't spam the user with target units that always get started.

     

       1183
       1183
       +
                               if std::env::var("STC_DISPLAY_ALL_UNITS").as_deref() != Ok("1") {

     

       1184
       1184
       +
                                   units_to_filter.insert(unit.to_string(), ());

     

       1185
       1185
       +
                               }

     

       1186
       1186
       +
                           }

     

       1187
       1187
       +
                       }

     

       1188
       1188
       +
       

     

       1189
       1189
       +
                       // Stop targets that have X-StopOnReconfiguration set. This is necessary to respect

     

       1190
       1190
       +
                       // dependency orderings involving targets: if unit X starts after target Y and

     

       1191
       1191
       +
                       // target Y starts after unit Z, then if X and Z have both changed, then X should

     

       1192
       1192
       +
                       // be restarted after Z.  However, if target Y is in the "active" state, X and Z

     

       1193
       1193
       +
                       // will be restarted at the same time because X's dependency on Y is already

     

       1194
       1194
       +
                       // satisfied.  Thus, we need to stop Y first. Stopping a target generally has no

     

       1195
       1195
       +
                       // effect on other units (unless there is a PartOf dependency), so this is just a

     

       1196
       1196
       +
                       // bookkeeping thing to get systemd to do the right thing.

     

       1197
       1197
       +
                       if parse_systemd_bool(

     

       1198
       1198
       +
                           Some(&new_unit_info),

     

       1199
       1199
       +
                           "Unit",

     

       1200
       1200
       +
                           "X-StopOnReconfiguration",

     

       1201
       1201
       +
                           false,

     

       1202
       1202
       +
                       ) {

     

       1203
       1203
       +
                           units_to_stop.insert(unit.to_string(), ());

     

       1204
       1204
       +
                       }

     

       1205
       1205
       +
                   } else {

     

       1206
       1206
       +
                       let current_unit_info = parse_unit(&current_unit_file, &current_base_unit_file)?;

     

       1207
       1207
       +
                       let new_unit_info = parse_unit(&new_unit_file, &new_base_unit_file)?;

     

       1208
       1208
       +
                       match compare_units(&current_unit_info, &new_unit_info) {

     

       1209
       1209
       +
                           UnitComparison::UnequalNeedsRestart => {

     

       1210
       1210
       +
                               handle_modified_unit(

     

       1211
       1211
       +
                                   &toplevel,

     

       1212
       1212
       +
                                   &unit,

     

       1213
       1213
       +
                                   base_name,

     

       1214
       1214
       +
                                   &new_unit_file,

     

       1215
       1215
       +
                                   &new_base_unit_file,

     

       1216
       1216
       +
                                   Some(&new_unit_info),

     

       1217
       1217
       +
                                   &current_active_units,

     

       1218
       1218
       +
                                   &mut units_to_stop,

     

       1219
       1219
       +
                                   &mut units_to_start,

     

       1220
       1220
       +
                                   &mut units_to_reload,

     

       1221
       1221
       +
                                   &mut units_to_restart,

     

       1222
       1222
       +
                                   &mut units_to_skip,

     

       1223
       1223
       +
                               )?;

     

       1224
       1224
       +
                           }

     

       1225
       1225
       +
                           UnitComparison::UnequalNeedsReload if !units_to_restart.contains_key(unit) => {

     

       1226
       1226
       +
                               units_to_reload.insert(unit.clone(), ());

     

       1227
       1227
       +
                               record_unit(RELOAD_LIST_FILE, &unit);

     

       1228
       1228
       +
                           }

     

       1229
       1229
       +
                           _ => {}

     

       1230
       1230
       +
                       }

     

       1231
       1231
       +
                   }

     

       1232
       1232
       +
               }

     

       1233
       1233
       +
           }

     

       1234
       1234
       +
       

     

       1235
       1235
       +
           // Compare the previous and new fstab to figure out which filesystems need a remount or need to

     

       1236
       1236
       +
           // be unmounted. New filesystems are mounted automatically by starting local-fs.target.

     

       1237
       1237
       +
           // FIXME: might be nicer if we generated units for all mounts; then we could unify this with

     

       1238
       1238
       +
           // the unit checking code above.

     

       1239
       1239
       +
           let (current_filesystems, current_swaps) = std::fs::read_to_string("/etc/fstab")

     

       1240
       1240
       +
               .map(|fstab| parse_fstab(std::io::Cursor::new(fstab)))

     

       1241
       1241
       +
               .unwrap_or_default();

     

       1242
       1242
       +
           let (new_filesystems, new_swaps) = std::fs::read_to_string(toplevel.join("etc/fstab"))

     

       1243
       1243
       +
               .map(|fstab| parse_fstab(std::io::Cursor::new(fstab)))

     

       1244
       1244
       +
               .unwrap_or_default();

     

       1245
       1245
       +
       

     

       1246
       1246
       +
           for (mountpoint, current_filesystem) in current_filesystems {

     

       1247
       1247
       +
               // Use current version of systemctl binary before daemon is reexeced.

     

       1248
       1248
       +
               let unit = path_to_unit_name(&current_system_bin, &mountpoint);

     

       1249
       1249
       +
               if let Some(new_filesystem) = new_filesystems.get(&mountpoint) {

     

       1250
       1250
       +
                   if current_filesystem.fs_type != new_filesystem.fs_type

     

       1251
       1251
       +
                       || current_filesystem.device != new_filesystem.device

     

       1252
       1252
       +
                   {

     

       1253
       1253
       +
                       if matches!(mountpoint.as_str(), "/" | "/nix") {

     

       1254
       1254
       +
                           if current_filesystem.options != new_filesystem.options {

     

       1255
       1255
       +
                               // Mount options changes, so remount it.

     

       1256
       1256
       +
                               units_to_reload.insert(unit.to_string(), ());

     

       1257
       1257
       +
                               record_unit(RELOAD_LIST_FILE, &unit)

     

       1258
       1258
       +
                           } else {

     

       1259
       1259
       +
                               // Don't unmount / or /nix if the device changed

     

       1260
       1260
       +
                               units_to_skip.insert(unit, ());

     

       1261
       1261
       +
                           }

     

       1262
       1262
       +
                       } else {

     

       1263
       1263
       +
                           // Filesystem type or device changed, so unmount and mount it.

     

       1264
       1264
       +
                           units_to_restart.insert(unit.to_string(), ());

     

       1265
       1265
       +
                           record_unit(RESTART_LIST_FILE, &unit);

     

       1266
       1266
       +
                       }

     

       1267
       1267
       +
                   } else if current_filesystem.options != new_filesystem.options {

     

       1268
       1268
       +
                       // Mount options changes, so remount it.

     

       1269
       1269
       +
                       units_to_reload.insert(unit.to_string(), ());

     

       1270
       1270
       +
                       record_unit(RELOAD_LIST_FILE, &unit)

     

       1271
       1271
       +
                   }

     

       1272
       1272
       +
               } else {

     

       1273
       1273
       +
                   // Filesystem entry disappeared, so unmount it.

     

       1274
       1274
       +
                   units_to_stop.insert(unit, ());

     

       1275
       1275
       +
               }

     

       1276
       1276
       +
           }

     

       1277
       1277
       +
       

     

       1278
       1278
       +
           // Also handles swap devices.

     

       1279
       1279
       +
           for (device, _) in current_swaps {

     

       1280
       1280
       +
               if new_swaps.get(&device).is_none() {

     

       1281
       1281
       +
                   // Swap entry disappeared, so turn it off.  Can't use "systemctl stop" here because

     

       1282
       1282
       +
                   // systemd has lots of alias units that prevent a stop from actually calling "swapoff".

     

       1283
       1283
       +
                   if *action == Action::DryActivate {

     

       1284
       1284
       +
                       eprintln!("would stop swap device: {}", &device);

     

       1285
       1285
       +
                   } else {

     

       1286
       1286
       +
                       eprintln!("stopping swap device: {}", &device);

     

       1287
       1287
       +
                       let c_device = std::ffi::CString::new(device.clone())

     

       1288
       1288
       +
                           .context("failed to convert device to cstring")?;

     

       1289
       1289
       +
                       if unsafe { nix::libc::swapoff(c_device.as_ptr()) } != 0 {

     

       1290
       1290
       +
                           let err = std::io::Error::last_os_error();

     

       1291
       1291
       +
                           eprintln!("Failed to stop swapping to {device}: {err}");

     

       1292
       1292
       +
                       }

     

       1293
       1293
       +
                   }

     

       1294
       1294
       +
               }

     

       1295
       1295
       +
               // FIXME: update swap options (i.e. its priority).

     

       1296
       1296
       +
           }

     

       1297
       1297
       +
       

     

       1298
       1298
       +
           // Should we have systemd re-exec itself?

     

       1299
       1299
       +
           let current_pid1_path = Path::new("/proc/1/exe")

     

       1300
       1300
       +
               .canonicalize()

     

       1301
       1301
       +
               .unwrap_or_else(|_| PathBuf::from("/unknown"));

     

       1302
       1302
       +
           let current_systemd_system_config = Path::new("/etc/systemd/system.conf")

     

       1303
       1303
       +
               .canonicalize()

     

       1304
       1304
       +
               .unwrap_or_else(|_| PathBuf::from("/unknown"));

     

       1305
       1305
       +
           let Ok(new_pid1_path) = new_systemd.join("lib/systemd/systemd").canonicalize() else {

     

       1306
       1306
       +
               die();

     

       1307
       1307
       +
           };

     

       1308
       1308
       +
           let new_systemd_system_config = toplevel

     

       1309
       1309
       +
               .join("etc/systemd/system.conf")

     

       1310
       1310
       +
               .canonicalize()

     

       1311
       1311
       +
               .unwrap_or_else(|_| PathBuf::from("/unknown"));

     

       1312
       1312
       +
       

     

       1313
       1313
       +
           let restart_systemd = current_pid1_path != new_pid1_path

     

       1314
       1314
       +
               || current_systemd_system_config != new_systemd_system_config;

     

       1315
       1315
       +
       

     

       1316
       1316
       +
           let units_to_stop_filtered = filter_units(&units_to_filter, &units_to_stop);

     

       1317
       1317
       +
       

     

       1318
       1318
       +
           // Show dry-run actions.

     

       1319
       1319
       +
           if *action == Action::DryActivate {

     

       1320
       1320
       +
               if !units_to_stop_filtered.is_empty() {

     

       1321
       1321
       +
                   let mut units = units_to_stop_filtered

     

       1322
       1322
       +
                       .keys()

     

       1323
       1323
       +
                       .into_iter()

     

       1324
       1324
       +
                       .map(String::as_str)

     

       1325
       1325
       +
                       .collect::<Vec<&str>>();

     

       1326
       1326
       +
                   units.sort_by_key(|name| name.to_lowercase());

     

       1327
       1327
       +
                   eprintln!("would stop the following units: {}", units.join(", "));

     

       1328
       1328
       +
               }

     

       1329
       1329
       +
       

     

       1330
       1330
       +
               if !units_to_skip.is_empty() {

     

       1331
       1331
       +
                   let mut units = units_to_skip

     

       1332
       1332
       +
                       .keys()

     

       1333
       1333
       +
                       .into_iter()

     

       1334
       1334
       +
                       .map(String::as_str)

     

       1335
       1335
       +
                       .collect::<Vec<&str>>();

     

       1336
       1336
       +
                   units.sort_by_key(|name| name.to_lowercase());

     

       1337
       1337
       +
                   eprintln!(

     

       1338
       1338
       +
                       "would NOT stop the following changed units: {}",

     

       1339
       1339
       +
                       units.join(", ")

     

       1340
       1340
       +
                   );

     

       1341
       1341
       +
               }

     

       1342
       1342
       +
       

     

       1343
       1343
       +
               eprintln!("would activate the configuration...");

     

       1344
       1344
       +
               _ = std::process::Command::new(out.join("dry-activate"))

     

       1345
       1345
       +
                   .arg(&out)

     

       1346
       1346
       +
                   .spawn()

     

       1347
       1347
       +
                   .map(|mut child| child.wait());

     

       1348
       1348
       +
       

     

       1349
       1349
       +
               // Handle the activation script requesting the restart or reload of a unit.

     

       1350
       1350
       +
               for unit in std::fs::read_to_string(DRY_RESTART_BY_ACTIVATION_LIST_FILE)

     

       1351
       1351
       +
                   .unwrap_or_default()

     

       1352
       1352
       +
                   .lines()

     

       1353
       1353
       +
               {

     

       1354
       1354
       +
                   let current_unit_file = Path::new("/etc/systemd/system").join(unit);

     

       1355
       1355
       +
                   let new_unit_file = toplevel.join("etc/systemd/system").join(unit);

     

       1356
       1356
       +
                   let mut base_unit = unit.to_string();

     

       1357
       1357
       +
                   let mut new_base_unit_file = new_unit_file.clone();

     

       1358
       1358
       +
       

     

       1359
       1359
       +
                   // Detect template instances.

     

       1360
       1360
       +
                   if let Some((Some(template_name), Some(template_instance))) =

     

       1361
       1361
       +
                       template_unit_re.captures(&unit).map(|captures| {

     

       1362
       1362
       +
                           (

     

       1363
       1363
       +
                               captures.get(1).map(|c| c.as_str()),

     

       1364
       1364
       +
                               captures.get(2).map(|c| c.as_str()),

     

       1365
       1365
       +
                           )

     

       1366
       1366
       +
                       })

     

       1367
       1367
       +
                   {

     

       1368
       1368
       +
                       if !current_unit_file.exists() && !new_unit_file.exists() {

     

       1369
       1369
       +
                           base_unit = format!("{}@.{}", template_name, template_instance);

     

       1370
       1370
       +
                           new_base_unit_file = toplevel.join("etc/systemd/system").join(&base_unit);

     

       1371
       1371
       +
                       }

     

       1372
       1372
       +
                   }

     

       1373
       1373
       +
       

     

       1374
       1374
       +
                   let mut base_name = base_unit.as_str();

     

       1375
       1375
       +
                   if let Some(Some(new_base_name)) = unit_name_re

     

       1376
       1376
       +
                       .captures(&base_unit)

     

       1377
       1377
       +
                       .map(|capture| capture.get(1).map(|first| first.as_str()))

     

       1378
       1378
       +
                   {

     

       1379
       1379
       +
                       base_name = new_base_name;

     

       1380
       1380
       +
                   }

     

       1381
       1381
       +
       

     

       1382
       1382
       +
                   // Start units if they were not active previously

     

       1383
       1383
       +
                   if !current_active_units.contains_key(unit) {

     

       1384
       1384
       +
                       units_to_start.insert(unit.to_string(), ());

     

       1385
       1385
       +
                       continue;

     

       1386
       1386
       +
                   }

     

       1387
       1387
       +
       

     

       1388
       1388
       +
                   handle_modified_unit(

     

       1389
       1389
       +
                       &toplevel,

     

       1390
       1390
       +
                       unit,

     

       1391
       1391
       +
                       base_name,

     

       1392
       1392
       +
                       &new_unit_file,

     

       1393
       1393
       +
                       &new_base_unit_file,

     

       1394
       1394
       +
                       None,

     

       1395
       1395
       +
                       &current_active_units,

     

       1396
       1396
       +
                       &mut units_to_stop,

     

       1397
       1397
       +
                       &mut units_to_start,

     

       1398
       1398
       +
                       &mut units_to_reload,

     

       1399
       1399
       +
                       &mut units_to_restart,

     

       1400
       1400
       +
                       &mut units_to_skip,

     

       1401
       1401
       +
                   )?;

     

       1402
       1402
       +
               }

     

       1403
       1403
       +
       

     

       1404
       1404
       +
               remove_file_if_exists(DRY_RESTART_BY_ACTIVATION_LIST_FILE)

     

       1405
       1405
       +
                   .with_context(|| format!("Failed to remove {}", DRY_RESTART_BY_ACTIVATION_LIST_FILE))?;

     

       1406
       1406
       +
       

     

       1407
       1407
       +
               for unit in std::fs::read_to_string(DRY_RELOAD_BY_ACTIVATION_LIST_FILE)

     

       1408
       1408
       +
                   .unwrap_or_default()

     

       1409
       1409
       +
                   .lines()

     

       1410
       1410
       +
               {

     

       1411
       1411
       +
                   if current_active_units.contains_key(unit)

     

       1412
       1412
       +
                       && !units_to_restart.contains_key(unit)

     

       1413
       1413
       +
                       && !units_to_stop.contains_key(unit)

     

       1414
       1414
       +
                   {

     

       1415
       1415
       +
                       units_to_reload.insert(unit.to_string(), ());

     

       1416
       1416
       +
                       record_unit(RELOAD_LIST_FILE, unit);

     

       1417
       1417
       +
                   }

     

       1418
       1418
       +
               }

     

       1419
       1419
       +
       

     

       1420
       1420
       +
               remove_file_if_exists(DRY_RELOAD_BY_ACTIVATION_LIST_FILE)

     

       1421
       1421
       +
                   .with_context(|| format!("Failed to remove {}", DRY_RELOAD_BY_ACTIVATION_LIST_FILE))?;

     

       1422
       1422
       +
       

     

       1423
       1423
       +
               if restart_systemd {

     

       1424
       1424
       +
                   eprintln!("would restart systemd");

     

       1425
       1425
       +
               }

     

       1426
       1426
       +
       

     

       1427
       1427
       +
               if !units_to_reload.is_empty() {

     

       1428
       1428
       +
                   let mut units = units_to_reload

     

       1429
       1429
       +
                       .keys()

     

       1430
       1430
       +
                       .into_iter()

     

       1431
       1431
       +
                       .map(String::as_str)

     

       1432
       1432
       +
                       .collect::<Vec<&str>>();

     

       1433
       1433
       +
                   units.sort_by_key(|name| name.to_lowercase());

     

       1434
       1434
       +
                   eprintln!("would reload the following units: {}", units.join(", "));

     

       1435
       1435
       +
               }

     

       1436
       1436
       +
       

     

       1437
       1437
       +
               if !units_to_restart.is_empty() {

     

       1438
       1438
       +
                   let mut units = units_to_restart

     

       1439
       1439
       +
                       .keys()

     

       1440
       1440
       +
                       .into_iter()

     

       1441
       1441
       +
                       .map(String::as_str)

     

       1442
       1442
       +
                       .collect::<Vec<&str>>();

     

       1443
       1443
       +
                   units.sort_by_key(|name| name.to_lowercase());

     

       1444
       1444
       +
                   eprintln!("would restart the following units: {}", units.join(", "));

     

       1445
       1445
       +
               }

     

       1446
       1446
       +
       

     

       1447
       1447
       +
               let units_to_start_filtered = filter_units(&units_to_filter, &units_to_start);

     

       1448
       1448
       +
               if !units_to_start_filtered.is_empty() {

     

       1449
       1449
       +
                   let mut units = units_to_start_filtered

     

       1450
       1450
       +
                       .keys()

     

       1451
       1451
       +
                       .into_iter()

     

       1452
       1452
       +
                       .map(String::as_str)

     

       1453
       1453
       +
                       .collect::<Vec<&str>>();

     

       1454
       1454
       +
                   units.sort_by_key(|name| name.to_lowercase());

     

       1455
       1455
       +
                   eprintln!("would start the following units: {}", units.join(", "));

     

       1456
       1456
       +
               }

     

       1457
       1457
       +
       

     

       1458
       1458
       +
               std::process::exit(0);

     

       1459
       1459
       +
           }

     

       1460
       1460
       +
       

     

       1461
       1461
       +
           log::info!("switching to system configuration {}", toplevel.display());

     

       1462
       1462
       +
       

     

       1463
       1463
       +
           if !units_to_stop.is_empty() {

     

       1464
       1464
       +
               if !units_to_stop_filtered.is_empty() {

     

       1465
       1465
       +
                   let mut units = units_to_stop_filtered

     

       1466
       1466
       +
                       .keys()

     

       1467
       1467
       +
                       .into_iter()

     

       1468
       1468
       +
                       .map(String::as_str)

     

       1469
       1469
       +
                       .collect::<Vec<&str>>();

     

       1470
       1470
       +
                   units.sort_by_key(|name| name.to_lowercase());

     

       1471
       1471
       +
                   eprintln!("stopping the following units: {}", units.join(", "));

     

       1472
       1472
       +
               }

     

       1473
       1473
       +
       

     

       1474
       1474
       +
               for unit in units_to_stop.keys() {

     

       1475
       1475
       +
                   match systemd.stop_unit(unit, "replace") {

     

       1476
       1476
       +
                       Ok(job_path) => {

     

       1477
       1477
       +
                           let mut j = submitted_jobs.borrow_mut();

     

       1478
       1478
       +
                           j.insert(job_path.to_owned(), Job::Stop);

     

       1479
       1479
       +
                       }

     

       1480
       1480
       +
                       Err(_) => {}

     

       1481
       1481
       +
                   };

     

       1482
       1482
       +
               }

     

       1483
       1483
       +
       

     

       1484
       1484
       +
               block_on_jobs(&dbus_conn, &submitted_jobs);

     

       1485
       1485
       +
           }

     

       1486
       1486
       +
       

     

       1487
       1487
       +
           if !units_to_skip.is_empty() {

     

       1488
       1488
       +
               let mut units = units_to_skip

     

       1489
       1489
       +
                   .keys()

     

       1490
       1490
       +
                   .into_iter()

     

       1491
       1491
       +
                   .map(String::as_str)

     

       1492
       1492
       +
                   .collect::<Vec<&str>>();

     

       1493
       1493
       +
               units.sort_by_key(|name| name.to_lowercase());

     

       1494
       1494
       +
               eprintln!(

     

       1495
       1495
       +
                   "NOT restarting the following changed units: {}",

     

       1496
       1496
       +
                   units.join(", "),

     

       1497
       1497
       +
               );

     

       1498
       1498
       +
           }

     

       1499
       1499
       +
       

     

       1500
       1500
       +
           // Wait for all stop jobs to finish

     

       1501
       1501
       +
           block_on_jobs(&dbus_conn, &submitted_jobs);

     

       1502
       1502
       +
       

     

       1503
       1503
       +
           let mut exit_code = 0;

     

       1504
       1504
       +
       

     

       1505
       1505
       +
           // Activate the new configuration (i.e., update /etc, make accounts, and so on).

     

       1506
       1506
       +
           eprintln!("activating the configuration...");

     

       1507
       1507
       +
           match std::process::Command::new(out.join("activate"))

     

       1508
       1508
       +
               .arg(&out)

     

       1509
       1509
       +
               .spawn()

     

       1510
       1510
       +
               .map(|mut child| child.wait())

     

       1511
       1511
       +
           {

     

       1512
       1512
       +
               Ok(Ok(status)) if status.success() => {}

     

       1513
       1513
       +
               Err(_) => {

     

       1514
       1514
       +
                   // allow toplevel to not have an activation script

     

       1515
       1515
       +
               }

     

       1516
       1516
       +
               _ => {

     

       1517
       1517
       +
                   eprintln!("Failed to run activate script");

     

       1518
       1518
       +
                   exit_code = 2;

     

       1519
       1519
       +
               }

     

       1520
       1520
       +
           }

     

       1521
       1521
       +
       

     

       1522
       1522
       +
           // Handle the activation script requesting the restart or reload of a unit.

     

       1523
       1523
       +
           for unit in std::fs::read_to_string(RESTART_BY_ACTIVATION_LIST_FILE)

     

       1524
       1524
       +
               .unwrap_or_default()

     

       1525
       1525
       +
               .lines()

     

       1526
       1526
       +
           {

     

       1527
       1527
       +
               let new_unit_file = toplevel.join("etc/systemd/system").join(unit);

     

       1528
       1528
       +
               let mut base_unit = unit.to_string();

     

       1529
       1529
       +
               let mut new_base_unit_file = new_unit_file.clone();

     

       1530
       1530
       +
       

     

       1531
       1531
       +
               // Detect template instances.

     

       1532
       1532
       +
               if let Some((Some(template_name), Some(template_instance))) =

     

       1533
       1533
       +
                   template_unit_re.captures(&unit).map(|captures| {

     

       1534
       1534
       +
                       (

     

       1535
       1535
       +
                           captures.get(1).map(|c| c.as_str()),

     

       1536
       1536
       +
                           captures.get(2).map(|c| c.as_str()),

     

       1537
       1537
       +
                       )

     

       1538
       1538
       +
                   })

     

       1539
       1539
       +
               {

     

       1540
       1540
       +
                   if !new_unit_file.exists() {

     

       1541
       1541
       +
                       base_unit = format!("{}@.{}", template_name, template_instance);

     

       1542
       1542
       +
                       new_base_unit_file = toplevel.join("etc/systemd/system").join(&base_unit);

     

       1543
       1543
       +
                   }

     

       1544
       1544
       +
               }

     

       1545
       1545
       +
       

     

       1546
       1546
       +
               let mut base_name = base_unit.as_str();

     

       1547
       1547
       +
               if let Some(Some(new_base_name)) = unit_name_re

     

       1548
       1548
       +
                   .captures(&base_unit)

     

       1549
       1549
       +
                   .map(|capture| capture.get(1).map(|first| first.as_str()))

     

       1550
       1550
       +
               {

     

       1551
       1551
       +
                   base_name = new_base_name;

     

       1552
       1552
       +
               }

     

       1553
       1553
       +
       

     

       1554
       1554
       +
               // Start units if they were not active previously

     

       1555
       1555
       +
               if !current_active_units.contains_key(unit) {

     

       1556
       1556
       +
                   units_to_start.insert(unit.to_string(), ());

     

       1557
       1557
       +
                   record_unit(START_LIST_FILE, unit);

     

       1558
       1558
       +
                   continue;

     

       1559
       1559
       +
               }

     

       1560
       1560
       +
       

     

       1561
       1561
       +
               handle_modified_unit(

     

       1562
       1562
       +
                   &toplevel,

     

       1563
       1563
       +
                   unit,

     

       1564
       1564
       +
                   base_name,

     

       1565
       1565
       +
                   &new_unit_file,

     

       1566
       1566
       +
                   &new_base_unit_file,

     

       1567
       1567
       +
                   None,

     

       1568
       1568
       +
                   &current_active_units,

     

       1569
       1569
       +
                   &mut units_to_stop,

     

       1570
       1570
       +
                   &mut units_to_start,

     

       1571
       1571
       +
                   &mut units_to_reload,

     

       1572
       1572
       +
                   &mut units_to_restart,

     

       1573
       1573
       +
                   &mut units_to_skip,

     

       1574
       1574
       +
               )?;

     

       1575
       1575
       +
           }

     

       1576
       1576
       +
       

     

       1577
       1577
       +
           // We can remove the file now because it has been propagated to the other restart/reload files

     

       1578
       1578
       +
           remove_file_if_exists(RESTART_BY_ACTIVATION_LIST_FILE)

     

       1579
       1579
       +
               .with_context(|| format!("Failed to remove {}", RESTART_BY_ACTIVATION_LIST_FILE))?;

     

       1580
       1580
       +
       

     

       1581
       1581
       +
           for unit in std::fs::read_to_string(RELOAD_BY_ACTIVATION_LIST_FILE)

     

       1582
       1582
       +
               .unwrap_or_default()

     

       1583
       1583
       +
               .lines()

     

       1584
       1584
       +
           {

     

       1585
       1585
       +
               if current_active_units.contains_key(unit)

     

       1586
       1586
       +
                   && !units_to_restart.contains_key(unit)

     

       1587
       1587
       +
                   && !units_to_stop.contains_key(unit)

     

       1588
       1588
       +
               {

     

       1589
       1589
       +
                   units_to_reload.insert(unit.to_string(), ());

     

       1590
       1590
       +
                   record_unit(RELOAD_LIST_FILE, unit);

     

       1591
       1591
       +
               }

     

       1592
       1592
       +
           }

     

       1593
       1593
       +
       

     

       1594
       1594
       +
           // We can remove the file now because it has been propagated to the other reload file

     

       1595
       1595
       +
           remove_file_if_exists(RELOAD_BY_ACTIVATION_LIST_FILE)

     

       1596
       1596
       +
               .with_context(|| format!("Failed to remove {}", RELOAD_BY_ACTIVATION_LIST_FILE))?;

     

       1597
       1597
       +
       

     

       1598
       1598
       +
           // Restart systemd if necessary. Note that this is done using the current version of systemd,

     

       1599
       1599
       +
           // just in case the new one has trouble communicating with the running pid 1.

     

       1600
       1600
       +
           if restart_systemd {

     

       1601
       1601
       +
               eprintln!("restarting systemd...");

     

       1602
       1602
       +
               _ = systemd.reexecute(); // we don't get a dbus reply here

     

       1603
       1603
       +
       

     

       1604
       1604
       +
               while !*systemd_reload_status.borrow() {

     

       1605
       1605
       +
                   _ = dbus_conn

     

       1606
       1606
       +
                       .process(Duration::from_millis(500))

     

       1607
       1607
       +
                       .context("Failed to process dbus messages")?;

     

       1608
       1608
       +
               }

     

       1609
       1609
       +
           }

     

       1610
       1610
       +
       

     

       1611
       1611
       +
           // Forget about previously failed services.

     

       1612
       1612
       +
           systemd

     

       1613
       1613
       +
               .reset_failed()

     

       1614
       1614
       +
               .context("Failed to reset failed units")?;

     

       1615
       1615
       +
       

     

       1616
       1616
       +
           // Make systemd reload its units.

     

       1617
       1617
       +
           _ = systemd.reload(); // we don't get a dbus reply here

     

       1618
       1618
       +
           while !*systemd_reload_status.borrow() {

     

       1619
       1619
       +
               _ = dbus_conn

     

       1620
       1620
       +
                   .process(Duration::from_millis(500))

     

       1621
       1621
       +
                   .context("Failed to process dbus messages")?;

     

       1622
       1622
       +
           }

     

       1623
       1623
       +
       

     

       1624
       1624
       +
           dbus_conn

     

       1625
       1625
       +
               .remove_match(reloading_token)

     

       1626
       1626
       +
               .context("Failed to cleanup systemd Reloading match")?;

     

       1627
       1627
       +
       

     

       1628
       1628
       +
           // Reload user units

     

       1629
       1629
       +
           match logind.list_users() {

     

       1630
       1630
       +
               Err(err) => {

     

       1631
       1631
       +
                   eprintln!("Unable to list users with logind: {err}");

     

       1632
       1632
       +
                   die();

     

       1633
       1633
       +
               }

     

       1634
       1634
       +
               Ok(users) => {

     

       1635
       1635
       +
                   for (uid, name, _) in users {

     

       1636
       1636
       +
                       eprintln!("reloading user units for {}...", name);

     

       1637
       1637
       +
                       let myself = Path::new("/proc/self/exe")

     

       1638
       1638
       +
                           .canonicalize()

     

       1639
       1639
       +
                           .context("Failed to get full path to /proc/self/exe")?;

     

       1640
       1640
       +
       

     

       1641
       1641
       +
                       std::process::Command::new(&myself)

     

       1642
       1642
       +
                           .uid(uid)

     

       1643
       1643
       +
                           .env("XDG_RUNTIME_DIR", format!("/run/user/{}", uid))

     

       1644
       1644
       +
                           .env("__NIXOS_SWITCH_TO_CONFIGURATION_PARENT_EXE", &myself)

     

       1645
       1645
       +
                           .spawn()

     

       1646
       1646
       +
                           .map(|mut child| _ = child.wait())

     

       1647
       1647
       +
                           .with_context(|| format!("Failed to run user activation for {name}"))?;

     

       1648
       1648
       +
                   }

     

       1649
       1649
       +
               }

     

       1650
       1650
       +
           }

     

       1651
       1651
       +
       

     

       1652
       1652
       +
           // Restart sysinit-reactivation.target. This target only exists to restart services ordered

     

       1653
       1653
       +
           // before sysinit.target. We cannot use X-StopOnReconfiguration to restart sysinit.target

     

       1654
       1654
       +
           // because then ALL services of the system would be restarted since all normal services have a

     

       1655
       1655
       +
           // default dependency on sysinit.target. sysinit-reactivation.target ensures that services

     

       1656
       1656
       +
           // ordered BEFORE sysinit.target get re-started in the correct order. Ordering between these

     

       1657
       1657
       +
           // services is respected.

     

       1658
       1658
       +
           eprintln!("restarting {SYSINIT_REACTIVATION_TARGET}");

     

       1659
       1659
       +
           match systemd.restart_unit(SYSINIT_REACTIVATION_TARGET, "replace") {

     

       1660
       1660
       +
               Ok(job_path) => {

     

       1661
       1661
       +
                   let mut jobs = submitted_jobs.borrow_mut();

     

       1662
       1662
       +
                   jobs.insert(job_path, Job::Restart);

     

       1663
       1663
       +
               }

     

       1664
       1664
       +
               Err(err) => {

     

       1665
       1665
       +
                   eprintln!("Failed to restart {SYSINIT_REACTIVATION_TARGET}: {err}");

     

       1666
       1666
       +
                   exit_code = 4;

     

       1667
       1667
       +
               }

     

       1668
       1668
       +
           }

     

       1669
       1669
       +
       

     

       1670
       1670
       +
           // Wait for the restart job of sysinit-reactivation.service to finish

     

       1671
       1671
       +
           block_on_jobs(&dbus_conn, &submitted_jobs);

     

       1672
       1672
       +
       

     

       1673
       1673
       +
           // Before reloading we need to ensure that the units are still active. They may have been

     

       1674
       1674
       +
           // deactivated because one of their requirements got stopped. If they are inactive but should

     

       1675
       1675
       +
           // have been reloaded, the user probably expects them to be started.

     

       1676
       1676
       +
           if !units_to_reload.is_empty() {

     

       1677
       1677
       +
               for (unit, _) in units_to_reload.clone() {

     

       1678
       1678
       +
                   if !unit_is_active(&dbus_conn, &unit)? {

     

       1679
       1679
       +
                       // Figure out if we need to start the unit

     

       1680
       1680
       +
                       let unit_info = parse_unit(

     

       1681
       1681
       +
                           toplevel.join("etc/systemd/system").join(&unit).as_path(),

     

       1682
       1682
       +
                           toplevel.join("etc/systemd/system").join(&unit).as_path(),

     

       1683
       1683
       +
                       )?;

     

       1684
       1684
       +
                       if !parse_systemd_bool(Some(&unit_info), "Unit", "RefuseManualStart", false)

     

       1685
       1685
       +
                           || parse_systemd_bool(Some(&unit_info), "Unit", "X-OnlyManualStart", false)

     

       1686
       1686
       +
                       {

     

       1687
       1687
       +
                           units_to_start.insert(unit.clone(), ());

     

       1688
       1688
       +
                           record_unit(START_LIST_FILE, &unit);

     

       1689
       1689
       +
                       }

     

       1690
       1690
       +
                       // Don't reload the unit, reloading would fail

     

       1691
       1691
       +
                       units_to_reload.remove(&unit);

     

       1692
       1692
       +
                       unrecord_unit(RELOAD_LIST_FILE, &unit);

     

       1693
       1693
       +
                   }

     

       1694
       1694
       +
               }

     

       1695
       1695
       +
           }

     

       1696
       1696
       +
       

     

       1697
       1697
       +
           // Reload units that need it. This includes remounting changed mount units.

     

       1698
       1698
       +
           if !units_to_reload.is_empty() {

     

       1699
       1699
       +
               let mut units = units_to_reload

     

       1700
       1700
       +
                   .keys()

     

       1701
       1701
       +
                   .into_iter()

     

       1702
       1702
       +
                   .map(String::as_str)

     

       1703
       1703
       +
                   .collect::<Vec<&str>>();

     

       1704
       1704
       +
               units.sort_by_key(|name| name.to_lowercase());

     

       1705
       1705
       +
               eprintln!("reloading the following units: {}", units.join(", "));

     

       1706
       1706
       +
       

     

       1707
       1707
       +
               for unit in units {

     

       1708
       1708
       +
                   match systemd.reload_unit(unit, "replace") {

     

       1709
       1709
       +
                       Ok(job_path) => {

     

       1710
       1710
       +
                           submitted_jobs

     

       1711
       1711
       +
                               .borrow_mut()

     

       1712
       1712
       +
                               .insert(job_path.clone(), Job::Reload);

     

       1713
       1713
       +
                       }

     

       1714
       1714
       +
                       Err(err) => {

     

       1715
       1715
       +
                           eprintln!("Failed to reload {unit}: {err}");

     

       1716
       1716
       +
                           exit_code = 4;

     

       1717
       1717
       +
                       }

     

       1718
       1718
       +
                   }

     

       1719
       1719
       +
               }

     

       1720
       1720
       +
       

     

       1721
       1721
       +
               block_on_jobs(&dbus_conn, &submitted_jobs);

     

       1722
       1722
       +
       

     

       1723
       1723
       +
               remove_file_if_exists(RELOAD_LIST_FILE)

     

       1724
       1724
       +
                   .with_context(|| format!("Failed to remove {}", RELOAD_LIST_FILE))?;

     

       1725
       1725
       +
           }

     

       1726
       1726
       +
       

     

       1727
       1727
       +
           // Restart changed services (those that have to be restarted rather than stopped and started).

     

       1728
       1728
       +
           if !units_to_restart.is_empty() {

     

       1729
       1729
       +
               let mut units = units_to_restart

     

       1730
       1730
       +
                   .keys()

     

       1731
       1731
       +
                   .into_iter()

     

       1732
       1732
       +
                   .map(String::as_str)

     

       1733
       1733
       +
                   .collect::<Vec<&str>>();

     

       1734
       1734
       +
               units.sort_by_key(|name| name.to_lowercase());

     

       1735
       1735
       +
               eprintln!("restarting the following units: {}", units.join(", "));

     

       1736
       1736
       +
       

     

       1737
       1737
       +
               for unit in units {

     

       1738
       1738
       +
                   match systemd.restart_unit(unit, "replace") {

     

       1739
       1739
       +
                       Ok(job_path) => {

     

       1740
       1740
       +
                           let mut jobs = submitted_jobs.borrow_mut();

     

       1741
       1741
       +
                           jobs.insert(job_path, Job::Restart);

     

       1742
       1742
       +
                       }

     

       1743
       1743
       +
                       Err(err) => {

     

       1744
       1744
       +
                           eprintln!("Failed to restart {unit}: {err}");

     

       1745
       1745
       +
                           exit_code = 4;

     

       1746
       1746
       +
                       }

     

       1747
       1747
       +
                   }

     

       1748
       1748
       +
               }

     

       1749
       1749
       +
       

     

       1750
       1750
       +
               block_on_jobs(&dbus_conn, &submitted_jobs);

     

       1751
       1751
       +
       

     

       1752
       1752
       +
               remove_file_if_exists(RESTART_LIST_FILE)

     

       1753
       1753
       +
                   .with_context(|| format!("Failed to remove {}", RESTART_LIST_FILE))?;

     

       1754
       1754
       +
           }

     

       1755
       1755
       +
       

     

       1756
       1756
       +
           // Start all active targets, as well as changed units we stopped above. The latter is necessary

     

       1757
       1757
       +
           // because some may not be dependencies of the targets (i.e., they were manually started).

     

       1758
       1758
       +
           // FIXME: detect units that are symlinks to other units.  We shouldn't start both at the same

     

       1759
       1759
       +
           // time because we'll get a "Failed to add path to set" error from systemd.

     

       1760
       1760
       +
           let units_to_start_filtered = filter_units(&units_to_filter, &units_to_start);

     

       1761
       1761
       +
           if !units_to_start_filtered.is_empty() {

     

       1762
       1762
       +
               let mut units = units_to_start_filtered

     

       1763
       1763
       +
                   .keys()

     

       1764
       1764
       +
                   .into_iter()

     

       1765
       1765
       +
                   .map(String::as_str)

     

       1766
       1766
       +
                   .collect::<Vec<&str>>();

     

       1767
       1767
       +
               units.sort_by_key(|name| name.to_lowercase());

     

       1768
       1768
       +
               eprintln!("starting the following units: {}", units.join(", "));

     

       1769
       1769
       +
           }

     

       1770
       1770
       +
       

     

       1771
       1771
       +
           for unit in units_to_start.keys() {

     

       1772
       1772
       +
               match systemd.start_unit(unit, "replace") {

     

       1773
       1773
       +
                   Ok(job_path) => {

     

       1774
       1774
       +
                       let mut jobs = submitted_jobs.borrow_mut();

     

       1775
       1775
       +
                       jobs.insert(job_path, Job::Start);

     

       1776
       1776
       +
                   }

     

       1777
       1777
       +
                   Err(err) => {

     

       1778
       1778
       +
                       eprintln!("Failed to start {unit}: {err}");

     

       1779
       1779
       +
                       exit_code = 4;

     

       1780
       1780
       +
                   }

     

       1781
       1781
       +
               }

     

       1782
       1782
       +
           }

     

       1783
       1783
       +
       

     

       1784
       1784
       +
           block_on_jobs(&dbus_conn, &submitted_jobs);

     

       1785
       1785
       +
       

     

       1786
       1786
       +
           remove_file_if_exists(START_LIST_FILE)

     

       1787
       1787
       +
               .with_context(|| format!("Failed to remove {}", START_LIST_FILE))?;

     

       1788
       1788
       +
       

     

       1789
       1789
       +
           for (unit, job, result) in finished_jobs.borrow().values() {

     

       1790
       1790
       +
               match result.as_str() {

     

       1791
       1791
       +
                   "timeout" | "failed" | "dependency" => {

     

       1792
       1792
       +
                       eprintln!("Failed to {} {}", job, unit);

     

       1793
       1793
       +
                       exit_code = 4;

     

       1794
       1794
       +
                   }

     

       1795
       1795
       +
                   _ => {}

     

       1796
       1796
       +
               }

     

       1797
       1797
       +
           }

     

       1798
       1798
       +
       

     

       1799
       1799
       +
           dbus_conn

     

       1800
       1800
       +
               .remove_match(job_removed_token)

     

       1801
       1801
       +
               .context("Failed to cleanup systemd job match")?;

     

       1802
       1802
       +
       

     

       1803
       1803
       +
           // Print failed and new units.

     

       1804
       1804
       +
           let mut failed_units = Vec::new();

     

       1805
       1805
       +
           let mut new_units = Vec::new();

     

       1806
       1806
       +
       

     

       1807
       1807
       +
           // NOTE: We want switch-to-configuration to be able to report to the user any units that failed

     

       1808
       1808
       +
           // to start or units that systemd had to restart due to having previously failed. This is

     

       1809
       1809
       +
           // inherently a race condition between how long our program takes to run and how long the unit

     

       1810
       1810
       +
           // in question takes to potentially fail. The amount of time we wait for new messages on the

     

       1811
       1811
       +
           // bus to settle is purely tuned so that this program is compatible with the Perl

     

       1812
       1812
       +
           // implementation.

     

       1813
       1813
       +
           //

     

       1814
       1814
       +
           // Wait for events from systemd to settle. process() will return true if we have received any

     

       1815
       1815
       +
           // messages on the bus.

     

       1816
       1816
       +
           while dbus_conn

     

       1817
       1817
       +
               .process(Duration::from_millis(250))

     

       1818
       1818
       +
               .unwrap_or_default()

     

       1819
       1819
       +
           {}

     

       1820
       1820
       +
       

     

       1821
       1821
       +
           let new_active_units = get_active_units(&systemd)?;

     

       1822
       1822
       +
       

     

       1823
       1823
       +
           for (unit, unit_state) in new_active_units {

     

       1824
       1824
       +
               if &unit_state.state == "failed" {

     

       1825
       1825
       +
                   failed_units.push(unit);

     

       1826
       1826
       +
                   continue;

     

       1827
       1827
       +
               }

     

       1828
       1828
       +
       

     

       1829
       1829
       +
               if unit_state.substate == "auto-restart" && unit.ends_with(".service") {

     

       1830
       1830
       +
                   // A unit in auto-restart substate is a failure *if* it previously failed to start

     

       1831
       1831
       +
                   let unit_object_path = systemd

     

       1832
       1832
       +
                       .get_unit(&unit)

     

       1833
       1833
       +
                       .context("Failed to get unit info for {unit}")?;

     

       1834
       1834
       +
                   let exec_main_status: i32 = dbus_conn

     

       1835
       1835
       +
                       .with_proxy(

     

       1836
       1836
       +
                           "org.freedesktop.systemd1",

     

       1837
       1837
       +
                           unit_object_path,

     

       1838
       1838
       +
                           Duration::from_millis(5000),

     

       1839
       1839
       +
                       )

     

       1840
       1840
       +
                       .get("org.freedesktop.systemd1.Service", "ExecMainStatus")

     

       1841
       1841
       +
                       .context("Failed to get ExecMainStatus for {unit}")?;

     

       1842
       1842
       +
       

     

       1843
       1843
       +
                   if exec_main_status != 0 {

     

       1844
       1844
       +
                       failed_units.push(unit);

     

       1845
       1845
       +
                       continue;

     

       1846
       1846
       +
                   }

     

       1847
       1847
       +
               }

     

       1848
       1848
       +
       

     

       1849
       1849
       +
               // Ignore scopes since they are not managed by this script but rather created and managed

     

       1850
       1850
       +
               // by third-party services via the systemd dbus API. This only lists units that are not

     

       1851
       1851
       +
               // failed (including ones that are in auto-restart but have not failed previously)

     

       1852
       1852
       +
               if unit_state.state != "failed"

     

       1853
       1853
       +
                   && !current_active_units.contains_key(&unit)

     

       1854
       1854
       +
                   && !unit.ends_with(".scope")

     

       1855
       1855
       +
               {

     

       1856
       1856
       +
                   new_units.push(unit);

     

       1857
       1857
       +
               }

     

       1858
       1858
       +
           }

     

       1859
       1859
       +
       

     

       1860
       1860
       +
           if !new_units.is_empty() {

     

       1861
       1861
       +
               new_units.sort_by_key(|name| name.to_lowercase());

     

       1862
       1862
       +
               eprintln!(

     

       1863
       1863
       +
                   "the following new units were started: {}",

     

       1864
       1864
       +
                   new_units.join(", ")

     

       1865
       1865
       +
               );

     

       1866
       1866
       +
           }

     

       1867
       1867
       +
       

     

       1868
       1868
       +
           if !failed_units.is_empty() {

     

       1869
       1869
       +
               failed_units.sort_by_key(|name| name.to_lowercase());

     

       1870
       1870
       +
               eprintln!(

     

       1871
       1871
       +
                   "warning: the following units failed: {}",

     

       1872
       1872
       +
                   failed_units.join(", ")

     

       1873
       1873
       +
               );

     

       1874
       1874
       +
               _ = std::process::Command::new(new_systemd.join("bin/systemctl"))

     

       1875
       1875
       +
                   .arg("status")

     

       1876
       1876
       +
                   .arg("--no-pager")

     

       1877
       1877
       +
                   .arg("--full")

     

       1878
       1878
       +
                   .args(failed_units)

     

       1879
       1879
       +
                   .spawn()

     

       1880
       1880
       +
                   .map(|mut child| child.wait());

     

       1881
       1881
       +
       

     

       1882
       1882
       +
               exit_code = 4;

     

       1883
       1883
       +
           }

     

       1884
       1884
       +
       

     

       1885
       1885
       +
           if exit_code == 0 {

     

       1886
       1886
       +
               log::info!(

     

       1887
       1887
       +
                   "finished switching to system configuration {}",

     

       1888
       1888
       +
                   toplevel.display()

     

       1889
       1889
       +
               );

     

       1890
       1890
       +
           } else {

     

       1891
       1891
       +
               log::error!(

     

       1892
       1892
       +
                   "switching to system configuration {} failed (status {})",

     

       1893
       1893
       +
                   toplevel.display(),

     

       1894
       1894
       +
                   exit_code

     

       1895
       1895
       +
               );

     

       1896
       1896
       +
           }

     

       1897
       1897
       +
       

     

       1898
       1898
       +
           std::process::exit(exit_code);

     

       1899
       1899
       +
       }

     

       1900
       1900
       +
       

     

       1901
       1901
       +
       fn main() -> anyhow::Result<()> {

     

       1902
       1902
       +
           match (

     

       1903
       1903
       +
               unsafe { nix::libc::geteuid() },

     

       1904
       1904
       +
               std::env::var("__NIXOS_SWITCH_TO_CONFIGURATION_PARENT_EXE").ok(),

     

       1905
       1905
       +
           ) {

     

       1906
       1906
       +
               (0, None) => do_system_switch(),

     

       1907
       1907
       +
               (1..=u32::MAX, None) => bail!("This program does not support being ran outside of the switch-to-configuration environment"),

     

       1908
       1908
       +
               (_, Some(parent_exe)) => do_user_switch(parent_exe),

     

       1909
       1909
       +
           }

     

       1910
       1910
       +
       }

     

       1911
       1911
       +
       

     

       1912
       1912
       +
       #[cfg(test)]

     

       1913
       1913
       +
       mod tests {

     

       1914
       1914
       +
           use std::collections::HashMap;

     

       1915
       1915
       +
       

     

       1916
       1916
       +
           #[test]

     

       1917
       1917
       +
           fn parse_fstab() {

     

       1918
       1918
       +
               {

     

       1919
       1919
       +
                   let (filesystems, swaps) = super::parse_fstab(std::io::Cursor::new(""));

     

       1920
       1920
       +
                   assert!(filesystems.is_empty());

     

       1921
       1921
       +
                   assert!(swaps.is_empty());

     

       1922
       1922
       +
               }

     

       1923
       1923
       +
       

     

       1924
       1924
       +
               {

     

       1925
       1925
       +
                   let (filesystems, swaps) = super::parse_fstab(std::io::Cursor::new(

     

       1926
       1926
       +
                       r#"\

     

       1927
       1927
       +
       invalid

     

       1928
       1928
       +
                           "#,

     

       1929
       1929
       +
                   ));

     

       1930
       1930
       +
                   assert!(filesystems.is_empty());

     

       1931
       1931
       +
                   assert!(swaps.is_empty());

     

       1932
       1932
       +
               }

     

       1933
       1933
       +
       

     

       1934
       1934
       +
               {

     

       1935
       1935
       +
                   let (filesystems, swaps) = super::parse_fstab(std::io::Cursor::new(

     

       1936
       1936
       +
                       r#"\

     

       1937
       1937
       +
       # This is a generated file.  Do not edit!

     

       1938
       1938
       +
       #

     

       1939
       1939
       +
       # To make changes, edit the fileSystems and swapDevices NixOS options

     

       1940
       1940
       +
       # in your /etc/nixos/configuration.nix file.

     

       1941
       1941
       +
       #

     

       1942
       1942
       +
       # <file system> <mount point>   <type>  <options>       <dump>  <pass>

     

       1943
       1943
       +
       

     

       1944
       1944
       +
       # Filesystems.

     

       1945
       1945
       +
       /dev/mapper/root / btrfs x-initrd.mount,compress=zstd,noatime,defaults 0 0

     

       1946
       1946
       +
       /dev/disk/by-partlabel/BOOT /boot vfat x-systemd.automount 0 2

     

       1947
       1947
       +
       /dev/disk/by-partlabel/home /home ext4 defaults 0 2

     

       1948
       1948
       +
       /dev/mapper/usr /nix/.ro-store erofs x-initrd.mount,ro 0 2

     

       1949
       1949
       +
       

     

       1950
       1950
       +
       

     

       1951
       1951
       +
       # Swap devices.

     

       1952
       1952
       +
                           "#,

     

       1953
       1953
       +
                   ));

     

       1954
       1954
       +
                   assert_eq!(filesystems.len(), 4);

     

       1955
       1955
       +
                   assert_eq!(swaps.len(), 0);

     

       1956
       1956
       +
                   let home_fs = filesystems.get("/home").unwrap();

     

       1957
       1957
       +
                   assert_eq!(home_fs.fs_type, "ext4");

     

       1958
       1958
       +
                   assert_eq!(home_fs.device, "/dev/disk/by-partlabel/home");

     

       1959
       1959
       +
                   assert_eq!(home_fs.options, "defaults");

     

       1960
       1960
       +
               }

     

       1961
       1961
       +
           }

     

       1962
       1962
       +
       

     

       1963
       1963
       +
           #[test]

     

       1964
       1964
       +
           fn filter_units() {

     

       1965
       1965
       +
               assert_eq!(

     

       1966
       1966
       +
                   super::filter_units(&HashMap::from([]), &HashMap::from([])),

     

       1967
       1967
       +
                   HashMap::from([])

     

       1968
       1968
       +
               );

     

       1969
       1969
       +
       

     

       1970
       1970
       +
               assert_eq!(

     

       1971
       1971
       +
                   super::filter_units(

     

       1972
       1972
       +
                       &HashMap::from([("foo".to_string(), ())]),

     

       1973
       1973
       +
                       &HashMap::from([("foo".to_string(), ()), ("bar".to_string(), ())])

     

       1974
       1974
       +
                   ),

     

       1975
       1975
       +
                   HashMap::from([("bar".to_string(), ())])

     

       1976
       1976
       +
               );

     

       1977
       1977
       +
           }

     

       1978
       1978
       +
       

     

       1979
       1979
       +
           #[test]

     

       1980
       1980
       +
           fn compare_units() {

     

       1981
       1981
       +
               {

     

       1982
       1982
       +
                   assert!(

     

       1983
       1983
       +
                       super::compare_units(&HashMap::from([]), &HashMap::from([]))

     

       1984
       1984
       +
                           == super::UnitComparison::Equal

     

       1985
       1985
       +
                   );

     

       1986
       1986
       +
       

     

       1987
       1987
       +
                   assert!(

     

       1988
       1988
       +
                       super::compare_units(

     

       1989
       1989
       +
                           &HashMap::from([("Unit".to_string(), HashMap::from([]))]),

     

       1990
       1990
       +
                           &HashMap::from([])

     

       1991
       1991
       +
                       ) == super::UnitComparison::Equal

     

       1992
       1992
       +
                   );

     

       1993
       1993
       +
       

     

       1994
       1994
       +
                   assert!(

     

       1995
       1995
       +
                       super::compare_units(

     

       1996
       1996
       +
                           &HashMap::from([(

     

       1997
       1997
       +
                               "Unit".to_string(),

     

       1998
       1998
       +
                               HashMap::from([(

     

       1999
       1999
       +
                                   "X-Reload-Triggers".to_string(),

     

       2000
       2000
       +
                                   vec!["foobar".to_string()]

     

       2001
       2001
       +
                               )])

     

       2002
       2002
       +
                           )]),

     

       2003
       2003
       +
                           &HashMap::from([])

     

       2004
       2004
       +
                       ) == super::UnitComparison::Equal

     

       2005
       2005
       +
                   );

     

       2006
       2006
       +
               }

     

       2007
       2007
       +
       

     

       2008
       2008
       +
               {

     

       2009
       2009
       +
                   assert!(

     

       2010
       2010
       +
                       super::compare_units(

     

       2011
       2011
       +
                           &HashMap::from([("foobar".to_string(), HashMap::from([]))]),

     

       2012
       2012
       +
                           &HashMap::from([])

     

       2013
       2013
       +
                       ) == super::UnitComparison::UnequalNeedsRestart

     

       2014
       2014
       +
                   );

     

       2015
       2015
       +
       

     

       2016
       2016
       +
                   assert!(

     

       2017
       2017
       +
                       super::compare_units(

     

       2018
       2018
       +
                           &HashMap::from([(

     

       2019
       2019
       +
                               "Mount".to_string(),

     

       2020
       2020
       +
                               HashMap::from([("Options".to_string(), vec![])])

     

       2021
       2021
       +
                           )]),

     

       2022
       2022
       +
                           &HashMap::from([(

     

       2023
       2023
       +
                               "Mount".to_string(),

     

       2024
       2024
       +
                               HashMap::from([("Options".to_string(), vec!["ro".to_string()])])

     

       2025
       2025
       +
                           )])

     

       2026
       2026
       +
                       ) == super::UnitComparison::UnequalNeedsReload

     

       2027
       2027
       +
                   );

     

       2028
       2028
       +
               }

     

       2029
       2029
       +
       

     

       2030
       2030
       +
               {

     

       2031
       2031
       +
                   assert!(

     

       2032
       2032
       +
                       super::compare_units(

     

       2033
       2033
       +
                           &HashMap::from([]),

     

       2034
       2034
       +
                           &HashMap::from([(

     

       2035
       2035
       +
                               "Unit".to_string(),

     

       2036
       2036
       +
                               HashMap::from([(

     

       2037
       2037
       +
                                   "X-Reload-Triggers".to_string(),

     

       2038
       2038
       +
                                   vec!["foobar".to_string()]

     

       2039
       2039
       +
                               )])

     

       2040
       2040
       +
                           )])

     

       2041
       2041
       +
                       ) == super::UnitComparison::UnequalNeedsReload

     

       2042
       2042
       +
                   );

     

       2043
       2043
       +
       

     

       2044
       2044
       +
                   assert!(

     

       2045
       2045
       +
                       super::compare_units(

     

       2046
       2046
       +
                           &HashMap::from([(

     

       2047
       2047
       +
                               "Unit".to_string(),

     

       2048
       2048
       +
                               HashMap::from([(

     

       2049
       2049
       +
                                   "X-Reload-Triggers".to_string(),

     

       2050
       2050
       +
                                   vec!["foobar".to_string()]

     

       2051
       2051
       +
                               )])

     

       2052
       2052
       +
                           )]),

     

       2053
       2053
       +
                           &HashMap::from([(

     

       2054
       2054
       +
                               "Unit".to_string(),

     

       2055
       2055
       +
                               HashMap::from([(

     

       2056
       2056
       +
                                   "X-Reload-Triggers".to_string(),

     

       2057
       2057
       +
                                   vec!["barfoo".to_string()]

     

       2058
       2058
       +
                               )])

     

       2059
       2059
       +
                           )])

     

       2060
       2060
       +
                       ) == super::UnitComparison::UnequalNeedsReload

     

       2061
       2061
       +
                   );

     

       2062
       2062
       +
       

     

       2063
       2063
       +
                   assert!(

     

       2064
       2064
       +
                       super::compare_units(

     

       2065
       2065
       +
                           &HashMap::from([(

     

       2066
       2066
       +
                               "Mount".to_string(),

     

       2067
       2067
       +
                               HashMap::from([("Type".to_string(), vec!["ext4".to_string()])])

     

       2068
       2068
       +
                           )]),

     

       2069
       2069
       +
                           &HashMap::from([(

     

       2070
       2070
       +
                               "Mount".to_string(),

     

       2071
       2071
       +
                               HashMap::from([("Type".to_string(), vec!["btrfs".to_string()])])

     

       2072
       2072
       +
                           )])

     

       2073
       2073
       +
                       ) == super::UnitComparison::UnequalNeedsRestart

     

       2074
       2074
       +
                   );

     

       2075
       2075
       +
               }

     

       2076
       2076
       +
           }

     

       2077
       2077
       +
       }

+33

pkgs/by-name/tr/treefmt2/package.nix

···

       1
       1
       +
       { lib, buildGoModule, fetchFromGitHub }:

     

       2
       2
       +
       buildGoModule rec {

     

       3
       3
       +
         pname = "treefmt";

     

       4
       4
       +
         version = "2.0.0-rc1";

     

       5
       5
       +
       

     

       6
       6
       +
         src = fetchFromGitHub {

     

       7
       7
       +
           owner = "numtide";

     

       8
       8
       +
           repo = "treefmt";

     

       9
       9
       +
           rev = "v${version}";

     

       10
       10
       +
           hash = "sha256-iRjd7iYd3617XZrGD6Bi6d1SoE8dgATMbT4AMXklfgM=";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         vendorHash = "sha256-xbXy5Csl2JD5/F5mtvh8J36VZqrUIfO3OBV/LE+KzWA=";

     

       14
       14
       +
       

     

       15
       15
       +
         subPackages = [ "." ];

     

       16
       16
       +
       

     

       17
       17
       +
         CGO_ENABLED = 1;

     

       18
       18
       +
       

     

       19
       19
       +
         ldflags = [

     

       20
       20
       +
           "-s"

     

       21
       21
       +
           "-w"

     

       22
       22
       +
           "-X git.numtide.com/numtide/treefmt/build.Name=${pname}"

     

       23
       23
       +
           "-X git.numtide.com/numtide/treefmt/build.Version=v${version}"

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         meta = {

     

       27
       27
       +
           description = "one CLI to format the code tree";

     

       28
       28
       +
           homepage = "https://github.com/numtide/treefmt";

     

       29
       29
       +
           license = lib.licenses.mit;

     

       30
       30
       +
           maintainers = [ lib.maintainers.brianmcgee lib.maintainers.zimbatm ];

     

       31
       31
       +
           mainProgram = "treefmt";

     

       32
       32
       +
         };

     

       33
       33
       +
       }

+49

pkgs/by-name/yd/ydotool/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         cmake,

     

       6
       6
       +
         scdoc,

     

       7
       7
       +
         util-linux,

     

       8
       8
       +
         xorg,

     

       9
       9
       +
         nixosTests,

     

       10
       10
       +
       }:

     

       11
       11
       +
       

     

       12
       12
       +
       stdenv.mkDerivation (finalAttrs: {

     

       13
       13
       +
         pname = "ydotool";

     

       14
       14
       +
         version = "1.0.4";

     

       15
       15
       +
       

     

       16
       16
       +
         src = fetchFromGitHub {

     

       17
       17
       +
           owner = "ReimuNotMoe";

     

       18
       18
       +
           repo = "ydotool";

     

       19
       19
       +
           rev = "v${finalAttrs.version}";

     

       20
       20
       +
           hash = "sha256-MtanR+cxz6FsbNBngqLE+ITKPZFHmWGsD1mBDk0OVng=";

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         postPatch = ''

     

       24
       24
       +
           substituteInPlace Daemon/ydotoold.c \

     

       25
       25
       +
             --replace "/usr/bin/xinput" "${xorg.xinput}/bin/xinput"

     

       26
       26
       +
           substituteInPlace Daemon/ydotool.service.in \

     

       27
       27
       +
             --replace "/usr/bin/kill" "${util-linux}/bin/kill"

     

       28
       28
       +
         '';

     

       29
       29
       +
       

     

       30
       30
       +
         strictDeps = true;

     

       31
       31
       +
         nativeBuildInputs = [

     

       32
       32
       +
           cmake

     

       33
       33
       +
           scdoc

     

       34
       34
       +
         ];

     

       35
       35
       +
       

     

       36
       36
       +
         passthru.tests.basic = nixosTests.ydotool;

     

       37
       37
       +
       

     

       38
       38
       +
         meta = {

     

       39
       39
       +
           description = "Generic Linux command-line automation tool";

     

       40
       40
       +
           homepage = "https://github.com/ReimuNotMoe/ydotool";

     

       41
       41
       +
           license = lib.licenses.agpl3Plus;

     

       42
       42
       +
           mainProgram = "ydotool";

     

       43
       43
       +
           maintainers = with lib.maintainers; [

     

       44
       44
       +
             willibutz

     

       45
       45
       +
             kraem

     

       46
       46
       +
           ];

     

       47
       47
       +
           platforms = lib.platforms.linux;

     

       48
       48
       +
         };

     

       49
       49
       +
       })

+2 -2

pkgs/data/themes/colloid-gtk-theme/default.nix

···

       22
       22
        
       

     

       23
       23
        
       stdenvNoCC.mkDerivation rec {

     

       24
       24
        
         inherit pname;

     

       25
       25
       -
         version = "2024-04-14";

     

       25
       25
       +
         version = "2024-05-13";

     

       26
       26
        
       

     

       27
       27
        
         src = fetchFromGitHub {

     

       28
       28
        
           owner = "vinceliuice";

     

       29
       29
        
           repo = pname;

     

       30
       30
        
           rev = version;

     

       31
       31
       -
           hash = "sha256-DQYnR2V86KbIJfAA4ObRtKQq1IuECie1qdOBYVu8NtA=";

     

       31
       31
       +
           hash = "sha256-24U1iMByy+cFQuLUWYPBSuvJwYzwS0rCr7L6OWyMUz0=";

     

       32
       32
        
         };

     

       33
       33
        
       

     

       34
       34
        
         nativeBuildInputs = [

+2 -2

pkgs/development/libraries/cjson/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "cjson";

     

       5
       5
       -
         version = "1.7.17";

     

       5
       5
       +
         version = "1.7.18";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "DaveGamble";

     

       9
       9
        
           repo = "cJSON";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-jU9UbXvdXiNXFh7c9p/LppMsuqryFK40NTTyQGbNU84=";

     

       11
       11
       +
           sha256 = "sha256-UgUWc/+Zie2QNijxKK5GFe4Ypk97EidG8nTiiHhn5Ys=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ cmake ];

+2 -2

pkgs/development/libraries/science/math/openspecfun/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "openspecfun";

     

       5
       5
       -
         version = "0.5.6";

     

       5
       5
       +
         version = "0.5.7";

     

       6
       6
        
         src = fetchFromGitHub {

     

       7
       7
        
           owner = "JuliaLang";

     

       8
       8
        
           repo = "openspecfun";

     

       9
       9
        
           rev = "v${version}";

     

       10
       10
       -
           sha256 = "sha256-4MPoRMtDTkdvDfhNXKk/80pZjXRNEPcysLNTb5ohxWk=";

     

       10
       10
       +
           sha256 = "sha256-fx9z6bbU2V4x6Pr7/vmlSxkWxZ6qTYuPxnfqKLv08CA=";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         makeFlags = [ "prefix=$(out)" ];

+2 -2

pkgs/development/python-modules/aiounifi/default.nix

···

       16
       16
        
       

     

       17
       17
        
       buildPythonPackage rec {

     

       18
       18
        
         pname = "aiounifi";

     

       19
       19
       -
         version = "77";

     

       19
       19
       +
         version = "78";

     

       20
       20
        
         pyproject = true;

     

       21
       21
        
       

     

       22
       22
        
         disabled = pythonOlder "3.11";

     
···

       25
       25
        
           owner = "Kane610";

     

       26
       26
        
           repo = "aiounifi";

     

       27
       27
        
           rev = "refs/tags/v${version}";

     

       28
       28
       -
           hash = "sha256-c3UR/AwnQLm6h1jsM6mk6MOii2/xQzFcrci+oG4BsDs=";

     

       28
       28
       +
           hash = "sha256-fY3VsXJfs/uqqQjR6Sp03XlkCOk+8GvXq476dgagJQ8=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         postPatch = ''

+16 -19

pkgs/development/python-modules/androidtvremote2/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , aiofiles

     

       3
       3
       -
       , buildPythonPackage

     

       4
       4
       -
       , cryptography

     

       5
       5
       -
       , fetchFromGitHub

     

       6
       6
       -
       , protobuf

     

       7
       7
       -
       , pythonOlder

     

       8
       8
       -
       , setuptools

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         aiofiles,

     

       4
       4
       +
         buildPythonPackage,

     

       5
       5
       +
         cryptography,

     

       6
       6
       +
         fetchFromGitHub,

     

       7
       7
       +
         protobuf,

     

       8
       8
       +
         pythonOlder,

     

       9
       9
       +
         setuptools,

     

       9
       10
        
       }:

     

       10
       11
        
       

     

       11
       12
        
       buildPythonPackage rec {

     

       12
       13
        
         pname = "androidtvremote2";

     

       13
       13
       -
         version = "0.0.15";

     

       14
       14
       -
         format = "pyproject";

     

       14
       14
       +
         version = "0.1.1";

     

       15
       15
       +
         pyproject = true;

     

       15
       16
        
       

     

       16
       16
       -
         disabled = pythonOlder "3.7";

     

       17
       17
       +
         disabled = pythonOlder "3.10";

     

       17
       18
        
       

     

       18
       19
        
         src = fetchFromGitHub {

     

       19
       20
        
           owner = "tronikos";

     

       20
       21
        
           repo = "androidtvremote2";

     

       21
       22
        
           rev = "refs/tags/v${version}";

     

       22
       22
       -
           hash = "sha256-aLNmuMuwaMhl/Utv6bVU4fR8zmhj0fUiInL4RHT4dVw=";

     

       23
       23
       +
           hash = "sha256-Zem2IWBUWmyVdBjqoVKFk+/lg5T7CPXCKFXhFusQFLY=";

     

       23
       24
        
         };

     

       24
       25
        
       

     

       25
       25
       -
         nativeBuildInputs = [

     

       26
       26
       -
           setuptools

     

       27
       27
       -
         ];

     

       26
       26
       +
         build-system = [ setuptools ];

     

       28
       27
        
       

     

       29
       29
       -
         propagatedBuildInputs = [

     

       28
       28
       +
         dependencies = [

     

       30
       29
        
           aiofiles

     

       31
       30
        
           cryptography

     

       32
       31
        
           protobuf

     

       33
       32
        
         ];

     

       34
       33
        
       

     

       35
       35
       -
         pythonImportsCheck = [

     

       36
       36
       -
           "androidtvremote2"

     

       37
       37
       -
         ];

     

       34
       34
       +
         pythonImportsCheck = [ "androidtvremote2" ];

     

       38
       35
        
       

     

       39
       36
        
         # Module only has a dummy test

     

       40
       37
        
         doCheck = false;

+2 -2

pkgs/development/python-modules/b2sdk/default.nix

···

       21
       21
        
       

     

       22
       22
        
       buildPythonPackage rec {

     

       23
       23
        
         pname = "b2sdk";

     

       24
       24
       -
         version = "2.1.0";

     

       24
       24
       +
         version = "2.2.1";

     

       25
       25
        
         pyproject = true;

     

       26
       26
        
       

     

       27
       27
        
         disabled = pythonOlder "3.7";

     
···

       30
       30
        
           owner = "Backblaze";

     

       31
       31
        
           repo = "b2-sdk-python";

     

       32
       32
        
           rev = "refs/tags/v${version}";

     

       33
       33
       -
           hash = "sha256-/TuPT+Y0asGGtfRNxxvpX0WkS4O4asFmIuqSdQ4I9fQ=";

     

       33
       33
       +
           hash = "sha256-ENEAynUd66sjS+/Qoy9qyffPpSvxdnY1Nwdi+JTE96I=";

     

       34
       34
        
         };

     

       35
       35
        
       

     

       36
       36
        
         build-system = [ pdm-backend ];

+2 -2

pkgs/development/python-modules/bc-detect-secrets/default.nix

···

       17
       17
        
       

     

       18
       18
        
       buildPythonPackage rec {

     

       19
       19
        
         pname = "bc-detect-secrets";

     

       20
       20
       -
         version = "1.5.9";

     

       20
       20
       +
         version = "1.5.10";

     

       21
       21
        
         pyproject = true;

     

       22
       22
        
       

     

       23
       23
        
         disabled = pythonOlder "3.8";

     
···

       26
       26
        
           owner = "bridgecrewio";

     

       27
       27
        
           repo = "detect-secrets";

     

       28
       28
        
           rev = "refs/tags/${version}";

     

       29
       29
       -
           hash = "sha256-3O1taxOxVI+36h2Qz+dzOuilmapm9QO4X4XjRgX4kUc=";

     

       29
       29
       +
           hash = "sha256-b0t5xv4fWiErQsYvDKTJuweiGLqS2WpR9ECGo/cpvQ8=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         build-system = [ setuptools ];

+6 -2

pkgs/development/python-modules/blackjax/default.nix

···

       16
       16
        
       

     

       17
       17
        
       buildPythonPackage rec {

     

       18
       18
        
         pname = "blackjax";

     

       19
       19
       -
         version = "1.2.0";

     

       19
       19
       +
         version = "1.2.1";

     

       20
       20
        
         pyproject = true;

     

       21
       21
        
       

     

       22
       22
        
         disabled = pythonOlder "3.9";

     
···

       25
       25
        
           owner = "blackjax-devs";

     

       26
       26
        
           repo = "blackjax";

     

       27
       27
        
           rev = "refs/tags/${version}";

     

       28
       28
       -
           hash = "sha256-vXyxK3xALKG61YGK7fmoqQNGfOiagHFrvnU02WKZThw=";

     

       28
       28
       +
           hash = "sha256-VoWBCjFMyE5LVJyf7du/pKlnvDHj22lguiP6ZUzH9ak=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         build-system = [

     
···

       56
       56
        
         disabledTests = [

     

       57
       57
        
           # too slow

     

       58
       58
        
           "test_adaptive_tempered_smc"

     

       59
       59
       +
         ] ++ lib.optionals (stdenv.isLinux && stdenv.isAarch64) [

     

       60
       60
       +
           # Numerical test (AssertionError)

     

       61
       61
       +
           # https://github.com/blackjax-devs/blackjax/issues/668

     

       62
       62
       +
           "test_chees_adaptation"

     

       59
       63
        
         ];

     

       60
       64
        
       

     

       61
       65
        
         pythonImportsCheck = [

-100

pkgs/development/python-modules/cadquery/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , buildPythonPackage

     

       3
       3
       -
       , toPythonModule

     

       4
       4
       -
       , pythonOlder

     

       5
       5
       -
       , pythonAtLeast

     

       6
       6
       -
       , fetchFromGitHub

     

       7
       7
       -
       , pyparsing

     

       8
       8
       -
       , opencascade-occt

     

       9
       9
       -
       , stdenv

     

       10
       10
       -
       , python

     

       11
       11
       -
       , cmake

     

       12
       12
       -
       , swig

     

       13
       13
       -
       , freetype

     

       14
       14
       -
       , libGL

     

       15
       15
       -
       , libGLU

     

       16
       16
       -
       , libX11

     

       17
       17
       -
       , six

     

       18
       18
       -
       , pytest

     

       19
       19
       -
       , makeFontsConf

     

       20
       20
       -
       , freefont_ttf

     

       21
       21
       -
       , Cocoa

     

       22
       22
       -
       }:

     

       23
       23
       -
       

     

       24
       24
       -
       let

     

       25
       25
       -
         pythonocc-core-cadquery = toPythonModule (stdenv.mkDerivation {

     

       26
       26
       -
           pname = "pythonocc-core-cadquery";

     

       27
       27
       -
           version = "0.18.2";

     

       28
       28
       -
           format = "setuptools";

     

       29
       29
       -
       

     

       30
       30
       -
           src = fetchFromGitHub {

     

       31
       31
       -
             owner = "CadQuery";

     

       32
       32
       -
             repo = "pythonocc-core";

     

       33
       33
       -
             # no proper release to to use, this commit copied from the Anaconda receipe

     

       34
       34
       -
             rev = "701e924ae40701cbe6f9992bcbdc2ef22aa9b5ab";

     

       35
       35
       -
             sha256 = "07zmiiw74dyj4v0ar5vqkvk30wzcpjjzbi04nsdk5mnlzslmyi6c";

     

       36
       36
       -
           };

     

       37
       37
       -
       

     

       38
       38
       -
           nativeBuildInputs = [

     

       39
       39
       -
             cmake

     

       40
       40
       -
             swig

     

       41
       41
       -
           ];

     

       42
       42
       -
       

     

       43
       43
       -
           buildInputs = [

     

       44
       44
       -
             python

     

       45
       45
       -
             opencascade-occt

     

       46
       46
       -
             freetype

     

       47
       47
       -
             libGL

     

       48
       48
       -
             libGLU

     

       49
       49
       -
             libX11

     

       50
       50
       -
           ] ++ lib.optionals stdenv.isDarwin [ Cocoa ];

     

       51
       51
       -
       

     

       52
       52
       -
           propagatedBuildInputs = [

     

       53
       53
       -
             six

     

       54
       54
       -
           ];

     

       55
       55
       -
       

     

       56
       56
       -
           cmakeFlags = [

     

       57
       57
       -
             "-Wno-dev"

     

       58
       58
       -
             "-DPYTHONOCC_INSTALL_DIRECTORY=${placeholder "out"}/${python.sitePackages}/OCC"

     

       59
       59
       -
           ];

     

       60
       60
       -
         });

     

       61
       61
       -
       

     

       62
       62
       -
       in

     

       63
       63
       -
         buildPythonPackage rec {

     

       64
       64
       -
           pname = "cadquery";

     

       65
       65
       -
           version = "2.0";

     

       66
       66
       -
       

     

       67
       67
       -
           src = fetchFromGitHub {

     

       68
       68
       -
             owner = "CadQuery";

     

       69
       69
       -
             repo = pname;

     

       70
       70
       -
             rev = version;

     

       71
       71
       -
             sha256 = "1n63b6cjjrdwdfmwq0zx1xabjnhndk9mgfkm4w7z9ardcfpvg84l";

     

       72
       72
       -
           };

     

       73
       73
       -
       

     

       74
       74
       -
           buildInputs = [

     

       75
       75
       -
             opencascade-occt

     

       76
       76
       -
           ];

     

       77
       77
       -
       

     

       78
       78
       -
           propagatedBuildInputs = [

     

       79
       79
       -
             pyparsing

     

       80
       80
       -
             pythonocc-core-cadquery

     

       81
       81
       -
           ];

     

       82
       82
       -
       

     

       83
       83
       -
           FONTCONFIG_FILE = makeFontsConf {

     

       84
       84
       -
             fontDirectories = [ freefont_ttf ];

     

       85
       85
       -
           };

     

       86
       86
       -
       

     

       87
       87
       -
           nativeCheckInputs = [

     

       88
       88
       -
             pytest

     

       89
       89
       -
           ];

     

       90
       90
       -
       

     

       91
       91
       -
           disabled = pythonOlder "3.6" || pythonAtLeast "3.8";

     

       92
       92
       -
       

     

       93
       93
       -
           meta = with lib; {

     

       94
       94
       -
             description = "Parametric scripting language for creating and traversing CAD models";

     

       95
       95
       -
             homepage = "https://github.com/CadQuery/cadquery";

     

       96
       96
       -
             license = licenses.asl20;

     

       97
       97
       -
             maintainers = with maintainers; [ marcus7070 ];

     

       98
       98
       -
             broken = true;

     

       99
       99
       -
           };

     

       100
       100
       -
         }

-27

pkgs/development/python-modules/cryptacular/default.nix

···

       1
       1
       -
       { lib, buildPythonPackage, fetchPypi, isPy27, pythonAtLeast

     

       2
       2
       -
       , coverage, nose, pbkdf2 }:

     

       3
       3
       -
       

     

       4
       4
       -
       buildPythonPackage rec {

     

       5
       5
       -
         pname = "cryptacular";

     

       6
       6
       -
         version = "1.6.2";

     

       7
       7
       -
         format = "setuptools";

     

       8
       8
       -
       

     

       9
       9
       -
         src = fetchPypi {

     

       10
       10
       -
           inherit pname version;

     

       11
       11
       -
           sha256 = "7b529cb2b8a3c7e5be77921bf1ebc653d4d3a8f791375cc6f971b20db2404176";

     

       12
       12
       -
         };

     

       13
       13
       -
       

     

       14
       14
       -
         buildInputs = [ coverage nose ];

     

       15
       15
       -
         propagatedBuildInputs = [ pbkdf2 ];

     

       16
       16
       -
       

     

       17
       17
       -
         # TODO: tests fail: TypeError: object of type 'NoneType' has no len()

     

       18
       18
       -
         doCheck = false;

     

       19
       19
       -
       

     

       20
       20
       -
         # Python >=2.7.15, >=3.6.5 are incompatible:

     

       21
       21
       -
         # https://bitbucket.org/dholth/cryptacular/issues/11

     

       22
       22
       -
         disabled = isPy27 || pythonAtLeast "3.6";

     

       23
       23
       -
       

     

       24
       24
       -
         meta = with lib; {

     

       25
       25
       -
           maintainers = with maintainers; [ domenkozar ];

     

       26
       26
       -
         };

     

       27
       27
       -
       }

+19 -5

pkgs/development/python-modules/devito/default.nix

···

       15
       15
        
       , nbval

     

       16
       16
        
       , psutil

     

       17
       17
        
       , py-cpuinfo

     

       18
       18
       -
       , pyrevolve

     

       19
       18
        
       , pytest-xdist

     

       20
       19
        
       , pytestCheckHook

     

       21
       20
        
       , pythonOlder

     
···

       26
       25
        
       

     

       27
       26
        
       buildPythonPackage rec {

     

       28
       27
        
         pname = "devito";

     

       29
       29
       -
         version = "4.8.3";

     

       28
       28
       +
         version = "4.8.6";

     

       30
       29
        
         format = "setuptools";

     

       31
       30
        
       

     

       32
       31
        
         disabled = pythonOlder "3.7";

     
···

       35
       34
        
           owner = "devitocodes";

     

       36
       35
        
           repo = "devito";

     

       37
       36
        
           rev = "refs/tags/v${version}";

     

       38
       38
       -
           hash = "sha256-g9rRJF1JrZ6+s3tj4RZHuGOjt5LJjtK9I5CJmq4CJL4=";

     

       37
       37
       +
           hash = "sha256-unuJLp+zTyGpOk5O78xYbW6Zrzp60WyqgT9mf2YpTG4=";

     

       39
       38
        
         };

     

       40
       39
        
       

     

       41
       40
        
         pythonRemoveDeps = [

     
···

       51
       50
        
           pythonRelaxDepsHook

     

       52
       51
        
         ];

     

       53
       52
        
       

     

       54
       54
       -
         propagatedBuildInputs = [

     

       53
       53
       +
         dependencies = [

     

       55
       54
        
           anytree

     

       56
       55
        
           cached-property

     

       57
       56
        
           cgen

     
···

       62
       61
        
           multidict

     

       63
       62
        
           psutil

     

       64
       63
        
           py-cpuinfo

     

       65
       65
       -
           pyrevolve

     

       66
       64
        
           scipy

     

       67
       65
        
           sympy

     

       68
       66
        
         ] ++ lib.optionals stdenv.cc.isClang [

     
···

       99
       97
        
           "test_setupWOverQ"

     

       100
       98
        
           "test_shortcuts"

     

       101
       99
        
           "test_subdomainset_mpi"

     

       100
       100
       +
           "test_subdomains_mpi"

     

       101
       101
       +
         ] ++ lib.optionals (stdenv.isLinux && stdenv.isAarch64) [

     

       102
       102
       +
           # FAILED tests/test_unexpansion.py::Test2Pass::test_v0 - assert False

     

       103
       103
       +
           "test_v0"

     

       104
       104
       +
         ] ++ lib.optionals stdenv.isDarwin [

     

       105
       105
       +
           # FAILED tests/test_caching.py::TestCaching::test_special_symbols - ValueError: not enough values to unpack (expected 3, got 2)

     

       106
       106
       +
           "test_special_symbols"

     

       107
       107
       +
       

     

       108
       108
       +
           # FAILED tests/test_unexpansion.py::Test2Pass::test_v0 - codepy.CompileError: module compilation failed

     

       109
       109
       +
           "test_v0"

     

       110
       110
       +
         ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [

     

       111
       111
       +
           # Numerical tests

     

       112
       112
       +
           "test_lm_fb"

     

       113
       113
       +
           "test_lm_ds"

     

       102
       114
        
         ];

     

       103
       115
        
       

     

       104
       116
        
         disabledTestPaths = [

     
···

       109
       121
        
           "tests/test_data.py"

     

       110
       122
        
           "tests/test_dse.py"

     

       111
       123
        
           "tests/test_gradient.py"

     

       124
       124
       +
         ] ++ lib.optionals ((stdenv.isLinux && stdenv.isAarch64) || stdenv.isDarwin) [

     

       125
       125
       +
           "tests/test_dle.py"

     

       112
       126
        
         ];

     

       113
       127
        
       

     

       114
       128
        
         pythonImportsCheck = [

+2 -2

pkgs/development/python-modules/dirigera/default.nix

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "dirigera";

     

       15
       15
       -
         version = "1.1.6";

     

       15
       15
       +
         version = "1.1.7";

     

       16
       16
        
         pyproject = true;

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.7";

     
···

       21
       21
        
           owner = "Leggin";

     

       22
       22
        
           repo = "dirigera";

     

       23
       23
        
           rev = "refs/tags/v${version}";

     

       24
       24
       -
           hash = "sha256-OXq8eJyZQBsJEK81GxstfMHqDShlZyOWSXLwP9Zfpqw=";

     

       24
       24
       +
           hash = "sha256-KAwXpcs0EvmaxBVgZ7TlT1hDI0m7f8hJigUTluVATsw=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         build-system = [ setuptools ];

+2 -2

pkgs/development/python-modules/dogpile-cache/default.nix

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "dogpile-cache";

     

       15
       15
       -
         version = "1.3.2";

     

       15
       15
       +
         version = "1.3.3";

     

       16
       16
        
         format = "pyproject";

     

       17
       17
        
       

     

       18
       18
        
         disabled = pythonOlder "3.6";

     
···

       20
       20
        
         src = fetchPypi {

     

       21
       21
        
           pname = "dogpile.cache";

     

       22
       22
        
           inherit version;

     

       23
       23
       -
           hash = "sha256-T3HcAzOtNRycb3BPW6Kje/Ucbu0EN9Gt9W4HWVmv5js=";

     

       23
       23
       +
           hash = "sha256-+EuO0LD7KX0VEFVEf6jcr3uuVm1Nve/s3MHzdmKrWIs=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         nativeBuildInputs = [

+15 -2

pkgs/development/python-modules/equinox/default.nix

···

       48
       48
        
         pythonImportsCheck = [ "equinox" ];

     

       49
       49
        
       

     

       50
       50
        
         disabledTests = [

     

       51
       51
       -
           # Failed: DID NOT WARN. No warnings of type (<class 'UserWarning'>,) were emitted.

     

       52
       52
       -
           "test_tracetime"

     

       51
       51
       +
           # For simplicity, JAX has removed its internal frames from the traceback of the following exception.

     

       52
       52
       +
           # https://github.com/patrick-kidger/equinox/issues/716

     

       53
       53
       +
           "test_abstract"

     

       54
       54
       +
           "test_complicated"

     

       55
       55
       +
           "test_grad"

     

       56
       56
       +
           "test_jvp"

     

       57
       57
       +
           "test_mlp"

     

       58
       58
       +
           "test_num_traces"

     

       59
       59
       +
           "test_pytree_in"

     

       60
       60
       +
           "test_simple"

     

       61
       61
       +
           "test_vmap"

     

       62
       62
       +
       

     

       63
       63
       +
           # AssertionError: assert 'foo:\n   pri...pe=float32)\n' == 'foo:\n   pri...pe=float32)\n'

     

       64
       64
       +
           # Also reported in patrick-kidger/equinox#716

     

       65
       65
       +
           "test_backward_nan"

     

       53
       66
        
         ];

     

       54
       67
        
       

     

       55
       68
        
         meta = with lib; {

+4 -4

pkgs/development/python-modules/flax/default.nix

···

       25
       25
        
       

     

       26
       26
        
       buildPythonPackage rec {

     

       27
       27
        
         pname = "flax";

     

       28
       28
       -
         version = "0.8.2";

     

       28
       28
       +
         version = "0.8.3";

     

       29
       29
        
         pyproject = true;

     

       30
       30
        
       

     

       31
       31
        
         disabled = pythonOlder "3.9";

     
···

       34
       34
        
           owner = "google";

     

       35
       35
        
           repo = "flax";

     

       36
       36
        
           rev = "refs/tags/v${version}";

     

       37
       37
       -
           hash = "sha256-UABgJGe1grUSkwOJpjeIoFqhXsqG//HlC1YyYPxXV+g=";

     

       37
       37
       +
           hash = "sha256-uDGTyksUZTTL6FiTJP+qteFLOjr75dcTj9yRJ6Jm8xU=";

     

       38
       38
        
         };

     

       39
       39
        
       

     

       40
       40
       -
         nativeBuildInputs = [

     

       40
       40
       +
         build-system = [

     

       41
       41
        
           jaxlib

     

       42
       42
        
           pythonRelaxDepsHook

     

       43
       43
        
           setuptools-scm

     

       44
       44
        
         ];

     

       45
       45
        
       

     

       46
       46
       -
         propagatedBuildInputs = [

     

       46
       46
       +
         dependencies = [

     

       47
       47
        
           jax

     

       48
       48
        
           msgpack

     

       49
       49
        
           numpy

-29

pkgs/development/python-modules/globre/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , pythonAtLeast

     

       3
       3
       -
       , buildPythonPackage

     

       4
       4
       -
       , fetchPypi

     

       5
       5
       -
       , nose

     

       6
       6
       -
       , coverage

     

       7
       7
       -
       }:

     

       8
       8
       -
       

     

       9
       9
       -
       buildPythonPackage rec {

     

       10
       10
       -
         pname = "globre";

     

       11
       11
       -
         version = "0.1.5";

     

       12
       12
       -
         format = "setuptools";

     

       13
       13
       -
         # https://github.com/metagriffin/globre/issues/7

     

       14
       14
       -
         disabled = pythonAtLeast "3.7";

     

       15
       15
       -
       

     

       16
       16
       -
         src = fetchPypi {

     

       17
       17
       -
           inherit pname version;

     

       18
       18
       -
           sha256 = "1qhjpg0722871dm5m7mmldf6c7mx58fbdvk1ix5i3s9py82448gf";

     

       19
       19
       -
         };

     

       20
       20
       -
       

     

       21
       21
       -
         nativeCheckInputs = [ nose coverage ];

     

       22
       22
       -
       

     

       23
       23
       -
         meta = with lib; {

     

       24
       24
       -
           homepage = "https://github.com/metagriffin/globre";

     

       25
       25
       -
           description = "A python glob-like regular expression generation library.";

     

       26
       26
       -
           maintainers = with maintainers; [ glittershark ];

     

       27
       27
       -
           license = licenses.gpl3;

     

       28
       28
       -
         };

     

       29
       29
       -
       }

+2 -2

pkgs/development/python-modules/hikari/default.nix

···

       17
       17
        
       }:

     

       18
       18
        
       buildPythonPackage rec {

     

       19
       19
        
         pname = "hikari";

     

       20
       20
       -
         version = "2.0.0.dev124";

     

       20
       20
       +
         version = "2.0.0.dev125";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchFromGitHub {

     

       23
       23
        
           owner = "hikari-py";

     

       24
       24
        
           repo = "hikari";

     

       25
       25
        
           rev = version;

     

       26
       26
       -
           hash = "sha256-zDgU3Ol/I3YNnwXm+aBh20KwonW746p5TObuwuWORog=";

     

       26
       26
       +
           hash = "sha256-qxgIYquXUWrm8bS8EamERMHOnjI2aPyK7bQieVG66uA=";

     

       27
       27
        
           # The git commit is part of the `hikari.__git_sha1__` original output;

     

       28
       28
        
           # leave that output the same in nixpkgs. Use the `.git` directory

     

       29
       29
        
           # to retrieve the commit SHA, and remove the directory afterwards,

+10 -2

pkgs/development/python-modules/jax/default.nix

···

       29
       29
        
       in

     

       30
       30
        
       buildPythonPackage rec {

     

       31
       31
        
         pname = "jax";

     

       32
       32
       -
         version = "0.4.25";

     

       32
       32
       +
         version = "0.4.28";

     

       33
       33
        
         pyproject = true;

     

       34
       34
        
       

     

       35
       35
        
         disabled = pythonOlder "3.9";

     
···

       39
       39
        
           repo = "jax";

     

       40
       40
        
           # google/jax contains tags for jax and jaxlib. Only use jax tags!

     

       41
       41
        
           rev = "refs/tags/jax-v${version}";

     

       42
       42
       -
           hash = "sha256-poQQo2ZgEhPYzK3aCs+BjaHTNZbezJAECd+HOdY1Yok=";

     

       42
       42
       +
           hash = "sha256-qSHPwi3is6Ts7pz5s4KzQHBMbcjGp+vAOsejW3o36Ek=";

     

       43
       43
        
         };

     

       44
       44
        
       

     

       45
       45
        
         nativeBuildInputs = [

     
···

       80
       80
        
           "-W ignore::DeprecationWarning"

     

       81
       81
        
           "tests/"

     

       82
       82
        
         ];

     

       83
       83
       +
       

     

       84
       84
       +
         # Prevents `tests/export_back_compat_test.py::CompatTest::test_*` tests from failing on darwin with

     

       85
       85
       +
         # PermissionError: [Errno 13] Permission denied: '/tmp/back_compat_testdata/test_*.py'

     

       86
       86
       +
         # See https://github.com/google/jax/blob/jaxlib-v0.4.27/jax/_src/internal_test_util/export_back_compat_test_util.py#L240-L241

     

       87
       87
       +
         # NOTE: this doesn't seem to be an issue on linux

     

       88
       88
       +
         preCheck = lib.optionalString stdenv.isDarwin ''

     

       89
       89
       +
           export TEST_UNDECLARED_OUTPUTS_DIR=$(mktemp -d)

     

       90
       90
       +
         '';

     

       83
       91
        
       

     

       84
       92
        
         disabledTests = [

     

       85
       93
        
           # Exceeds tolerance when the machine is busy

+22 -38

pkgs/development/python-modules/jaxlib/bin.nix

···

       20
       20
        
       , stdenv

     

       21
       21
        
         # Options:

     

       22
       22
        
       , cudaSupport ? config.cudaSupport

     

       23
       23
       -
       , cudaPackagesGoogle

     

       23
       23
       +
       , cudaPackages

     

       24
       24
        
       }:

     

       25
       25
        
       

     

       26
       26
        
       let

     

       27
       27
       -
         inherit (cudaPackagesGoogle) cudaVersion;

     

       27
       27
       +
         inherit (cudaPackages) cudaVersion;

     

       28
       28
        
       

     

       29
       29
       -
         version = "0.4.24";

     

       29
       29
       +
         version = "0.4.28";

     

       30
       30
        
       

     

       31
       31
        
         inherit (python) pythonVersion;

     

       32
       32
        
       

     

       33
       33
       -
         cudaLibPath = lib.makeLibraryPath (with cudaPackagesGoogle; [

     

       33
       33
       +
         cudaLibPath = lib.makeLibraryPath (with cudaPackages; [

     

       34
       34
        
           cuda_cudart.lib # libcudart.so

     

       35
       35
        
           cuda_cupti.lib # libcupti.so

     

       36
       36
        
           cudnn.lib # libcudnn.so

     
···

       56
       56
        
             "3.9-x86_64-linux" = getSrcFromPypi {

     

       57
       57
        
               platform = "manylinux2014_x86_64";

     

       58
       58
        
               dist = "cp39";

     

       59
       59
       -
               hash = "sha256-6P5ArMoLZiUkHUoQ/mJccbNj5/7el/op+Qo6cGQ33xE=";

     

       59
       59
       +
               hash = "sha256-Slbr8FtKTBeRaZ2HTgcvP4CPCYa0AQsU+1SaackMqdw=";

     

       60
       60
        
             };

     

       61
       61
        
             "3.9-aarch64-darwin" = getSrcFromPypi {

     

       62
       62
        
               platform = "macosx_11_0_arm64";

     

       63
       63
        
               dist = "cp39";

     

       64
       64
       -
               hash = "sha256-23JQZRwMLtt7sK/JlCBqqRyfTVIAVJFN2sL+nAkQgvU=";

     

       64
       64
       +
               hash = "sha256-sBVi7IrXVxm30DiXUkiel+trTctMjBE75JFjTVKCrTw=";

     

       65
       65
        
             };

     

       66
       66
        
             "3.9-x86_64-darwin" = getSrcFromPypi {

     

       67
       67
        
               platform = "macosx_10_14_x86_64";

     

       68
       68
        
               dist = "cp39";

     

       69
       69
       -
               hash = "sha256-OgMedn9GHGs5THZf3pkP3Aw/jJ0vL5qK1b+Lzf634Ik=";

     

       69
       69
       +
               hash = "sha256-T5jMg3srbG3P4Kt/+esQkxSSCUYRmqOvn6oTlxj/J4c=";

     

       70
       70
        
             };

     

       71
       71
        
       

     

       72
       72
        
             "3.10-x86_64-linux" = getSrcFromPypi {

     

       73
       73
        
               platform = "manylinux2014_x86_64";

     

       74
       74
        
               dist = "cp310";

     

       75
       75
       -
               hash = "sha256-/VwUIIa7mTs/wLz0ArsEfNrz2pGriVVT5GX9XRFRxfY=";

     

       75
       75
       +
               hash = "sha256-47zcb45g+FVPQVwU2TATTmAuPKM8OOVGJ0/VRfh1dps=";

     

       76
       76
        
             };

     

       77
       77
        
             "3.10-aarch64-darwin" = getSrcFromPypi {

     

       78
       78
        
               platform = "macosx_11_0_arm64";

     

       79
       79
        
               dist = "cp310";

     

       80
       80
       -
               hash = "sha256-LgICOyDGts840SQQJh+yOMobMASb62llvJjpGvhzrSw=";

     

       80
       80
       +
               hash = "sha256-8Djmi9ENGjVUcisLvjbmpEg4RDenWqnSg/aW8O2fjAk=";

     

       81
       81
        
             };

     

       82
       82
        
             "3.10-x86_64-darwin" = getSrcFromPypi {

     

       83
       83
        
               platform = "macosx_10_14_x86_64";

     

       84
       84
        
               dist = "cp310";

     

       85
       85
       -
               hash = "sha256-vhyULw+zBpz1UEi2tqgBMQEzY9a6YBgEIg6A4PPh3bQ=";

     

       85
       85
       +
               hash = "sha256-pCHSN/jCXShQFm0zRgPGc925tsJvUrxJZwS4eCKXvWY=";

     

       86
       86
        
             };

     

       87
       87
        
       

     

       88
       88
        
             "3.11-x86_64-linux" = getSrcFromPypi {

     

       89
       89
        
               platform = "manylinux2014_x86_64";

     

       90
       90
        
               dist = "cp311";

     

       91
       91
       -
               hash = "sha256-VJO/VVwBFkOEtq4y/sLVgAV8Cung01JULiuT6W96E/8=";

     

       91
       91
       +
               hash = "sha256-Rc4PPIQM/4I2z/JsN/Jsn/B4aV+T4MFiwyDCgfUEEnU=";

     

       92
       92
        
             };

     

       93
       93
        
             "3.11-aarch64-darwin" = getSrcFromPypi {

     

       94
       94
        
               platform = "macosx_11_0_arm64";

     

       95
       95
        
               dist = "cp311";

     

       96
       96
       -
               hash = "sha256-VtuwXxurpSp1KI8ty1bizs5cdy8GEBN2MgS227sOCmE=";

     

       96
       96
       +
               hash = "sha256-eThX+vN/Nxyv51L+pfyBH0NeQ7j7S1AgWERKf17M+Ck=";

     

       97
       97
        
             };

     

       98
       98
        
             "3.11-x86_64-darwin" = getSrcFromPypi {

     

       99
       99
        
               platform = "macosx_10_14_x86_64";

     

       100
       100
        
               dist = "cp311";

     

       101
       101
       -
               hash = "sha256-4Dj5dEGKb9hpg3HlVogNO1Gc9UibJhy1eym2mjivxAQ=";

     

       101
       101
       +
               hash = "sha256-L/gpDtx7ksfq5SUX9lSSYz4mey6QZ7rT5MMj0hPnfPU=";

     

       102
       102
        
             };

     

       103
       103
        
       

     

       104
       104
        
             "3.12-x86_64-linux" = getSrcFromPypi {

     

       105
       105
        
               platform = "manylinux2014_x86_64";

     

       106
       106
        
               dist = "cp312";

     

       107
       107
       -
               hash = "sha256-TlrGVtb3NTLmhnILWPLJR+jISCZ5SUV4wxNFpSfkCBo=";

     

       107
       107
       +
               hash = "sha256-RqGqhX9P7uikP8upXA4Kti1AwmzJcwtsaWVZCLo1n40=";

     

       108
       108
        
             };

     

       109
       109
        
             "3.12-aarch64-darwin" = getSrcFromPypi {

     

       110
       110
        
               platform = "macosx_11_0_arm64";

     

       111
       111
        
               dist = "cp312";

     

       112
       112
       -
               hash = "sha256-FIwK5CGykQjteuWzLZnbtAggIxLQeGV96bXlZGEytN0=";

     

       112
       112
       +
               hash = "sha256-jdi//jhTcC9jzZJNoO4lc0pNGc1ckmvgM9dyun0cF10=";

     

       113
       113
        
             };

     

       114
       114
        
             "3.12-x86_64-darwin" = getSrcFromPypi {

     

       115
       115
        
               platform = "macosx_10_14_x86_64";

     

       116
       116
        
               dist = "cp312";

     

       117
       117
       -
               hash = "sha256-9/jw/wr6oUD9pOadVAaMRL086iVMUXwVgnUMcG1UNvE=";

     

       117
       117
       +
               hash = "sha256-1sCaVFMpciRhrwVuc1FG0sjHTCKsdCaoRetp8ya096A=";

     

       118
       118
        
             };

     

       119
       119
        
           };

     

       120
       120
        
       

     
···

       130
       130
        
         gpuSrcs = {

     

       131
       131
        
           "cuda12.2-3.9" = fetchurl {

     

       132
       132
        
             url = "https://storage.googleapis.com/jax-releases/cuda12/jaxlib-${version}+cuda12.cudnn89-cp39-cp39-manylinux2014_x86_64.whl";

     

       133
       133
       -
             hash = "sha256-xdJKLPtx+CIza2CrWKM3M0cZJzyNFVTTTsvlgh38bfM=";

     

       133
       133
       +
             hash = "sha256-d8LIl22gIvmWfoyKfXKElZJXicPQIZxdS4HumhwQGCw=";

     

       134
       134
        
           };

     

       135
       135
        
           "cuda12.2-3.10" = fetchurl {

     

       136
       136
        
             url = "https://storage.googleapis.com/jax-releases/cuda12/jaxlib-${version}+cuda12.cudnn89-cp310-cp310-manylinux2014_x86_64.whl";

     

       137
       137
       -
             hash = "sha256-QCjrOczD2mp+CDwVXBc0/4rJnAizeV62AK0Dpx9X6TE=";

     

       137
       137
       +
             hash = "sha256-PXtWv+UEcMWF8LhWe6Z1UGkf14PG3dkJ0Iop0LiimnQ=";

     

       138
       138
        
           };

     

       139
       139
        
           "cuda12.2-3.11" = fetchurl {

     

       140
       140
        
             url = "https://storage.googleapis.com/jax-releases/cuda12/jaxlib-${version}+cuda12.cudnn89-cp311-cp311-manylinux2014_x86_64.whl";

     

       141
       141
       -
             hash = "sha256-Ipy3vk1yUplpNzECAFt63aOIhgEWgXG7hkoeTIk9bQQ=";

     

       141
       141
       +
             hash = "sha256-QO2WSOzmJ48VaCha596mELiOfPsAGLpGctmdzcCHE/o=";

     

       142
       142
        
           };

     

       143
       143
        
           "cuda12.2-3.12" = fetchurl {

     

       144
       144
        
             url = "https://storage.googleapis.com/jax-releases/cuda12/jaxlib-${version}+cuda12.cudnn89-cp312-cp312-manylinux2014_x86_64.whl";

     

       145
       145
       -
             hash = "sha256-LSnZHaUga/8Z65iKXWBnZDk4yUpNykFTu3vukCchO6Q=";

     

       146
       146
       -
           };

     

       147
       147
       -
           "cuda11.8-3.9" = fetchurl {

     

       148
       148
       -
             url = "https://storage.googleapis.com/jax-releases/cuda11/jaxlib-${version}+cuda11.cudnn86-cp39-cp39-manylinux2014_x86_64.whl";

     

       149
       149
       -
             hash = "sha256-UmyugL0VjlXkiD7fuDPWgW8XUpr/QaP5ggp6swoZTzU=";

     

       150
       150
       -
           };

     

       151
       151
       -
           "cuda11.8-3.10" = fetchurl {

     

       152
       152
       -
             url = "https://storage.googleapis.com/jax-releases/cuda11/jaxlib-${version}+cuda11.cudnn86-cp310-cp310-manylinux2014_x86_64.whl";

     

       153
       153
       -
             hash = "sha256-luKULEiV1t/sO6eckDxddJTiOFa0dtJeDlrvp+WYmHk=";

     

       154
       154
       -
           };

     

       155
       155
       -
           "cuda11.8-3.11" = fetchurl {

     

       156
       156
       -
             url = "https://storage.googleapis.com/jax-releases/cuda11/jaxlib-${version}+cuda11.cudnn86-cp311-cp311-manylinux2014_x86_64.whl";

     

       157
       157
       -
             hash = "sha256-4+uJ8Ij6mFGEmjFEgi3fLnSLZs+v18BRoOt7mZuqydw=";

     

       158
       158
       -
           };

     

       159
       159
       -
           "cuda11.8-3.12" = fetchurl {

     

       160
       160
       -
             url = "https://storage.googleapis.com/jax-releases/cuda11/jaxlib-${version}+cuda11.cudnn86-cp312-cp312-manylinux2014_x86_64.whl";

     

       161
       161
       -
             hash = "sha256-bUDFb94Ar/65SzzR9RLIs/SL/HdjaPT1Su5whmjkS00=";

     

       145
       145
       +
             hash = "sha256-ixWMaIChy4Ammsn23/3cCoala0lFibuUxyUr3tjfFKU=";

     

       162
       146
        
           };

     

       163
       147
        
         };

     

       164
       148
        
       

     
···

       213
       197
        
         # for more info.

     

       214
       198
        
         postInstall = lib.optional cudaSupport ''

     

       215
       199
        
           mkdir -p $out/${python.sitePackages}/jaxlib/cuda/bin

     

       216
       216
       -
           ln -s ${lib.getExe' cudaPackagesGoogle.cuda_nvcc "ptxas"} $out/${python.sitePackages}/jaxlib/cuda/bin/ptxas

     

       200
       200
       +
           ln -s ${lib.getExe' cudaPackages.cuda_nvcc "ptxas"} $out/${python.sitePackages}/jaxlib/cuda/bin/ptxas

     

       217
       201
        
         '';

     

       218
       202
        
       

     

       219
       203
        
         inherit (jaxlib-build) pythonImportsCheck;

     
···

       227
       211
        
           platforms = [ "aarch64-darwin" "x86_64-linux" "x86_64-darwin" ];

     

       228
       212
        
           broken =

     

       229
       213
        
             !(cudaSupport -> lib.versionAtLeast cudaVersion "11.1")

     

       230
       230
       -
             || !(cudaSupport -> lib.versionAtLeast cudaPackagesGoogle.cudnn.version "8.2")

     

       214
       214
       +
             || !(cudaSupport -> lib.versionAtLeast cudaPackages.cudnn.version "8.2")

     

       231
       215
        
             || !(cudaSupport -> stdenv.isLinux)

     

       232
       216
        
             || !(cudaSupport -> (gpuSrcs ? "cuda${cudaVersion}-${pythonVersion}"))

     

       233
       217
        
             # Fails at pythonImportsCheckPhase:

+15 -25

pkgs/development/python-modules/jaxlib/default.nix

···

       13
       13
        
       , curl

     

       14
       14
        
       , cython

     

       15
       15
        
       , fetchFromGitHub

     

       16
       16
       -
       , fetchpatch

     

       17
       16
        
       , git

     

       18
       17
        
       , IOKit

     

       19
       18
        
       , jsoncpp

     
···

       45
       44
        
       , config

     

       46
       45
        
         # CUDA flags:

     

       47
       46
        
       , cudaSupport ? config.cudaSupport

     

       48
       48
       -
       , cudaPackagesGoogle

     

       47
       47
       +
       , cudaPackages

     

       49
       48
        
       

     

       50
       49
        
         # MKL:

     

       51
       50
        
       , mklSupport ? true

     

       52
       51
        
       }@inputs:

     

       53
       52
        
       

     

       54
       53
        
       let

     

       55
       55
       -
         inherit (cudaPackagesGoogle) cudaFlags cudaVersion cudnn nccl;

     

       54
       54
       +
         inherit (cudaPackages) cudaFlags cudaVersion cudnn nccl;

     

       56
       55
        
       

     

       57
       56
        
         pname = "jaxlib";

     

       58
       58
       -
         version = "0.4.24";

     

       57
       57
       +
         version = "0.4.28";

     

       59
       58
        
       

     

       60
       59
        
         # It's necessary to consistently use backendStdenv when building with CUDA

     

       61
       60
        
         # support, otherwise we get libstdc++ errors downstream

     

       62
       61
        
         stdenv = throw "Use effectiveStdenv instead";

     

       63
       63
       -
         effectiveStdenv = if cudaSupport then cudaPackagesGoogle.backendStdenv else inputs.stdenv;

     

       62
       62
       +
         effectiveStdenv = if cudaSupport then cudaPackages.backendStdenv else inputs.stdenv;

     

       64
       63
        
       

     

       65
       64
        
         meta = with lib; {

     

       66
       65
        
           description = "JAX is Autograd and XLA, brought together for high-performance machine learning research.";

     
···

       78
       77
        
         # These are necessary at build time and run time.

     

       79
       78
        
         cuda_libs_joined = symlinkJoin {

     

       80
       79
        
           name = "cuda-joined";

     

       81
       81
       -
           paths = with cudaPackagesGoogle; [

     

       80
       80
       +
           paths = with cudaPackages; [

     

       82
       81
        
             cuda_cudart.lib # libcudart.so

     

       83
       82
        
             cuda_cudart.static # libcudart_static.a

     

       84
       83
        
             cuda_cupti.lib # libcupti.so

     
···

       92
       91
        
         # These are only necessary at build time.

     

       93
       92
        
         cuda_build_deps_joined = symlinkJoin {

     

       94
       93
        
           name = "cuda-build-deps-joined";

     

       95
       95
       -
           paths = with cudaPackagesGoogle; [

     

       94
       94
       +
           paths = with cudaPackages; [

     

       96
       95
        
             cuda_libs_joined

     

       97
       96
        
       

     

       98
       97
        
             # Binaries

     

       99
       99
       -
             cudaPackagesGoogle.cuda_nvcc.bin # nvcc

     

       98
       98
       +
             cudaPackages.cuda_nvcc.bin # nvcc

     

       100
       99
        
       

     

       101
       100
        
             # Headers

     

       102
       101
        
             cuda_cccl.dev # block_load.cuh

     
···

       181
       180
        
             owner = "openxla";

     

       182
       181
        
             repo = "xla";

     

       183
       182
        
             # Update this according to https://github.com/google/jax/blob/jaxlib-v${version}/third_party/xla/workspace.bzl.

     

       184
       184
       -
             rev = "12eee889e1f2ad41e27d7b0e970cb92d282d3ec5";

     

       185
       185
       -
             hash = "sha256-68kjjgwYjRlcT0TVJo9BN6s+WTkdu5UMJqQcfHpBT90=";

     

       183
       183
       +
             rev = "e8247c3ea1d4d7f31cf27def4c7ac6f2ce64ecd4";

     

       184
       184
       +
             hash = "sha256-ZhgMIVs3Z4dTrkRWDqaPC/i7yJz2dsYXrZbjzqvPX3E=";

     

       186
       185
        
           };

     

       187
       186
        
       

     

       188
       188
       -
           patches = [

     

       189
       189
       -
             # Resolves "could not convert ‘result’ from ‘SmallVector<[...],6>’ to

     

       190
       190
       -
             # ‘SmallVector<[...],4>’" compilation error. See https://github.com/google/jax/issues/19814#issuecomment-1945141259.

     

       191
       191
       -
             (fetchpatch {

     

       192
       192
       -
               url = "https://github.com/openxla/xla/commit/7a614cd346594fc7ea2fe75570c9c53a4a444f60.patch";

     

       193
       193
       -
               hash = "sha256-RtuQTH8wzNiJcOtISLhf+gMlH1gg8hekvxEB+4wX6BM=";

     

       194
       194
       -
             })

     

       195
       195
       -
           ];

     

       196
       196
       -
       

     

       197
       187
        
           dontBuild = true;

     

       198
       188
        
       

     

       199
       189
        
           # This is necessary for patchShebangs to know the right path to use.

     
···

       220
       210
        
             repo = "jax";

     

       221
       211
        
             # google/jax contains tags for jax and jaxlib. Only use jaxlib tags!

     

       222
       212
        
             rev = "refs/tags/${pname}-v${version}";

     

       223
       223
       -
             hash = "sha256-hmx7eo3pephc6BQfoJ3U0QwWBWmhkAc+7S4QmW32qQs=";

     

       213
       213
       +
             hash = "sha256-qSHPwi3is6Ts7pz5s4KzQHBMbcjGp+vAOsejW3o36Ek=";

     

       224
       214
        
           };

     

       225
       215
        
       

     

       226
       216
        
           nativeBuildInputs = [

     
···

       364
       354
        
             ];

     

       365
       355
        
       

     

       366
       356
        
             sha256 = (if cudaSupport then {

     

       367
       367
       -
               x86_64-linux = "sha256-8JilAoTbqOjOOJa/Zc/n/quaEDcpdcLXCNb34mfB+OM=";

     

       357
       357
       +
               x86_64-linux = "sha256-VGNMf5/DgXbgsu1w5J1Pmrukw+7UO31BNU+crKVsX5k=";

     

       368
       358
        
             } else {

     

       369
       369
       -
               x86_64-linux = "sha256-iqS+I1FQLNWXNMsA20cJp7YkyGUeshee5b2QfRBNZtk=";

     

       370
       370
       -
               aarch64-linux = "sha256-qmJ0Fm/VGMTmko4PhKs1P8/GLEJmVxb8xg+ss/HsakY==";

     

       359
       359
       +
               x86_64-linux = "sha256-uOoAyMBLHPX6jzdN43b5wZV5eW0yI8sCDD7BSX2h4oQ=";

     

       360
       360
       +
               aarch64-linux = "sha256-+SnGKY9LIT1Qhu/x6Uh7sHRaAEjlc//qyKj1m4t16PA=";

     

       371
       361
        
             }).${effectiveStdenv.system} or (throw "jaxlib: unsupported system: ${effectiveStdenv.system}");

     

       372
       362
        
           };

     

       373
       363
        
       

     
···

       414
       404
        
         # for more info.

     

       415
       405
        
         postInstall = lib.optionalString cudaSupport ''

     

       416
       406
        
           mkdir -p $out/bin

     

       417
       417
       -
           ln -s ${cudaPackagesGoogle.cuda_nvcc.bin}/bin/ptxas $out/bin/ptxas

     

       407
       407
       +
           ln -s ${cudaPackages.cuda_nvcc.bin}/bin/ptxas $out/bin/ptxas

     

       418
       408
        
       

     

       419
       409
        
           find $out -type f \( -name '*.so' -or -name '*.so.*' \) | while read lib; do

     

       420
       410
        
             patchelf --add-rpath "${lib.makeLibraryPath [cuda_libs_joined cudnn nccl]}" "$lib"

     
···

       423
       413
        
       

     

       424
       414
        
         nativeBuildInputs = lib.optionals cudaSupport [ autoAddDriverRunpath ];

     

       425
       415
        
       

     

       426
       426
       -
         propagatedBuildInputs = [

     

       416
       416
       +
         dependencies = [

     

       427
       417
        
           absl-py

     

       428
       418
        
           curl

     

       429
       419
        
           double-conversion

+17 -3

pkgs/development/python-modules/jaxopt/default.nix

···

       6
       6
        
       , fetchpatch

     

       7
       7
        
       , pytest-xdist

     

       8
       8
        
       , pytestCheckHook

     

       9
       9
       +
       , setuptools

     

       9
       10
        
       , absl-py

     

       10
       11
        
       , cvxpy

     

       11
       12
        
       , jax

     
···

       20
       21
        
       buildPythonPackage rec {

     

       21
       22
        
         pname = "jaxopt";

     

       22
       23
        
         version = "0.8.3";

     

       23
       23
       -
         format = "setuptools";

     

       24
       24
       +
         pyproject = true;

     

       24
       25
        
       

     

       25
       26
        
         disabled = pythonOlder "3.8";

     

       26
       27
        
       

     
···

       41
       42
        
           })

     

       42
       43
        
         ];

     

       43
       44
        
       

     

       44
       44
       -
         propagatedBuildInputs = [

     

       45
       45
       +
         build-system = [

     

       46
       46
       +
           setuptools

     

       47
       47
       +
         ];

     

       48
       48
       +
       

     

       49
       49
       +
         dependencies = [

     

       45
       50
        
           absl-py

     

       46
       51
        
           jax

     

       47
       52
        
           jaxlib

     
···

       66
       71
        
           "jaxopt.tree_util"

     

       67
       72
        
         ];

     

       68
       73
        
       

     

       69
       69
       -
         disabledTests = lib.optionals (stdenv.isLinux && stdenv.isAarch64) [

     

       74
       74
       +
         disabledTests = [

     

       75
       75
       +
           # https://github.com/google/jaxopt/issues/592

     

       76
       76
       +
           "test_solve_sparse"

     

       77
       77
       +
         ] ++ lib.optionals (stdenv.isLinux && stdenv.isAarch64) [

     

       70
       78
        
           # https://github.com/google/jaxopt/issues/577

     

       71
       79
        
           "test_binary_logit_log_likelihood"

     

       72
       80
        
           "test_solve_sparse"

     

       73
       81
        
           "test_logreg_with_intercept_manual_loop3"

     

       82
       82
       +
       

     

       83
       83
       +
           # https://github.com/google/jaxopt/issues/593

     

       84
       84
       +
           # Makes the test suite crash

     

       85
       85
       +
           "test_dtype_consistency"

     

       86
       86
       +
           # AssertionError: Array(0.01411963, dtype=float32) not less than or equal to 0.01

     

       87
       87
       +
           "test_multiclass_logreg6"

     

       74
       88
        
         ];

     

       75
       89
        
       

     

       76
       90
        
         meta = with lib; {

+4 -2

pkgs/development/python-modules/nanobind/default.nix

···

       51
       51
        
           scipy

     

       52
       52
        
           torch

     

       53
       53
        
           tensorflow

     

       54
       54
       -
           jax

     

       55
       55
       -
           jaxlib

     

       54
       54
       +
           # Uncomment at next release (1.9.3)

     

       55
       55
       +
           # See https://github.com/wjakob/nanobind/issues/578

     

       56
       56
       +
           # jax

     

       57
       57
       +
           # jaxlib

     

       56
       58
        
         ];

     

       57
       59
        
       

     

       58
       60
        
         meta = with lib; {

+7 -3

pkgs/development/python-modules/objax/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
       -
       , fetchpatch

     

       5
       4
        
       , jax

     

       6
       5
        
       , jaxlib

     

       7
       6
        
       , keras

     
···

       30
       29
        
           hash = "sha256-WD+pmR8cEay4iziRXqF3sHUzCMBjmLJ3wZ3iYOD+hzk=";

     

       31
       30
        
         };

     

       32
       31
        
       

     

       33
       33
       -
         nativeBuildInputs = [

     

       32
       32
       +
         patches = [

     

       33
       33
       +
           # Issue reported upstream: https://github.com/google/objax/issues/270

     

       34
       34
       +
           ./replace-deprecated-device_buffers.patch

     

       35
       35
       +
         ];

     

       36
       36
       +
       

     

       37
       37
       +
         build-system = [

     

       34
       38
        
           setuptools

     

       35
       39
        
         ];

     

       36
       40
        
       

     
···

       40
       44
        
           jaxlib

     

       41
       45
        
         ];

     

       42
       46
        
       

     

       43
       43
       -
         propagatedBuildInputs = [

     

       47
       47
       +
         dependencies = [

     

       44
       48
        
           jax

     

       45
       49
        
           numpy

     

       46
       50
        
           parameterized

+14

pkgs/development/python-modules/objax/replace-deprecated-device_buffers.patch

···

       1
       1
       +
       diff --git a/objax/util/util.py b/objax/util/util.py

     

       2
       2
       +
       index c31a356..344cf9a 100644

     

       3
       3
       +
       --- a/objax/util/util.py

     

       4
       4
       +
       +++ b/objax/util/util.py

     

       5
       5
       +
       @@ -117,7 +117,8 @@ def get_local_devices():

     

       6
       6
       +
            if _local_devices is None:

     

       7
       7
       +
                x = jn.zeros((jax.local_device_count(), 1), dtype=jn.float32)

     

       8
       8
       +
                sharded_x = map_to_device(x)

     

       9
       9
       +
       -        _local_devices = [b.device() for b in sharded_x.device_buffers]

     

       10
       10
       +
       +        device_buffers = [buf.data for buf in sharded_x.addressable_shards]

     

       11
       11
       +
       +        _local_devices = [list(b.devices())[0] for b in device_buffers]

     

       12
       12
       +
            return _local_devices

     

       13
       13
       +
        

     

       14
       14
       +

+2 -2

pkgs/development/python-modules/opower/default.nix

···

       13
       13
        
       

     

       14
       14
        
       buildPythonPackage rec {

     

       15
       15
        
         pname = "opower";

     

       16
       16
       -
         version = "0.4.4";

     

       16
       16
       +
         version = "0.4.5";

     

       17
       17
        
         pyproject = true;

     

       18
       18
        
       

     

       19
       19
        
         disabled = pythonOlder "3.9";

     
···

       22
       22
        
           owner = "tronikos";

     

       23
       23
        
           repo = "opower";

     

       24
       24
        
           rev = "refs/tags/v${version}";

     

       25
       25
       -
           hash = "sha256-GG7r0/rZcB4cuog3m0qCOrmcYiscPQggQhRC9sQGG40=";

     

       25
       25
       +
           hash = "sha256-PBxxLbVOvJSFmDXgKeI5sICUR7NJGUEUUahK9eBsvbE=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         build-system = [ setuptools ];

-27

pkgs/development/python-modules/pathlib/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , buildPythonPackage

     

       3
       3
       -
       , fetchPypi

     

       4
       4
       -
       , unittestCheckHook

     

       5
       5
       -
       , pythonAtLeast

     

       6
       6
       -
       }:

     

       7
       7
       -
       

     

       8
       8
       -
       buildPythonPackage rec {

     

       9
       9
       -
         pname = "pathlib";

     

       10
       10
       -
         version = "1.0.1";

     

       11
       11
       -
         format = "setuptools";

     

       12
       12
       -
         disabled = pythonAtLeast "3.4"; # Was added to std library in Python 3.4

     

       13
       13
       -
       

     

       14
       14
       -
         src = fetchPypi {

     

       15
       15
       -
           inherit pname version;

     

       16
       16
       -
           sha256 = "17zajiw4mjbkkv6ahp3xf025qglkj0805m9s41c45zryzj6p2h39";

     

       17
       17
       -
         };

     

       18
       18
       -
       

     

       19
       19
       -
         nativeCheckInputs = [ unittestCheckHook ];

     

       20
       20
       -
       

     

       21
       21
       -
         meta = {

     

       22
       22
       -
           description = "Object-oriented filesystem paths";

     

       23
       23
       -
           homepage = "https://pathlib.readthedocs.org/";

     

       24
       24
       -
           license = lib.licenses.mit;

     

       25
       25
       -
           maintainers = with lib.maintainers; [ ];

     

       26
       26
       -
         };

     

       27
       27
       -
       }

-37

pkgs/development/python-modules/pxml/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , pythonAtLeast

     

       3
       3
       -
       , buildPythonPackage

     

       4
       4
       -
       , fetchPypi

     

       5
       5
       -
       , blessings

     

       6
       6
       -
       , six

     

       7
       7
       -
       , nose

     

       8
       8
       -
       , coverage

     

       9
       9
       -
       }:

     

       10
       10
       -
       

     

       11
       11
       -
       buildPythonPackage rec {

     

       12
       12
       -
         pname = "pxml";

     

       13
       13
       -
         version = "0.2.13";

     

       14
       14
       -
         format = "setuptools";

     

       15
       15
       -
         disabled = pythonAtLeast "3.8";

     

       16
       16
       -
       

     

       17
       17
       -
         src = fetchPypi {

     

       18
       18
       -
           inherit pname version;

     

       19
       19
       -
           sha256 = "0c9zzfv6ciyf9qm7556wil45xxgykg1cj8isp1b88gimwcb2hxg4";

     

       20
       20
       -
         };

     

       21
       21
       -
       

     

       22
       22
       -
         propagatedBuildInputs = [ blessings six ];

     

       23
       23
       -
         nativeCheckInputs = [ nose coverage ];

     

       24
       24
       -
       

     

       25
       25
       -
         # test_prefixedWhitespace fails due to a python3 StringIO issue requiring

     

       26
       26
       -
         # bytes rather than str

     

       27
       27
       -
         checkPhase = ''

     

       28
       28
       -
           nosetests -e 'test_prefixedWhitespace'

     

       29
       29
       -
         '';

     

       30
       30
       -
       

     

       31
       31
       -
         meta = with lib; {

     

       32
       32
       -
           homepage = "https://github.com/metagriffin/pxml";

     

       33
       33
       -
           description = ''A python library and command-line tool to "prettify" and colorize XML.'';

     

       34
       34
       -
           maintainers = with maintainers; [ glittershark ];

     

       35
       35
       -
           license = licenses.gpl3;

     

       36
       36
       -
         };

     

       37
       37
       -
       }

+2 -2

pkgs/development/python-modules/pycrdt-websocket/default.nix

···

       18
       18
        
       

     

       19
       19
        
       buildPythonPackage rec {

     

       20
       20
        
         pname = "pycrdt-websocket";

     

       21
       21
       -
         version = "0.13.3";

     

       21
       21
       +
         version = "0.13.4";

     

       22
       22
        
         pyproject = true;

     

       23
       23
        
       

     

       24
       24
        
         disabled = pythonOlder "3.8";

     
···

       27
       27
        
           owner = "jupyter-server";

     

       28
       28
        
           repo = "pycrdt-websocket";

     

       29
       29
        
           rev = "refs/tags/v${version}";

     

       30
       30
       -
           hash = "sha256-4kxPRPb8XfbQHYmQqnSNfqywUZxQy5b0qWIryLDtP8w=";

     

       30
       30
       +
           hash = "sha256-nkm1ZQ6bYBRDDoREovhEthDZoHApYxzAnwVgDgpWW/s=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         build-system = [

+2 -2

pkgs/development/python-modules/pyexploitdb/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildPythonPackage rec {

     

       13
       13
        
         pname = "pyexploitdb";

     

       14
       14
       -
         version = "0.2.16";

     

       14
       14
       +
         version = "0.2.17";

     

       15
       15
        
         pyproject = true;

     

       16
       16
        
       

     

       17
       17
        
         disabled = pythonOlder "3.7";

     
···

       19
       19
        
         src = fetchPypi {

     

       20
       20
        
           pname = "pyExploitDb";

     

       21
       21
        
           inherit version;

     

       22
       22
       -
           hash = "sha256-PP9dR8Jl4eWsky3vO9Pgraw0plik/5aWvmOAEc2/Qpo=";

     

       22
       22
       +
           hash = "sha256-I7uDmKvHVx8mpqlq+kOyp57wCii8fy9ecJTSm7uHbZ0=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         build-system = [ setuptools ];

+19 -1

pkgs/development/python-modules/pymilter/default.nix

···

       1
       1
       -
       { lib, python, buildPythonPackage, fetchFromGitHub, libmilter, bsddb3, pydns, iana-etc, libredirect }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , python

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fetchFromGitHub

     

       5
       5
       +
       , fetchpatch

     

       6
       6
       +
       , libmilter

     

       7
       7
       +
       , bsddb3

     

       8
       8
       +
       , pydns

     

       9
       9
       +
       , iana-etc

     

       10
       10
       +
       , libredirect

     

       11
       11
       +
       , pyasyncore

     

       12
       12
       +
       }:

     

       2
       13
        
       

     

       3
       14
        
       buildPythonPackage rec {

     

       4
       15
        
         pname = "pymilter";

     
···

       13
       24
        
         };

     

       14
       25
        
       

     

       15
       26
        
         buildInputs = [ libmilter ];

     

       27
       27
       +
         nativeCheckInputs = [ pyasyncore ];

     

       16
       28
        
         propagatedBuildInputs = [ bsddb3 pydns ];

     

       29
       29
       +
         patches = [ (fetchpatch {

     

       30
       30
       +
           name = "Remove-calls-to-the-deprecated-method-assertEquals";

     

       31
       31
       +
           url = "https://github.com/sdgathman/pymilter/pull/57.patch";

     

       32
       32
       +
           hash = "sha256-/5LlDR15nMR3l7rkVjT3w4FbDTFAAgNdERWlPNL2TVg=";

     

       33
       33
       +
           })

     

       34
       34
       +
         ];

     

       17
       35
        
       

     

       18
       36
        
         preBuild = ''

     

       19
       37
        
           sed -i 's/import thread/import _thread as thread/' Milter/greylist.py

+21 -21

pkgs/development/python-modules/pynws/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , aiohttp

     

       3
       3
       -
       , buildPythonPackage

     

       4
       4
       -
       , fetchFromGitHub

     

       5
       5
       -
       , freezegun

     

       6
       6
       -
       , metar

     

       7
       7
       -
       , pytest-aiohttp

     

       8
       8
       -
       , pytest-asyncio

     

       9
       9
       -
       , pytest-cov

     

       10
       10
       -
       , pytestCheckHook

     

       11
       11
       -
       , pythonOlder

     

       12
       12
       -
       , setuptools

     

       13
       13
       -
       , setuptools-scm

     

       14
       14
       -
       , tenacity

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         aiohttp,

     

       4
       4
       +
         buildPythonPackage,

     

       5
       5
       +
         fetchFromGitHub,

     

       6
       6
       +
         freezegun,

     

       7
       7
       +
         metar,

     

       8
       8
       +
         pytest-aiohttp,

     

       9
       9
       +
         pytest-asyncio,

     

       10
       10
       +
         pytest-cov,

     

       11
       11
       +
         pytestCheckHook,

     

       12
       12
       +
         pythonOlder,

     

       13
       13
       +
         setuptools,

     

       14
       14
       +
         setuptools-scm,

     

       15
       15
       +
         tenacity,

     

       15
       16
        
       }:

     

       16
       17
        
       

     

       17
       18
        
       buildPythonPackage rec {

     

       18
       19
        
         pname = "pynws";

     

       19
       19
       -
         version = "1.7.0";

     

       20
       20
       +
         version = "1.8.0";

     

       20
       21
        
         pyproject = true;

     

       21
       22
        
       

     

       22
       22
       -
         disabled = pythonOlder "3.6";

     

       23
       23
       +
         disabled = pythonOlder "3.8";

     

       23
       24
        
       

     

       24
       25
        
         src = fetchFromGitHub {

     

       25
       26
        
           owner = "MatthewFlamm";

     

       26
       26
       -
           repo = pname;

     

       27
       27
       +
           repo = "pynws";

     

       27
       28
        
           rev = "refs/tags/v${version}";

     

       28
       28
       -
           hash = "sha256-JjXGDjLITzJxEmCIv7RPvb+Jqe9hm++ptpJOryuK9M0=";

     

       29
       29
       +
           hash = "sha256-KUCylHYng6mn2TWKf8C7k0IoerM22OIQ7pJMKi5SF3A=";

     

       29
       30
        
         };

     

       30
       31
        
       

     

       31
       32
        
         build-system = [

     
···

       38
       39
        
           metar

     

       39
       40
        
         ];

     

       40
       41
        
       

     

       41
       41
       -
         optional-dependencies.retry = [

     

       42
       42
       -
           tenacity

     

       43
       43
       -
         ];

     

       42
       42
       +
         optional-dependencies.retry = [ tenacity ];

     

       44
       43
        
       

     

       45
       44
        
         nativeCheckInputs = [

     

       46
       45
        
           freezegun

     
···

       55
       54
        
         meta = with lib; {

     

       56
       55
        
           description = "Python library to retrieve data from NWS/NOAA";

     

       57
       56
        
           homepage = "https://github.com/MatthewFlamm/pynws";

     

       57
       57
       +
           changelog = "https://github.com/MatthewFlamm/pynws/releases/tag/v${version}";

     

       58
       58
        
           license = with licenses; [ mit ];

     

       59
       59
        
           maintainers = with maintainers; [ fab ];

     

       60
       60
        
         };

+1 -5

pkgs/development/python-modules/pyscss/default.nix

···

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , pytestCheckHook

     

       5
       5
        
       , six

     

       6
       6
       -
       , enum34

     

       7
       7
       -
       , pathlib

     

       8
       8
       -
       , pythonOlder

     

       9
       6
        
       }:

     

       10
       7
        
       

     

       11
       8
        
       buildPythonPackage rec {

     
···

       21
       18
        
       

     

       22
       19
        
         nativeCheckInputs = [ pytestCheckHook ];

     

       23
       20
        
       

     

       24
       24
       -
         propagatedBuildInputs = [ six ]

     

       25
       25
       -
           ++ lib.optionals (pythonOlder "3.4") [ enum34 pathlib ];

     

       21
       21
       +
         propagatedBuildInputs = [ six ];

     

       26
       22
        
       

     

       27
       23
        
         # Test suite is broken.

     

       28
       24
        
         # See https://github.com/Kronuz/pyScss/issues/415

+2 -2

pkgs/development/python-modules/pysigma-backend-insightidr/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "pysigma-backend-insightidr";

     

       13
       13
       -
         version = "0.2.2";

     

       13
       13
       +
         version = "0.2.3";

     

       14
       14
        
         format = "pyproject";

     

       15
       15
        
       

     

       16
       16
        
         disabled = pythonOlder "3.8";

     
···

       19
       19
        
           owner = "SigmaHQ";

     

       20
       20
        
           repo = "pySigma-backend-insightidr";

     

       21
       21
        
           rev = "refs/tags/v${version}";

     

       22
       22
       -
           hash = "sha256-B42MADteF0+GC/CPJPLaTGdGcQjC8KEsK9u3tBmtObg=";

     

       22
       22
       +
           hash = "sha256-wQMnnJ0KU+53MS3PIBkwIhUiyUdCrDbdUT6upk2Pp/8=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         nativeBuildInputs = [

+2 -2

pkgs/development/python-modules/pytrydan/default.nix

···

       17
       17
        
       

     

       18
       18
        
       buildPythonPackage rec {

     

       19
       19
        
         pname = "pytrydan";

     

       20
       20
       -
         version = "0.6.0";

     

       20
       20
       +
         version = "0.6.1";

     

       21
       21
        
         pyproject = true;

     

       22
       22
        
       

     

       23
       23
        
         disabled = pythonOlder "3.10";

     
···

       26
       26
        
           owner = "dgomes";

     

       27
       27
        
           repo = "pytrydan";

     

       28
       28
        
           rev = "refs/tags/v${version}";

     

       29
       29
       -
           hash = "sha256-+hFwBFYtRseVwesZtSrL3J/ZnsMAjD2ZAhTlk41hfqU=";

     

       29
       29
       +
           hash = "sha256-5sTHfxNV4JEonGke8ZZ/pXoLA15iCuJ/iSW1XwFMltg=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         postPatch = ''

+5 -5

pkgs/development/python-modules/qtile/default.nix

···

       34
       34
        
       buildPythonPackage rec {

     

       35
       35
        
         pname = "qtile";

     

       36
       36
        
         version = "0.25.0";

     

       37
       37
       -
         format = "setuptools";

     

       37
       37
       +
         pyproject = true;

     

       38
       38
        
       

     

       39
       39
        
         src = fetchFromGitHub {

     

       40
       40
        
           owner = "qtile";

     
···

       59
       59
        
               --replace /usr/include/libdrm ${lib.getDev libdrm}/include/libdrm

     

       60
       60
        
         '';

     

       61
       61
        
       

     

       62
       62
       -
         nativeBuildInputs = [

     

       63
       63
       -
           pkg-config

     

       62
       62
       +
         build-system = [

     

       64
       63
        
           setuptools

     

       65
       64
        
           setuptools-scm

     

       65
       65
       +
           pkg-config

     

       66
       66
        
         ];

     

       67
       67
        
       

     

       68
       68
       -
         propagatedBuildInputs = [

     

       68
       68
       +
         dependencies = [

     

       69
       69
        
           (cairocffi.override { withXcffib = true; })

     

       70
       70
        
           dbus-next

     

       71
       71
        
           dbus-python

     
···

       102
       102
        
           description = "A small, flexible, scriptable tiling window manager written in Python";

     

       103
       103
        
           mainProgram = "qtile";

     

       104
       104
        
           platforms = platforms.linux;

     

       105
       105
       -
           maintainers = with maintainers; [ arjan-s ];

     

       105
       105
       +
           maintainers = with maintainers; [ arjan-s sigmanificient ];

     

       106
       106
        
         };

     

       107
       107
        
       }

+1 -4

pkgs/development/python-modules/slicedimage/default.nix

···

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , boto3

     

       5
       5
        
       , diskcache

     

       6
       6
       -
       , enum34

     

       7
       6
        
       , packaging

     

       8
       8
       -
       , pathlib

     

       9
       7
        
       , numpy

     

       10
       8
        
       , requests

     

       11
       9
        
       , scikit-image

     

       12
       10
        
       , six

     

       13
       11
        
       , pytestCheckHook

     

       14
       14
       -
       , isPy27

     

       15
       12
        
       , tifffile

     

       16
       13
        
       }:

     

       17
       14
        
       

     
···

       36
       33
        
           scikit-image

     

       37
       34
        
           six

     

       38
       35
        
           tifffile

     

       39
       39
       -
         ] ++ lib.optionals isPy27 [ pathlib enum34 ];

     

       36
       36
       +
         ];

     

       40
       37
        
       

     

       41
       38
        
         nativeCheckInputs = [

     

       42
       39
        
           pytestCheckHook

+2 -2

pkgs/development/python-modules/snakemake-storage-plugin-s3/default.nix

···

       12
       12
        
       

     

       13
       13
        
       buildPythonPackage rec {

     

       14
       14
        
         pname = "snakemake-storage-plugin-s3";

     

       15
       15
       -
         version = "0.2.10";

     

       15
       15
       +
         version = "0.2.11";

     

       16
       16
        
         format = "pyproject";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "snakemake";

     

       20
       20
        
           repo = pname;

     

       21
       21
        
           rev = "refs/tags/v${version}";

     

       22
       22
       -
           hash = "sha256-k21DRQdSUFkdwNb7MZJmClhIg+pdSc7H6FkDrbf4DT8=";

     

       22
       22
       +
           hash = "sha256-pAMrWJe4+PWHglZ/C83Af+uHBg9wupfSlH4W8CvO9as=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         postPatch = ''

+2 -2

pkgs/development/python-modules/sphinxcontrib-confluencebuilder/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "sphinxcontrib-confluencebuilder";

     

       13
       13
       -
         version = "2.5.1";

     

       13
       13
       +
         version = "2.5.2";

     

       14
       14
        
         format = "pyproject";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchPypi {

     

       17
       17
        
           pname = "sphinxcontrib_confluencebuilder";

     

       18
       18
        
           inherit version;

     

       19
       19
       -
           hash = "sha256-PQpkwQ95UVJwDGTAq1xdcSvd07FZpZfA/4jq3ywlMas=";

     

       19
       19
       +
           hash = "sha256-FwjjlMTIhAD/v4Ig+uqrJJybdPqpPG+7OMuJwSqWo84=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         nativeBuildInputs = [

+2 -5

pkgs/development/python-modules/sqlbag/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
       -
       , isPy27

     

       5
       4
        
       , psycopg2

     

       6
       5
        
       , pymysql

     

       7
       6
        
       , sqlalchemy

     

       8
       8
       -
       , pathlib

     

       9
       7
        
       , six

     

       10
       8
        
       , flask

     

       11
       9
        
       , pendulum

     
···

       17
       15
        
       , pytest-sugar

     

       18
       16
        
       , postgresql

     

       19
       17
        
       , postgresqlTestHook

     

       20
       20
       -
       ,

     

       21
       18
        
       }:

     

       22
       19
        
       buildPythonPackage rec {

     

       23
       20
        
         pname = "sqlbag";

     
···

       46
       43
        
             pymysql

     

       47
       44
        
       

     

       48
       45
        
             setuptools # needed for 'pkg_resources'

     

       49
       49
       -
           ]

     

       50
       50
       -
           ++ lib.optional isPy27 pathlib;

     

       46
       46
       +
           ];

     

       51
       47
        
       

     

       52
       48
        
         nativeCheckInputs = [

     

       53
       49
        
           pytestCheckHook

     
···

       91
       87
        
           homepage = "https://github.com/djrobstep/sqlbag";

     

       92
       88
        
           license = with licenses; [ unlicense ];

     

       93
       89
        
           maintainers = with maintainers; [ soispha ];

     

       90
       90
       +
           broken = true; # Fails to build against the current flask version

     

       94
       91
        
         };

     

       95
       92
        
       }

-23

pkgs/development/python-modules/sqlsoup/default.nix

···

       1
       1
       -
       { buildPythonPackage, fetchPypi, lib, sqlalchemy, nose }:

     

       2
       2
       -
       

     

       3
       3
       -
       buildPythonPackage rec {

     

       4
       4
       -
         pname = "sqlsoup";

     

       5
       5
       -
         version = "0.9.1";

     

       6
       6
       -
         format = "setuptools";

     

       7
       7
       -
       

     

       8
       8
       -
         src = fetchPypi {

     

       9
       9
       -
           inherit pname version;

     

       10
       10
       -
           sha256 = "1mj00fhxj75ac3i8xk9jmm7hvcjz9p4x2r3yndcwsgb659rvgbrg";

     

       11
       11
       -
         };

     

       12
       12
       -
       

     

       13
       13
       -
         propagatedBuildInputs = [ sqlalchemy ];

     

       14
       14
       -
         nativeCheckInputs = [ nose ];

     

       15
       15
       -
       

     

       16
       16
       -
         meta = with lib; {

     

       17
       17
       -
           description = "A one step database access tool, built on the SQLAlchemy ORM";

     

       18
       18
       -
           homepage = "https://github.com/zzzeek/sqlsoup";

     

       19
       19
       -
           license = licenses.mit;

     

       20
       20
       -
           maintainers = [];

     

       21
       21
       -
           broken = true; # incompatible with sqlalchemy>=1.4 and unmaintained since 2016

     

       22
       22
       -
         };

     

       23
       23
       -
       }

pkgs/development/python-modules/stem/default.nix

···

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , pythonOlder

     

       4
       4
        
       , fetchFromGitHub

     

       5
       5
       +
       , fetchpatch

     

       5
       6
        
       , setuptools

     

       6
       7
        
       , cryptography

     

       7
       8
        
       , mock

     
···

       22
       23
        
           rev = "9a9c7d43a7fdcde6d4a9cf95b831fb5e5923a160";

     

       23
       24
        
           hash = "sha256-Oc73Jx31SLzuhT9Iym5HHszKfflKZ+3aky5flXudvmI=";

     

       24
       25
        
         };

     

       26
       26
       +
       

     

       27
       27
       +
         patches = [

     

       28
       28
       +
           # fixes deprecated test assertion, assertRaisesRegexp in python 3

     

       29
       29
       +
           (fetchpatch {

     

       30
       30
       +
             url = "https://github.com/trishtzy/stem/commit/d5012a1039f05c69ebe832723ce96ecbe8f79fe1.patch";

     

       31
       31
       +
             hash = "sha256-ozOTx4/c86sW/9Ss5eZ6ZxX63ByJT5x7JF6wBBd+VFY=";

     

       32
       32
       +
           })

     

       33
       33
       +
         ];

     

       25
       34
        
       

     

       26
       35
        
         nativeBuildInputs = [

     

       27
       36
        
           setuptools

+2 -2

pkgs/development/python-modules/tencentcloud-sdk-python/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "tencentcloud-sdk-python";

     

       13
       13
       -
         version = "3.0.1143";

     

       13
       13
       +
         version = "3.0.1144";

     

       14
       14
        
         pyproject = true;

     

       15
       15
        
       

     

       16
       16
        
         disabled = pythonOlder "3.9";

     
···

       19
       19
        
           owner = "TencentCloud";

     

       20
       20
        
           repo = "tencentcloud-sdk-python";

     

       21
       21
        
           rev = "refs/tags/${version}";

     

       22
       22
       -
           hash = "sha256-xUjOgqhHk1Yj0WNcx051kqRmpg/YqVVvA40ueIDkr10=";

     

       22
       22
       +
           hash = "sha256-cUuigY67wgYj6DvFiplXJbqcLNKxH9odeG5a8bSZ7/8=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         build-system = [ setuptools ];

+2 -6

pkgs/development/python-modules/tensorflow/bin.nix

···

       22
       22
        
       , tensorboard

     

       23
       23
        
       , config

     

       24
       24
        
       , cudaSupport ? config.cudaSupport

     

       25
       25
       -
       , cudaPackagesGoogle

     

       25
       25
       +
       , cudaPackages

     

       26
       26
        
       , zlib

     

       27
       27
        
       , python

     

       28
       28
        
       , keras-applications

     
···

       43
       43
        
       

     

       44
       44
        
       let

     

       45
       45
        
         packages = import ./binary-hashes.nix;

     

       46
       46
       -
         inherit (cudaPackagesGoogle) cudatoolkit cudnn;

     

       46
       46
       +
         inherit (cudaPackages) cudatoolkit cudnn;

     

       47
       47
        
       in buildPythonPackage {

     

       48
       48
        
         pname = "tensorflow" + lib.optionalString cudaSupport "-gpu";

     

       49
       49
        
         inherit (packages) version;

     
···

       198
       198
        
           "tensorflow.python"

     

       199
       199
        
           "tensorflow.python.framework"

     

       200
       200
        
         ];

     

       201
       201
       -
       

     

       202
       202
       -
         passthru = {

     

       203
       203
       -
           cudaPackages = cudaPackagesGoogle;

     

       204
       204
       -
         };

     

       205
       201
        
       

     

       206
       202
        
         meta = with lib; {

     

       207
       203
        
           description = "Computation using data flow graphs for scalable machine learning";

+7 -8

pkgs/development/python-modules/tensorflow/default.nix

···

       19
       19
        
       # https://groups.google.com/a/tensorflow.org/forum/#!topic/developers/iRCt5m4qUz0

     

       20
       20
        
       , config

     

       21
       21
        
       , cudaSupport ? config.cudaSupport

     

       22
       22
       -
       , cudaPackagesGoogle

     

       23
       23
       -
       , cudaCapabilities ? cudaPackagesGoogle.cudaFlags.cudaCapabilities

     

       22
       22
       +
       , cudaPackages

     

       23
       23
       +
       , cudaCapabilities ? cudaPackages.cudaFlags.cudaCapabilities

     

       24
       24
        
       , mklSupport ? false, mkl

     

       25
       25
        
       , tensorboardSupport ? true

     

       26
       26
        
       # XLA without CUDA is broken

     
···

       50
       50
        
         # __ZN4llvm11SmallPtrSetIPKNS_10AllocaInstELj8EED1Ev in any of the

     

       51
       51
        
         # translation units, so the build fails at link time

     

       52
       52
        
         stdenv =

     

       53
       53
       -
           if cudaSupport then cudaPackagesGoogle.backendStdenv

     

       53
       53
       +
           if cudaSupport then cudaPackages.backendStdenv

     

       54
       54
        
           else if originalStdenv.isDarwin then llvmPackages.stdenv

     

       55
       55
        
           else originalStdenv;

     

       56
       56
       -
         inherit (cudaPackagesGoogle) cudatoolkit nccl;

     

       56
       56
       +
         inherit (cudaPackages) cudatoolkit nccl;

     

       57
       57
        
         # use compatible cuDNN (https://www.tensorflow.org/install/source#gpu)

     

       58
       58
        
         # cudaPackages.cudnn led to this:

     

       59
       59
        
         # https://github.com/tensorflow/tensorflow/issues/60398

     

       60
       60
        
         cudnnAttribute = "cudnn_8_6";

     

       61
       61
       -
         cudnn = cudaPackagesGoogle.${cudnnAttribute};

     

       61
       61
       +
         cudnn = cudaPackages.${cudnnAttribute};

     

       62
       62
        
         gentoo-patches = fetchzip {

     

       63
       63
        
           url = "https://dev.gentoo.org/~perfinion/patches/tensorflow-patches-2.12.0.tar.bz2";

     

       64
       64
        
           hash = "sha256-SCRX/5/zML7LmKEPJkcM5Tebez9vv/gmE4xhT/jyqWs=";

     
···

       490
       490
        
             broken =

     

       491
       491
        
               stdenv.isDarwin

     

       492
       492
        
               || !(xlaSupport -> cudaSupport)

     

       493
       493
       -
               || !(cudaSupport -> builtins.hasAttr cudnnAttribute cudaPackagesGoogle)

     

       494
       494
       -
               || !(cudaSupport -> cudaPackagesGoogle ? cudatoolkit);

     

       493
       493
       +
               || !(cudaSupport -> builtins.hasAttr cudnnAttribute cudaPackages)

     

       494
       494
       +
               || !(cudaSupport -> cudaPackages ? cudatoolkit);

     

       495
       495
        
           } // lib.optionalAttrs stdenv.isDarwin {

     

       496
       496
        
             timeout = 86400; # 24 hours

     

       497
       497
        
             maxSilent = 14400; # 4h, double the default of 7200s

     
···

       594
       594
        
         # Regression test for #77626 removed because not more `tensorflow.contrib`.

     

       595
       595
        
       

     

       596
       596
        
         passthru = {

     

       597
       597
       -
           cudaPackages = cudaPackagesGoogle;

     

       598
       597
        
           deps = bazel-build.deps;

     

       599
       598
        
           libtensorflow = bazel-build.out;

     

       600
       599
        
         };

+4 -2

pkgs/development/ruby-modules/gem-config/default.nix

···

       586
       586
        
           ];

     

       587
       587
        
         };

     

       588
       588
        
       

     

       589
       589
       -
         nokogiri = attrs: {

     

       589
       589
       +
         nokogiri = attrs: ({

     

       590
       590
        
           buildFlags = [

     

       591
       591
        
             "--use-system-libraries"

     

       592
       592
        
             "--with-zlib-lib=${zlib.out}/lib"

     
···

       601
       601
        
             "--with-iconv-dir=${libiconv}"

     

       602
       602
        
             "--with-opt-include=${libiconv}/include"

     

       603
       603
        
           ];

     

       604
       604
       -
         };

     

       604
       604
       +
         } // lib.optionalAttrs stdenv.isDarwin {

     

       605
       605
       +
           buildInputs = [ libxml2 ];

     

       606
       606
       +
         });

     

       605
       607
        
       

     

       606
       608
        
         openssl = attrs: {

     

       607
       609
        
           # https://github.com/ruby/openssl/issues/369

+2 -2

pkgs/development/tools/analysis/checkov/default.nix

···

       6
       6
        
       

     

       7
       7
        
       python3.pkgs.buildPythonApplication rec {

     

       8
       8
        
         pname = "checkov";

     

       9
       9
       -
         version = "3.2.90";

     

       9
       9
       +
         version = "3.2.91";

     

       10
       10
        
         pyproject = true;

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "bridgecrewio";

     

       14
       14
        
           repo = "checkov";

     

       15
       15
        
           rev = "refs/tags/${version}";

     

       16
       16
       -
           hash = "sha256-I/fSguqs5h4YTP/6whBFYceYd4tC8wrh+PfW8i7+kpY=";

     

       16
       16
       +
           hash = "sha256-lw89E7xD1tSAxgf1bwuPojOikOqIBfisePAtTGHXr4c=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         patches = [ ./flake8-compat-5.x.patch ];

+3 -3

pkgs/development/tools/changie/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildGoModule rec {

     

       8
       8
        
         pname = "changie";

     

       9
       9
       -
         version = "1.18.0";

     

       9
       9
       +
         version = "1.19.0";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "miniscruff";

     

       13
       13
        
           repo = "changie";

     

       14
       14
        
           rev = "v${version}";

     

       15
       15
       -
           hash = "sha256-pZe9T/WALFX5xwCiZKbf8fpaG3wmBJbqgM7FTPqlN2k=";

     

       15
       15
       +
           hash = "sha256-3GQ9C9UteJG3LfJmDsBbFJ9hnz7ouQ/6bZkQ/8CZ8PI=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         vendorHash = "sha256-SdaDu9LXgelSEXdOCAbtvt1LnrSVpAIoN6MDSjTeEOs=";

     

       18
       18
       +
         vendorHash = "sha256-2SkHId5BDAv525PISLjlrP862Z2fJDN4L839rz8rWaw=";

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [

     

       21
       21
        
           installShellFiles

+3 -3

pkgs/development/tools/language-servers/fortls/default.nix

···

       8
       8
        
       

     

       9
       9
        
       buildPythonApplication rec {

     

       10
       10
        
         pname = "fortls";

     

       11
       11
       -
         version = "2.13.0";

     

       11
       11
       +
         version = "3.0.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "fortran-lang";

     

       15
       15
        
           repo = pname;

     

       16
       16
       -
           rev = "v${version}";

     

       17
       17
       -
           hash = "sha256-kFk2Dlnb0FXM3Ysvsy+g2AAMgpWmwzxuyJPovDm/FJU=";

     

       16
       16
       +
           rev = "refs/tags/v${version}";

     

       17
       17
       +
           hash = "sha256-kRL4kLX1T2Sontl8f3VO8Hb7uI41JwhZBiH//gdcmNE=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [ setuptools-scm ];

+5 -5

pkgs/development/tools/mysql-shell/default.nix

···

       37
       37
        
       in

     

       38
       38
        
       stdenv.mkDerivation (finalAttrs: {

     

       39
       39
        
         pname = "mysql-shell";

     

       40
       40
       -
         version = "8.0.36";

     

       40
       40
       +
         version = "8.0.37";

     

       41
       41
        
       

     

       42
       42
        
         srcs = [

     

       43
       43
        
           (fetchurl {

     

       44
       44
       -
             url = "https://cdn.mysql.com//Downloads/MySQL-${lib.versions.majorMinor finalAttrs.version}/mysql-${finalAttrs.version}.tar.gz";

     

       45
       45
       -
             hash = "sha256-9PJwa5WKinOA72yVjdlyMHvb7qRR76/DQuTEbim36d0=";

     

       44
       44
       +
             url = "https://dev.mysql.com/get/Downloads/MySQL-${lib.versions.majorMinor finalAttrs.version}/mysql-${finalAttrs.version}.tar.gz";

     

       45
       45
       +
             hash = "sha256-4GOgkazZ7EC7BfLATfZPiZan5OJuiDu2UChJ1fa0pho=";

     

       46
       46
        
           })

     

       47
       47
        
           (fetchurl {

     

       48
       48
       -
             url = "https://cdn.mysql.com//Downloads/MySQL-Shell/mysql-shell-${finalAttrs.version}-src.tar.gz";

     

       49
       49
       -
             hash = "sha256-s0+7dbcLcgS8u/6p7vpVAV9sR2gf2j9VDnSCJvw77fQ=";

     

       48
       48
       +
             url = "https://dev.mysql.com/get/Downloads/MySQL-Shell/mysql-shell-${finalAttrs.version}-src.tar.gz";

     

       49
       49
       +
             hash = "sha256-UtZ7/Ip5h9CXKy3lkSt8/TXJgbPPUO73rMSIFPfX0Is=";

     

       50
       50
        
           })

     

       51
       51
        
         ];

     

       52
       52

pkgs/development/tools/treefmt/default.nix pkgs/by-name/tr/treefmt/package.nix

+20

pkgs/kde/gear/kdeconnect-kde/default.nix

···

       1
       1
        
       {

     

       2
       2
       +
         lib,

     

       2
       3
        
         mkKdeDerivation,

     

       4
       4
       +
         substituteAll,

     

       5
       5
       +
         sshfs,

     

       3
       6
        
         qtconnectivity,

     

       4
       7
        
         qtmultimedia,

     

       5
       8
        
         qtwayland,

     
···

       10
       13
        
       }:

     

       11
       14
        
       mkKdeDerivation {

     

       12
       15
        
         pname = "kdeconnect-kde";

     

       16
       16
       +
       

     

       17
       17
       +
         patches = [

     

       18
       18
       +
           (substituteAll {

     

       19
       19
       +
             src = ./hardcode-sshfs-path.patch;

     

       20
       20
       +
             sshfs = lib.getExe sshfs;

     

       21
       21
       +
           })

     

       22
       22
       +
           # We build OpenSSH without ssh-dss support, so sshfs explodes at runtime.

     

       23
       23
       +
           # See: https://github.com/NixOS/nixpkgs/commit/6ee4b8c8bf815567f7d0fa131576d2b8c0a18167

     

       24
       24
       +
           # FIXME: upstream?

     

       25
       25
       +
           ./remove-ssh-dss.patch

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         # Hardcoded as a QString, which is UTF-16 so Nix can't pick it up automatically

     

       29
       29
       +
         postFixup = ''

     

       30
       30
       +
           mkdir -p $out/nix-support

     

       31
       31
       +
           echo "${sshfs}" > $out/nix-support/depends

     

       32
       32
       +
         '';

     

       13
       33
        
       

     

       14
       34
        
         extraNativeBuildInputs = [pkg-config];

     

       15
       35
        
         extraBuildInputs = [qtconnectivity qtmultimedia qtwayland wayland wayland-protocols libfakekey];

+13

pkgs/kde/gear/kdeconnect-kde/hardcode-sshfs-path.patch

···

       1
       1
       +
       diff --git a/plugins/sftp/mounter.cpp b/plugins/sftp/mounter.cpp

     

       2
       2
       +
       index 29e94f3b..c71e552f 100644

     

       3
       3
       +
       --- a/plugins/sftp/mounter.cpp

     

       4
       4
       +
       +++ b/plugins/sftp/mounter.cpp

     

       5
       5
       +
       @@ -94,7 +94,7 @@ void Mounter::onPacketReceived(const NetworkPacket &np)

     

       6
       6
       +
        

     

       7
       7
       +
            QDir().mkpath(m_mountPoint);

     

       8
       8
       +
        

     

       9
       9
       +
       -    const QString program = QStringLiteral("sshfs");

     

       10
       10
       +
       +    const QString program = QStringLiteral("@sshfs@");

     

       11
       11
       +
        

     

       12
       12
       +
            QString path;

     

       13
       13
       +
            if (np.has(QStringLiteral("multiPaths")))

+13

pkgs/kde/gear/kdeconnect-kde/remove-ssh-dss.patch

···

       1
       1
       +
       diff --git a/plugins/sftp/mounter.cpp b/plugins/sftp/mounter.cpp

     

       2
       2
       +
       index 29e94f3b..0f300c63 100644

     

       3
       3
       +
       --- a/plugins/sftp/mounter.cpp

     

       4
       4
       +
       +++ b/plugins/sftp/mounter.cpp

     

       5
       5
       +
       @@ -122,7 +122,7 @@ void Mounter::onPacketReceived(const NetworkPacket &np)

     

       6
       6
       +
                              << QStringLiteral("-o") << QStringLiteral("IdentityFile=") + KdeConnectConfig::instance().privateKeyPath()

     

       7
       7
       +
                              << QStringLiteral("-o") << QStringLiteral("StrictHostKeyChecking=no") // Do not ask for confirmation because it is not a known host

     

       8
       8
       +
                              << QStringLiteral("-o") << QStringLiteral("UserKnownHostsFile=/dev/null") // Prevent storing as a known host

     

       9
       9
       +
       -                      << QStringLiteral("-o") << QStringLiteral("HostKeyAlgorithms=+ssh-dss\\,ssh-rsa") // https://bugs.kde.org/show_bug.cgi?id=351725

     

       10
       10
       +
       +                      << QStringLiteral("-o") << QStringLiteral("HostKeyAlgorithms=+ssh-rsa") // https://bugs.kde.org/show_bug.cgi?id=351725

     

       11
       11
       +
                              << QStringLiteral("-o") << QStringLiteral("PubkeyAcceptedKeyTypes=+ssh-rsa") // https://bugs.kde.org/show_bug.cgi?id=443155

     

       12
       12
       +
                              << QStringLiteral("-o") << QStringLiteral("uid=") + QString::number(getuid())

     

       13
       13
       +
                              << QStringLiteral("-o") << QStringLiteral("gid=") + QString::number(getgid())

+2 -2

pkgs/os-specific/darwin/rectangle/default.nix

···

       7
       7
        
       

     

       8
       8
        
       stdenvNoCC.mkDerivation rec {

     

       9
       9
        
         pname = "rectangle";

     

       10
       10
       -
         version = "0.77";

     

       10
       10
       +
         version = "0.79";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchurl {

     

       13
       13
        
           url = "https://github.com/rxhanson/Rectangle/releases/download/v${version}/Rectangle${version}.dmg";

     

       14
       14
       -
           hash = "sha256-wViFngw6iwlOG7KsW+zqxjm9ZRJahscX0TYz7/7T5nw=";

     

       14
       14
       +
           hash = "sha256-XczwgLONTt7wL+oW1ruw6wBwZTMd5VyN+79xJy0NUIg=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         sourceRoot = ".";

+1 -5

pkgs/os-specific/linux/mstflint_access/default.nix

···

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://github.com/Mellanox/mstflint/releases/download/v${version}/kernel-mstflint-${version}.tar.gz";

     

       9
       9
       -
           hash = "sha256-rfZts0m8x6clVazpbAa2xK+dYgRU9Us5rbcWa0uHJ1M=";

     

       9
       9
       +
           hash = "sha256-bWYglHJUNCPT13N7aBdjbLPMZIk7vjvF+o9W3abDNr0=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         nativeBuildInputs = [ kmod ] ++ kernel.moduleBuildDependencies;

     
···

       17
       17
        
         ];

     

       18
       18
        
       

     

       19
       19
        
         enableParallelBuilding = true;

     

       20
       20
       -
       

     

       21
       21
       -
         preConfigure = lib.optionals (lib.versionAtLeast kernel.version "6.4") ''

     

       22
       22
       -
           sed -i "s/class_create(THIS_MODULE, dev->name)/class_create(dev->name)/g" mst_main.c

     

       23
       23
       -
         '';

     

       24
       20
        
       

     

       25
       21
        
         installPhase = ''

     

       26
       22
        
           runHook preInstall

+11 -9

pkgs/servers/home-assistant/custom-components/xiaomi_gateway3/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , buildHomeAssistantComponent

     

       3
       3
       -
       , fetchFromGitHub

     

       4
       4
       -
       , zigpy

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         buildHomeAssistantComponent,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         zigpy,

     

       6
       6
       +
         nix-update-script,

     

       5
       7
        
       }:

     

       6
       8
        
       

     

       7
       9
        
       buildHomeAssistantComponent rec {

     

       8
       10
        
         owner = "AlexxIT";

     

       9
       11
        
         domain = "xiaomi_gateway3";

     

       10
       10
       -
         version = "4.0.3";

     

       12
       12
       +
         version = "4.0.5";

     

       11
       13
        
       

     

       12
       14
        
         src = fetchFromGitHub {

     

       13
       15
        
           owner = "AlexxIT";

     

       14
       16
        
           repo = "XiaomiGateway3";

     

       15
       17
        
           rev = "v${version}";

     

       16
       16
       -
           hash = "sha256-YGaVQaz3A0yM8AIC02CvMKWMJ3tW3OADYgKY8ViIt5U=";

     

       18
       18
       +
           hash = "sha256-C8aY23e6iWANbhCRQYNHx+3fomVO+7qdxj+qfv+K3JM=";

     

       17
       19
        
         };

     

       18
       20
        
       

     

       19
       19
       -
         propagatedBuildInputs = [

     

       20
       20
       -
           zigpy

     

       21
       21
       -
         ];

     

       21
       21
       +
         propagatedBuildInputs = [ zigpy ];

     

       22
       22
        
       

     

       23
       23
        
         dontBuild = true;

     

       24
       24
       +
       

     

       25
       25
       +
         passthru.updateScript = nix-update-script { };

     

       24
       26
        
       

     

       25
       27
        
         meta = with lib; {

     

       26
       28
        
           changelog = "https://github.com/AlexxIT/XiaomiGateway3/releases/tag/v{version}";

+13 -9

pkgs/servers/home-assistant/custom-components/xiaomi_miot/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , buildHomeAssistantComponent

     

       3
       3
       -
       , fetchFromGitHub

     

       4
       4
       -
       , hap-python

     

       5
       5
       -
       , micloud

     

       6
       6
       -
       , pyqrcode

     

       7
       7
       -
       , python-miio

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         buildHomeAssistantComponent,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         hap-python,

     

       6
       6
       +
         micloud,

     

       7
       7
       +
         pyqrcode,

     

       8
       8
       +
         python-miio,

     

       9
       9
       +
         nix-update-script,

     

       8
       10
        
       }:

     

       9
       11
        
       

     

       10
       12
        
       buildHomeAssistantComponent rec {

     

       11
       13
        
         owner = "al-one";

     

       12
       14
        
         domain = "xiaomi_miot";

     

       13
       13
       -
         version = "0.7.17";

     

       15
       15
       +
         version = "0.7.18";

     

       14
       16
        
       

     

       15
       17
        
         src = fetchFromGitHub {

     

       16
       18
        
           owner = "al-one";

     

       17
       19
        
           repo = "hass-xiaomi-miot";

     

       18
       20
        
           rev = "v${version}";

     

       19
       19
       -
           hash = "sha256-IpL4e2mKCdtNu8NtI+xpx4FPW/uj1M5Rk6DswXmSJBk=";

     

       21
       21
       +
           hash = "sha256-/Zn2jEjwkCHiz48nVjKEPcCpPVajLaZ81DCTNpx1vbk=";

     

       20
       22
        
         };

     

       21
       23
        
       

     

       22
       24
        
         propagatedBuildInputs = [

     
···

       27
       29
        
         ];

     

       28
       30
        
       

     

       29
       31
        
         dontBuild = true;

     

       32
       32
       +
       

     

       33
       33
       +
         passthru.updateScript = nix-update-script { };

     

       30
       34
        
       

     

       31
       35
        
         meta = with lib; {

     

       32
       36
        
           changelog = "https://github.com/al-one/hass-xiaomi-miot/releases/tag/${version}";

+2 -2

pkgs/servers/http/nginx/stable.nix

···

       1
       1
        
       { callPackage, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       callPackage ./generic.nix args {

     

       4
       4
       -
         version = "1.24.0";

     

       5
       5
       -
         hash = "sha256-d6JUFje5KmIePudndsi3tAz21wfmm6U6lAKD4w/y9V0=";

     

       4
       4
       +
         version = "1.26.0";

     

       5
       5
       +
         hash = "sha256-0ubIQ51sbbUBXY6qskcKtSrvhae/NjGCh5l34IQ3BJc=";

     

       6
       6
        
       }

+2 -2

pkgs/servers/knxd/default.nix

···

       14
       14
        
       

     

       15
       15
        
       stdenv.mkDerivation rec {

     

       16
       16
        
         pname = "knxd";

     

       17
       17
       -
         version = "0.14.60";

     

       17
       17
       +
         version = "0.14.61";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchFromGitHub {

     

       20
       20
        
           owner = "knxd";

     

       21
       21
        
           repo = "knxd";

     

       22
       22
        
           rev = version;

     

       23
       23
       -
           hash = "sha256-djcp3b0OSnyrNOkvaacjQ3Nw9H54HOfKeBo26tkz/Ew=";

     

       23
       23
       +
           hash = "sha256-b8svjGaxW8YqonhXewebDUitezKoMcZxcUFGd2EKZQ4=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         postPatch = ''

+2 -2

pkgs/shells/hishtory/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "hishtory";

     

       8
       8
       -
         version = "0.293";

     

       8
       8
       +
         version = "0.294";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "ddworken";

     

       12
       12
        
           repo = pname;

     

       13
       13
        
           rev = "v${version}";

     

       14
       14
       -
           hash = "sha256-5I61ey7GJ78dhSgRMkbRcKf3zk0j7zW2MyN2QSbAnpE=";

     

       14
       14
       +
           hash = "sha256-vwjzJTBgD4XzZekxGk02WW9/A7wLlLBsIUyvt0VCkOg=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         vendorHash = "sha256-zTwZ/sMhQdlf7RYfR2/K/m08U1Il0VQmYFyNNiYsWhc=";

-1

pkgs/test/cuda/default.nix

···

       3
       3
        
         recurseIntoAttrs,

     

       4
       4
        
       

     

       5
       5
        
         cudaPackages,

     

       6
       6
       -
         cudaPackagesGoogle,

     

       7
       6
        
       

     

       8
       7
        
         cudaPackages_10_0,

     

       9
       8
        
         cudaPackages_10_1,

+3 -3

pkgs/tools/admin/aliyun-cli/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "aliyun-cli";

     

       5
       5
       -
         version = "3.0.204";

     

       5
       5
       +
         version = "3.0.205";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           rev = "v${version}";

     

       9
       9
        
           owner = "aliyun";

     

       10
       10
        
           repo = pname;

     

       11
       11
        
           fetchSubmodules = true;

     

       12
       12
       -
           sha256 = "sha256-Wi35FcuDaTgGG7KgCcU/m6UIKzUuAaMF8J96YvjWgJc=";

     

       12
       12
       +
           sha256 = "sha256-fUInyAJKMvHZ13sWjqWr4KPge/hpeDSkJl69nnWJkPc=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       -
         vendorHash = "sha256-AvlDqaJ5w9oDV1slwArr12KA1d3FKVU9H5WK4s3ePtU=";

     

       15
       15
       +
         vendorHash = "sha256-4jGwhcWANYUXuzFjXmFKzMVQXqFtPJt/y3IrjveRNYA=";

     

       16
       16
        
       

     

       17
       17
        
         subPackages = [ "main" ];

     

       18
       18

+1 -1

pkgs/tools/admin/google-cloud-sdk/default.nix

···

       122
       122
        
       

     

       123
       123
        
         meta = with lib; {

     

       124
       124
        
           description = "Tools for the google cloud platform";

     

       125
       125
       -
           longDescription = "The Google Cloud SDK. This package has the programs: gcloud, gsutil, and bq";

     

       125
       125
       +
           longDescription = "The Google Cloud SDK for GCE hosts. Used by `google-cloud-sdk` only on GCE guests.";

     

       126
       126
        
           sourceProvenance = with sourceTypes; [

     

       127
       127
        
             fromSource

     

       128
       128
        
             binaryNativeCode  # anthoscli and possibly more

+32 -30

pkgs/tools/admin/google-cloud-sdk/withExtraComponents.nix

···

       1
       1
       -
       { lib, google-cloud-sdk, runCommand, components }:

     

       1
       1
       +
       { lib, google-cloud-sdk, symlinkJoin, components }:

     

       2
       2
        
       

     

       3
       3
        
       comps_:

     

       4
       4
        
       

     
···

       19
       19
        
         defaultComponents = with components; [ alpha beta ];

     

       20
       20
        
       

     

       21
       21
        
         comps = [ google-cloud-sdk ] ++ filterPreInstalled (findDepsRecursive (defaultComponents ++ comps_));

     

       22
       22
       -
       in

     

       23
       23
       -
       # Components are installed by copying the `google-cloud-sdk` package, along

     

       24
       24
       -
       # with each component, over to a new location, and then patching that location

     

       25
       25
       -
       # with `sed` to ensure the proper paths are used.

     

       26
       26
       -
       # For some reason, this does not work properly with a `symlinkJoin`: the

     

       27
       27
       -
       # `gcloud` binary doesn't seem able to find the installed components.

     

       28
       28
       -
       runCommand "google-cloud-sdk-${google-cloud-sdk.version}"

     

       29
       29
       -
       {

     

       30
       30
       -
         inherit (google-cloud-sdk) meta;

     

       31
       31
       -
         inherit comps;

     

       32
       32
       -
         passAsFile = [ "comps" ];

     

       33
       22
        
       

     

       34
       34
       -
         doInstallCheck = true;

     

       35
       35
       -
         disallowedRequisites = [ google-cloud-sdk ];

     

       36
       36
       -
         installCheckPhase =

     

       23
       23
       +
         installCheck =

     

       37
       24
        
           let

     

       38
       38
       -
             compNames = builtins.map (drv: drv.name) comps_;

     

       25
       25
       +
             compNames = builtins.map lib.getName comps_;

     

       39
       26
        
           in

     

       40
       27
        
           ''

     

       41
       41
       -
             $out/bin/gcloud components list > component_list.txt

     

       28
       28
       +
             $out/bin/gcloud components list --only-local-state --format 'value(id)' > component_list.txt

     

       42
       29
        
             for comp in ${builtins.toString compNames}; do

     

       43
       43
       -
               if [ ! grep ... component_list.txt | grep "Not Installed" ]; then

     

       30
       30
       +
               snapshot_file="$out/google-cloud-sdk/.install/$comp.snapshot.json"

     

       31
       31
       +
       

     

       32
       32
       +
               if ! [ -f "$snapshot_file"  ]; then

     

       33
       33
       +
                 echo "Failed to install component '$comp'"

     

       34
       34
       +
                 exit 1

     

       35
       35
       +
               fi

     

       36
       36
       +
       

     

       37
       37
       +
               if grep --quiet '"is_hidden":true' "$snapshot_file"; then

     

       38
       38
       +
                 continue

     

       39
       39
       +
               fi

     

       40
       40
       +
       

     

       41
       41
       +
               if ! grep --quiet "^$comp$" component_list.txt; then

     

       44
       42
        
                 echo "Failed to install component '$comp'"

     

       45
       43
        
                 exit 1

     

       46
       44
        
               fi

     

       47
       45
        
             done

     

       48
       46
        
           '';

     

       49
       49
       -
       }

     

       50
       50
       -
         ''

     

       51
       51
       -
           mkdir -p $out

     

       47
       47
       +
       in

     

       48
       48
       +
       # The `gcloud` entrypoint script has some custom logic to determine the "real" cloud sdk

     

       49
       49
       +
       # root. In order to not trip up this logic and still have the symlink joined root we copy

     

       50
       50
       +
       # over this file. Since this file also has a Python wrapper, we need to copy that as well.

     

       51
       51
       +
       symlinkJoin {

     

       52
       52
       +
         name = "google-cloud-sdk-${google-cloud-sdk.version}";

     

       53
       53
       +
         inherit (google-cloud-sdk) meta;

     

       52
       54
        
       

     

       53
       53
       -
           # Install each component

     

       54
       54
       -
           for comp in $(cat $compsPath); do

     

       55
       55
       -
             echo "installing component $comp"

     

       56
       56
       -
             cp -dRf $comp/. $out

     

       57
       57
       -
             find $out -type d -exec chmod 744 {} +

     

       58
       58
       -
           done

     

       55
       55
       +
         paths = [

     

       56
       56
       +
           google-cloud-sdk

     

       57
       57
       +
         ] ++ comps;

     

       59
       58
        
       

     

       60
       60
       -
           # Replace references to the original google-cloud-sdk with this one

     

       61
       61
       -
           find $out/google-cloud-sdk -type f -exec sed -i -e "s#${google-cloud-sdk}#$out#" {} \;

     

       62
       62
       -
         ''

     

       59
       59
       +
         postBuild = ''

     

       60
       60
       +
           sed -i ';' $out/google-cloud-sdk/bin/.gcloud-wrapped

     

       61
       61
       +
           sed -i -e "s#${google-cloud-sdk}#$out#" "$out/google-cloud-sdk/bin/gcloud"

     

       62
       62
       +
           ${installCheck}

     

       63
       63
       +
         '';

     

       64
       64
       +
       }

+2 -2

pkgs/tools/misc/diffoscope/default.nix

···

       96
       96
        
       # Note: when upgrading this package, please run the list-missing-tools.sh script as described below!

     

       97
       97
        
       python.pkgs.buildPythonApplication rec {

     

       98
       98
        
         pname = "diffoscope";

     

       99
       99
       -
         version = "265";

     

       99
       99
       +
         version = "266";

     

       100
       100
        
       

     

       101
       101
        
         src = fetchurl {

     

       102
       102
        
           url = "https://diffoscope.org/archive/diffoscope-${version}.tar.bz2";

     

       103
       103
       -
           hash = "sha256-YE81R8lTOM3wmv/GIaIBqUq2O6UvnUaHjuXZ00yDU8U=";

     

       103
       103
       +
           hash = "sha256-whEFBUFl8yFsZOtOWHbDm6Tx6i6UJYmQ5Fz7svLqGgs=";

     

       104
       104
        
         };

     

       105
       105
        
       

     

       106
       106
        
         outputs = [

+2 -2

pkgs/tools/misc/graylog/5.2.nix

···

       2
       2
        
       let

     

       3
       3
        
         buildGraylog = callPackage ./graylog.nix {};

     

       4
       4
        
       in buildGraylog {

     

       5
       5
       -
         version = "5.2.4";

     

       6
       6
       -
         sha256 = "sha256-TbZMRMLpYlg6wrsC+tDEk8sLYJ1nwJum/rL30CEGQcw=";

     

       5
       5
       +
         version = "5.2.7";

     

       6
       6
       +
         sha256 = "sha256-so9IHX0r3dmj5wLrLtQgrcXk+hu6E8/1d7wJu1XDcVA=";

     

       7
       7
        
         maintainers = [ lib.maintainers.f2k1de ];

     

       8
       8
        
         license = lib.licenses.sspl;

     

       9
       9
        
       }

+2 -11

pkgs/tools/misc/mstflint/default.nix

···

       26
       26
        
       

     

       27
       27
        
       stdenv.mkDerivation rec {

     

       28
       28
        
         pname = "mstflint";

     

       29
       29
       -
         version = "4.26.0-1";

     

       29
       29
       +
         version = "4.28.0-1";

     

       30
       30
        
       

     

       31
       31
        
         src = fetchurl {

     

       32
       32
        
           url = "https://github.com/Mellanox/mstflint/releases/download/v${version}/mstflint-${version}.tar.gz";

     

       33
       33
       -
           hash = "sha256-P8XACcz6d8UTOhFFeTijfFOthBqnUghGlDj9K145sZ8=";

     

       33
       33
       +
           hash = "sha256-zvCDc/9wAqT3XBI9A5kOprnnm52Ek8oGe2Je3dKHti0=";

     

       34
       34
        
         };

     

       35
       35
       -
       

     

       36
       36
       -
         patches = [

     

       37
       37
       -
           # needed to introduce this with GCC 13. Remove, when https://github.com/Mellanox/mstflint/pull/916 is upstream.

     

       38
       38
       -
           (fetchpatch {

     

       39
       39
       -
             name = "elf.patch";

     

       40
       40
       -
             url = "https://patch-diff.githubusercontent.com/raw/Mellanox/mstflint/pull/916.patch";

     

       41
       41
       -
             hash = "sha256-quBdmiuzwThu4MkAaT74eJDlZwIcUZMrLZa8OIcO96w=";

     

       42
       42
       -
           })

     

       43
       43
       -
         ];

     

       44
       35
        
       

     

       45
       36
        
         nativeBuildInputs = [

     

       46
       37
        
           autoconf

+2 -2

pkgs/tools/misc/ttyplot/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "ttyplot";

     

       5
       5
       -
         version = "1.6.2";

     

       5
       5
       +
         version = "1.6.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "tenox7";

     

       9
       9
        
           repo = "ttyplot";

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           hash = "sha256-HBJvTDhp1CA96gRU2Q+lMxcFaZ+txXcmNb8Cg1BFiH4=";

     

       11
       11
       +
           hash = "sha256-yxAFqi3TgiKiZYgR891ahkwUqZLk/JDsjujOYmBjUtk=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [

+22 -11

pkgs/tools/misc/undocker/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildGoModule

     

       3
       3
       -
       , fetchFromSourcehut

     

       3
       3
       +
       , fetchFromGitea

     

       4
       4
       +
       , gnumake

     

       4
       5
        
       }:

     

       5
       5
       -
       buildGoModule rec {

     

       6
       6
       +
       let

     

       7
       7
       +
         version = "1.2.2";

     

       8
       8
       +
         hash = "sha256-kBqNopcHpldU5oD6zoVjPjP84t12QFcbWBSNNgwImKg=";

     

       9
       9
       +
         src = fetchFromGitea {

     

       10
       10
       +
           domain = "git.jakstys.lt";

     

       11
       11
       +
           owner = "motiejus";

     

       12
       12
       +
           repo = "undocker";

     

       13
       13
       +
           rev = "v${version}";

     

       14
       14
       +
           hash = hash;

     

       15
       15
       +
         };

     

       16
       16
       +
       in

     

       17
       17
       +
       buildGoModule {

     

       6
       18
        
         pname = "undocker";

     

       7
       7
       -
         version = "1.0.4";

     

       19
       19
       +
         inherit version src;

     

       8
       20
        
       

     

       9
       9
       -
         src = fetchFromSourcehut {

     

       10
       10
       -
           owner = "~motiejus";

     

       11
       11
       -
           repo = pname;

     

       12
       12
       -
           rev = "v${version}";

     

       13
       13
       -
           hash = "sha256-I+pTbr1lKELyYlyHrx2gB+aeZ3/PmcePQfXu1ckhKAk=";

     

       14
       14
       -
         };

     

       21
       21
       +
         nativeBuildInputs = [ gnumake ];

     

       22
       22
       +
       

     

       23
       23
       +
         buildPhase = "make VSN=v${version} VSNHASH=${hash} undocker";

     

       24
       24
       +
       

     

       25
       25
       +
         installPhase = "install -D undocker $out/bin/undocker";

     

       15
       26
        
       

     

       16
       27
        
         vendorHash = null;

     

       17
       28
        
       

     

       18
       29
        
         meta = with lib; {

     

       19
       19
       -
           homepage = "https://git.sr.ht/~motiejus/undocker";

     

       30
       30
       +
           homepage = "https://git.jakstys.lt/motiejus/undocker";

     

       20
       31
        
           description = "A CLI tool to convert a Docker image to a flattened rootfs tarball";

     

       21
       32
        
           license = licenses.asl20;

     

       22
       22
       -
           maintainers = with maintainers; [ jordanisaacs ];

     

       33
       33
       +
           maintainers = with maintainers; [ jordanisaacs motiejus ];

     

       23
       34
        
           mainProgram = "undocker";

     

       24
       35
        
         };

     

       25
       36
        
       }

+12 -3

pkgs/tools/security/qdigidoc/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , mkDerivation

     

       3
       3
        
       , fetchurl

     

       4
       4
       +
       , fetchpatch

     

       4
       5
        
       , cmake

     

       5
       6
        
       , flatbuffers

     

       6
       7
        
       , gettext

     
···

       17
       18
        
       

     

       18
       19
        
       mkDerivation rec {

     

       19
       20
        
         pname = "qdigidoc";

     

       20
       20
       -
         version = "4.4.0";

     

       21
       21
       +
         version = "4.5.1";

     

       21
       22
        
       

     

       22
       23
        
         src = fetchurl {

     

       23
       24
        
           url =

     

       24
       25
        
             "https://github.com/open-eid/DigiDoc4-Client/releases/download/v${version}/qdigidoc4-${version}.tar.gz";

     

       25
       25
       -
           hash = "sha256-5zo0yoY0wufm9DWRIccxJ5g4DXn75nT4fd2h+5QP4oQ=";

     

       26
       26
       +
           hash = "sha256-grhSuexp5yd/s8h5AdmdSLBmQY85l9HKZ15oTTvC6PI=";

     

       26
       27
        
         };

     

       27
       28
        
       

     

       28
       29
        
         tsl = fetchurl {

     
···

       30
       31
        
           sha256 = "1cikz36w9phgczcqnwk4k3mx3kk919wy2327jksmfa4cjfjq4a8d";

     

       31
       32
        
         };

     

       32
       33
        
       

     

       34
       34
       +
         patches = [

     

       35
       35
       +
           # https://github.com/open-eid/DigiDoc4-Client/pull/1251

     

       36
       36
       +
           (fetchpatch {

     

       37
       37
       +
             url = "https://github.com/open-eid/DigiDoc4-Client/commit/30281d14c5fb5582832eafbc254b56f8d685227d.patch";

     

       38
       38
       +
             hash = "sha256-nv23NbPUogOhS8No3SMIrAcPChl+d1HkxnePpCKIoUw=";

     

       39
       39
       +
           })

     

       40
       40
       +
         ];

     

       41
       41
       +
       

     

       33
       42
        
         nativeBuildInputs = [ cmake gettext pkg-config qttools ];

     

       34
       43
        
       

     

       35
       44
        
         postPatch = ''

     
···

       64
       73
        
           homepage = "https://www.id.ee/";

     

       65
       74
        
           license = licenses.lgpl21Plus;

     

       66
       75
        
           platforms = platforms.linux;

     

       67
       67
       -
           maintainers = with maintainers; [ mmahut yana ];

     

       76
       76
       +
           maintainers = with maintainers; [ flokli mmahut yana ];

     

       68
       77
        
         };

     

       69
       78
        
       }

+2 -2

pkgs/tools/security/web-eid-app/default.nix

···

       10
       10
        
       

     

       11
       11
        
       mkDerivation rec {

     

       12
       12
        
         pname = "web-eid-app";

     

       13
       13
       -
         version = "2.4.0";

     

       13
       13
       +
         version = "2.5.0";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "web-eid";

     

       17
       17
        
           repo = "web-eid-app";

     

       18
       18
        
           rev = "v${version}";

     

       19
       19
       -
           sha256 = "sha256-xWwguxs/121BFF1zhb/HxS9b1vTwQRemhPKOfHEXVZQ=";

     

       19
       19
       +
           sha256 = "sha256-CaMf7cRhZ8K6YAUG38B+ijNOKaOmaACqNabNfHZGT68=";

     

       20
       20
        
           fetchSubmodules = true;

     

       21
       21
        
         };

     

       22
       22

+3 -3

pkgs/tools/text/mdbook-open-on-gh/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "mdbook-open-on-gh";

     

       5
       5
       -
         version = "2.4.2";

     

       5
       5
       +
         version = "2.4.3";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "badboy";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           hash = "sha256-ZExmOHvQApGZaepOuf3yXYe8NV3FpMtCqCR1KE6q4no=";

     

       11
       11
       +
           hash = "sha256-73738Vei7rQ67LQIOrHPGOtsBnHClaXClRWDmA5pP58=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         cargoHash = "sha256-WLCcYgkrH5fZvv3LZNEolBQUcTZC2URs6bIgzf4BtWU=";

     

       14
       14
       +
         cargoHash = "sha256-TQBjgQaoI88xGdhkffNWRH6aZ99WWbkkpiPu4LqBD3g=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           description = "mdbook preprocessor to add a open-on-github link on every page";

+2 -2

pkgs/tools/wayland/mpvpaper/default.nix

···

       16
       16
        
       

     

       17
       17
        
       stdenv.mkDerivation rec {

     

       18
       18
        
         pname = "mpvpaper";

     

       19
       19
       -
         version = "1.5";

     

       19
       19
       +
         version = "1.6";

     

       20
       20
        
       

     

       21
       21
        
         src = fetchFromGitHub {

     

       22
       22
        
           owner = "GhostNaN";

     

       23
       23
        
           repo = pname;

     

       24
       24
        
           rev = version;

     

       25
       25
       -
           sha256 = "sha256-TlA2hmpHGe4PWb+Pe3cq2Hhce4NXVI1DnknseGmuFeY=";

     

       25
       25
       +
           sha256 = "sha256-/A2C6T7gP+VGON3Peaz2Y4rNC63UT+zYr4RNM2gdLUY=";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         strictDeps = true;

-31

pkgs/tools/wayland/ydotool/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, cmake, scdoc, util-linux, xorg }:

     

       2
       2
       -
       

     

       3
       3
       -
       stdenv.mkDerivation rec {

     

       4
       4
       -
         pname = "ydotool";

     

       5
       5
       -
         version = "1.0.4";

     

       6
       6
       -
       

     

       7
       7
       -
         src = fetchFromGitHub {

     

       8
       8
       -
           owner = "ReimuNotMoe";

     

       9
       9
       -
           repo = "ydotool";

     

       10
       10
       -
           rev = "v${version}";

     

       11
       11
       -
           hash = "sha256-MtanR+cxz6FsbNBngqLE+ITKPZFHmWGsD1mBDk0OVng=";

     

       12
       12
       -
         };

     

       13
       13
       -
       

     

       14
       14
       -
         postPatch = ''

     

       15
       15
       -
           substituteInPlace Daemon/ydotoold.c \

     

       16
       16
       -
             --replace "/usr/bin/xinput" "${xorg.xinput}/bin/xinput"

     

       17
       17
       -
           substituteInPlace Daemon/ydotool.service.in \

     

       18
       18
       -
             --replace "/usr/bin/kill" "${util-linux}/bin/kill"

     

       19
       19
       -
         '';

     

       20
       20
       -
       

     

       21
       21
       -
         strictDeps = true;

     

       22
       22
       -
         nativeBuildInputs = [ cmake scdoc ];

     

       23
       23
       -
       

     

       24
       24
       -
         meta = with lib; {

     

       25
       25
       -
           homepage = "https://github.com/ReimuNotMoe/ydotool";

     

       26
       26
       -
           description = "Generic Linux command-line automation tool";

     

       27
       27
       -
           license = licenses.agpl3Plus;

     

       28
       28
       -
           maintainers = with maintainers; [ willibutz kraem ];

     

       29
       29
       -
           platforms = with platforms; linux;

     

       30
       30
       -
         };

     

       31
       31
       -
       }

pkgs/top-level/aliases.nix

···

       231
       231
        
         clang_10 = throw "clang_10 has been removed from nixpkgs"; # Added 2024-01-26

     

       232
       232
        
         clang_11 = throw "clang_11 has been removed from nixpkgs"; # Added 2023-01-24

     

       233
       233
        
       

     

       234
       234
       +
         cq-editor = throw "cq-editor has been removed, as it use a dependency that was disabled since python 3.8 and was last updated in 2021"; # Added 2024-05-13

     

       234
       235
        
         ### D ###

     

       235
       236
        
       

     

       236
       237
        
         dagger = throw "'dagger' has been removed from nixpkgs, as the trademark policy of the upstream project is incompatible"; # Added 2023-10-16

+1 -11

pkgs/top-level/all-packages.nix

···

       1081
       1081
        
           antlr = antlr4_10;

     

       1082
       1082
        
           boost = boost177; # Configure checks for specific version.

     

       1083
       1083
        
           icu =  icu73;

     

       1084
       1084
       -
           protobuf = protobuf_21;

     

       1084
       1084
       +
           protobuf = protobuf_24;

     

       1085
       1085
        
         };

     

       1086
       1086
        
       

     

       1087
       1087
        
         mysql-shell-innovation = callPackage ../development/tools/mysql-shell/innovation.nix {

     
···

       4765
       4765
        
       

     

       4766
       4766
        
         wtype = callPackage ../tools/wayland/wtype { };

     

       4767
       4767
        
       

     

       4768
       4768
       -
         ydotool = callPackage ../tools/wayland/ydotool { };

     

       4769
       4769
       -
       

     

       4770
       4768
        
         cambalache = callPackage ../development/tools/cambalache { };

     

       4771
       4769
        
       

     

       4772
       4770
        
         cambrinary = python3Packages.callPackage ../applications/misc/cambrinary { };

     
···

       7126
       7124
        
         cudaPackages_12_2 = callPackage ./cuda-packages.nix { cudaVersion = "12.2"; };

     

       7127
       7125
        
         cudaPackages_12_3 = callPackage ./cuda-packages.nix { cudaVersion = "12.3"; };

     

       7128
       7126
        
         cudaPackages_12 = cudaPackages_12_2; # Latest supported by cudnn

     

       7129
       7129
       -
       

     

       7130
       7130
       -
         # Use the older cudaPackages for tensorflow and jax, as determined by cudnn

     

       7131
       7131
       -
         # compatibility: https://www.tensorflow.org/install/source#gpu

     

       7132
       7132
       -
         cudaPackagesGoogle = cudaPackages_11;

     

       7133
       7127
        
       

     

       7134
       7128
        
         cudaPackages = recurseIntoAttrs cudaPackages_12;

     

       7135
       7129
        
       

     
···

       30175
       30169
        
       

     

       30176
       30170
        
         cplay-ng = callPackage ../applications/audio/cplay-ng { };

     

       30177
       30171
        
       

     

       30178
       30178
       -
         cq-editor = libsForQt5.callPackage ../applications/graphics/cq-editor { };

     

       30179
       30179
       -
       

     

       30180
       30172
        
         cqrlog = callPackage ../applications/radio/cqrlog {

     

       30181
       30173
        
           hamlib = hamlib_4;

     

       30182
       30174
        
         };

     
···

       40942
       40934
        
         fac-build = callPackage ../development/tools/build-managers/fac {

     

       40943
       40935
        
           inherit (darwin.apple_sdk.frameworks) CoreServices;

     

       40944
       40936
        
         };

     

       40945
       40945
       -
       

     

       40946
       40946
       -
         treefmt = callPackage ../development/tools/treefmt { };

     

       40947
       40937
        
       

     

       40948
       40938
        
         nufmt = callPackage ../development/tools/nufmt { };

     

       40949
       40939

pkgs/top-level/python-aliases.nix

···

       80
       80
        
         bt_proximity = bt-proximity; # added 2021-07-02

     

       81
       81
        
         BTrees = btrees; # added 2023-02-19

     

       82
       82
        
         cacheyou = throw "cacheyou has been removed, as it was no longer used for the only consumer pdm"; # added 2023-12-21

     

       83
       83
       +
         cadquery = throw "cadquery was removed, because it was disabled on all python version since 3.8 and marked as broken"; # added 2024-05-13

     

       83
       84
        
         carrot = throw "carrot has been removed, as its development was discontinued in 2012"; # added 2022-01-18

     

       84
       85
        
         cchardet = faust-cchardet; # added 2023-03-02

     

       85
       86
        
         cepa = throw "cepa has been removed, as onionshare switched back to stem"; # added 2024-05-07

     
···

       93
       94
        
         coronavirus = throw "coronavirus was removed, because the source is not providing the data anymore."; # added 2023-05-04

     

       94
       95
        
         covCore = cov-core; # added 2024-01-03

     

       95
       96
        
         cozy = throw "cozy was removed because it was not actually https://pypi.org/project/Cozy/."; # added 2022-01-14

     

       97
       97
       +
         cryptacular = throw "cryptacular was removed, because it was disabled on all python version since 3.6 and last updated in 2021"; # Added 2024-05-13

     

       96
       98
        
         cryptography_vectors = "cryptography_vectors is no longer exposed in python*Packages because it is used for testing cryptography only."; # Added 2022-03-23

     

       97
       99
        
         cx_Freeze = cx-freeze; # added 2023-08-02

     

       98
       100
        
         cx_oracle = cx-oracle; # added 2024-01-03

     
···

       193
       195
        
         GitPython = gitpython; # added 2022-10-28

     

       194
       196
        
         glances = throw "glances has moved to pkgs.glances"; # added 2020-20-28

     

       195
       197
        
         glasgow = throw "glasgow has been promoted to a top-level attribute name: `pkgs.glasgow`"; # added 2023-02-05

     

       198
       198
       +
         globre = throw "globre was removed, because it was disabled on all python version since 3.7 and last updated in 2020."; # added 2024-05-13

     

       196
       199
        
         google_api_python_client = google-api-python-client; # added 2021-03-19

     

       197
       200
        
         googleapis_common_protos = googleapis-common-protos; # added 2021-03-19

     

       198
       201
        
         google-apitools = throw "google-apitools was removed because it is deprecated and unsupported by upstream"; # added 2023-02-25

     
···

       307
       310
        
         pafy = throw "pafy has been removed because it is unmaintained and only a dependency of mps-youtube, itself superseded by yewtube"; # Added 2023-01-19

     

       308
       311
        
         pam = python-pam; # added 2020-09-07.

     

       309
       312
        
         PasteDeploy = pastedeploy; # added 2021-10-07

     

       313
       313
       +
         pathlib = throw "pathlib was removed as it has been integrated in python standard library in version 3.4"; # added 2024-05-13

     

       310
       314
        
         pathpy = path; # added 2022-04-12

     

       311
       315
        
         pcbnew-transition = pcbnewtransition; # added 2024-03-21

     

       312
       316
        
         pdfposter = throw "pdfposter was promoted to a top-level attribute"; # Added 2023-06-29

     
···

       327
       331
        
         pur = throw "pur has been renamed to pkgs.pur"; # added 2021-11-08

     

       328
       332
        
         pushbullet = pushbullet-py;  # Added 2022-10-15

     

       329
       333
        
         Pweave = pweave; # added 2023-02-19

     

       334
       334
       +
         pxml = throw "pxml was removed, because it was disabled on all python version since 3.8 and last updated in 2020."; # added 2024-05-13

     

       330
       335
        
         py-radix = throw "py-radix has been removed, since it abandoned"; # added 2023-07-07

     

       331
       336
        
         py_stringmatching = py-stringmatching; # added 2023-11-12

     

       332
       337
        
         pyalmond = throw "pyalmond has been removed, since its API endpoints have been shutdown"; # added 2023-02-02

     
···

       494
       499
        
         sphinx-navtree = throw "sphinx-navtree has been removed since it is not compatible with sphinx 3.3 and unmaintained"; # added 2023-07-03

     

       495
       500
        
         sqlalchemy_migrate = sqlalchemy-migrate; # added 2021-10-28

     

       496
       501
        
         SQLAlchemy-ImageAttach = throw "sqlalchemy-imageattach has been removed as it is incompatible with sqlalchemy 1.4 and unmaintained"; # added 2022-04-23

     

       502
       502
       +
         sqlsoup = throw "sqlsoup has been removed as it is incompatible with modern SQLAlchemy and unmaintained"; # added 2024-05-13

     

       497
       503
        
         subdownloader = throw "subdownloader has been removed, because it depended on pyqt4"; # added 2022-06-09

     

       498
       504
        
         suds-jurko = throw "suds-jurko has been removed, it was using setuptools 2to3 translation feature, which has been removed in setuptools 58"; # added 2023-02-27

     

       499
       505
        
         supervise_api = supervise-api; # added 2023-10-11

+5 -14

pkgs/top-level/python-packages.nix

···

       1858
       1858
        
       

     

       1859
       1859
        
         cachy = callPackage ../development/python-modules/cachy { };

     

       1860
       1860
        
       

     

       1861
       1861
       -
         cadquery = callPackage ../development/python-modules/cadquery {

     

       1862
       1862
       -
           inherit (pkgs.darwin.apple_sdk.frameworks) Cocoa;

     

       1863
       1863
       -
         };

     

       1864
       1864
       -
       

     

       1865
       1861
        
         caffe = toPythonModule (pkgs.caffe.override {

     

       1866
       1862
        
           pythonSupport = true;

     

       1867
       1863
        
           inherit (self) python numpy boost;

     
···

       2570
       2566
        
         crownstone-sse = callPackage ../development/python-modules/crownstone-sse { };

     

       2571
       2567
        
       

     

       2572
       2568
        
         crownstone-uart = callPackage ../development/python-modules/crownstone-uart { };

     

       2573
       2573
       -
       

     

       2574
       2574
       -
         cryptacular = callPackage ../development/python-modules/cryptacular { };

     

       2575
       2569
        
       

     

       2576
       2570
        
         cryptg = callPackage ../development/python-modules/cryptg { };

     

       2577
       2571
        
       

     
···

       4841
       4835
        
         glfw = callPackage ../development/python-modules/glfw { };

     

       4842
       4836
        
       

     

       4843
       4837
        
         glob2 = callPackage ../development/python-modules/glob2 { };

     

       4844
       4844
       -
       

     

       4845
       4845
       -
         globre = callPackage ../development/python-modules/globre { };

     

       4846
       4838
        
       

     

       4847
       4839
        
         globus-sdk = callPackage ../development/python-modules/globus-sdk { };

     

       4848
       4840
        
       

     
···

       9522
       9514
        
         pathable = callPackage ../development/python-modules/pathable { };

     

       9523
       9515
        
       

     

       9524
       9516
        
         pathlib2 = callPackage ../development/python-modules/pathlib2 { };

     

       9525
       9525
       -
       

     

       9526
       9526
       -
         pathlib = callPackage ../development/python-modules/pathlib { };

     

       9527
       9517
        
       

     

       9528
       9518
        
         pathlib-abc = callPackage ../development/python-modules/pathlib-abc { };

     

       9529
       9519
        
       

     
···

       10541
       10531
        
           debugger = pkgs.gdb;

     

       10542
       10532
        
         };

     

       10543
       10533
        
       

     

       10544
       10544
       -
         pxml = callPackage ../development/python-modules/pxml { };

     

       10545
       10545
       -
       

     

       10546
       10534
        
         py-air-control = callPackage ../development/python-modules/py-air-control { };

     

       10547
       10535
        
       

     

       10548
       10536
        
         py-air-control-exporter = callPackage ../development/python-modules/py-air-control-exporter { };

     
···

       14476
       14464
        
       

     

       14477
       14465
        
         sqlparse = callPackage ../development/python-modules/sqlparse { };

     

       14478
       14466
        
       

     

       14479
       14479
       -
         sqlsoup = callPackage ../development/python-modules/sqlsoup { };

     

       14480
       14480
       -
       

     

       14481
       14467
        
         sqltrie = callPackage ../development/python-modules/sqltrie { };

     

       14482
       14468
        
       

     

       14483
       14469
        
         squarify = callPackage ../development/python-modules/squarify { };

     
···

       14885
       14871
        
       

     

       14886
       14872
        
         tensorflow-bin = callPackage ../development/python-modules/tensorflow/bin.nix {

     

       14887
       14873
        
           inherit (pkgs.config) cudaSupport;

     

       14874
       14874
       +
           # https://www.tensorflow.org/install/source#gpu

     

       14875
       14875
       +
           cudaPackages = pkgs.cudaPackages_11;

     

       14888
       14876
        
         };

     

       14889
       14877
        
       

     

       14890
       14878
        
         tensorflow-build = let

     
···

       14892
       14880
        
             protobufTF = pkgs.protobuf_21.override {

     

       14893
       14881
        
               abseil-cpp = pkgs.abseil-cpp_202301;

     

       14894
       14882
        
             };

     

       14883
       14883
       +
             # https://www.tensorflow.org/install/source#gpu

     

       14884
       14884
       +
             cudaPackagesTF = pkgs.cudaPackages_11;

     

       14895
       14885
        
             grpcTF = (pkgs.grpc.overrideAttrs (

     

       14896
       14886
        
               oldAttrs: rec {

     

       14897
       14887
        
                 # nvcc fails on recent grpc versions, so we use the latest patch level

     
···

       14937
       14927
        
           inherit (pkgs.darwin.apple_sdk.frameworks) Foundation Security;

     

       14938
       14928
        
           flatbuffers-core = pkgs.flatbuffers;

     

       14939
       14929
        
           flatbuffers-python = self.flatbuffers;

     

       14930
       14930
       +
           cudaPackages = compat.cudaPackagesTF;

     

       14940
       14931
        
           protobuf-core = compat.protobufTF;

     

       14941
       14932
        
           protobuf-python = compat.protobuf-pythonTF;

     

       14942
       14933
        
           grpc = compat.grpcTF;